blob: e974550f2254b7b1ad5223f35469d4cbb1c4ae76 [file] [log] [blame]
Daniel Jasperf7935112012-12-03 18:12:45 +00001//===- unittest/Format/FormatTest.cpp - Formatting unit tests -------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
Chandler Carruth320d9662012-12-04 09:45:34 +000010#include "clang/Format/Format.h"
Manuel Klimekb12e5a52016-03-01 12:37:30 +000011
Eric Liu40ef2fb2016-08-01 10:16:37 +000012#include "../Tooling/ReplacementTest.h"
Manuel Klimekb12e5a52016-03-01 12:37:30 +000013#include "FormatTestUtils.h"
14
15#include "clang/Frontend/TextDiagnosticPrinter.h"
Chandler Carruth4b417452013-01-19 08:09:44 +000016#include "llvm/Support/Debug.h"
Eric Liu547d8792016-03-24 13:22:42 +000017#include "llvm/Support/MemoryBuffer.h"
Chandler Carruth4b417452013-01-19 08:09:44 +000018#include "gtest/gtest.h"
Manuel Klimek24998102013-01-16 14:55:28 +000019
Chandler Carruth10346662014-04-22 03:17:02 +000020#define DEBUG_TYPE "format-test"
21
Eric Liu40ef2fb2016-08-01 10:16:37 +000022using clang::tooling::ReplacementTest;
23using clang::tooling::toReplacements;
24
Daniel Jasperf7935112012-12-03 18:12:45 +000025namespace clang {
26namespace format {
Daniel Jasperd246a5a2015-06-15 15:25:11 +000027namespace {
Daniel Jasperf7935112012-12-03 18:12:45 +000028
Daniel Jaspera44991332015-04-29 13:06:49 +000029FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); }
Nico Weber514ecc82014-02-02 20:50:45 +000030
Daniel Jasperf7935112012-12-03 18:12:45 +000031class FormatTest : public ::testing::Test {
32protected:
Krasimir Georgievbcda54b2017-04-21 14:35:20 +000033 enum StatusCheck {
34 SC_ExpectComplete,
35 SC_ExpectIncomplete,
36 SC_DoNotCheck
Manuel Klimekec5c3db2015-05-07 12:26:30 +000037 };
38
Daniel Jasperd246a5a2015-06-15 15:25:11 +000039 std::string format(llvm::StringRef Code,
40 const FormatStyle &Style = getLLVMStyle(),
Krasimir Georgievbcda54b2017-04-21 14:35:20 +000041 StatusCheck CheckComplete = SC_ExpectComplete) {
Manuel Klimek24998102013-01-16 14:55:28 +000042 DEBUG(llvm::errs() << "---\n");
Manuel Klimek71814b42013-10-11 21:25:45 +000043 DEBUG(llvm::errs() << Code << "\n\n");
Daniel Jasperd246a5a2015-06-15 15:25:11 +000044 std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));
Krasimir Georgievbcda54b2017-04-21 14:35:20 +000045 FormattingAttemptStatus Status;
Manuel Klimekec5c3db2015-05-07 12:26:30 +000046 tooling::Replacements Replaces =
Krasimir Georgievbcda54b2017-04-21 14:35:20 +000047 reformat(Style, Code, Ranges, "<stdin>", &Status);
48 if (CheckComplete != SC_DoNotCheck) {
49 bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete;
50 EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete)
51 << Code << "\n\n";
Manuel Klimekec5c3db2015-05-07 12:26:30 +000052 }
Daniel Jasperec04c0d2013-05-16 10:40:07 +000053 ReplacementCount = Replaces.size();
Eric Liu4f8d9942016-07-11 13:53:12 +000054 auto Result = applyAllReplacements(Code, Replaces);
55 EXPECT_TRUE(static_cast<bool>(Result));
56 DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
57 return *Result;
Daniel Jasperf7935112012-12-03 18:12:45 +000058 }
59
Francois Ferranda6b6d512017-05-24 11:36:58 +000060 FormatStyle getStyleWithColumns(FormatStyle Style, unsigned ColumnLimit) {
Manuel Klimekb69e3c62013-01-02 18:33:23 +000061 Style.ColumnLimit = ColumnLimit;
62 return Style;
63 }
64
Francois Ferranda6b6d512017-05-24 11:36:58 +000065 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) {
66 return getStyleWithColumns(getLLVMStyle(), ColumnLimit);
67 }
68
Daniel Jasper1b750ed2013-01-14 16:24:39 +000069 FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) {
Francois Ferranda6b6d512017-05-24 11:36:58 +000070 return getStyleWithColumns(getGoogleStyle(), ColumnLimit);
Daniel Jasper1b750ed2013-01-14 16:24:39 +000071 }
72
Manuel Klimekb69e3c62013-01-02 18:33:23 +000073 void verifyFormat(llvm::StringRef Code,
74 const FormatStyle &Style = getLLVMStyle()) {
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000075 EXPECT_EQ(Code.str(), format(test::messUp(Code), Style));
Nico Weberd96ae862017-02-24 19:10:12 +000076 if (Style.Language == FormatStyle::LK_Cpp) {
77 // Objective-C++ is a superset of C++, so everything checked for C++
78 // needs to be checked for Objective-C++ as well.
79 FormatStyle ObjCStyle = Style;
80 ObjCStyle.Language = FormatStyle::LK_ObjC;
81 EXPECT_EQ(Code.str(), format(test::messUp(Code), ObjCStyle));
82 }
Daniel Jasperf7935112012-12-03 18:12:45 +000083 }
84
Manuel Klimekec5c3db2015-05-07 12:26:30 +000085 void verifyIncompleteFormat(llvm::StringRef Code,
86 const FormatStyle &Style = getLLVMStyle()) {
87 EXPECT_EQ(Code.str(),
Krasimir Georgievbcda54b2017-04-21 14:35:20 +000088 format(test::messUp(Code), Style, SC_ExpectIncomplete));
Manuel Klimekec5c3db2015-05-07 12:26:30 +000089 }
90
Daniel Jasperf7935112012-12-03 18:12:45 +000091 void verifyGoogleFormat(llvm::StringRef Code) {
Manuel Klimekb69e3c62013-01-02 18:33:23 +000092 verifyFormat(Code, getGoogleStyle());
Daniel Jasperf7935112012-12-03 18:12:45 +000093 }
Daniel Jasper5b49f472013-01-23 12:10:53 +000094
95 void verifyIndependentOfContext(llvm::StringRef text) {
96 verifyFormat(text);
97 verifyFormat(llvm::Twine("void f() { " + text + " }").str());
98 }
Daniel Jasper7b038a22013-01-30 09:46:12 +000099
Daniel Jasper675b4f82015-01-19 10:51:23 +0000100 /// \brief Verify that clang-format does not crash on the given input.
101 void verifyNoCrash(llvm::StringRef Code,
102 const FormatStyle &Style = getLLVMStyle()) {
Krasimir Georgievbcda54b2017-04-21 14:35:20 +0000103 format(Code, Style, SC_DoNotCheck);
Daniel Jasper675b4f82015-01-19 10:51:23 +0000104 }
105
Daniel Jasper7b038a22013-01-30 09:46:12 +0000106 int ReplacementCount;
Daniel Jasperf7935112012-12-03 18:12:45 +0000107};
108
Manuel Klimek52b15152013-01-09 15:25:02 +0000109TEST_F(FormatTest, MessUp) {
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +0000110 EXPECT_EQ("1 2 3", test::messUp("1 2 3"));
111 EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n"));
112 EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc"));
113 EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc"));
114 EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne"));
Manuel Klimek52b15152013-01-09 15:25:02 +0000115}
116
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000117//===----------------------------------------------------------------------===//
118// Basic function tests.
119//===----------------------------------------------------------------------===//
120
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +0000121TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) {
Daniel Jasperf7935112012-12-03 18:12:45 +0000122 EXPECT_EQ(";", format(";"));
123}
124
125TEST_F(FormatTest, FormatsGlobalStatementsAt0) {
126 EXPECT_EQ("int i;", format(" int i;"));
Alexander Kornienko9e649af2013-09-11 12:25:57 +0000127 EXPECT_EQ("\nint i;", format(" \n\t \v \f int i;"));
Daniel Jasperf7935112012-12-03 18:12:45 +0000128 EXPECT_EQ("int i;\nint j;", format(" int i; int j;"));
129 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;"));
130}
131
132TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) {
133 EXPECT_EQ("int i;", format("int\ni;"));
134}
135
136TEST_F(FormatTest, FormatsNestedBlockStatements) {
Manuel Klimeke7d10a12013-01-10 13:24:24 +0000137 EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}"));
Daniel Jasperf7935112012-12-03 18:12:45 +0000138}
139
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000140TEST_F(FormatTest, FormatsNestedCall) {
141 verifyFormat("Method(f1, f2(f3));");
142 verifyFormat("Method(f1(f2, f3()));");
Daniel Jasper48cb3b92013-01-13 08:19:51 +0000143 verifyFormat("Method(f1(f2, (f3())));");
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000144}
145
Daniel Jasper14556742013-02-07 21:08:36 +0000146TEST_F(FormatTest, NestedNameSpecifiers) {
Chandler Carruthf8b72662014-03-02 12:37:31 +0000147 verifyFormat("vector<::Type> v;");
Daniel Jasper14556742013-02-07 21:08:36 +0000148 verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())");
Daniel Jasper11be8ac2013-08-28 07:07:07 +0000149 verifyFormat("static constexpr bool Bar = decltype(bar())::value;");
Daniel Jasperf322eb52014-10-23 20:22:22 +0000150 verifyFormat("bool a = 2 < ::SomeFunction();");
Daniel Jasper23c2b5a2017-02-17 10:44:07 +0000151 verifyFormat("ALWAYS_INLINE ::std::string getName();");
152 verifyFormat("some::string getName();");
Daniel Jasper736c14f2013-01-16 07:19:28 +0000153}
154
Daniel Jasper7b038a22013-01-30 09:46:12 +0000155TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) {
156 EXPECT_EQ("if (a) {\n"
157 " f();\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000158 "}",
159 format("if(a){f();}"));
Daniel Jasper7b038a22013-01-30 09:46:12 +0000160 EXPECT_EQ(4, ReplacementCount);
161 EXPECT_EQ("if (a) {\n"
162 " f();\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000163 "}",
164 format("if (a) {\n"
165 " f();\n"
166 "}"));
Daniel Jasper7b038a22013-01-30 09:46:12 +0000167 EXPECT_EQ(0, ReplacementCount);
Daniel Jasperd6e61882015-06-17 12:23:15 +0000168 EXPECT_EQ("/*\r\n"
169 "\r\n"
170 "*/\r\n",
171 format("/*\r\n"
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +0000172 "\r\n"
173 "*/\r\n"));
Daniel Jasperd6e61882015-06-17 12:23:15 +0000174 EXPECT_EQ(0, ReplacementCount);
Daniel Jasper7b038a22013-01-30 09:46:12 +0000175}
176
Daniel Jasper1027c6e2013-06-03 16:16:41 +0000177TEST_F(FormatTest, RemovesEmptyLines) {
178 EXPECT_EQ("class C {\n"
179 " int i;\n"
180 "};",
181 format("class C {\n"
182 " int i;\n"
183 "\n"
184 "};"));
185
Nico Weber34272652014-11-13 16:25:37 +0000186 // Don't remove empty lines at the start of namespaces or extern "C" blocks.
Daniel Jasper01b35482014-03-21 13:03:33 +0000187 EXPECT_EQ("namespace N {\n"
188 "\n"
189 "int i;\n"
Krasimir Georgiev9163fe22017-03-02 09:54:44 +0000190 "}",
Daniel Jasper01b35482014-03-21 13:03:33 +0000191 format("namespace N {\n"
192 "\n"
193 "int i;\n"
Daniel Jaspera26fc5c2014-03-21 13:43:14 +0000194 "}",
195 getGoogleStyle()));
Nico Weber34272652014-11-13 16:25:37 +0000196 EXPECT_EQ("extern /**/ \"C\" /**/ {\n"
197 "\n"
198 "int i;\n"
199 "}",
200 format("extern /**/ \"C\" /**/ {\n"
201 "\n"
202 "int i;\n"
203 "}",
204 getGoogleStyle()));
205
206 // ...but do keep inlining and removing empty lines for non-block extern "C"
207 // functions.
208 verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle());
209 EXPECT_EQ("extern \"C\" int f() {\n"
210 " int i = 42;\n"
211 " return i;\n"
212 "}",
213 format("extern \"C\" int f() {\n"
214 "\n"
215 " int i = 42;\n"
216 " return i;\n"
217 "}",
218 getGoogleStyle()));
Daniel Jasper01b35482014-03-21 13:03:33 +0000219
Daniel Jasper11164bd2014-03-21 12:58:53 +0000220 // Remove empty lines at the beginning and end of blocks.
221 EXPECT_EQ("void f() {\n"
Daniel Jaspera26fc5c2014-03-21 13:43:14 +0000222 "\n"
223 " if (a) {\n"
224 "\n"
225 " f();\n"
226 " }\n"
227 "}",
228 format("void f() {\n"
229 "\n"
230 " if (a) {\n"
231 "\n"
232 " f();\n"
233 "\n"
234 " }\n"
235 "\n"
236 "}",
237 getLLVMStyle()));
238 EXPECT_EQ("void f() {\n"
Daniel Jasper11164bd2014-03-21 12:58:53 +0000239 " if (a) {\n"
240 " f();\n"
241 " }\n"
242 "}",
243 format("void f() {\n"
244 "\n"
245 " if (a) {\n"
246 "\n"
247 " f();\n"
248 "\n"
249 " }\n"
250 "\n"
Daniel Jaspera26fc5c2014-03-21 13:43:14 +0000251 "}",
252 getGoogleStyle()));
Daniel Jasper11164bd2014-03-21 12:58:53 +0000253
Daniel Jasper1027c6e2013-06-03 16:16:41 +0000254 // Don't remove empty lines in more complex control statements.
255 EXPECT_EQ("void f() {\n"
256 " if (a) {\n"
257 " f();\n"
258 "\n"
259 " } else if (b) {\n"
260 " f();\n"
261 " }\n"
262 "}",
263 format("void f() {\n"
264 " if (a) {\n"
265 " f();\n"
266 "\n"
267 " } else if (b) {\n"
268 " f();\n"
269 "\n"
270 " }\n"
271 "\n"
272 "}"));
273
274 // FIXME: This is slightly inconsistent.
Krasimir Georgiev32eaa862017-03-01 15:35:39 +0000275 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
276 LLVMWithNoNamespaceFix.FixNamespaceComments = false;
Daniel Jasper1027c6e2013-06-03 16:16:41 +0000277 EXPECT_EQ("namespace {\n"
278 "int i;\n"
279 "}",
280 format("namespace {\n"
281 "int i;\n"
282 "\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +0000283 "}", LLVMWithNoNamespaceFix));
284 EXPECT_EQ("namespace {\n"
285 "int i;\n"
Krasimir Georgiev9163fe22017-03-02 09:54:44 +0000286 "}",
Krasimir Georgiev32eaa862017-03-01 15:35:39 +0000287 format("namespace {\n"
288 "int i;\n"
289 "\n"
Daniel Jasper1027c6e2013-06-03 16:16:41 +0000290 "}"));
291 EXPECT_EQ("namespace {\n"
292 "int i;\n"
293 "\n"
294 "} // namespace",
295 format("namespace {\n"
296 "int i;\n"
297 "\n"
298 "} // namespace"));
Cameron Desrochers1991e5d2016-11-15 15:07:07 +0000299
300 FormatStyle Style = getLLVMStyle();
301 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
302 Style.MaxEmptyLinesToKeep = 2;
303 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
304 Style.BraceWrapping.AfterClass = true;
305 Style.BraceWrapping.AfterFunction = true;
306 Style.KeepEmptyLinesAtTheStartOfBlocks = false;
307
308 EXPECT_EQ("class Foo\n"
309 "{\n"
310 " Foo() {}\n"
311 "\n"
312 " void funk() {}\n"
313 "};",
314 format("class Foo\n"
315 "{\n"
316 " Foo()\n"
317 " {\n"
318 " }\n"
319 "\n"
320 " void funk() {}\n"
321 "};",
322 Style));
Daniel Jasper1027c6e2013-06-03 16:16:41 +0000323}
324
Nikola Smiljanice08a91e2014-05-08 00:05:13 +0000325TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) {
Daniel Jaspera44991332015-04-29 13:06:49 +0000326 verifyFormat("x = (a) and (b);");
327 verifyFormat("x = (a) or (b);");
328 verifyFormat("x = (a) bitand (b);");
329 verifyFormat("x = (a) bitor (b);");
330 verifyFormat("x = (a) not_eq (b);");
331 verifyFormat("x = (a) and_eq (b);");
332 verifyFormat("x = (a) or_eq (b);");
333 verifyFormat("x = (a) xor (b);");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +0000334}
335
Olivier Goffart90f981b2017-07-14 09:23:40 +0000336TEST_F(FormatTest, RecognizesUnaryOperatorKeywords) {
337 verifyFormat("x = compl(a);");
338 verifyFormat("x = not(a);");
339 verifyFormat("x = bitand(a);");
340 // Unary operator must not be merged with the next identifier
341 verifyFormat("x = compl a;");
342 verifyFormat("x = not a;");
343 verifyFormat("x = bitand a;");
344}
345
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000346//===----------------------------------------------------------------------===//
347// Tests for control statements.
348//===----------------------------------------------------------------------===//
349
Daniel Jaspercdd06622013-05-14 10:31:09 +0000350TEST_F(FormatTest, FormatIfWithoutCompoundStatement) {
Daniel Jasper1b750ed2013-01-14 16:24:39 +0000351 verifyFormat("if (true)\n f();\ng();");
352 verifyFormat("if (a)\n if (b)\n if (c)\n g();\nh();");
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000353 verifyFormat("if (a)\n if (b) {\n f();\n }\ng();");
Daniel Jasper6a7d5a72017-06-19 07:40:49 +0000354 verifyFormat("if constexpr (true)\n"
355 " f();\ng();");
356 verifyFormat("if constexpr (a)\n"
357 " if constexpr (b)\n"
358 " if constexpr (c)\n"
359 " g();\n"
360 "h();");
361 verifyFormat("if constexpr (a)\n"
362 " if constexpr (b) {\n"
363 " f();\n"
364 " }\n"
365 "g();");
Daniel Jasperced17f82013-01-16 15:44:34 +0000366
Daniel Jasper3a685df2013-05-16 12:12:21 +0000367 FormatStyle AllowsMergedIf = getLLVMStyle();
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +0000368 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left;
Daniel Jasperced17f82013-01-16 15:44:34 +0000369 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true;
370 verifyFormat("if (a)\n"
371 " // comment\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000372 " f();",
373 AllowsMergedIf);
Daniel Jasper40609472016-04-06 15:02:46 +0000374 verifyFormat("{\n"
375 " if (a)\n"
376 " label:\n"
377 " f();\n"
378 "}",
379 AllowsMergedIf);
Daniel Jasper2cce7b72016-04-06 16:41:39 +0000380 verifyFormat("#define A \\\n"
381 " if (a) \\\n"
382 " label: \\\n"
383 " f()",
384 AllowsMergedIf);
Daniel Jasper3a685df2013-05-16 12:12:21 +0000385 verifyFormat("if (a)\n"
386 " ;",
387 AllowsMergedIf);
388 verifyFormat("if (a)\n"
389 " if (b) return;",
390 AllowsMergedIf);
Daniel Jasperced17f82013-01-16 15:44:34 +0000391
Daniel Jasper3a685df2013-05-16 12:12:21 +0000392 verifyFormat("if (a) // Can't merge this\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000393 " f();\n",
394 AllowsMergedIf);
Daniel Jasperced17f82013-01-16 15:44:34 +0000395 verifyFormat("if (a) /* still don't merge */\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000396 " f();",
397 AllowsMergedIf);
Daniel Jasper3a685df2013-05-16 12:12:21 +0000398 verifyFormat("if (a) { // Never merge this\n"
Daniel Jasperced17f82013-01-16 15:44:34 +0000399 " f();\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000400 "}",
401 AllowsMergedIf);
Daniel Jaspereb65e912015-12-21 18:31:15 +0000402 verifyFormat("if (a) { /* Never merge this */\n"
Daniel Jasperced17f82013-01-16 15:44:34 +0000403 " f();\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000404 "}",
405 AllowsMergedIf);
Daniel Jasperced17f82013-01-16 15:44:34 +0000406
407 AllowsMergedIf.ColumnLimit = 14;
408 verifyFormat("if (a) return;", AllowsMergedIf);
Daniel Jasper3e9218e2013-01-14 16:02:06 +0000409 verifyFormat("if (aaaaaaaaa)\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000410 " return;",
411 AllowsMergedIf);
Daniel Jasperced17f82013-01-16 15:44:34 +0000412
413 AllowsMergedIf.ColumnLimit = 13;
414 verifyFormat("if (a)\n return;", AllowsMergedIf);
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000415}
416
Daniel Jasper3a685df2013-05-16 12:12:21 +0000417TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) {
418 FormatStyle AllowsMergedLoops = getLLVMStyle();
419 AllowsMergedLoops.AllowShortLoopsOnASingleLine = true;
420 verifyFormat("while (true) continue;", AllowsMergedLoops);
421 verifyFormat("for (;;) continue;", AllowsMergedLoops);
422 verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops);
423 verifyFormat("while (true)\n"
424 " ;",
425 AllowsMergedLoops);
426 verifyFormat("for (;;)\n"
427 " ;",
428 AllowsMergedLoops);
429 verifyFormat("for (;;)\n"
430 " for (;;) continue;",
431 AllowsMergedLoops);
432 verifyFormat("for (;;) // Can't merge this\n"
433 " continue;",
434 AllowsMergedLoops);
435 verifyFormat("for (;;) /* still don't merge */\n"
436 " continue;",
437 AllowsMergedLoops);
438}
439
Daniel Jasper17605d32014-05-14 09:33:35 +0000440TEST_F(FormatTest, FormatShortBracedStatements) {
441 FormatStyle AllowSimpleBracedStatements = getLLVMStyle();
Krasimir Georgiev3b0b50b2017-09-11 10:12:16 +0000442 AllowSimpleBracedStatements.ColumnLimit = 40;
Daniel Jasper17605d32014-05-14 09:33:35 +0000443 AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine = true;
444
445 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = true;
446 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
447
Krasimir Georgiev3b0b50b2017-09-11 10:12:16 +0000448 AllowSimpleBracedStatements.BreakBeforeBraces = FormatStyle::BS_Custom;
449 AllowSimpleBracedStatements.BraceWrapping.AfterFunction = true;
450 AllowSimpleBracedStatements.BraceWrapping.SplitEmptyRecord = false;
451
Daniel Jasper17605d32014-05-14 09:33:35 +0000452 verifyFormat("if (true) {}", AllowSimpleBracedStatements);
Daniel Jasper6a7d5a72017-06-19 07:40:49 +0000453 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements);
Daniel Jasper17605d32014-05-14 09:33:35 +0000454 verifyFormat("while (true) {}", AllowSimpleBracedStatements);
455 verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
456 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
Daniel Jasper6a7d5a72017-06-19 07:40:49 +0000457 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements);
Daniel Jasper17605d32014-05-14 09:33:35 +0000458 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
459 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
Krasimir Georgiev3b0b50b2017-09-11 10:12:16 +0000460 verifyFormat("if (true) {\n"
461 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
462 "}",
463 AllowSimpleBracedStatements);
Daniel Jasper17605d32014-05-14 09:33:35 +0000464 verifyFormat("if (true) { //\n"
465 " f();\n"
466 "}",
467 AllowSimpleBracedStatements);
468 verifyFormat("if (true) {\n"
469 " f();\n"
470 " f();\n"
471 "}",
472 AllowSimpleBracedStatements);
Daniel Jaspere9f53572015-04-30 09:24:17 +0000473 verifyFormat("if (true) {\n"
474 " f();\n"
475 "} else {\n"
476 " f();\n"
477 "}",
478 AllowSimpleBracedStatements);
Daniel Jasper17605d32014-05-14 09:33:35 +0000479
Daniel Jasperf92659e2017-06-19 07:45:41 +0000480 verifyFormat("struct A2 {\n"
481 " int X;\n"
482 "};",
483 AllowSimpleBracedStatements);
484 verifyFormat("typedef struct A2 {\n"
485 " int X;\n"
486 "} A2_t;",
487 AllowSimpleBracedStatements);
Daniel Jasperbd630732014-05-22 13:25:26 +0000488 verifyFormat("template <int> struct A2 {\n"
489 " struct B {};\n"
490 "};",
491 AllowSimpleBracedStatements);
492
Daniel Jasper17605d32014-05-14 09:33:35 +0000493 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = false;
Krasimir Georgiev3b0b50b2017-09-11 10:12:16 +0000494 verifyFormat("if (true) {}", AllowSimpleBracedStatements);
Daniel Jasper17605d32014-05-14 09:33:35 +0000495 verifyFormat("if (true) {\n"
496 " f();\n"
497 "}",
498 AllowSimpleBracedStatements);
Daniel Jaspere9f53572015-04-30 09:24:17 +0000499 verifyFormat("if (true) {\n"
500 " f();\n"
501 "} else {\n"
502 " f();\n"
503 "}",
504 AllowSimpleBracedStatements);
Daniel Jasper17605d32014-05-14 09:33:35 +0000505
506 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
Krasimir Georgiev3b0b50b2017-09-11 10:12:16 +0000507 verifyFormat("while (true) {}", AllowSimpleBracedStatements);
Daniel Jasper17605d32014-05-14 09:33:35 +0000508 verifyFormat("while (true) {\n"
509 " f();\n"
510 "}",
511 AllowSimpleBracedStatements);
Krasimir Georgiev3b0b50b2017-09-11 10:12:16 +0000512 verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
Daniel Jasper17605d32014-05-14 09:33:35 +0000513 verifyFormat("for (;;) {\n"
514 " f();\n"
515 "}",
516 AllowSimpleBracedStatements);
Krasimir Georgiev3b0b50b2017-09-11 10:12:16 +0000517
518 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = true;
519 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
520 AllowSimpleBracedStatements.BraceWrapping.AfterControlStatement = true;
521
522 verifyFormat("if (true) {}", AllowSimpleBracedStatements);
523 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements);
524 verifyFormat("while (true) {}", AllowSimpleBracedStatements);
525 verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
526 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
527 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements);
528 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
529 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
530 verifyFormat("if (true)\n"
531 "{\n"
532 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
533 "}",
534 AllowSimpleBracedStatements);
535 verifyFormat("if (true)\n"
536 "{ //\n"
537 " f();\n"
538 "}",
539 AllowSimpleBracedStatements);
540 verifyFormat("if (true)\n"
541 "{\n"
542 " f();\n"
543 " f();\n"
544 "}",
545 AllowSimpleBracedStatements);
546 verifyFormat("if (true)\n"
547 "{\n"
548 " f();\n"
549 "} else\n"
550 "{\n"
551 " f();\n"
552 "}",
553 AllowSimpleBracedStatements);
554
555 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = false;
556 verifyFormat("if (true) {}", AllowSimpleBracedStatements);
557 verifyFormat("if (true)\n"
558 "{\n"
559 " f();\n"
560 "}",
561 AllowSimpleBracedStatements);
562 verifyFormat("if (true)\n"
563 "{\n"
564 " f();\n"
565 "} else\n"
566 "{\n"
567 " f();\n"
568 "}",
569 AllowSimpleBracedStatements);
570
571 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
572 verifyFormat("while (true) {}", AllowSimpleBracedStatements);
573 verifyFormat("while (true)\n"
574 "{\n"
575 " f();\n"
576 "}",
577 AllowSimpleBracedStatements);
578 verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
579 verifyFormat("for (;;)\n"
580 "{\n"
581 " f();\n"
582 "}",
583 AllowSimpleBracedStatements);
Daniel Jasper17605d32014-05-14 09:33:35 +0000584}
585
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000586TEST_F(FormatTest, ParseIfElse) {
587 verifyFormat("if (true)\n"
588 " if (true)\n"
589 " if (true)\n"
590 " f();\n"
591 " else\n"
592 " g();\n"
593 " else\n"
594 " h();\n"
595 "else\n"
596 " i();");
597 verifyFormat("if (true)\n"
598 " if (true)\n"
599 " if (true) {\n"
Daniel Jasper1b750ed2013-01-14 16:24:39 +0000600 " if (true)\n"
601 " f();\n"
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000602 " } else {\n"
603 " g();\n"
604 " }\n"
605 " else\n"
606 " h();\n"
607 "else {\n"
608 " i();\n"
609 "}");
Daniel Jasper6a7d5a72017-06-19 07:40:49 +0000610 verifyFormat("if (true)\n"
611 " if constexpr (true)\n"
612 " if (true) {\n"
613 " if constexpr (true)\n"
614 " f();\n"
615 " } else {\n"
616 " g();\n"
617 " }\n"
618 " else\n"
619 " h();\n"
620 "else {\n"
621 " i();\n"
622 "}");
Daniel Jasper88f92222013-09-17 08:28:05 +0000623 verifyFormat("void f() {\n"
624 " if (a) {\n"
625 " } else {\n"
626 " }\n"
627 "}");
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000628}
629
630TEST_F(FormatTest, ElseIf) {
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000631 verifyFormat("if (a) {\n} else if (b) {\n}");
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000632 verifyFormat("if (a)\n"
633 " f();\n"
634 "else if (b)\n"
635 " g();\n"
636 "else\n"
637 " h();");
Daniel Jasper6a7d5a72017-06-19 07:40:49 +0000638 verifyFormat("if constexpr (a)\n"
639 " f();\n"
640 "else if constexpr (b)\n"
641 " g();\n"
642 "else\n"
643 " h();");
Daniel Jasper16fc7542013-10-30 14:04:10 +0000644 verifyFormat("if (a) {\n"
645 " f();\n"
646 "}\n"
647 "// or else ..\n"
648 "else {\n"
649 " g()\n"
650 "}");
Daniel Jasper8acf8222014-05-07 09:23:05 +0000651
652 verifyFormat("if (a) {\n"
653 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
654 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
655 "}");
Daniel Jaspera42de762015-02-26 09:49:08 +0000656 verifyFormat("if (a) {\n"
657 "} else if (\n"
658 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
659 "}",
660 getLLVMStyleWithColumns(62));
Daniel Jasper6a7d5a72017-06-19 07:40:49 +0000661 verifyFormat("if (a) {\n"
662 "} else if constexpr (\n"
663 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
664 "}",
665 getLLVMStyleWithColumns(62));
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000666}
667
Daniel Jasperf7935112012-12-03 18:12:45 +0000668TEST_F(FormatTest, FormatsForLoop) {
669 verifyFormat(
670 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n"
Alexander Kornienko37d6c942012-12-05 15:06:06 +0000671 " ++VeryVeryLongLoopVariable)\n"
672 " ;");
673 verifyFormat("for (;;)\n"
674 " f();");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000675 verifyFormat("for (;;) {\n}");
Alexander Kornienko37d6c942012-12-05 15:06:06 +0000676 verifyFormat("for (;;) {\n"
677 " f();\n"
678 "}");
Daniel Jasper72463d32013-05-03 14:50:50 +0000679 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}");
Daniel Jasperfbde69e2012-12-21 14:37:20 +0000680
681 verifyFormat(
682 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
683 " E = UnwrappedLines.end();\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000684 " I != E; ++I) {\n}");
Daniel Jasperfbde69e2012-12-21 14:37:20 +0000685
686 verifyFormat(
687 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000688 " ++IIIII) {\n}");
Daniel Jaspera628c982013-04-03 13:36:17 +0000689 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n"
690 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000691 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}");
Daniel Jasper37905f72013-02-21 15:00:29 +0000692 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n"
693 " I = FD->getDeclsInPrototypeScope().begin(),\n"
694 " E = FD->getDeclsInPrototypeScope().end();\n"
695 " I != E; ++I) {\n}");
Daniel Jasperd6e09e82015-05-19 11:51:39 +0000696 verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n"
697 " I = Container.begin(),\n"
698 " E = Container.end();\n"
699 " I != E; ++I) {\n}",
700 getLLVMStyleWithColumns(76));
Daniel Jasper48c62f92013-01-28 17:30:17 +0000701
Daniel Jasper48c62f92013-01-28 17:30:17 +0000702 verifyFormat(
703 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
704 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n"
Daniel Jasper98f8ae32015-03-06 10:57:12 +0000705 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
706 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
Daniel Jasper48c62f92013-01-28 17:30:17 +0000707 " ++aaaaaaaaaaa) {\n}");
Daniel Jasper98f8ae32015-03-06 10:57:12 +0000708 verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
709 " bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n"
710 " ++i) {\n}");
Daniel Jasper2cf17bf2013-02-27 09:47:53 +0000711 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n"
712 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
713 "}");
Daniel Jaspera628c982013-04-03 13:36:17 +0000714 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n"
715 " aaaaaaaaaa);\n"
716 " iter; ++iter) {\n"
717 "}");
Daniel Jasper3bacc4d2015-07-07 16:09:39 +0000718 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
719 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
720 " aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n"
721 " ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {");
Daniel Jasperf7f13c02013-02-04 07:30:30 +0000722
Daniel Jasper2cf17bf2013-02-27 09:47:53 +0000723 FormatStyle NoBinPacking = getLLVMStyle();
724 NoBinPacking.BinPackParameters = false;
725 verifyFormat("for (int aaaaaaaaaaa = 1;\n"
726 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n"
727 " aaaaaaaaaaaaaaaa,\n"
728 " aaaaaaaaaaaaaaaa,\n"
729 " aaaaaaaaaaaaaaaa);\n"
730 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
731 "}",
732 NoBinPacking);
733 verifyFormat(
Daniel Jaspercd8599e2013-02-23 21:01:55 +0000734 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
735 " E = UnwrappedLines.end();\n"
736 " I != E;\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +0000737 " ++I) {\n}",
738 NoBinPacking);
Daniel Jasper7b85a192017-09-03 08:56:24 +0000739
740 FormatStyle AlignLeft = getLLVMStyle();
741 AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
742 verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft);
Daniel Jasperf7935112012-12-03 18:12:45 +0000743}
744
Daniel Jasper0b41cbb2013-01-28 13:21:16 +0000745TEST_F(FormatTest, RangeBasedForLoops) {
746 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
747 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
748 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n"
749 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}");
Daniel Jasper16b35622013-02-26 13:18:08 +0000750 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n"
751 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasper9cc3e972014-02-07 10:09:46 +0000752 verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n"
753 " aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}");
Daniel Jasper0b41cbb2013-01-28 13:21:16 +0000754}
755
Daniel Jaspere1e43192014-04-01 12:55:11 +0000756TEST_F(FormatTest, ForEachLoops) {
757 verifyFormat("void f() {\n"
758 " foreach (Item *item, itemlist) {}\n"
759 " Q_FOREACH (Item *item, itemlist) {}\n"
760 " BOOST_FOREACH (Item *item, itemlist) {}\n"
761 " UNKNOWN_FORACH(Item * item, itemlist) {}\n"
762 "}");
Daniel Jasper229628b2015-06-11 08:38:19 +0000763
764 // As function-like macros.
765 verifyFormat("#define foreach(x, y)\n"
766 "#define Q_FOREACH(x, y)\n"
767 "#define BOOST_FOREACH(x, y)\n"
768 "#define UNKNOWN_FOREACH(x, y)\n");
769
770 // Not as function-like macros.
771 verifyFormat("#define foreach (x, y)\n"
772 "#define Q_FOREACH (x, y)\n"
773 "#define BOOST_FOREACH (x, y)\n"
774 "#define UNKNOWN_FOREACH (x, y)\n");
Daniel Jaspere1e43192014-04-01 12:55:11 +0000775}
776
Daniel Jasperf7935112012-12-03 18:12:45 +0000777TEST_F(FormatTest, FormatsWhileLoop) {
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000778 verifyFormat("while (true) {\n}");
Alexander Kornienko37d6c942012-12-05 15:06:06 +0000779 verifyFormat("while (true)\n"
780 " f();");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000781 verifyFormat("while () {\n}");
Alexander Kornienko37d6c942012-12-05 15:06:06 +0000782 verifyFormat("while () {\n"
783 " f();\n"
784 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +0000785}
786
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000787TEST_F(FormatTest, FormatsDoWhile) {
788 verifyFormat("do {\n"
789 " do_something();\n"
790 "} while (something());");
791 verifyFormat("do\n"
792 " do_something();\n"
793 "while (something());");
Daniel Jasperf7935112012-12-03 18:12:45 +0000794}
795
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000796TEST_F(FormatTest, FormatsSwitchStatement) {
Daniel Jasperf7935112012-12-03 18:12:45 +0000797 verifyFormat("switch (x) {\n"
798 "case 1:\n"
799 " f();\n"
800 " break;\n"
801 "case kFoo:\n"
802 "case ns::kBar:\n"
803 "case kBaz:\n"
804 " break;\n"
805 "default:\n"
806 " g();\n"
807 " break;\n"
808 "}");
809 verifyFormat("switch (x) {\n"
810 "case 1: {\n"
811 " f();\n"
812 " break;\n"
813 "}\n"
Daniel Jasper922349c2014-04-04 06:46:23 +0000814 "case 2: {\n"
815 " break;\n"
816 "}\n"
Daniel Jasperf7935112012-12-03 18:12:45 +0000817 "}");
Nico Webera5510af2013-01-18 05:50:57 +0000818 verifyFormat("switch (x) {\n"
819 "case 1: {\n"
820 " f();\n"
821 " {\n"
822 " g();\n"
823 " h();\n"
824 " }\n"
825 " break;\n"
826 "}\n"
827 "}");
828 verifyFormat("switch (x) {\n"
829 "case 1: {\n"
830 " f();\n"
831 " if (foo) {\n"
832 " g();\n"
833 " h();\n"
834 " }\n"
835 " break;\n"
836 "}\n"
837 "}");
838 verifyFormat("switch (x) {\n"
839 "case 1: {\n"
840 " f();\n"
841 " g();\n"
842 "} break;\n"
843 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +0000844 verifyFormat("switch (test)\n"
845 " ;");
Daniel Jasper18104652013-03-12 12:26:55 +0000846 verifyFormat("switch (x) {\n"
847 "default: {\n"
848 " // Do nothing.\n"
Manuel Klimek1a18c402013-04-12 14:13:36 +0000849 "}\n"
Daniel Jasper18104652013-03-12 12:26:55 +0000850 "}");
Daniel Jasper0f8ed9e2013-03-13 15:53:12 +0000851 verifyFormat("switch (x) {\n"
Daniel Jasperb67cc422013-04-09 17:46:55 +0000852 "// comment\n"
Daniel Jasper0f8ed9e2013-03-13 15:53:12 +0000853 "// if 1, do f()\n"
854 "case 1:\n"
855 " f();\n"
856 "}");
Daniel Jasper2bd32ca2013-03-19 18:33:58 +0000857 verifyFormat("switch (x) {\n"
858 "case 1:\n"
859 " // Do amazing stuff\n"
860 " {\n"
861 " f();\n"
862 " g();\n"
863 " }\n"
864 " break;\n"
865 "}");
Daniel Jaspera1275122013-03-20 10:23:53 +0000866 verifyFormat("#define A \\\n"
867 " switch (x) { \\\n"
868 " case a: \\\n"
869 " foo = b; \\\n"
Daniel Jaspera44991332015-04-29 13:06:49 +0000870 " }",
871 getLLVMStyleWithColumns(20));
Daniel Jasper72407622013-09-02 08:26:29 +0000872 verifyFormat("#define OPERATION_CASE(name) \\\n"
873 " case OP_name: \\\n"
874 " return operations::Operation##name\n",
875 getLLVMStyleWithColumns(40));
Daniel Jasper1fe0d5c2015-05-06 15:19:47 +0000876 verifyFormat("switch (x) {\n"
877 "case 1:;\n"
878 "default:;\n"
879 " int i;\n"
880 "}");
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000881
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000882 verifyGoogleFormat("switch (x) {\n"
883 " case 1:\n"
884 " f();\n"
885 " break;\n"
886 " case kFoo:\n"
887 " case ns::kBar:\n"
888 " case kBaz:\n"
889 " break;\n"
890 " default:\n"
891 " g();\n"
892 " break;\n"
893 "}");
894 verifyGoogleFormat("switch (x) {\n"
895 " case 1: {\n"
896 " f();\n"
897 " break;\n"
898 " }\n"
899 "}");
900 verifyGoogleFormat("switch (test)\n"
Daniel Jasper516d7972013-07-25 11:31:57 +0000901 " ;");
902
903 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n"
904 " case OP_name: \\\n"
905 " return operations::Operation##name\n");
906 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n"
907 " // Get the correction operation class.\n"
908 " switch (OpCode) {\n"
909 " CASE(Add);\n"
910 " CASE(Subtract);\n"
911 " default:\n"
912 " return operations::Unknown;\n"
913 " }\n"
914 "#undef OPERATION_CASE\n"
915 "}");
Daniel Jasper1c5d9df2013-09-06 07:54:20 +0000916 verifyFormat("DEBUG({\n"
917 " switch (x) {\n"
918 " case A:\n"
919 " f();\n"
920 " break;\n"
Krasimir Georgieve0926342017-07-12 15:21:43 +0000921 " // fallthrough\n"
Daniel Jasper1c5d9df2013-09-06 07:54:20 +0000922 " case B:\n"
923 " g();\n"
924 " break;\n"
925 " }\n"
926 "});");
Krasimir Georgieve0926342017-07-12 15:21:43 +0000927 EXPECT_EQ("DEBUG({\n"
928 " switch (x) {\n"
929 " case A:\n"
930 " f();\n"
931 " break;\n"
932 " // On B:\n"
933 " case B:\n"
934 " g();\n"
935 " break;\n"
936 " }\n"
937 "});",
938 format("DEBUG({\n"
939 " switch (x) {\n"
940 " case A:\n"
941 " f();\n"
942 " break;\n"
943 " // On B:\n"
944 " case B:\n"
945 " g();\n"
946 " break;\n"
947 " }\n"
948 "});",
949 getLLVMStyle()));
Daniel Jasper031e2402014-04-28 07:48:36 +0000950 verifyFormat("switch (a) {\n"
951 "case (b):\n"
952 " return;\n"
953 "}");
Daniel Jasperd39312ec2014-05-28 10:09:11 +0000954
955 verifyFormat("switch (a) {\n"
956 "case some_namespace::\n"
957 " some_constant:\n"
958 " return;\n"
959 "}",
960 getLLVMStyleWithColumns(34));
Daniel Jasperf7935112012-12-03 18:12:45 +0000961}
962
Daniel Jasper2d0cd492013-10-20 16:56:16 +0000963TEST_F(FormatTest, CaseRanges) {
964 verifyFormat("switch (x) {\n"
965 "case 'A' ... 'Z':\n"
966 "case 1 ... 5:\n"
Daniel Jaspere2fab132016-05-19 06:19:17 +0000967 "case a ... b:\n"
Daniel Jasper2d0cd492013-10-20 16:56:16 +0000968 " break;\n"
969 "}");
970}
971
Daniel Jasperb87899b2014-09-10 13:11:45 +0000972TEST_F(FormatTest, ShortCaseLabels) {
973 FormatStyle Style = getLLVMStyle();
974 Style.AllowShortCaseLabelsOnASingleLine = true;
975 verifyFormat("switch (a) {\n"
976 "case 1: x = 1; break;\n"
977 "case 2: return;\n"
978 "case 3:\n"
979 "case 4:\n"
980 "case 5: return;\n"
Daniel Jasperd081e882014-11-21 12:36:25 +0000981 "case 6: // comment\n"
982 " return;\n"
983 "case 7:\n"
984 " // comment\n"
985 " return;\n"
Daniel Jasper368369b2015-09-21 09:50:01 +0000986 "case 8:\n"
987 " x = 8; // comment\n"
988 " break;\n"
Daniel Jasperb87899b2014-09-10 13:11:45 +0000989 "default: y = 1; break;\n"
990 "}",
991 Style);
992 verifyFormat("switch (a) {\n"
Francois Ferranda64ba702017-07-28 07:56:18 +0000993 "case 0: return; // comment\n"
994 "case 1: break; // comment\n"
995 "case 2: return;\n"
996 "// comment\n"
997 "case 3: return;\n"
998 "// comment 1\n"
999 "// comment 2\n"
1000 "// comment 3\n"
1001 "case 4: break; /* comment */\n"
1002 "case 5:\n"
1003 " // comment\n"
1004 " break;\n"
1005 "case 6: /* comment */ x = 1; break;\n"
1006 "case 7: x = /* comment */ 1; break;\n"
1007 "case 8:\n"
1008 " x = 1; /* comment */\n"
1009 " break;\n"
1010 "case 9:\n"
1011 " break; // comment line 1\n"
1012 " // comment line 2\n"
1013 "}",
1014 Style);
1015 EXPECT_EQ("switch (a) {\n"
1016 "case 1:\n"
1017 " x = 8;\n"
1018 " // fall through\n"
1019 "case 2: x = 8;\n"
1020 "// comment\n"
1021 "case 3:\n"
1022 " return; /* comment line 1\n"
1023 " * comment line 2 */\n"
1024 "case 4: i = 8;\n"
1025 "// something else\n"
1026 "#if FOO\n"
1027 "case 5: break;\n"
1028 "#endif\n"
1029 "}",
1030 format("switch (a) {\n"
1031 "case 1: x = 8;\n"
1032 " // fall through\n"
1033 "case 2:\n"
1034 " x = 8;\n"
1035 "// comment\n"
1036 "case 3:\n"
1037 " return; /* comment line 1\n"
1038 " * comment line 2 */\n"
1039 "case 4:\n"
1040 " i = 8;\n"
1041 "// something else\n"
1042 "#if FOO\n"
1043 "case 5: break;\n"
1044 "#endif\n"
1045 "}",
1046 Style));
1047 EXPECT_EQ("switch (a) {\n" "case 0:\n"
1048 " return; // long long long long long long long long long long long long comment\n"
1049 " // line\n" "}",
1050 format("switch (a) {\n"
1051 "case 0: return; // long long long long long long long long long long long long comment line\n"
1052 "}",
1053 Style));
1054 EXPECT_EQ("switch (a) {\n"
1055 "case 0:\n"
1056 " return; /* long long long long long long long long long long long long comment\n"
1057 " line */\n"
1058 "}",
1059 format("switch (a) {\n"
1060 "case 0: return; /* long long long long long long long long long long long long comment line */\n"
1061 "}",
1062 Style));
1063 verifyFormat("switch (a) {\n"
Daniel Jasper79f226e2014-11-23 21:45:03 +00001064 "#if FOO\n"
1065 "case 0: return 0;\n"
1066 "#endif\n"
1067 "}",
1068 Style);
1069 verifyFormat("switch (a) {\n"
Daniel Jasperb87899b2014-09-10 13:11:45 +00001070 "case 1: {\n"
1071 "}\n"
1072 "case 2: {\n"
1073 " return;\n"
1074 "}\n"
1075 "case 3: {\n"
1076 " x = 1;\n"
1077 " return;\n"
1078 "}\n"
1079 "case 4:\n"
1080 " if (x)\n"
1081 " return;\n"
1082 "}",
1083 Style);
1084 Style.ColumnLimit = 21;
1085 verifyFormat("switch (a) {\n"
1086 "case 1: x = 1; break;\n"
1087 "case 2: return;\n"
1088 "case 3:\n"
1089 "case 4:\n"
1090 "case 5: return;\n"
1091 "default:\n"
1092 " y = 1;\n"
1093 " break;\n"
1094 "}",
1095 Style);
1096}
1097
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001098TEST_F(FormatTest, FormatsLabels) {
Daniel Jasperf7935112012-12-03 18:12:45 +00001099 verifyFormat("void f() {\n"
1100 " some_code();\n"
1101 "test_label:\n"
1102 " some_other_code();\n"
1103 " {\n"
1104 " some_more_code();\n"
1105 " another_label:\n"
1106 " some_more_code();\n"
1107 " }\n"
1108 "}");
Daniel Jasper676e5162015-04-07 14:36:33 +00001109 verifyFormat("{\n"
1110 " some_code();\n"
Daniel Jasperf7935112012-12-03 18:12:45 +00001111 "test_label:\n"
Daniel Jasper676e5162015-04-07 14:36:33 +00001112 " some_other_code();\n"
1113 "}");
Daniel Jasper1fe0d5c2015-05-06 15:19:47 +00001114 verifyFormat("{\n"
1115 " some_code();\n"
1116 "test_label:;\n"
1117 " int i = 0;\n"
1118 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +00001119}
1120
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001121//===----------------------------------------------------------------------===//
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001122// Tests for classes, namespaces, etc.
1123//===----------------------------------------------------------------------===//
1124
1125TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) {
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001126 verifyFormat("class A {};");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001127}
1128
1129TEST_F(FormatTest, UnderstandsAccessSpecifiers) {
1130 verifyFormat("class A {\n"
1131 "public:\n"
Daniel Jasperc04baae2013-04-10 09:49:49 +00001132 "public: // comment\n"
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001133 "protected:\n"
1134 "private:\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00001135 " void f() {}\n"
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001136 "};");
1137 verifyGoogleFormat("class A {\n"
1138 " public:\n"
1139 " protected:\n"
1140 " private:\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00001141 " void f() {}\n"
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001142 "};");
Daniel Jasper84c47a12013-11-23 17:53:41 +00001143 verifyFormat("class A {\n"
1144 "public slots:\n"
Daniel Jaspera00de632015-12-01 12:05:04 +00001145 " void f1() {}\n"
Daniel Jasper1556b592013-11-29 08:51:56 +00001146 "public Q_SLOTS:\n"
Daniel Jaspera00de632015-12-01 12:05:04 +00001147 " void f2() {}\n"
1148 "protected slots:\n"
1149 " void f3() {}\n"
1150 "protected Q_SLOTS:\n"
1151 " void f4() {}\n"
1152 "private slots:\n"
1153 " void f5() {}\n"
1154 "private Q_SLOTS:\n"
1155 " void f6() {}\n"
Daniel Jasper53395402015-04-07 15:04:40 +00001156 "signals:\n"
Daniel Jaspera00de632015-12-01 12:05:04 +00001157 " void g1();\n"
1158 "Q_SIGNALS:\n"
1159 " void g2();\n"
Daniel Jasper84c47a12013-11-23 17:53:41 +00001160 "};");
Daniel Jasperde0d1f32015-04-24 07:50:34 +00001161
1162 // Don't interpret 'signals' the wrong way.
1163 verifyFormat("signals.set();");
1164 verifyFormat("for (Signals signals : f()) {\n}");
Daniel Jasper03618142015-05-06 19:21:23 +00001165 verifyFormat("{\n"
1166 " signals.set(); // This needs indentation.\n"
1167 "}");
Daniel Jasper31343832016-07-27 10:13:24 +00001168 verifyFormat("void f() {\n"
1169 "label:\n"
1170 " signals.baz();\n"
1171 "}");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001172}
1173
Alexander Kornienkofd433362013-03-27 17:08:02 +00001174TEST_F(FormatTest, SeparatesLogicalBlocks) {
1175 EXPECT_EQ("class A {\n"
1176 "public:\n"
1177 " void f();\n"
1178 "\n"
1179 "private:\n"
1180 " void g() {}\n"
1181 " // test\n"
1182 "protected:\n"
1183 " int h;\n"
1184 "};",
1185 format("class A {\n"
1186 "public:\n"
1187 "void f();\n"
1188 "private:\n"
1189 "void g() {}\n"
1190 "// test\n"
1191 "protected:\n"
1192 "int h;\n"
1193 "};"));
Daniel Jasper320997e2013-10-06 11:40:08 +00001194 EXPECT_EQ("class A {\n"
1195 "protected:\n"
1196 "public:\n"
1197 " void f();\n"
1198 "};",
1199 format("class A {\n"
1200 "protected:\n"
1201 "\n"
1202 "public:\n"
1203 "\n"
1204 " void f();\n"
1205 "};"));
Daniel Jasperac5c97e32015-03-09 08:13:55 +00001206
1207 // Even ensure proper spacing inside macros.
1208 EXPECT_EQ("#define B \\\n"
1209 " class A { \\\n"
1210 " protected: \\\n"
1211 " public: \\\n"
1212 " void f(); \\\n"
1213 " };",
1214 format("#define B \\\n"
1215 " class A { \\\n"
1216 " protected: \\\n"
1217 " \\\n"
1218 " public: \\\n"
1219 " \\\n"
1220 " void f(); \\\n"
1221 " };",
1222 getGoogleStyle()));
1223 // But don't remove empty lines after macros ending in access specifiers.
1224 EXPECT_EQ("#define A private:\n"
1225 "\n"
1226 "int i;",
1227 format("#define A private:\n"
1228 "\n"
1229 "int i;"));
Alexander Kornienkofd433362013-03-27 17:08:02 +00001230}
1231
Daniel Jasper83193602013-04-05 17:22:09 +00001232TEST_F(FormatTest, FormatsClasses) {
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001233 verifyFormat("class A : public B {};");
1234 verifyFormat("class A : public ::B {};");
Daniel Jaspereead02b2013-02-14 08:42:54 +00001235
1236 verifyFormat(
1237 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001238 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
Daniel Jaspera61aefb2013-05-06 06:45:09 +00001239 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
1240 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001241 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
Daniel Jaspereead02b2013-02-14 08:42:54 +00001242 verifyFormat(
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001243 "class A : public B, public C, public D, public E, public F {};");
Daniel Jaspereead02b2013-02-14 08:42:54 +00001244 verifyFormat("class AAAAAAAAAAAA : public B,\n"
1245 " public C,\n"
1246 " public D,\n"
1247 " public E,\n"
1248 " public F,\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001249 " public G {};");
Daniel Jasper83193602013-04-05 17:22:09 +00001250
1251 verifyFormat("class\n"
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00001252 " ReallyReallyLongClassName {\n"
1253 " int i;\n"
1254 "};",
Daniel Jasper83193602013-04-05 17:22:09 +00001255 getLLVMStyleWithColumns(32));
Daniel Jasperf9a5e402013-10-08 16:24:07 +00001256 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n"
1257 " aaaaaaaaaaaaaaaa> {};");
1258 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n"
1259 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n"
1260 " aaaaaaaaaaaaaaaaaaaaaa> {};");
Daniel Jasper3a122c02014-02-14 18:22:40 +00001261 verifyFormat("template <class R, class C>\n"
1262 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n"
1263 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};");
Manuel Klimek45bf56c2014-07-31 07:19:30 +00001264 verifyFormat("class ::A::B {};");
Daniel Jasperf7935112012-12-03 18:12:45 +00001265}
1266
Andi-Bogdan Postelnicu0ef8ee12017-03-10 15:10:37 +00001267TEST_F(FormatTest, BreakBeforeInheritanceComma) {
1268 FormatStyle StyleWithInheritanceBreak = getLLVMStyle();
1269 StyleWithInheritanceBreak.BreakBeforeInheritanceComma = true;
1270
1271 verifyFormat("class MyClass : public X {};", StyleWithInheritanceBreak);
1272 verifyFormat("class MyClass\n"
1273 " : public X\n"
1274 " , public Y {};",
1275 StyleWithInheritanceBreak);
1276}
1277
Manuel Klimek28cacc72013-01-07 18:10:23 +00001278TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) {
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00001279 verifyFormat("class A {\n} a, b;");
1280 verifyFormat("struct A {\n} a, b;");
1281 verifyFormat("union A {\n} a;");
Manuel Klimek28cacc72013-01-07 18:10:23 +00001282}
1283
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001284TEST_F(FormatTest, FormatsEnum) {
Alexander Kornienkob7076a22012-12-04 14:46:19 +00001285 verifyFormat("enum {\n"
1286 " Zero,\n"
1287 " One = 1,\n"
1288 " Two = One + 1,\n"
1289 " Three = (One + Two),\n"
1290 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1291 " Five = (One, Two, Three, Four, 5)\n"
1292 "};");
Daniel Jasper015ed022013-09-13 09:20:45 +00001293 verifyGoogleFormat("enum {\n"
1294 " Zero,\n"
1295 " One = 1,\n"
1296 " Two = One + 1,\n"
1297 " Three = (One + Two),\n"
1298 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1299 " Five = (One, Two, Three, Four, 5)\n"
1300 "};");
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001301 verifyFormat("enum Enum {};");
1302 verifyFormat("enum {};");
Daniel Jasper015ed022013-09-13 09:20:45 +00001303 verifyFormat("enum X E {} d;");
1304 verifyFormat("enum __attribute__((...)) E {} d;");
1305 verifyFormat("enum __declspec__((...)) E {} d;");
Daniel Jasper015ed022013-09-13 09:20:45 +00001306 verifyFormat("enum {\n"
1307 " Bar = Foo<int, int>::value\n"
Daniel Jasper96972812014-01-05 12:38:10 +00001308 "};",
1309 getLLVMStyleWithColumns(30));
1310
1311 verifyFormat("enum ShortEnum { A, B, C };");
Daniel Jasper1a148b42014-01-05 13:23:23 +00001312 verifyGoogleFormat("enum ShortEnum { A, B, C };");
Daniel Jaspera69ca9b2014-06-04 12:40:57 +00001313
1314 EXPECT_EQ("enum KeepEmptyLines {\n"
1315 " ONE,\n"
1316 "\n"
1317 " TWO,\n"
1318 "\n"
1319 " THREE\n"
1320 "}",
1321 format("enum KeepEmptyLines {\n"
1322 " ONE,\n"
1323 "\n"
1324 " TWO,\n"
1325 "\n"
1326 "\n"
1327 " THREE\n"
1328 "}"));
Daniel Jasper90818052014-06-10 10:42:26 +00001329 verifyFormat("enum E { // comment\n"
1330 " ONE,\n"
1331 " TWO\n"
Daniel Jasper502fac32014-11-05 10:55:36 +00001332 "};\n"
1333 "int i;");
Daniel Jasper47721ac2015-06-18 15:45:17 +00001334 // Not enums.
1335 verifyFormat("enum X f() {\n"
1336 " a();\n"
1337 " return 42;\n"
1338 "}");
Daniel Jasperb5a0b852015-06-19 08:17:32 +00001339 verifyFormat("enum X Type::f() {\n"
1340 " a();\n"
1341 " return 42;\n"
1342 "}");
Daniel Jasper47721ac2015-06-18 15:45:17 +00001343 verifyFormat("enum ::X f() {\n"
1344 " a();\n"
1345 " return 42;\n"
1346 "}");
1347 verifyFormat("enum ns::X f() {\n"
1348 " a();\n"
1349 " return 42;\n"
1350 "}");
Alexander Kornienkob7076a22012-12-04 14:46:19 +00001351}
1352
Daniel Jasperb7150872013-08-30 10:10:19 +00001353TEST_F(FormatTest, FormatsEnumsWithErrors) {
1354 verifyFormat("enum Type {\n"
Daniel Jasper96972812014-01-05 12:38:10 +00001355 " One = 0; // These semicolons should be commas.\n"
Daniel Jasperb7150872013-08-30 10:10:19 +00001356 " Two = 1;\n"
1357 "};");
1358 verifyFormat("namespace n {\n"
1359 "enum Type {\n"
1360 " One,\n"
Daniel Jasper96972812014-01-05 12:38:10 +00001361 " Two, // missing };\n"
Daniel Jasperb7150872013-08-30 10:10:19 +00001362 " int i;\n"
1363 "}\n"
1364 "void g() {}");
1365}
1366
Daniel Jasper2b41a822013-08-20 12:42:50 +00001367TEST_F(FormatTest, FormatsEnumStruct) {
1368 verifyFormat("enum struct {\n"
1369 " Zero,\n"
1370 " One = 1,\n"
1371 " Two = One + 1,\n"
1372 " Three = (One + Two),\n"
1373 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1374 " Five = (One, Two, Three, Four, 5)\n"
1375 "};");
1376 verifyFormat("enum struct Enum {};");
1377 verifyFormat("enum struct {};");
Daniel Jasper015ed022013-09-13 09:20:45 +00001378 verifyFormat("enum struct X E {} d;");
1379 verifyFormat("enum struct __attribute__((...)) E {} d;");
1380 verifyFormat("enum struct __declspec__((...)) E {} d;");
Daniel Jasper2b41a822013-08-20 12:42:50 +00001381 verifyFormat("enum struct X f() {\n a();\n return 42;\n}");
1382}
1383
1384TEST_F(FormatTest, FormatsEnumClass) {
1385 verifyFormat("enum class {\n"
1386 " Zero,\n"
1387 " One = 1,\n"
1388 " Two = One + 1,\n"
1389 " Three = (One + Two),\n"
1390 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1391 " Five = (One, Two, Three, Four, 5)\n"
1392 "};");
1393 verifyFormat("enum class Enum {};");
1394 verifyFormat("enum class {};");
Daniel Jasper015ed022013-09-13 09:20:45 +00001395 verifyFormat("enum class X E {} d;");
1396 verifyFormat("enum class __attribute__((...)) E {} d;");
1397 verifyFormat("enum class __declspec__((...)) E {} d;");
Daniel Jasper2b41a822013-08-20 12:42:50 +00001398 verifyFormat("enum class X f() {\n a();\n return 42;\n}");
1399}
1400
Manuel Klimek9a53c7f2013-09-05 15:34:55 +00001401TEST_F(FormatTest, FormatsEnumTypes) {
1402 verifyFormat("enum X : int {\n"
Daniel Jasper96972812014-01-05 12:38:10 +00001403 " A, // Force multiple lines.\n"
Manuel Klimek9a53c7f2013-09-05 15:34:55 +00001404 " B\n"
1405 "};");
Daniel Jasper96972812014-01-05 12:38:10 +00001406 verifyFormat("enum X : int { A, B };");
1407 verifyFormat("enum X : std::uint32_t { A, B };");
Manuel Klimek9a53c7f2013-09-05 15:34:55 +00001408}
1409
Krasimir Georgiev81341d72017-08-29 13:32:30 +00001410TEST_F(FormatTest, FormatsTypedefEnum) {
1411 FormatStyle Style = getLLVMStyle();
1412 Style.ColumnLimit = 40;
1413 verifyFormat("typedef enum {} EmptyEnum;");
1414 verifyFormat("typedef enum { A, B, C } ShortEnum;");
1415 verifyFormat("typedef enum {\n"
1416 " ZERO = 0,\n"
1417 " ONE = 1,\n"
1418 " TWO = 2,\n"
1419 " THREE = 3\n"
1420 "} LongEnum;",
1421 Style);
1422 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
1423 Style.BraceWrapping.AfterEnum = true;
1424 verifyFormat("typedef enum {} EmptyEnum;");
1425 verifyFormat("typedef enum { A, B, C } ShortEnum;");
1426 verifyFormat("typedef enum\n"
1427 "{\n"
1428 " ZERO = 0,\n"
1429 " ONE = 1,\n"
1430 " TWO = 2,\n"
1431 " THREE = 3\n"
1432 "} LongEnum;",
1433 Style);
1434}
1435
Daniel Jaspera88f80a2014-01-30 14:38:37 +00001436TEST_F(FormatTest, FormatsNSEnums) {
1437 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }");
1438 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n"
1439 " // Information about someDecentlyLongValue.\n"
1440 " someDecentlyLongValue,\n"
1441 " // Information about anotherDecentlyLongValue.\n"
1442 " anotherDecentlyLongValue,\n"
1443 " // Information about aThirdDecentlyLongValue.\n"
1444 " aThirdDecentlyLongValue\n"
1445 "};");
Daniel Jasper31f6c542014-12-05 10:42:21 +00001446 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n"
1447 " a = 1,\n"
1448 " b = 2,\n"
1449 " c = 3,\n"
1450 "};");
1451 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n"
1452 " a = 1,\n"
1453 " b = 2,\n"
1454 " c = 3,\n"
1455 "};");
1456 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n"
1457 " a = 1,\n"
1458 " b = 2,\n"
1459 " c = 3,\n"
1460 "};");
Daniel Jaspera88f80a2014-01-30 14:38:37 +00001461}
1462
Nico Weber7769a902013-01-14 05:49:49 +00001463TEST_F(FormatTest, FormatsBitfields) {
1464 verifyFormat("struct Bitfields {\n"
1465 " unsigned sClass : 8;\n"
1466 " unsigned ValueKind : 2;\n"
1467 "};");
Alexander Kornienko60d1b042013-10-10 13:36:20 +00001468 verifyFormat("struct A {\n"
1469 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n"
1470 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n"
1471 "};");
Daniel Jasper676e5162015-04-07 14:36:33 +00001472 verifyFormat("struct MyStruct {\n"
1473 " uchar data;\n"
1474 " uchar : 8;\n"
1475 " uchar : 8;\n"
1476 " uchar other;\n"
1477 "};");
Nico Weber7769a902013-01-14 05:49:49 +00001478}
1479
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001480TEST_F(FormatTest, FormatsNamespaces) {
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001481 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
1482 LLVMWithNoNamespaceFix.FixNamespaceComments = false;
1483
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001484 verifyFormat("namespace some_namespace {\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001485 "class A {};\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00001486 "void f() { f(); }\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001487 "}",
1488 LLVMWithNoNamespaceFix);
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001489 verifyFormat("namespace {\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001490 "class A {};\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00001491 "void f() { f(); }\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001492 "}",
1493 LLVMWithNoNamespaceFix);
Dmitri Gribenko58d64e22012-12-30 21:27:25 +00001494 verifyFormat("inline namespace X {\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001495 "class A {};\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00001496 "void f() { f(); }\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001497 "}",
1498 LLVMWithNoNamespaceFix);
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001499 verifyFormat("using namespace some_namespace;\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001500 "class A {};\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001501 "void f() { f(); }",
1502 LLVMWithNoNamespaceFix);
Manuel Klimek046b9302013-02-06 16:08:09 +00001503
1504 // This code is more common than we thought; if we
1505 // layout this correctly the semicolon will go into
Alp Tokerf6a24ce2013-12-05 16:25:25 +00001506 // its own line, which is undesirable.
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001507 verifyFormat("namespace {};",
1508 LLVMWithNoNamespaceFix);
Manuel Klimek046b9302013-02-06 16:08:09 +00001509 verifyFormat("namespace {\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001510 "class A {};\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001511 "};",
1512 LLVMWithNoNamespaceFix);
Daniel Jasper251b3c92013-07-01 11:22:57 +00001513
1514 verifyFormat("namespace {\n"
1515 "int SomeVariable = 0; // comment\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001516 "} // namespace",
1517 LLVMWithNoNamespaceFix);
Daniel Jasper251b3c92013-07-01 11:22:57 +00001518 EXPECT_EQ("#ifndef HEADER_GUARD\n"
1519 "#define HEADER_GUARD\n"
1520 "namespace my_namespace {\n"
1521 "int i;\n"
1522 "} // my_namespace\n"
1523 "#endif // HEADER_GUARD",
1524 format("#ifndef HEADER_GUARD\n"
1525 " #define HEADER_GUARD\n"
1526 " namespace my_namespace {\n"
1527 "int i;\n"
1528 "} // my_namespace\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001529 "#endif // HEADER_GUARD",
1530 LLVMWithNoNamespaceFix));
Daniel Jasper65ee3472013-07-31 23:16:02 +00001531
Saleem Abdulrasool328085f2015-10-30 05:07:56 +00001532 EXPECT_EQ("namespace A::B {\n"
1533 "class C {};\n"
1534 "}",
1535 format("namespace A::B {\n"
1536 "class C {};\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001537 "}",
1538 LLVMWithNoNamespaceFix));
Saleem Abdulrasool328085f2015-10-30 05:07:56 +00001539
Daniel Jasper65ee3472013-07-31 23:16:02 +00001540 FormatStyle Style = getLLVMStyle();
1541 Style.NamespaceIndentation = FormatStyle::NI_All;
1542 EXPECT_EQ("namespace out {\n"
1543 " int i;\n"
1544 " namespace in {\n"
1545 " int i;\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001546 " } // namespace in\n"
1547 "} // namespace out",
Daniel Jasper65ee3472013-07-31 23:16:02 +00001548 format("namespace out {\n"
1549 "int i;\n"
1550 "namespace in {\n"
1551 "int i;\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001552 "} // namespace in\n"
1553 "} // namespace out",
Daniel Jasper65ee3472013-07-31 23:16:02 +00001554 Style));
1555
1556 Style.NamespaceIndentation = FormatStyle::NI_Inner;
1557 EXPECT_EQ("namespace out {\n"
1558 "int i;\n"
1559 "namespace in {\n"
1560 " int i;\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001561 "} // namespace in\n"
1562 "} // namespace out",
Daniel Jasper65ee3472013-07-31 23:16:02 +00001563 format("namespace out {\n"
1564 "int i;\n"
1565 "namespace in {\n"
1566 "int i;\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001567 "} // namespace in\n"
1568 "} // namespace out",
Daniel Jasper65ee3472013-07-31 23:16:02 +00001569 Style));
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001570}
1571
Francois Ferrande56a8292017-06-14 12:29:47 +00001572TEST_F(FormatTest, FormatsCompactNamespaces) {
1573 FormatStyle Style = getLLVMStyle();
1574 Style.CompactNamespaces = true;
1575
1576 verifyFormat("namespace A { namespace B {\n"
1577 "}} // namespace A::B",
1578 Style);
1579
1580 EXPECT_EQ("namespace out { namespace in {\n"
1581 "}} // namespace out::in",
1582 format("namespace out {\n"
1583 "namespace in {\n"
1584 "} // namespace in\n"
1585 "} // namespace out",
1586 Style));
1587
1588 // Only namespaces which have both consecutive opening and end get compacted
1589 EXPECT_EQ("namespace out {\n"
1590 "namespace in1 {\n"
1591 "} // namespace in1\n"
1592 "namespace in2 {\n"
1593 "} // namespace in2\n"
1594 "} // namespace out",
1595 format("namespace out {\n"
1596 "namespace in1 {\n"
1597 "} // namespace in1\n"
1598 "namespace in2 {\n"
1599 "} // namespace in2\n"
1600 "} // namespace out",
1601 Style));
1602
1603 EXPECT_EQ("namespace out {\n"
1604 "int i;\n"
1605 "namespace in {\n"
1606 "int j;\n"
1607 "} // namespace in\n"
1608 "int k;\n"
1609 "} // namespace out",
1610 format("namespace out { int i;\n"
1611 "namespace in { int j; } // namespace in\n"
1612 "int k; } // namespace out",
1613 Style));
1614
1615 EXPECT_EQ("namespace A { namespace B { namespace C {\n"
1616 "}}} // namespace A::B::C\n",
1617 format("namespace A { namespace B {\n"
1618 "namespace C {\n"
1619 "}} // namespace B::C\n"
1620 "} // namespace A\n",
1621 Style));
1622
1623 Style.ColumnLimit = 40;
1624 EXPECT_EQ("namespace aaaaaaaaaa {\n"
1625 "namespace bbbbbbbbbb {\n"
1626 "}} // namespace aaaaaaaaaa::bbbbbbbbbb",
1627 format("namespace aaaaaaaaaa {\n"
1628 "namespace bbbbbbbbbb {\n"
1629 "} // namespace bbbbbbbbbb\n"
1630 "} // namespace aaaaaaaaaa",
1631 Style));
1632
1633 EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n"
1634 "namespace cccccc {\n"
1635 "}}} // namespace aaaaaa::bbbbbb::cccccc",
1636 format("namespace aaaaaa {\n"
1637 "namespace bbbbbb {\n"
1638 "namespace cccccc {\n"
1639 "} // namespace cccccc\n"
1640 "} // namespace bbbbbb\n"
1641 "} // namespace aaaaaa",
1642 Style));
1643 Style.ColumnLimit = 80;
1644
1645 // Extra semicolon after 'inner' closing brace prevents merging
1646 EXPECT_EQ("namespace out { namespace in {\n"
1647 "}; } // namespace out::in",
1648 format("namespace out {\n"
1649 "namespace in {\n"
1650 "}; // namespace in\n"
1651 "} // namespace out",
1652 Style));
1653
1654 // Extra semicolon after 'outer' closing brace is conserved
1655 EXPECT_EQ("namespace out { namespace in {\n"
1656 "}}; // namespace out::in",
1657 format("namespace out {\n"
1658 "namespace in {\n"
1659 "} // namespace in\n"
1660 "}; // namespace out",
1661 Style));
1662
1663 Style.NamespaceIndentation = FormatStyle::NI_All;
1664 EXPECT_EQ("namespace out { namespace in {\n"
1665 " int i;\n"
1666 "}} // namespace out::in",
1667 format("namespace out {\n"
1668 "namespace in {\n"
1669 "int i;\n"
1670 "} // namespace in\n"
1671 "} // namespace out",
1672 Style));
1673 EXPECT_EQ("namespace out { namespace mid {\n"
1674 " namespace in {\n"
1675 " int j;\n"
1676 " } // namespace in\n"
1677 " int k;\n"
1678 "}} // namespace out::mid",
1679 format("namespace out { namespace mid {\n"
1680 "namespace in { int j; } // namespace in\n"
1681 "int k; }} // namespace out::mid",
1682 Style));
1683
1684 Style.NamespaceIndentation = FormatStyle::NI_Inner;
1685 EXPECT_EQ("namespace out { namespace in {\n"
1686 " int i;\n"
1687 "}} // namespace out::in",
1688 format("namespace out {\n"
1689 "namespace in {\n"
1690 "int i;\n"
1691 "} // namespace in\n"
1692 "} // namespace out",
1693 Style));
1694 EXPECT_EQ("namespace out { namespace mid { namespace in {\n"
1695 " int i;\n"
1696 "}}} // namespace out::mid::in",
1697 format("namespace out {\n"
1698 "namespace mid {\n"
1699 "namespace in {\n"
1700 "int i;\n"
1701 "} // namespace in\n"
1702 "} // namespace mid\n"
1703 "} // namespace out",
1704 Style));
1705}
1706
Krasimir Georgievd6ce9372017-09-15 11:23:50 +00001707TEST_F(FormatTest, FormatsExternC) {
1708 verifyFormat("extern \"C\" {\nint a;");
1709 verifyFormat("extern \"C\" {}");
1710 verifyFormat("extern \"C\" {\n"
1711 "int foo();\n"
1712 "}");
1713 verifyFormat("extern \"C\" int foo() {}");
1714 verifyFormat("extern \"C\" int foo();");
1715 verifyFormat("extern \"C\" int foo() {\n"
1716 " int i = 42;\n"
1717 " return i;\n"
1718 "}");
1719
1720 FormatStyle Style = getLLVMStyle();
1721 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
1722 Style.BraceWrapping.AfterFunction = true;
1723 verifyFormat("extern \"C\" int foo() {}", Style);
1724 verifyFormat("extern \"C\" int foo();", Style);
1725 verifyFormat("extern \"C\" int foo()\n"
1726 "{\n"
1727 " int i = 42;\n"
1728 " return i;\n"
1729 "}",
1730 Style);
1731
1732 Style.BraceWrapping.AfterExternBlock = true;
1733 Style.BraceWrapping.SplitEmptyRecord = false;
1734 verifyFormat("extern \"C\"\n"
1735 "{}",
1736 Style);
1737 verifyFormat("extern \"C\"\n"
1738 "{\n"
1739 " int foo();\n"
1740 "}",
1741 Style);
1742}
Manuel Klimekae610d12013-01-21 14:32:05 +00001743
Daniel Jasper40aacf42013-03-14 13:45:21 +00001744TEST_F(FormatTest, FormatsInlineASM) {
1745 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));");
Daniel Jasperb23e20b2014-09-16 16:36:57 +00001746 verifyFormat("asm(\"nop\" ::: \"memory\");");
Daniel Jasper40aacf42013-03-14 13:45:21 +00001747 verifyFormat(
1748 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
1749 " \"cpuid\\n\\t\"\n"
1750 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
Daniel Jasper5dad58e2013-05-15 07:51:51 +00001751 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n"
Daniel Jasper40aacf42013-03-14 13:45:21 +00001752 " : \"a\"(value));");
Daniel Jasper8f463652014-08-26 23:15:12 +00001753 EXPECT_EQ(
1754 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n"
Daniel Jasper2337f282015-01-12 10:14:56 +00001755 " __asm {\n"
Daniel Jasper8f463652014-08-26 23:15:12 +00001756 " mov edx,[that] // vtable in edx\n"
1757 " mov eax,methodIndex\n"
1758 " call [edx][eax*4] // stdcall\n"
Daniel Jasper2337f282015-01-12 10:14:56 +00001759 " }\n"
Daniel Jasper8f463652014-08-26 23:15:12 +00001760 "}",
1761 format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n"
1762 " __asm {\n"
1763 " mov edx,[that] // vtable in edx\n"
1764 " mov eax,methodIndex\n"
1765 " call [edx][eax*4] // stdcall\n"
1766 " }\n"
1767 "}"));
Daniel Jasperc6366072015-05-10 08:42:04 +00001768 EXPECT_EQ("_asm {\n"
1769 " xor eax, eax;\n"
1770 " cpuid;\n"
1771 "}",
1772 format("_asm {\n"
1773 " xor eax, eax;\n"
1774 " cpuid;\n"
1775 "}"));
Daniel Jasper2337f282015-01-12 10:14:56 +00001776 verifyFormat("void function() {\n"
1777 " // comment\n"
1778 " asm(\"\");\n"
1779 "}");
Daniel Jasper790d4f92015-05-11 11:59:46 +00001780 EXPECT_EQ("__asm {\n"
1781 "}\n"
1782 "int i;",
1783 format("__asm {\n"
1784 "}\n"
1785 "int i;"));
Daniel Jasper40aacf42013-03-14 13:45:21 +00001786}
1787
Nico Weberd5650bd2013-01-07 16:36:17 +00001788TEST_F(FormatTest, FormatTryCatch) {
1789 verifyFormat("try {\n"
1790 " throw a * b;\n"
Daniel Jasper04a71a42014-05-08 11:58:24 +00001791 "} catch (int a) {\n"
Nico Weberd5650bd2013-01-07 16:36:17 +00001792 " // Do nothing.\n"
Daniel Jasper04a71a42014-05-08 11:58:24 +00001793 "} catch (...) {\n"
Nico Weberd5650bd2013-01-07 16:36:17 +00001794 " exit(42);\n"
1795 "}");
1796
1797 // Function-level try statements.
Daniel Jasper04a71a42014-05-08 11:58:24 +00001798 verifyFormat("int f() try { return 4; } catch (...) {\n"
Nico Weberd5650bd2013-01-07 16:36:17 +00001799 " return 5;\n"
1800 "}");
1801 verifyFormat("class A {\n"
1802 " int a;\n"
Daniel Jasper04a71a42014-05-08 11:58:24 +00001803 " A() try : a(0) {\n"
1804 " } catch (...) {\n"
Nico Weberd5650bd2013-01-07 16:36:17 +00001805 " throw;\n"
1806 " }\n"
1807 "};\n");
Daniel Jasper2bd7a642015-01-19 10:50:51 +00001808
1809 // Incomplete try-catch blocks.
Manuel Klimekec5c3db2015-05-07 12:26:30 +00001810 verifyIncompleteFormat("try {} catch (");
Nico Weberd5650bd2013-01-07 16:36:17 +00001811}
1812
Nico Weberfac23712015-02-04 15:26:27 +00001813TEST_F(FormatTest, FormatSEHTryCatch) {
1814 verifyFormat("__try {\n"
1815 " int a = b * c;\n"
1816 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n"
1817 " // Do nothing.\n"
1818 "}");
1819
1820 verifyFormat("__try {\n"
1821 " int a = b * c;\n"
1822 "} __finally {\n"
1823 " // Do nothing.\n"
1824 "}");
1825
1826 verifyFormat("DEBUG({\n"
1827 " __try {\n"
1828 " } __finally {\n"
1829 " }\n"
1830 "});\n");
1831}
1832
Daniel Jasper04a71a42014-05-08 11:58:24 +00001833TEST_F(FormatTest, IncompleteTryCatchBlocks) {
1834 verifyFormat("try {\n"
1835 " f();\n"
1836 "} catch {\n"
1837 " g();\n"
1838 "}");
1839 verifyFormat("try {\n"
1840 " f();\n"
1841 "} catch (A a) MACRO(x) {\n"
1842 " g();\n"
1843 "} catch (B b) MACRO(x) {\n"
1844 " g();\n"
1845 "}");
1846}
1847
1848TEST_F(FormatTest, FormatTryCatchBraceStyles) {
1849 FormatStyle Style = getLLVMStyle();
Daniel Jasper55bbe662015-10-07 04:06:10 +00001850 for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla,
1851 FormatStyle::BS_WebKit}) {
Roman Kashitsyn291f64f2015-08-10 13:43:19 +00001852 Style.BreakBeforeBraces = BraceStyle;
1853 verifyFormat("try {\n"
1854 " // something\n"
1855 "} catch (...) {\n"
1856 " // something\n"
1857 "}",
1858 Style);
1859 }
Daniel Jasper04a71a42014-05-08 11:58:24 +00001860 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
1861 verifyFormat("try {\n"
1862 " // something\n"
1863 "}\n"
1864 "catch (...) {\n"
1865 " // something\n"
1866 "}",
1867 Style);
Nico Weberfac23712015-02-04 15:26:27 +00001868 verifyFormat("__try {\n"
1869 " // something\n"
1870 "}\n"
1871 "__finally {\n"
1872 " // something\n"
1873 "}",
1874 Style);
Nico Weber33381f52015-02-07 01:57:32 +00001875 verifyFormat("@try {\n"
1876 " // something\n"
1877 "}\n"
1878 "@finally {\n"
1879 " // something\n"
1880 "}",
1881 Style);
Daniel Jasper04a71a42014-05-08 11:58:24 +00001882 Style.BreakBeforeBraces = FormatStyle::BS_Allman;
1883 verifyFormat("try\n"
1884 "{\n"
1885 " // something\n"
1886 "}\n"
1887 "catch (...)\n"
1888 "{\n"
1889 " // something\n"
1890 "}",
1891 Style);
1892 Style.BreakBeforeBraces = FormatStyle::BS_GNU;
1893 verifyFormat("try\n"
1894 " {\n"
1895 " // something\n"
1896 " }\n"
1897 "catch (...)\n"
1898 " {\n"
1899 " // something\n"
1900 " }",
1901 Style);
Daniel Jasper55bbe662015-10-07 04:06:10 +00001902 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
1903 Style.BraceWrapping.BeforeCatch = true;
1904 verifyFormat("try {\n"
1905 " // something\n"
1906 "}\n"
1907 "catch (...) {\n"
1908 " // something\n"
1909 "}",
1910 Style);
Daniel Jasper04a71a42014-05-08 11:58:24 +00001911}
1912
Daniel Jaspere25509f2012-12-17 11:29:41 +00001913TEST_F(FormatTest, StaticInitializers) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00001914 verifyFormat("static SomeClass SC = {1, 'a'};");
Daniel Jaspere25509f2012-12-17 11:29:41 +00001915
Daniel Jaspera44991332015-04-29 13:06:49 +00001916 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n"
1917 " 100000000, "
1918 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};");
Manuel Klimek0ddd57a2013-01-10 15:58:26 +00001919
Daniel Jasper473c62c2013-05-17 09:35:01 +00001920 // Here, everything other than the "}" would fit on a line.
1921 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00001922 " 10000000000000000000000000};");
Daniel Jaspera69ca9b2014-06-04 12:40:57 +00001923 EXPECT_EQ("S s = {a,\n"
1924 "\n"
1925 " b};",
1926 format("S s = {\n"
1927 " a,\n"
1928 "\n"
1929 " b\n"
1930 "};"));
Daniel Jasper473c62c2013-05-17 09:35:01 +00001931
1932 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first
1933 // line. However, the formatting looks a bit off and this probably doesn't
1934 // happen often in practice.
1935 verifyFormat("static int Variable[1] = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00001936 " {1000000000000000000000000000000000000}};",
Daniel Jasper473c62c2013-05-17 09:35:01 +00001937 getLLVMStyleWithColumns(40));
Daniel Jaspere25509f2012-12-17 11:29:41 +00001938}
1939
Daniel Jasperbca4bbe2013-05-28 11:30:49 +00001940TEST_F(FormatTest, DesignatedInitializers) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00001941 verifyFormat("const struct A a = {.a = 1, .b = 2};");
1942 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n"
1943 " .bbbbbbbbbb = 2,\n"
1944 " .cccccccccc = 3,\n"
1945 " .dddddddddd = 4,\n"
1946 " .eeeeeeeeee = 5};");
Daniel Jasperbca4bbe2013-05-28 11:30:49 +00001947 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00001948 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n"
1949 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n"
1950 " .ccccccccccccccccccccccccccc = 3,\n"
1951 " .ddddddddddddddddddddddddddd = 4,\n"
1952 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};");
Daniel Jasperbca4bbe2013-05-28 11:30:49 +00001953
1954 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};");
Francois Ferrand5f07f442017-06-19 14:41:21 +00001955
1956 verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
1957 verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n"
1958 " [2] = bbbbbbbbbb,\n"
1959 " [3] = cccccccccc,\n"
1960 " [4] = dddddddddd,\n"
1961 " [5] = eeeeeeeeee};");
1962 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
1963 " [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
1964 " [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
1965 " [3] = cccccccccccccccccccccccccccccccccccccc,\n"
1966 " [4] = dddddddddddddddddddddddddddddddddddddd,\n"
1967 " [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};");
Daniel Jasperbca4bbe2013-05-28 11:30:49 +00001968}
1969
Manuel Klimeka54d1a92013-01-14 16:41:43 +00001970TEST_F(FormatTest, NestedStaticInitializers) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00001971 verifyFormat("static A x = {{{}}};\n");
1972 verifyFormat("static A x = {{{init1, init2, init3, init4},\n"
1973 " {init1, init2, init3, init4}}};",
1974 getLLVMStyleWithColumns(50));
Daniel Jasper9278eb92013-01-16 14:59:02 +00001975
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001976 verifyFormat("somes Status::global_reps[3] = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00001977 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
1978 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
1979 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};",
1980 getLLVMStyleWithColumns(60));
Daniel Jaspere5777d22013-05-23 10:15:45 +00001981 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n"
Daniel Jasper6ab54682013-07-16 18:22:10 +00001982 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
1983 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
1984 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};");
Daniel Jaspera44991332015-04-29 13:06:49 +00001985 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n"
1986 " {rect.fRight - rect.fLeft, rect.fBottom - "
1987 "rect.fTop}};");
Manuel Klimeka54d1a92013-01-14 16:41:43 +00001988
Daniel Jasper8a8ce242013-01-31 14:59:26 +00001989 verifyFormat(
Chandler Carruthf8b72662014-03-02 12:37:31 +00001990 "SomeArrayOfSomeType a = {\n"
1991 " {{1, 2, 3},\n"
1992 " {1, 2, 3},\n"
1993 " {111111111111111111111111111111, 222222222222222222222222222222,\n"
1994 " 333333333333333333333333333333},\n"
1995 " {1, 2, 3},\n"
1996 " {1, 2, 3}}};");
Daniel Jasper1ca05cc2013-02-03 18:07:15 +00001997 verifyFormat(
Daniel Jasper6ab54682013-07-16 18:22:10 +00001998 "SomeArrayOfSomeType a = {\n"
Daniel Jasper01603472014-01-09 13:42:56 +00001999 " {{1, 2, 3}},\n"
2000 " {{1, 2, 3}},\n"
Daniel Jasper6ab54682013-07-16 18:22:10 +00002001 " {{111111111111111111111111111111, 222222222222222222222222222222,\n"
2002 " 333333333333333333333333333333}},\n"
Daniel Jasper01603472014-01-09 13:42:56 +00002003 " {{1, 2, 3}},\n"
2004 " {{1, 2, 3}}};");
Daniel Jasper8a8ce242013-01-31 14:59:26 +00002005
Daniel Jaspera44991332015-04-29 13:06:49 +00002006 verifyFormat("struct {\n"
2007 " unsigned bit;\n"
2008 " const char *const name;\n"
2009 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n"
2010 " {kOsWin, \"Windows\"},\n"
2011 " {kOsLinux, \"Linux\"},\n"
2012 " {kOsCrOS, \"Chrome OS\"}};");
2013 verifyFormat("struct {\n"
2014 " unsigned bit;\n"
2015 " const char *const name;\n"
2016 "} kBitsToOs[] = {\n"
2017 " {kOsMac, \"Mac\"},\n"
2018 " {kOsWin, \"Windows\"},\n"
2019 " {kOsLinux, \"Linux\"},\n"
2020 " {kOsCrOS, \"Chrome OS\"},\n"
2021 "};");
Manuel Klimeka54d1a92013-01-14 16:41:43 +00002022}
2023
Manuel Klimeka71e5d82013-01-02 16:30:12 +00002024TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) {
2025 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("
2026 " \\\n"
2027 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)");
2028}
2029
Daniel Jasperda16db32013-01-07 10:48:50 +00002030TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) {
Alexander Kornienko384b40b2013-10-11 21:43:05 +00002031 verifyFormat("virtual void write(ELFWriter *writerrr,\n"
2032 " OwningPtr<FileOutputBuffer> &buffer) = 0;");
Daniel Jaspercaf84fe2015-04-23 12:59:09 +00002033
2034 // Do break defaulted and deleted functions.
2035 verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
2036 " default;",
2037 getLLVMStyleWithColumns(40));
2038 verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
2039 " delete;",
2040 getLLVMStyleWithColumns(40));
Alexander Kornienko384b40b2013-10-11 21:43:05 +00002041}
2042
2043TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) {
2044 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3",
2045 getLLVMStyleWithColumns(40));
2046 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
2047 getLLVMStyleWithColumns(40));
2048 EXPECT_EQ("#define Q \\\n"
2049 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n"
2050 " \"aaaaaaaa.cpp\"",
2051 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
2052 getLLVMStyleWithColumns(40)));
2053}
2054
2055TEST_F(FormatTest, UnderstandsLinePPDirective) {
2056 EXPECT_EQ("# 123 \"A string literal\"",
2057 format(" # 123 \"A string literal\""));
Daniel Jasperda16db32013-01-07 10:48:50 +00002058}
2059
Manuel Klimek591b5802013-01-31 15:58:48 +00002060TEST_F(FormatTest, LayoutUnknownPPDirective) {
Manuel Klimek591b5802013-01-31 15:58:48 +00002061 EXPECT_EQ("#;", format("#;"));
Manuel Klimek78725712013-01-07 10:03:37 +00002062 verifyFormat("#\n;\n;\n;");
Manuel Klimeka71e5d82013-01-02 16:30:12 +00002063}
2064
2065TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) {
2066 EXPECT_EQ("#line 42 \"test\"\n",
2067 format("# \\\n line \\\n 42 \\\n \"test\"\n"));
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002068 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n",
2069 getLLVMStyleWithColumns(12)));
Manuel Klimeka71e5d82013-01-02 16:30:12 +00002070}
2071
2072TEST_F(FormatTest, EndOfFileEndsPPDirective) {
2073 EXPECT_EQ("#line 42 \"test\"",
2074 format("# \\\n line \\\n 42 \\\n \"test\""));
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002075 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B"));
Manuel Klimeka71e5d82013-01-02 16:30:12 +00002076}
2077
Daniel Jasper877615c2013-10-11 19:45:02 +00002078TEST_F(FormatTest, DoesntRemoveUnknownTokens) {
2079 verifyFormat("#define A \\x20");
2080 verifyFormat("#define A \\ x20");
2081 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20"));
2082 verifyFormat("#define A ''");
2083 verifyFormat("#define A ''qqq");
2084 verifyFormat("#define A `qqq");
2085 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");
Daniel Jasperda353cd2014-03-12 08:24:47 +00002086 EXPECT_EQ("const char *c = STRINGIFY(\n"
2087 "\\na : b);",
2088 format("const char * c = STRINGIFY(\n"
2089 "\\na : b);"));
Daniel Jasper30029c62015-02-05 11:05:31 +00002090
2091 verifyFormat("a\r\\");
2092 verifyFormat("a\v\\");
2093 verifyFormat("a\f\\");
Daniel Jasper877615c2013-10-11 19:45:02 +00002094}
2095
Manuel Klimekb69e3c62013-01-02 18:33:23 +00002096TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {
Daniel Jasperc22f5b42013-02-28 11:05:57 +00002097 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
2098 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12));
Manuel Klimekb69e3c62013-01-02 18:33:23 +00002099 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12));
Daniel Jasperc22f5b42013-02-28 11:05:57 +00002100 // FIXME: We never break before the macro name.
Daniel Jaspera49393f2013-08-28 09:07:32 +00002101 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12));
Daniel Jasper39825ea2013-01-14 15:40:57 +00002102
2103 verifyFormat("#define A A\n#define A A");
2104 verifyFormat("#define A(X) A\n#define A A");
2105
Daniel Jasperc22f5b42013-02-28 11:05:57 +00002106 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
2107 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22));
Manuel Klimekb69e3c62013-01-02 18:33:23 +00002108}
2109
2110TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {
Alexander Kornienkoefd98382013-03-28 18:40:55 +00002111 EXPECT_EQ("// somecomment\n"
Manuel Klimek1abf7892013-01-04 23:34:14 +00002112 "#include \"a.h\"\n"
Daniel Jasperc22f5b42013-02-28 11:05:57 +00002113 "#define A( \\\n"
2114 " A, B)\n"
Manuel Klimek1abf7892013-01-04 23:34:14 +00002115 "#include \"b.h\"\n"
Alexander Kornienkoffd6d042013-03-27 11:52:18 +00002116 "// somecomment\n",
Alexander Kornienkoefd98382013-03-28 18:40:55 +00002117 format(" // somecomment\n"
Manuel Klimek1abf7892013-01-04 23:34:14 +00002118 " #include \"a.h\"\n"
2119 "#define A(A,\\\n"
2120 " B)\n"
2121 " #include \"b.h\"\n"
Alexander Kornienkoffd6d042013-03-27 11:52:18 +00002122 " // somecomment\n",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002123 getLLVMStyleWithColumns(13)));
Manuel Klimekb69e3c62013-01-02 18:33:23 +00002124}
2125
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002126TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
Manuel Klimek1abf7892013-01-04 23:34:14 +00002127
2128TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
2129 EXPECT_EQ("#define A \\\n"
2130 " c; \\\n"
2131 " e;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002132 "f;",
2133 format("#define A c; e;\n"
2134 "f;",
2135 getLLVMStyleWithColumns(14)));
Manuel Klimek1abf7892013-01-04 23:34:14 +00002136}
2137
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002138TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
Manuel Klimek1abf7892013-01-04 23:34:14 +00002139
Manuel Klimek1abf7892013-01-04 23:34:14 +00002140TEST_F(FormatTest, MacroDefinitionInsideStatement) {
Manuel Klimek52b15152013-01-09 15:25:02 +00002141 EXPECT_EQ("int x,\n"
2142 "#define A\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002143 " y;",
2144 format("int x,\n#define A\ny;"));
Manuel Klimek1abf7892013-01-04 23:34:14 +00002145}
2146
Manuel Klimek09e07972013-01-05 21:34:55 +00002147TEST_F(FormatTest, HashInMacroDefinition) {
Alexander Kornienkod8d47fa2013-09-10 13:41:43 +00002148 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle()));
Manuel Klimek09e07972013-01-05 21:34:55 +00002149 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11));
Daniel Jaspera49393f2013-08-28 09:07:32 +00002150 verifyFormat("#define A \\\n"
2151 " { \\\n"
2152 " f(#c); \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002153 " }",
2154 getLLVMStyleWithColumns(11));
Daniel Jasper4f397152013-01-08 16:17:54 +00002155
2156 verifyFormat("#define A(X) \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002157 " void function##X()",
2158 getLLVMStyleWithColumns(22));
Daniel Jasper4f397152013-01-08 16:17:54 +00002159
2160 verifyFormat("#define A(a, b, c) \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002161 " void a##b##c()",
2162 getLLVMStyleWithColumns(22));
Daniel Jasper4f397152013-01-08 16:17:54 +00002163
Daniel Jasper39825ea2013-01-14 15:40:57 +00002164 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
Manuel Klimek09e07972013-01-05 21:34:55 +00002165}
2166
Manuel Klimekd053c5b2013-01-23 14:37:36 +00002167TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) {
Alexander Kornienkofdca83d2013-12-10 10:18:34 +00002168 EXPECT_EQ("#define A (x)", format("#define A (x)"));
2169 EXPECT_EQ("#define A(x)", format("#define A(x)"));
Manuel Klimekd053c5b2013-01-23 14:37:36 +00002170}
2171
Manuel Klimek0c137952013-02-11 12:33:24 +00002172TEST_F(FormatTest, EmptyLinesInMacroDefinitions) {
2173 EXPECT_EQ("#define A b;", format("#define A \\\n"
2174 " \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002175 " b;",
2176 getLLVMStyleWithColumns(25)));
Manuel Klimek0c137952013-02-11 12:33:24 +00002177 EXPECT_EQ("#define A \\\n"
2178 " \\\n"
2179 " a; \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002180 " b;",
2181 format("#define A \\\n"
2182 " \\\n"
2183 " a; \\\n"
2184 " b;",
2185 getLLVMStyleWithColumns(11)));
Manuel Klimek0c137952013-02-11 12:33:24 +00002186 EXPECT_EQ("#define A \\\n"
2187 " a; \\\n"
2188 " \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002189 " b;",
2190 format("#define A \\\n"
2191 " a; \\\n"
2192 " \\\n"
2193 " b;",
2194 getLLVMStyleWithColumns(11)));
Manuel Klimek0c137952013-02-11 12:33:24 +00002195}
2196
Daniel Jasper00475962013-02-19 17:14:38 +00002197TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
Manuel Klimekec5c3db2015-05-07 12:26:30 +00002198 verifyIncompleteFormat("#define A :");
Daniel Jasper00475962013-02-19 17:14:38 +00002199 verifyFormat("#define SOMECASES \\\n"
Daniel Jaspera1275122013-03-20 10:23:53 +00002200 " case 1: \\\n"
Daniel Jasper00475962013-02-19 17:14:38 +00002201 " case 2\n",
2202 getLLVMStyleWithColumns(20));
Daniel Jasper451544a2016-05-19 06:30:48 +00002203 verifyFormat("#define MACRO(a) \\\n"
2204 " if (a) \\\n"
2205 " f(); \\\n"
2206 " else \\\n"
2207 " g()",
2208 getLLVMStyleWithColumns(18));
Daniel Jasper00475962013-02-19 17:14:38 +00002209 verifyFormat("#define A template <typename T>");
Manuel Klimekec5c3db2015-05-07 12:26:30 +00002210 verifyIncompleteFormat("#define STR(x) #x\n"
2211 "f(STR(this_is_a_string_literal{));");
Daniel Jasper96df37a2013-08-28 09:17:37 +00002212 verifyFormat("#pragma omp threadprivate( \\\n"
2213 " y)), // expected-warning",
2214 getLLVMStyleWithColumns(28));
Daniel Jasperb1567c12015-01-19 10:50:08 +00002215 verifyFormat("#d, = };");
Daniel Jasper9d22bcc2015-01-19 10:51:05 +00002216 verifyFormat("#if \"a");
Manuel Klimekec5c3db2015-05-07 12:26:30 +00002217 verifyIncompleteFormat("({\n"
Manuel Klimek3d3ea842015-05-12 09:23:57 +00002218 "#define b \\\n"
2219 " } \\\n"
Manuel Klimekec5c3db2015-05-07 12:26:30 +00002220 " a\n"
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00002221 "a",
2222 getLLVMStyleWithColumns(15));
Daniel Jasper9ecb0e92015-03-13 13:32:11 +00002223 verifyFormat("#define A \\\n"
2224 " { \\\n"
2225 " {\n"
2226 "#define B \\\n"
2227 " } \\\n"
2228 " }",
2229 getLLVMStyleWithColumns(15));
Daniel Jasperfd725c02015-01-21 17:35:29 +00002230 verifyNoCrash("#if a\na(\n#else\n#endif\n{a");
Daniel Jasperd1debfc2015-01-21 18:04:02 +00002231 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}");
Daniel Jasper04b979d2015-01-21 18:35:47 +00002232 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};");
Daniel Jasperd1c13732015-01-23 19:37:25 +00002233 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}");
Daniel Jasper00475962013-02-19 17:14:38 +00002234}
2235
Daniel Jasper40e19212013-05-29 13:16:10 +00002236TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) {
2237 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
2238 EXPECT_EQ("class A : public QObject {\n"
2239 " Q_OBJECT\n"
2240 "\n"
2241 " A() {}\n"
2242 "};",
2243 format("class A : public QObject {\n"
2244 " Q_OBJECT\n"
2245 "\n"
2246 " A() {\n}\n"
2247 "} ;"));
Daniel Jaspere60cba12015-05-13 11:35:53 +00002248 EXPECT_EQ("MACRO\n"
2249 "/*static*/ int i;",
2250 format("MACRO\n"
2251 " /*static*/ int i;"));
Daniel Jasper41a0f782013-05-29 14:09:17 +00002252 EXPECT_EQ("SOME_MACRO\n"
2253 "namespace {\n"
2254 "void f();\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00002255 "} // namespace",
Daniel Jasper41a0f782013-05-29 14:09:17 +00002256 format("SOME_MACRO\n"
2257 " namespace {\n"
2258 "void f( );\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00002259 "} // namespace"));
Daniel Jasper40e19212013-05-29 13:16:10 +00002260 // Only if the identifier contains at least 5 characters.
Daniel Jaspera44991332015-04-29 13:06:49 +00002261 EXPECT_EQ("HTTP f();", format("HTTP\nf();"));
2262 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();"));
Daniel Jasper40e19212013-05-29 13:16:10 +00002263 // Only if everything is upper case.
2264 EXPECT_EQ("class A : public QObject {\n"
2265 " Q_Object A() {}\n"
2266 "};",
2267 format("class A : public QObject {\n"
2268 " Q_Object\n"
Daniel Jasper40e19212013-05-29 13:16:10 +00002269 " A() {\n}\n"
2270 "} ;"));
Daniel Jasper680b09b2014-11-05 10:48:04 +00002271
2272 // Only if the next line can actually start an unwrapped line.
2273 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;",
2274 format("SOME_WEIRD_LOG_MACRO\n"
2275 "<< SomeThing;"));
Nico Weber23846262014-12-09 23:22:35 +00002276
2277 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), "
Daniel Jaspera44991332015-04-29 13:06:49 +00002278 "(n, buffers))\n",
2279 getChromiumStyle(FormatStyle::LK_Cpp));
Daniel Jasper40e19212013-05-29 13:16:10 +00002280}
2281
Alexander Kornienkode644272013-04-08 22:16:06 +00002282TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) {
2283 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
2284 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
2285 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00002286 "class X {};\n"
Alexander Kornienkode644272013-04-08 22:16:06 +00002287 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
2288 "int *createScopDetectionPass() { return 0; }",
2289 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
2290 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
2291 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
2292 " class X {};\n"
2293 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
2294 " int *createScopDetectionPass() { return 0; }"));
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002295 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as
2296 // braces, so that inner block is indented one level more.
2297 EXPECT_EQ("int q() {\n"
2298 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
2299 " IPC_MESSAGE_HANDLER(xxx, qqq)\n"
2300 " IPC_END_MESSAGE_MAP()\n"
2301 "}",
2302 format("int q() {\n"
2303 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
2304 " IPC_MESSAGE_HANDLER(xxx, qqq)\n"
2305 " IPC_END_MESSAGE_MAP()\n"
2306 "}"));
Daniel Jasper545c6522013-09-17 09:26:07 +00002307
Daniel Jasper352dae12014-01-03 11:50:46 +00002308 // Same inside macros.
2309 EXPECT_EQ("#define LIST(L) \\\n"
2310 " L(A) \\\n"
2311 " L(B) \\\n"
2312 " L(C)",
2313 format("#define LIST(L) \\\n"
2314 " L(A) \\\n"
2315 " L(B) \\\n"
2316 " L(C)",
2317 getGoogleStyle()));
2318
Daniel Jasper545c6522013-09-17 09:26:07 +00002319 // These must not be recognized as macros.
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002320 EXPECT_EQ("int q() {\n"
2321 " f(x);\n"
2322 " f(x) {}\n"
2323 " f(x)->g();\n"
2324 " f(x)->*g();\n"
2325 " f(x).g();\n"
2326 " f(x) = x;\n"
2327 " f(x) += x;\n"
2328 " f(x) -= x;\n"
2329 " f(x) *= x;\n"
2330 " f(x) /= x;\n"
2331 " f(x) %= x;\n"
2332 " f(x) &= x;\n"
2333 " f(x) |= x;\n"
2334 " f(x) ^= x;\n"
2335 " f(x) >>= x;\n"
2336 " f(x) <<= x;\n"
2337 " f(x)[y].z();\n"
2338 " LOG(INFO) << x;\n"
2339 " ifstream(x) >> x;\n"
2340 "}\n",
2341 format("int q() {\n"
2342 " f(x)\n;\n"
2343 " f(x)\n {}\n"
2344 " f(x)\n->g();\n"
2345 " f(x)\n->*g();\n"
2346 " f(x)\n.g();\n"
2347 " f(x)\n = x;\n"
2348 " f(x)\n += x;\n"
2349 " f(x)\n -= x;\n"
2350 " f(x)\n *= x;\n"
2351 " f(x)\n /= x;\n"
2352 " f(x)\n %= x;\n"
2353 " f(x)\n &= x;\n"
2354 " f(x)\n |= x;\n"
2355 " f(x)\n ^= x;\n"
2356 " f(x)\n >>= x;\n"
2357 " f(x)\n <<= x;\n"
2358 " f(x)\n[y].z();\n"
2359 " LOG(INFO)\n << x;\n"
2360 " ifstream(x)\n >> x;\n"
2361 "}\n"));
2362 EXPECT_EQ("int q() {\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002363 " F(x)\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002364 " if (1) {\n"
2365 " }\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002366 " F(x)\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002367 " while (1) {\n"
2368 " }\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002369 " F(x)\n"
2370 " G(x);\n"
2371 " F(x)\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002372 " try {\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002373 " Q();\n"
Daniel Jasper04a71a42014-05-08 11:58:24 +00002374 " } catch (...) {\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002375 " }\n"
2376 "}\n",
2377 format("int q() {\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002378 "F(x)\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002379 "if (1) {}\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002380 "F(x)\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002381 "while (1) {}\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002382 "F(x)\n"
2383 "G(x);\n"
2384 "F(x)\n"
2385 "try { Q(); } catch (...) {}\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002386 "}\n"));
2387 EXPECT_EQ("class A {\n"
2388 " A() : t(0) {}\n"
Daniel Jasper5ebb2f32014-05-21 13:08:17 +00002389 " A(int i) noexcept() : {}\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002390 " A(X x)\n" // FIXME: function-level try blocks are broken.
2391 " try : t(0) {\n"
Daniel Jasper04a71a42014-05-08 11:58:24 +00002392 " } catch (...) {\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002393 " }\n"
2394 "};",
2395 format("class A {\n"
2396 " A()\n : t(0) {}\n"
Daniel Jasper5ebb2f32014-05-21 13:08:17 +00002397 " A(int i)\n noexcept() : {}\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002398 " A(X x)\n"
2399 " try : t(0) {} catch (...) {}\n"
2400 "};"));
Daniel Jaspera44991332015-04-29 13:06:49 +00002401 EXPECT_EQ("class SomeClass {\n"
2402 "public:\n"
2403 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
2404 "};",
2405 format("class SomeClass {\n"
2406 "public:\n"
2407 " SomeClass()\n"
2408 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
2409 "};"));
2410 EXPECT_EQ("class SomeClass {\n"
2411 "public:\n"
2412 " SomeClass()\n"
2413 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
2414 "};",
2415 format("class SomeClass {\n"
2416 "public:\n"
2417 " SomeClass()\n"
2418 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
2419 "};",
2420 getLLVMStyleWithColumns(40)));
Daniel Jasper7fa524b2015-11-20 15:26:50 +00002421
2422 verifyFormat("MACRO(>)");
Alexander Kornienkode644272013-04-08 22:16:06 +00002423}
2424
Manuel Klimek4fe43002013-05-22 12:51:29 +00002425TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) {
2426 verifyFormat("#define A \\\n"
2427 " f({ \\\n"
2428 " g(); \\\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00002429 " });",
2430 getLLVMStyleWithColumns(11));
Manuel Klimek4fe43002013-05-22 12:51:29 +00002431}
2432
Krasimir Georgievad47c902017-08-30 14:34:57 +00002433TEST_F(FormatTest, IndentPreprocessorDirectives) {
2434 FormatStyle Style = getLLVMStyle();
2435 Style.IndentPPDirectives = FormatStyle::PPDIS_None;
2436 Style.ColumnLimit = 40;
2437 verifyFormat("#ifdef _WIN32\n"
2438 "#define A 0\n"
2439 "#ifdef VAR2\n"
2440 "#define B 1\n"
2441 "#include <someheader.h>\n"
2442 "#define MACRO \\\n"
2443 " some_very_long_func_aaaaaaaaaa();\n"
2444 "#endif\n"
2445 "#else\n"
2446 "#define A 1\n"
2447 "#endif",
2448 Style);
Krasimir Georgievad47c902017-08-30 14:34:57 +00002449 Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash;
2450 verifyFormat("#ifdef _WIN32\n"
2451 "# define A 0\n"
2452 "# ifdef VAR2\n"
2453 "# define B 1\n"
2454 "# include <someheader.h>\n"
2455 "# define MACRO \\\n"
2456 " some_very_long_func_aaaaaaaaaa();\n"
2457 "# endif\n"
2458 "#else\n"
2459 "# define A 1\n"
2460 "#endif",
2461 Style);
2462 verifyFormat("#if A\n"
2463 "# define MACRO \\\n"
2464 " void a(int x) { \\\n"
2465 " b(); \\\n"
2466 " c(); \\\n"
2467 " d(); \\\n"
2468 " e(); \\\n"
2469 " f(); \\\n"
2470 " }\n"
2471 "#endif",
2472 Style);
2473 // Comments before include guard.
2474 verifyFormat("// file comment\n"
2475 "// file comment\n"
2476 "#ifndef HEADER_H\n"
2477 "#define HEADER_H\n"
2478 "code();\n"
2479 "#endif",
2480 Style);
2481 // Test with include guards.
2482 // EXPECT_EQ is used because verifyFormat() calls messUp() which incorrectly
2483 // merges lines.
2484 verifyFormat("#ifndef HEADER_H\n"
2485 "#define HEADER_H\n"
2486 "code();\n"
2487 "#endif",
2488 Style);
2489 // Include guards must have a #define with the same variable immediately
2490 // after #ifndef.
2491 verifyFormat("#ifndef NOT_GUARD\n"
2492 "# define FOO\n"
2493 "code();\n"
2494 "#endif",
2495 Style);
2496
2497 // Include guards must cover the entire file.
2498 verifyFormat("code();\n"
2499 "code();\n"
2500 "#ifndef NOT_GUARD\n"
2501 "# define NOT_GUARD\n"
2502 "code();\n"
2503 "#endif",
2504 Style);
2505 verifyFormat("#ifndef NOT_GUARD\n"
2506 "# define NOT_GUARD\n"
2507 "code();\n"
2508 "#endif\n"
2509 "code();",
2510 Style);
2511 // Test with trailing blank lines.
2512 verifyFormat("#ifndef HEADER_H\n"
2513 "#define HEADER_H\n"
2514 "code();\n"
2515 "#endif\n",
2516 Style);
2517 // Include guards don't have #else.
2518 verifyFormat("#ifndef NOT_GUARD\n"
2519 "# define NOT_GUARD\n"
2520 "code();\n"
2521 "#else\n"
2522 "#endif",
2523 Style);
2524 verifyFormat("#ifndef NOT_GUARD\n"
2525 "# define NOT_GUARD\n"
2526 "code();\n"
2527 "#elif FOO\n"
2528 "#endif",
2529 Style);
2530 // FIXME: This doesn't handle the case where there's code between the
2531 // #ifndef and #define but all other conditions hold. This is because when
2532 // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the
2533 // previous code line yet, so we can't detect it.
2534 EXPECT_EQ("#ifndef NOT_GUARD\n"
2535 "code();\n"
2536 "#define NOT_GUARD\n"
2537 "code();\n"
2538 "#endif",
2539 format("#ifndef NOT_GUARD\n"
2540 "code();\n"
2541 "# define NOT_GUARD\n"
2542 "code();\n"
2543 "#endif",
2544 Style));
2545 // FIXME: This doesn't handle cases where legitimate preprocessor lines may
2546 // be outside an include guard. Examples are #pragma once and
2547 // #pragma GCC diagnostic, or anything else that does not change the meaning
2548 // of the file if it's included multiple times.
2549 EXPECT_EQ("#ifdef WIN32\n"
2550 "# pragma once\n"
2551 "#endif\n"
2552 "#ifndef HEADER_H\n"
2553 "# define HEADER_H\n"
2554 "code();\n"
2555 "#endif",
2556 format("#ifdef WIN32\n"
2557 "# pragma once\n"
2558 "#endif\n"
2559 "#ifndef HEADER_H\n"
2560 "#define HEADER_H\n"
2561 "code();\n"
2562 "#endif",
2563 Style));
2564 // FIXME: This does not detect when there is a single non-preprocessor line
2565 // in front of an include-guard-like structure where other conditions hold
2566 // because ScopedLineState hides the line.
2567 EXPECT_EQ("code();\n"
2568 "#ifndef HEADER_H\n"
2569 "#define HEADER_H\n"
2570 "code();\n"
2571 "#endif",
2572 format("code();\n"
2573 "#ifndef HEADER_H\n"
2574 "# define HEADER_H\n"
2575 "code();\n"
2576 "#endif",
2577 Style));
2578 // FIXME: The comment indent corrector in TokenAnnotator gets thrown off by
2579 // preprocessor indentation.
2580 EXPECT_EQ("#if 1\n"
2581 " // comment\n"
2582 "# define A 0\n"
2583 "// comment\n"
2584 "# define B 0\n"
2585 "#endif",
2586 format("#if 1\n"
2587 "// comment\n"
2588 "# define A 0\n"
2589 " // comment\n"
2590 "# define B 0\n"
2591 "#endif",
2592 Style));
2593 // Test with tabs.
2594 Style.UseTab = FormatStyle::UT_Always;
2595 Style.IndentWidth = 8;
2596 Style.TabWidth = 8;
2597 verifyFormat("#ifdef _WIN32\n"
2598 "#\tdefine A 0\n"
2599 "#\tifdef VAR2\n"
2600 "#\t\tdefine B 1\n"
2601 "#\t\tinclude <someheader.h>\n"
2602 "#\t\tdefine MACRO \\\n"
2603 "\t\t\tsome_very_long_func_aaaaaaaaaa();\n"
2604 "#\tendif\n"
2605 "#else\n"
2606 "#\tdefine A 1\n"
2607 "#endif",
2608 Style);
Daniel Jasper4df130f2017-09-04 13:33:52 +00002609
2610 // Regression test: Multiline-macro inside include guards.
2611 verifyFormat("#ifndef HEADER_H\n"
2612 "#define HEADER_H\n"
2613 "#define A() \\\n"
2614 " int i; \\\n"
2615 " int j;\n"
2616 "#endif // HEADER_H",
2617 getLLVMStyleWithColumns(20));
Manuel Klimekef2cfb12013-01-05 22:14:16 +00002618}
2619
Manuel Klimek52d0fd82013-01-05 22:56:06 +00002620TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) {
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00002621 verifyFormat("{\n { a #c; }\n}");
Manuel Klimek52d0fd82013-01-05 22:56:06 +00002622}
2623
Manuel Klimek1058d982013-01-06 20:07:31 +00002624TEST_F(FormatTest, FormatUnbalancedStructuralElements) {
2625 EXPECT_EQ("#define A \\\n { \\\n {\nint i;",
2626 format("#define A { {\nint i;", getLLVMStyleWithColumns(11)));
2627 EXPECT_EQ("#define A \\\n } \\\n }\nint i;",
2628 format("#define A } }\nint i;", getLLVMStyleWithColumns(11)));
2629}
Manuel Klimek1abf7892013-01-04 23:34:14 +00002630
Daniel Jaspere2408e32015-05-06 11:16:43 +00002631TEST_F(FormatTest, EscapedNewlines) {
Daniel Jasper8d1832e2013-01-07 13:26:07 +00002632 EXPECT_EQ(
2633 "#define A \\\n int i; \\\n int j;",
2634 format("#define A \\\nint i;\\\n int j;", getLLVMStyleWithColumns(11)));
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00002635 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;"));
Alexander Kornienkoee4ca9b2013-06-07 17:45:07 +00002636 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
Krasimir Georgievbb99a362017-02-16 12:39:31 +00002637 EXPECT_EQ("/* \\ \\ \\\n */", format("\\\n/* \\ \\ \\\n */"));
Daniel Jaspere2408e32015-05-06 11:16:43 +00002638 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>"));
Jacob Bandes-Storchd6a7e982017-08-10 00:15:31 +00002639
2640 FormatStyle DontAlign = getLLVMStyle();
2641 DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
2642 DontAlign.MaxEmptyLinesToKeep = 3;
2643 // FIXME: can't use verifyFormat here because the newline before
2644 // "public:" is not inserted the first time it's reformatted
2645 EXPECT_EQ("#define A \\\n"
2646 " class Foo { \\\n"
2647 " void bar(); \\\n"
2648 "\\\n"
2649 "\\\n"
2650 "\\\n"
2651 " public: \\\n"
2652 " void baz(); \\\n"
2653 " };",
2654 format("#define A \\\n"
2655 " class Foo { \\\n"
2656 " void bar(); \\\n"
2657 "\\\n"
2658 "\\\n"
2659 "\\\n"
2660 " public: \\\n"
2661 " void baz(); \\\n"
2662 " };", DontAlign));
Alexander Kornienkobe633902013-06-14 11:46:10 +00002663}
2664
Manuel Klimek38ba11e2013-01-07 09:24:17 +00002665TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) {
2666 verifyFormat("#define A \\\n"
2667 " int v( \\\n"
2668 " a); \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002669 " int i;",
2670 getLLVMStyleWithColumns(11));
Manuel Klimek38ba11e2013-01-07 09:24:17 +00002671}
2672
Manuel Klimeka71e5d82013-01-02 16:30:12 +00002673TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) {
Manuel Klimek1abf7892013-01-04 23:34:14 +00002674 EXPECT_EQ(
2675 "#define ALooooooooooooooooooooooooooooooooooooooongMacro("
2676 " \\\n"
2677 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
2678 "\n"
2679 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
2680 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n",
2681 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro("
2682 "\\\n"
2683 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
2684 " \n"
2685 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
2686 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n"));
Manuel Klimeka71e5d82013-01-02 16:30:12 +00002687}
2688
Manuel Klimek52b15152013-01-09 15:25:02 +00002689TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {
2690 EXPECT_EQ("int\n"
2691 "#define A\n"
Daniel Jasper8e357692013-05-06 08:27:33 +00002692 " a;",
Daniel Jasper4355e7f2014-07-09 07:50:33 +00002693 format("int\n#define A\na;"));
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002694 verifyFormat("functionCallTo(\n"
2695 " someOtherFunction(\n"
2696 " withSomeParameters, whichInSequence,\n"
2697 " areLongerThanALine(andAnotherCall,\n"
2698 "#define A B\n"
2699 " withMoreParamters,\n"
2700 " whichStronglyInfluenceTheLayout),\n"
Daniel Jasper37905f72013-02-21 15:00:29 +00002701 " andMoreParameters),\n"
2702 " trailing);",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002703 getLLVMStyleWithColumns(69));
Daniel Jasperfb81b092013-09-17 09:52:48 +00002704 verifyFormat("Foo::Foo()\n"
2705 "#ifdef BAR\n"
2706 " : baz(0)\n"
2707 "#endif\n"
2708 "{\n"
2709 "}");
Manuel Klimek71814b42013-10-11 21:25:45 +00002710 verifyFormat("void f() {\n"
2711 " if (true)\n"
2712 "#ifdef A\n"
2713 " f(42);\n"
2714 " x();\n"
2715 "#else\n"
2716 " g();\n"
2717 " x();\n"
2718 "#endif\n"
2719 "}");
2720 verifyFormat("void f(param1, param2,\n"
2721 " param3,\n"
2722 "#ifdef A\n"
2723 " param4(param5,\n"
2724 "#ifdef A1\n"
2725 " param6,\n"
2726 "#ifdef A2\n"
2727 " param7),\n"
2728 "#else\n"
2729 " param8),\n"
2730 " param9,\n"
2731 "#endif\n"
2732 " param10,\n"
2733 "#endif\n"
2734 " param11)\n"
2735 "#else\n"
2736 " param12)\n"
2737 "#endif\n"
2738 "{\n"
2739 " x();\n"
2740 "}",
2741 getLLVMStyleWithColumns(28));
Daniel Jasper53bd1672013-10-12 13:32:56 +00002742 verifyFormat("#if 1\n"
2743 "int i;");
Daniel Jaspera44991332015-04-29 13:06:49 +00002744 verifyFormat("#if 1\n"
2745 "#endif\n"
2746 "#if 1\n"
2747 "#else\n"
2748 "#endif\n");
Daniel Jasper472da862013-10-24 15:23:11 +00002749 verifyFormat("DEBUG({\n"
2750 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2751 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
2752 "});\n"
2753 "#if a\n"
2754 "#else\n"
2755 "#endif");
Daniel Jasper193cdd32015-01-19 10:52:16 +00002756
Manuel Klimekec5c3db2015-05-07 12:26:30 +00002757 verifyIncompleteFormat("void f(\n"
2758 "#if A\n"
Martin Probst2c1cdae2017-05-15 11:15:29 +00002759 ");\n"
Manuel Klimekec5c3db2015-05-07 12:26:30 +00002760 "#else\n"
2761 "#endif");
Manuel Klimek52b15152013-01-09 15:25:02 +00002762}
2763
Manuel Klimek14bd9172014-01-29 08:49:02 +00002764TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) {
2765 verifyFormat("#endif\n"
2766 "#if B");
2767}
2768
Manuel Klimek88033d72013-10-21 08:11:15 +00002769TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) {
2770 FormatStyle SingleLine = getLLVMStyle();
2771 SingleLine.AllowShortIfStatementsOnASingleLine = true;
Daniel Jaspera44991332015-04-29 13:06:49 +00002772 verifyFormat("#if 0\n"
2773 "#elif 1\n"
2774 "#endif\n"
2775 "void foo() {\n"
2776 " if (test) foo2();\n"
2777 "}",
2778 SingleLine);
Manuel Klimek88033d72013-10-21 08:11:15 +00002779}
2780
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00002781TEST_F(FormatTest, LayoutBlockInsideParens) {
Daniel Jasperacf67e32015-04-07 08:20:35 +00002782 verifyFormat("functionCall({ int i; });");
2783 verifyFormat("functionCall({\n"
2784 " int i;\n"
2785 " int j;\n"
2786 "});");
Daniel Jasper100ffc62015-08-21 11:44:57 +00002787 verifyFormat("functionCall(\n"
2788 " {\n"
2789 " int i;\n"
2790 " int j;\n"
2791 " },\n"
2792 " aaaa, bbbb, cccc);");
Daniel Jasperacf67e32015-04-07 08:20:35 +00002793 verifyFormat("functionA(functionB({\n"
2794 " int i;\n"
2795 " int j;\n"
2796 " }),\n"
2797 " aaaa, bbbb, cccc);");
2798 verifyFormat("functionCall(\n"
2799 " {\n"
2800 " int i;\n"
2801 " int j;\n"
2802 " },\n"
2803 " aaaa, bbbb, // comment\n"
2804 " cccc);");
2805 verifyFormat("functionA(functionB({\n"
2806 " int i;\n"
2807 " int j;\n"
2808 " }),\n"
2809 " aaaa, bbbb, // comment\n"
2810 " cccc);");
2811 verifyFormat("functionCall(aaaa, bbbb, { int i; });");
2812 verifyFormat("functionCall(aaaa, bbbb, {\n"
2813 " int i;\n"
2814 " int j;\n"
2815 "});");
Daniel Jasper393564f2013-05-31 14:56:29 +00002816 verifyFormat(
Daniel Jaspera44991332015-04-29 13:06:49 +00002817 "Aaa(\n" // FIXME: There shouldn't be a linebreak here.
Daniel Jasper4b444492014-11-21 13:38:53 +00002818 " {\n"
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00002819 " int i; // break\n"
2820 " },\n"
Daniel Jasper393564f2013-05-31 14:56:29 +00002821 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
2822 " ccccccccccccccccc));");
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00002823 verifyFormat("DEBUG({\n"
2824 " if (a)\n"
2825 " f();\n"
2826 "});");
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00002827}
2828
2829TEST_F(FormatTest, LayoutBlockInsideStatement) {
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00002830 EXPECT_EQ("SOME_MACRO { int i; }\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002831 "int i;",
2832 format(" SOME_MACRO {int i;} int i;"));
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00002833}
2834
2835TEST_F(FormatTest, LayoutNestedBlocks) {
2836 verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
2837 " struct s {\n"
2838 " int i;\n"
2839 " };\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00002840 " s kBitsToOs[] = {{10}};\n"
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00002841 " for (int i = 0; i < 10; ++i)\n"
2842 " return;\n"
2843 "}");
Daniel Jasper1c5d9df2013-09-06 07:54:20 +00002844 verifyFormat("call(parameter, {\n"
2845 " something();\n"
2846 " // Comment using all columns.\n"
2847 " somethingelse();\n"
2848 "});",
2849 getLLVMStyleWithColumns(40));
Daniel Jaspere40caf92013-11-29 08:46:20 +00002850 verifyFormat("DEBUG( //\n"
2851 " { f(); }, a);");
2852 verifyFormat("DEBUG( //\n"
2853 " {\n"
2854 " f(); //\n"
2855 " },\n"
2856 " a);");
2857
Daniel Jasper1c5d9df2013-09-06 07:54:20 +00002858 EXPECT_EQ("call(parameter, {\n"
2859 " something();\n"
2860 " // Comment too\n"
2861 " // looooooooooong.\n"
2862 " somethingElse();\n"
2863 "});",
2864 format("call(parameter, {\n"
2865 " something();\n"
2866 " // Comment too looooooooooong.\n"
2867 " somethingElse();\n"
2868 "});",
2869 getLLVMStyleWithColumns(29)));
Daniel Jasper9b246e02013-09-08 14:07:57 +00002870 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });"));
Daniel Jasperdcd5da12013-10-20 17:28:32 +00002871 EXPECT_EQ("DEBUG({ // comment\n"
2872 " int i;\n"
2873 "});",
2874 format("DEBUG({ // comment\n"
2875 "int i;\n"
2876 "});"));
Daniel Jasper9b246e02013-09-08 14:07:57 +00002877 EXPECT_EQ("DEBUG({\n"
2878 " int i;\n"
2879 "\n"
2880 " // comment\n"
2881 " int j;\n"
2882 "});",
2883 format("DEBUG({\n"
2884 " int i;\n"
2885 "\n"
2886 " // comment\n"
2887 " int j;\n"
2888 "});"));
Daniel Jasperbbf5c1c2013-11-05 19:10:03 +00002889
2890 verifyFormat("DEBUG({\n"
2891 " if (a)\n"
2892 " return;\n"
2893 "});");
2894 verifyGoogleFormat("DEBUG({\n"
2895 " if (a) return;\n"
2896 "});");
2897 FormatStyle Style = getGoogleStyle();
2898 Style.ColumnLimit = 45;
Daniel Jasper100ffc62015-08-21 11:44:57 +00002899 verifyFormat("Debug(aaaaa,\n"
2900 " {\n"
2901 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n"
2902 " },\n"
2903 " a);",
Daniel Jasper4b444492014-11-21 13:38:53 +00002904 Style);
Daniel Jasper47b35ae2015-01-29 10:47:14 +00002905
Daniel Jaspera87af7a2015-06-30 11:32:22 +00002906 verifyFormat("SomeFunction({MACRO({ return output; }), b});");
2907
Daniel Jasper47b35ae2015-01-29 10:47:14 +00002908 verifyNoCrash("^{v^{a}}");
Daniel Jasper9c199562013-11-28 15:58:55 +00002909}
2910
Daniel Jasper5fc133e2015-05-12 10:16:02 +00002911TEST_F(FormatTest, FormatNestedBlocksInMacros) {
2912 EXPECT_EQ("#define MACRO() \\\n"
2913 " Debug(aaa, /* force line break */ \\\n"
2914 " { \\\n"
2915 " int i; \\\n"
2916 " int j; \\\n"
2917 " })",
2918 format("#define MACRO() Debug(aaa, /* force line break */ \\\n"
2919 " { int i; int j; })",
2920 getGoogleStyle()));
Daniel Jasper1a028222015-05-26 07:03:42 +00002921
2922 EXPECT_EQ("#define A \\\n"
2923 " [] { \\\n"
2924 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
2925 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n"
2926 " }",
2927 format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
2928 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }",
2929 getGoogleStyle()));
Daniel Jasper5fc133e2015-05-12 10:16:02 +00002930}
2931
Manuel Klimeke7d10a12013-01-10 13:24:24 +00002932TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) {
2933 EXPECT_EQ("{}", format("{}"));
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00002934 verifyFormat("enum E {};");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00002935 verifyFormat("enum E {}");
Manuel Klimeke7d10a12013-01-10 13:24:24 +00002936}
2937
Birunthan Mohanathasb001a0b2015-07-03 17:25:16 +00002938TEST_F(FormatTest, FormatBeginBlockEndMacros) {
2939 FormatStyle Style = getLLVMStyle();
2940 Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$";
2941 Style.MacroBlockEnd = "^[A-Z_]+_END$";
2942 verifyFormat("FOO_BEGIN\n"
2943 " FOO_ENTRY\n"
2944 "FOO_END", Style);
2945 verifyFormat("FOO_BEGIN\n"
2946 " NESTED_FOO_BEGIN\n"
2947 " NESTED_FOO_ENTRY\n"
2948 " NESTED_FOO_END\n"
2949 "FOO_END", Style);
2950 verifyFormat("FOO_BEGIN(Foo, Bar)\n"
2951 " int x;\n"
2952 " x = 1;\n"
2953 "FOO_END(Baz)", Style);
2954}
2955
Alexander Kornienko578fdd82012-12-06 18:03:27 +00002956//===----------------------------------------------------------------------===//
2957// Line break tests.
2958//===----------------------------------------------------------------------===//
2959
Daniel Jasperf79b0b12013-08-30 08:29:25 +00002960TEST_F(FormatTest, PreventConfusingIndents) {
Alexander Kornienko578fdd82012-12-06 18:03:27 +00002961 verifyFormat(
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00002962 "void f() {\n"
2963 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n"
2964 " parameter, parameter, parameter)),\n"
2965 " SecondLongCall(parameter));\n"
2966 "}");
Daniel Jasper7b5773e92013-01-28 07:35:34 +00002967 verifyFormat(
2968 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2969 " aaaaaaaaaaaaaaaaaaaaaaaa(\n"
2970 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
2971 " aaaaaaaaaaaaaaaaaaaaaaaa);");
2972 verifyFormat(
Daniel Jasperaea3bde2013-07-12 11:19:37 +00002973 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2974 " [aaaaaaaaaaaaaaaaaaaaaaaa\n"
2975 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
2976 " [aaaaaaaaaaaaaaaaaaaaaaaa]];");
Daniel Jasper7b5773e92013-01-28 07:35:34 +00002977 verifyFormat(
2978 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
2979 " aaaaaaaaaaaaaaaaaaaaaaaa<\n"
2980 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n"
2981 " aaaaaaaaaaaaaaaaaaaaaaaa>;");
Daniel Jasper240527c2017-01-16 13:13:15 +00002982 verifyFormat("int a = bbbb && ccc &&\n"
2983 " fffff(\n"
Daniel Jasper20b09ef2013-01-28 09:35:24 +00002984 "#define A Just forcing a new line\n"
Daniel Jasper240527c2017-01-16 13:13:15 +00002985 " ddd);");
Daniel Jasper7b5773e92013-01-28 07:35:34 +00002986}
2987
Daniel Jasperd69fc772013-05-08 14:12:04 +00002988TEST_F(FormatTest, LineBreakingInBinaryExpressions) {
2989 verifyFormat(
2990 "bool aaaaaaa =\n"
2991 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n"
2992 " bbbbbbbb();");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00002993 verifyFormat(
2994 "bool aaaaaaa =\n"
2995 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n"
2996 " bbbbbbbb();");
2997
Daniel Jasperd69fc772013-05-08 14:12:04 +00002998 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
2999 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n"
3000 " ccccccccc == ddddddddddd;");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00003001 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
3002 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n"
3003 " ccccccccc == ddddddddddd;");
3004 verifyFormat(
3005 "bool aaaaaaaaaaaaaaaaaaaaa =\n"
3006 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n"
3007 " ccccccccc == ddddddddddd;");
Daniel Jasperd69fc772013-05-08 14:12:04 +00003008
3009 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
3010 " aaaaaa) &&\n"
3011 " bbbbbb && cccccc;");
Daniel Jasper9f82df22013-05-28 07:42:44 +00003012 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
3013 " aaaaaa) >>\n"
3014 " bbbbbb;");
Daniel Jasperf901a572015-12-07 19:50:48 +00003015 verifyFormat("aa = Whitespaces.addUntouchableComment(\n"
Daniel Jasperd69fc772013-05-08 14:12:04 +00003016 " SourceMgr.getSpellingColumnNumber(\n"
3017 " TheLine.Last->FormatTok.Tok.getLocation()) -\n"
3018 " 1);");
Daniel Jasper571f1af2013-05-14 20:39:56 +00003019
Daniel Jasper68d888c2013-06-03 08:42:05 +00003020 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3021 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n"
3022 " cccccc) {\n}");
Daniel Jasper6a7d5a72017-06-19 07:40:49 +00003023 verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3024 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
3025 " cccccc) {\n}");
Daniel Jasper3eb341c2014-11-11 23:04:51 +00003026 verifyFormat("b = a &&\n"
3027 " // Comment\n"
3028 " b.c && d;");
Daniel Jasper68d888c2013-06-03 08:42:05 +00003029
Daniel Jasper7ae41cd2013-07-03 10:34:47 +00003030 // If the LHS of a comparison is not a binary expression itself, the
3031 // additional linebreak confuses many people.
3032 verifyFormat(
3033 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3034 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n"
3035 "}");
3036 verifyFormat(
3037 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3038 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
3039 "}");
Daniel Jasper562ecd42013-09-06 08:08:14 +00003040 verifyFormat(
3041 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n"
3042 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
3043 "}");
Daniel Jasper7ae41cd2013-07-03 10:34:47 +00003044 // Even explicit parentheses stress the precedence enough to make the
3045 // additional break unnecessary.
Daniel Jaspera44991332015-04-29 13:06:49 +00003046 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3047 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
3048 "}");
Daniel Jasper7ae41cd2013-07-03 10:34:47 +00003049 // This cases is borderline, but with the indentation it is still readable.
3050 verifyFormat(
3051 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3052 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3053 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
3054 "}",
3055 getLLVMStyleWithColumns(75));
3056
3057 // If the LHS is a binary expression, we should still use the additional break
3058 // as otherwise the formatting hides the operator precedence.
Daniel Jaspera44991332015-04-29 13:06:49 +00003059 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3060 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
3061 " 5) {\n"
3062 "}");
Daniel Jasper7ae41cd2013-07-03 10:34:47 +00003063
Daniel Jasper571f1af2013-05-14 20:39:56 +00003064 FormatStyle OnePerLine = getLLVMStyle();
3065 OnePerLine.BinPackParameters = false;
3066 verifyFormat(
3067 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3068 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3069 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}",
3070 OnePerLine);
Daniel Jaspere61f9f92017-01-13 23:18:16 +00003071
3072 verifyFormat("int i = someFunction(aaaaaaa, 0)\n"
3073 " .aaa(aaaaaaaaaaaaa) *\n"
3074 " aaaaaaa +\n"
3075 " aaaaaaa;",
3076 getLLVMStyleWithColumns(40));
Daniel Jasperd69fc772013-05-08 14:12:04 +00003077}
3078
Daniel Jasper6bee6822013-04-08 20:33:42 +00003079TEST_F(FormatTest, ExpressionIndentation) {
3080 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3081 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3082 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
3083 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
3084 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
3085 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n"
3086 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
3087 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n"
3088 " ccccccccccccccccccccccccccccccccccccccccc;");
3089 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
3090 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3091 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
3092 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
3093 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3094 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
3095 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
3096 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
3097 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
3098 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
3099 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3100 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
Daniel Jasper6dcecb62013-06-06 09:11:58 +00003101 verifyFormat("if () {\n"
Daniel Jasper21f7dea2017-02-01 09:23:39 +00003102 "} else if (aaaaa && bbbbb > // break\n"
3103 " ccccc) {\n"
3104 "}");
3105 verifyFormat("if () {\n"
Daniel Jasper5c332652014-04-03 12:00:33 +00003106 "} else if (aaaaa &&\n"
3107 " bbbbb > // break\n"
Daniel Jasper21f7dea2017-02-01 09:23:39 +00003108 " ccccc &&\n"
3109 " ddddd) {\n"
Daniel Jasper6dcecb62013-06-06 09:11:58 +00003110 "}");
Alexander Kornienkoafaa8f52013-06-17 13:19:53 +00003111
3112 // Presence of a trailing comment used to change indentation of b.
3113 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
3114 " b;\n"
3115 "return aaaaaaaaaaaaaaaaaaa +\n"
3116 " b; //",
3117 getLLVMStyleWithColumns(30));
Daniel Jasper6bee6822013-04-08 20:33:42 +00003118}
3119
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003120TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) {
3121 // Not sure what the best system is here. Like this, the LHS can be found
3122 // immediately above an operator (everything with the same or a higher
3123 // indent). The RHS is aligned right of the operator and so compasses
3124 // everything until something with the same indent as the operator is found.
3125 // FIXME: Is this a good system?
3126 FormatStyle Style = getLLVMStyle();
Daniel Jasperac043c92014-09-15 11:11:00 +00003127 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003128 verifyFormat(
3129 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00003130 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3131 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3132 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3133 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
3134 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003135 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00003136 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3137 " > ccccccccccccccccccccccccccccccccccccccccc;",
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003138 Style);
3139 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00003140 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3141 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003142 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
3143 Style);
3144 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00003145 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3146 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003147 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
3148 Style);
3149 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3150 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00003151 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3152 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003153 Style);
3154 verifyFormat("if () {\n"
Daniel Jasperc0d606a2014-04-14 11:08:45 +00003155 "} else if (aaaaa\n"
3156 " && bbbbb // break\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00003157 " > ccccc) {\n"
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003158 "}",
3159 Style);
Daniel Jasper119ff532014-11-14 12:31:14 +00003160 verifyFormat("return (a)\n"
3161 " // comment\n"
3162 " + b;",
3163 Style);
Daniel Jaspera44991332015-04-29 13:06:49 +00003164 verifyFormat(
3165 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3166 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
3167 " + cc;",
3168 Style);
Daniel Jasper9e5ede02013-11-08 19:56:28 +00003169
Daniel Jaspere92bf6f2015-05-06 14:23:38 +00003170 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3171 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
3172 Style);
3173
Daniel Jasper9e5ede02013-11-08 19:56:28 +00003174 // Forced by comments.
3175 verifyFormat(
3176 "unsigned ContentSize =\n"
3177 " sizeof(int16_t) // DWARF ARange version number\n"
3178 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
3179 " + sizeof(int8_t) // Pointer Size (in bytes)\n"
3180 " + sizeof(int8_t); // Segment Size (in bytes)");
Daniel Jasper446d1cd2013-11-23 14:45:49 +00003181
3182 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
3183 " == boost::fusion::at_c<1>(iiii).second;",
3184 Style);
Daniel Jasper0a1e5ac2014-05-13 08:01:47 +00003185
3186 Style.ColumnLimit = 60;
3187 verifyFormat("zzzzzzzzzz\n"
3188 " = bbbbbbbbbbbbbbbbb\n"
3189 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
3190 Style);
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003191}
3192
Daniel Jasperb1270392017-02-01 23:27:37 +00003193TEST_F(FormatTest, EnforcedOperatorWraps) {
3194 // Here we'd like to wrap after the || operators, but a comment is forcing an
3195 // earlier wrap.
3196 verifyFormat("bool x = aaaaa //\n"
3197 " || bbbbb\n"
3198 " //\n"
3199 " || cccc;");
3200}
3201
Daniel Jasper3219e432014-12-02 13:24:51 +00003202TEST_F(FormatTest, NoOperandAlignment) {
3203 FormatStyle Style = getLLVMStyle();
3204 Style.AlignOperands = false;
Daniel Jasperc3aa05c2017-02-02 08:30:21 +00003205 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n"
3206 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3207 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
3208 Style);
Daniel Jasper3219e432014-12-02 13:24:51 +00003209 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
Daniel Jaspera44991332015-04-29 13:06:49 +00003210 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3211 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3212 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3213 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3214 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
3215 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
3216 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3217 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3218 " > ccccccccccccccccccccccccccccccccccccccccc;",
3219 Style);
Daniel Jasper3219e432014-12-02 13:24:51 +00003220
3221 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3222 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
3223 " + cc;",
3224 Style);
3225 verifyFormat("int a = aa\n"
3226 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
Daniel Jasper21f7dea2017-02-01 09:23:39 +00003227 " * cccccccccccccccccccccccccccccccccccc;\n",
Daniel Jasper3219e432014-12-02 13:24:51 +00003228 Style);
Daniel Jasperc0956632014-12-03 14:02:59 +00003229
Daniel Jasper6501f7e2015-10-27 12:38:37 +00003230 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
Daniel Jasperc0956632014-12-03 14:02:59 +00003231 verifyFormat("return (a > b\n"
3232 " // comment1\n"
3233 " // comment2\n"
3234 " || c);",
3235 Style);
Daniel Jasper3219e432014-12-02 13:24:51 +00003236}
3237
Daniel Jasperac043c92014-09-15 11:11:00 +00003238TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) {
3239 FormatStyle Style = getLLVMStyle();
3240 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
3241 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
3242 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper3219e432014-12-02 13:24:51 +00003243 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
3244 Style);
Daniel Jasperac043c92014-09-15 11:11:00 +00003245}
3246
Daniel Jasper988e7e42017-05-08 15:07:52 +00003247TEST_F(FormatTest, AllowBinPackingInsideArguments) {
3248 FormatStyle Style = getLLVMStyle();
3249 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
3250 Style.BinPackArguments = false;
3251 Style.ColumnLimit = 40;
3252 verifyFormat("void test() {\n"
3253 " someFunction(\n"
3254 " this + argument + is + quite\n"
3255 " + long + so + it + gets + wrapped\n"
3256 " + but + remains + bin - packed);\n"
3257 "}",
3258 Style);
3259 verifyFormat("void test() {\n"
3260 " someFunction(arg1,\n"
3261 " this + argument + is\n"
3262 " + quite + long + so\n"
3263 " + it + gets + wrapped\n"
3264 " + but + remains + bin\n"
3265 " - packed,\n"
3266 " arg3);\n"
3267 "}",
3268 Style);
3269 verifyFormat("void test() {\n"
3270 " someFunction(\n"
3271 " arg1,\n"
3272 " this + argument + has\n"
3273 " + anotherFunc(nested,\n"
3274 " calls + whose\n"
3275 " + arguments\n"
3276 " + are + also\n"
3277 " + wrapped,\n"
3278 " in + addition)\n"
3279 " + to + being + bin - packed,\n"
3280 " arg3);\n"
3281 "}",
3282 Style);
3283
3284 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
3285 verifyFormat("void test() {\n"
3286 " someFunction(\n"
3287 " arg1,\n"
3288 " this + argument + has +\n"
3289 " anotherFunc(nested,\n"
3290 " calls + whose +\n"
3291 " arguments +\n"
3292 " are + also +\n"
3293 " wrapped,\n"
3294 " in + addition) +\n"
3295 " to + being + bin - packed,\n"
3296 " arg3);\n"
3297 "}",
3298 Style);
3299}
3300
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003301TEST_F(FormatTest, ConstructorInitializers) {
Manuel Klimeke7d10a12013-01-10 13:24:24 +00003302 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
Daniel Jasper2408a8c2013-01-11 11:37:55 +00003303 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
3304 getLLVMStyleWithColumns(45));
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003305 verifyFormat("Constructor()\n"
3306 " : Inttializer(FitsOnTheLine) {}",
Daniel Jasper2408a8c2013-01-11 11:37:55 +00003307 getLLVMStyleWithColumns(44));
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003308 verifyFormat("Constructor()\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003309 " : Inttializer(FitsOnTheLine) {}",
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003310 getLLVMStyleWithColumns(43));
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003311
Daniel Jasper7b259cd2015-08-27 11:59:31 +00003312 verifyFormat("template <typename T>\n"
3313 "Constructor() : Initializer(FitsOnTheLine) {}",
3314 getLLVMStyleWithColumns(45));
3315
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003316 verifyFormat(
3317 "SomeClass::Constructor()\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003318 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003319
3320 verifyFormat(
3321 "SomeClass::Constructor()\n"
Daniel Jasper2408a8c2013-01-11 11:37:55 +00003322 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003323 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}");
Daniel Jasper2408a8c2013-01-11 11:37:55 +00003324 verifyFormat(
3325 "SomeClass::Constructor()\n"
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003326 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003327 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
Daniel Jasper7b259cd2015-08-27 11:59:31 +00003328 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3329 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3330 " : aaaaaaaaaa(aaaaaa) {}");
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003331
3332 verifyFormat("Constructor()\n"
3333 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3334 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3335 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003336 " aaaaaaaaaaaaaaaaaaaaaaa() {}");
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003337
Daniel Jasper65585ed2013-01-28 13:31:35 +00003338 verifyFormat("Constructor()\n"
3339 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003340 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasper65585ed2013-01-28 13:31:35 +00003341
Daniel Jasper62e68172013-02-25 15:59:54 +00003342 verifyFormat("Constructor(int Parameter = 0)\n"
3343 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
3344 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}");
Daniel Jasper87f18f12013-09-06 21:46:41 +00003345 verifyFormat("Constructor()\n"
3346 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
3347 "}",
3348 getLLVMStyleWithColumns(60));
Daniel Jasper4fcc8b92013-11-07 17:52:51 +00003349 verifyFormat("Constructor()\n"
3350 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3351 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}");
Daniel Jasper62e68172013-02-25 15:59:54 +00003352
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003353 // Here a line could be saved by splitting the second initializer onto two
Alp Tokerf6a24ce2013-12-05 16:25:25 +00003354 // lines, but that is not desirable.
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003355 verifyFormat("Constructor()\n"
3356 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
3357 " aaaaaaaaaaa(aaaaaaaaaaa),\n"
3358 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003359
Daniel Jasper23e8e0c2013-02-15 16:49:44 +00003360 FormatStyle OnePerLine = getLLVMStyle();
3361 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
Daniel Jasper7bec87c2016-01-07 18:11:54 +00003362 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false;
Daniel Jasper23e8e0c2013-02-15 16:49:44 +00003363 verifyFormat("SomeClass::Constructor()\n"
3364 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
3365 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003366 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003367 OnePerLine);
Daniel Jasper23e8e0c2013-02-15 16:49:44 +00003368 verifyFormat("SomeClass::Constructor()\n"
3369 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
3370 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003371 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003372 OnePerLine);
Daniel Jasper23e8e0c2013-02-15 16:49:44 +00003373 verifyFormat("MyClass::MyClass(int var)\n"
3374 " : some_var_(var), // 4 space indent\n"
3375 " some_other_var_(var + 1) { // lined up\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003376 "}",
3377 OnePerLine);
Daniel Jasperead41b62013-02-28 09:39:12 +00003378 verifyFormat("Constructor()\n"
3379 " : aaaaa(aaaaaa),\n"
3380 " aaaaa(aaaaaa),\n"
3381 " aaaaa(aaaaaa),\n"
3382 " aaaaa(aaaaaa),\n"
3383 " aaaaa(aaaaaa) {}",
3384 OnePerLine);
Daniel Jaspercc960fa2013-04-22 07:59:53 +00003385 verifyFormat("Constructor()\n"
3386 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
3387 " aaaaaaaaaaaaaaaaaaaaaa) {}",
3388 OnePerLine);
Daniel Jasper7bec87c2016-01-07 18:11:54 +00003389 OnePerLine.BinPackParameters = false;
3390 verifyFormat(
3391 "Constructor()\n"
3392 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n"
3393 " aaaaaaaaaaa().aaa(),\n"
3394 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
3395 OnePerLine);
Daniel Jasperbd73bcf2015-10-27 13:42:08 +00003396 OnePerLine.ColumnLimit = 60;
3397 verifyFormat("Constructor()\n"
3398 " : aaaaaaaaaaaaaaaaaaaa(a),\n"
3399 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
3400 OnePerLine);
Daniel Jasperf6c7c182014-01-13 14:10:04 +00003401
3402 EXPECT_EQ("Constructor()\n"
3403 " : // Comment forcing unwanted break.\n"
3404 " aaaa(aaaa) {}",
3405 format("Constructor() :\n"
3406 " // Comment forcing unwanted break.\n"
3407 " aaaa(aaaa) {}"));
Daniel Jaspere3c0e012013-04-25 13:31:51 +00003408}
3409
Francois Ferranda6b6d512017-05-24 11:36:58 +00003410TEST_F(FormatTest, BreakConstructorInitializersAfterColon) {
3411 FormatStyle Style = getLLVMStyle();
3412 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
3413
3414 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
3415 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}",
3416 getStyleWithColumns(Style, 45));
3417 verifyFormat("Constructor() :\n"
3418 " Initializer(FitsOnTheLine) {}",
3419 getStyleWithColumns(Style, 44));
3420 verifyFormat("Constructor() :\n"
3421 " Initializer(FitsOnTheLine) {}",
3422 getStyleWithColumns(Style, 43));
3423
3424 verifyFormat("template <typename T>\n"
3425 "Constructor() : Initializer(FitsOnTheLine) {}",
3426 getStyleWithColumns(Style, 50));
3427
3428 verifyFormat(
3429 "SomeClass::Constructor() :\n"
3430 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
3431 Style);
3432
3433 verifyFormat(
3434 "SomeClass::Constructor() :\n"
3435 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
3436 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
3437 Style);
3438 verifyFormat(
3439 "SomeClass::Constructor() :\n"
3440 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3441 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
3442 Style);
3443 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3444 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
3445 " aaaaaaaaaa(aaaaaa) {}",
3446 Style);
3447
3448 verifyFormat("Constructor() :\n"
3449 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3450 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3451 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3452 " aaaaaaaaaaaaaaaaaaaaaaa() {}",
3453 Style);
3454
3455 verifyFormat("Constructor() :\n"
3456 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3457 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
3458 Style);
3459
3460 verifyFormat("Constructor(int Parameter = 0) :\n"
3461 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
3462 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}",
3463 Style);
3464 verifyFormat("Constructor() :\n"
3465 " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
3466 "}",
3467 getStyleWithColumns(Style, 60));
3468 verifyFormat("Constructor() :\n"
3469 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3470 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}",
3471 Style);
3472
3473 // Here a line could be saved by splitting the second initializer onto two
3474 // lines, but that is not desirable.
3475 verifyFormat("Constructor() :\n"
3476 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
3477 " aaaaaaaaaaa(aaaaaaaaaaa),\n"
3478 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
3479 Style);
3480
3481 FormatStyle OnePerLine = Style;
3482 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
3483 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false;
3484 verifyFormat("SomeClass::Constructor() :\n"
3485 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
3486 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
3487 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
3488 OnePerLine);
3489 verifyFormat("SomeClass::Constructor() :\n"
3490 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
3491 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
3492 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
3493 OnePerLine);
3494 verifyFormat("MyClass::MyClass(int var) :\n"
3495 " some_var_(var), // 4 space indent\n"
3496 " some_other_var_(var + 1) { // lined up\n"
3497 "}",
3498 OnePerLine);
3499 verifyFormat("Constructor() :\n"
3500 " aaaaa(aaaaaa),\n"
3501 " aaaaa(aaaaaa),\n"
3502 " aaaaa(aaaaaa),\n"
3503 " aaaaa(aaaaaa),\n"
3504 " aaaaa(aaaaaa) {}",
3505 OnePerLine);
3506 verifyFormat("Constructor() :\n"
3507 " aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
3508 " aaaaaaaaaaaaaaaaaaaaaa) {}",
3509 OnePerLine);
3510 OnePerLine.BinPackParameters = false;
3511 verifyFormat(
3512 "Constructor() :\n"
3513 " aaaaaaaaaaaaaaaaaaaaaaaa(\n"
3514 " aaaaaaaaaaa().aaa(),\n"
3515 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
3516 OnePerLine);
3517 OnePerLine.ColumnLimit = 60;
3518 verifyFormat("Constructor() :\n"
3519 " aaaaaaaaaaaaaaaaaaaa(a),\n"
3520 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
3521 OnePerLine);
3522
3523 EXPECT_EQ("Constructor() :\n"
3524 " // Comment forcing unwanted break.\n"
3525 " aaaa(aaaa) {}",
3526 format("Constructor() :\n"
3527 " // Comment forcing unwanted break.\n"
3528 " aaaa(aaaa) {}",
3529 Style));
3530
3531 Style.ColumnLimit = 0;
3532 verifyFormat("SomeClass::Constructor() :\n"
3533 " a(a) {}",
3534 Style);
3535 verifyFormat("SomeClass::Constructor() noexcept :\n"
3536 " a(a) {}",
3537 Style);
3538 verifyFormat("SomeClass::Constructor() :\n"
3539 " a(a), b(b), c(c) {}",
3540 Style);
3541 verifyFormat("SomeClass::Constructor() :\n"
3542 " a(a) {\n"
3543 " foo();\n"
3544 " bar();\n"
3545 "}",
3546 Style);
3547
3548 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
3549 verifyFormat("SomeClass::Constructor() :\n"
3550 " a(a), b(b), c(c) {\n"
3551 "}",
3552 Style);
3553 verifyFormat("SomeClass::Constructor() :\n"
3554 " a(a) {\n"
3555 "}",
3556 Style);
3557
3558 Style.ColumnLimit = 80;
3559 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
3560 Style.ConstructorInitializerIndentWidth = 2;
3561 verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}",
3562 Style);
3563 verifyFormat("SomeClass::Constructor() :\n"
3564 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3565 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}",
3566 Style);
3567}
3568
David Blaikieea95dd72017-08-31 18:49:34 +00003569#ifndef EXPENSIVE_CHECKS
3570// Expensive checks enables libstdc++ checking which includes validating the
3571// state of ranges used in std::priority_queue - this blows out the
3572// runtime/scalability of the function and makes this test unacceptably slow.
Daniel Jaspere3c0e012013-04-25 13:31:51 +00003573TEST_F(FormatTest, MemoizationTests) {
3574 // This breaks if the memoization lookup does not take \c Indent and
3575 // \c LastSpace into account.
3576 verifyFormat(
3577 "extern CFRunLoopTimerRef\n"
3578 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
3579 " CFTimeInterval interval, CFOptionFlags flags,\n"
3580 " CFIndex order, CFRunLoopTimerCallBack callout,\n"
Daniel Jasper8e357692013-05-06 08:27:33 +00003581 " CFRunLoopTimerContext *context) {}");
Daniel Jaspere3c0e012013-04-25 13:31:51 +00003582
3583 // Deep nesting somewhat works around our memoization.
3584 verifyFormat(
3585 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
3586 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
3587 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
3588 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
3589 " aaaaa())))))))))))))))))))))))))))))))))))))));",
3590 getLLVMStyleWithColumns(65));
Daniel Jaspercc3044c2013-05-13 09:19:24 +00003591 verifyFormat(
3592 "aaaaa(\n"
3593 " aaaaa,\n"
3594 " aaaaa(\n"
3595 " aaaaa,\n"
3596 " aaaaa(\n"
3597 " aaaaa,\n"
3598 " aaaaa(\n"
3599 " aaaaa,\n"
3600 " aaaaa(\n"
3601 " aaaaa,\n"
3602 " aaaaa(\n"
3603 " aaaaa,\n"
3604 " aaaaa(\n"
3605 " aaaaa,\n"
3606 " aaaaa(\n"
3607 " aaaaa,\n"
3608 " aaaaa(\n"
3609 " aaaaa,\n"
3610 " aaaaa(\n"
3611 " aaaaa,\n"
3612 " aaaaa(\n"
3613 " aaaaa,\n"
3614 " aaaaa(\n"
3615 " aaaaa,\n"
3616 " aaaaa))))))))))));",
3617 getLLVMStyleWithColumns(65));
Daniel Jasperf8114cf2013-05-22 05:27:42 +00003618 verifyFormat(
3619 "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"
3620 " a),\n"
3621 " a),\n"
3622 " a),\n"
3623 " a),\n"
3624 " a),\n"
3625 " a),\n"
3626 " a),\n"
3627 " a),\n"
3628 " a),\n"
3629 " a),\n"
3630 " a),\n"
3631 " a),\n"
3632 " a),\n"
3633 " a),\n"
3634 " a),\n"
3635 " a),\n"
3636 " a)",
3637 getLLVMStyleWithColumns(65));
Daniel Jasper7b7877a2013-01-12 07:36:22 +00003638
3639 // This test takes VERY long when memoization is broken.
Daniel Jaspere3c0e012013-04-25 13:31:51 +00003640 FormatStyle OnePerLine = getLLVMStyle();
3641 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003642 OnePerLine.BinPackParameters = false;
Daniel Jasper9278eb92013-01-16 14:59:02 +00003643 std::string input = "Constructor()\n"
Daniel Jasper7a31af12013-01-25 15:43:32 +00003644 " : aaaa(a,\n";
Daniel Jasper9278eb92013-01-16 14:59:02 +00003645 for (unsigned i = 0, e = 80; i != e; ++i) {
3646 input += " a,\n";
3647 }
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003648 input += " a) {}";
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003649 verifyFormat(input, OnePerLine);
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003650}
David Blaikieea95dd72017-08-31 18:49:34 +00003651#endif
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003652
Alexander Kornienko578fdd82012-12-06 18:03:27 +00003653TEST_F(FormatTest, BreaksAsHighAsPossible) {
3654 verifyFormat(
Alexander Kornienkoa5151272013-03-12 16:28:18 +00003655 "void f() {\n"
3656 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
3657 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
3658 " f();\n"
3659 "}");
Daniel Jasper70bc8742013-02-26 13:59:14 +00003660 verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00003661 " Intervals[i - 1].getRange().getLast()) {\n}");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00003662}
3663
Daniel Jasper6728fc12013-04-11 14:29:13 +00003664TEST_F(FormatTest, BreaksFunctionDeclarations) {
3665 // Principially, we break function declarations in a certain order:
3666 // 1) break amongst arguments.
3667 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
3668 " Cccccccccccccc cccccccccccccc);");
Daniel Jaspera44991332015-04-29 13:06:49 +00003669 verifyFormat("template <class TemplateIt>\n"
3670 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n"
3671 " TemplateIt *stop) {}");
Daniel Jasper6728fc12013-04-11 14:29:13 +00003672
3673 // 2) break after return type.
Daniel Jasper8e357692013-05-06 08:27:33 +00003674 verifyFormat(
Manuel Klimek836c2862013-06-21 17:25:42 +00003675 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00003676 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);",
Manuel Klimek836c2862013-06-21 17:25:42 +00003677 getGoogleStyle());
Daniel Jasper6728fc12013-04-11 14:29:13 +00003678
3679 // 3) break after (.
3680 verifyFormat(
3681 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
Manuel Klimek836c2862013-06-21 17:25:42 +00003682 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);",
3683 getGoogleStyle());
Daniel Jasper6728fc12013-04-11 14:29:13 +00003684
3685 // 4) break before after nested name specifiers.
3686 verifyFormat(
3687 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00003688 "SomeClasssssssssssssssssssssssssssssssssssssss::\n"
3689 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);",
Manuel Klimek836c2862013-06-21 17:25:42 +00003690 getGoogleStyle());
Daniel Jasper6728fc12013-04-11 14:29:13 +00003691
3692 // However, there are exceptions, if a sufficient amount of lines can be
3693 // saved.
3694 // FIXME: The precise cut-offs wrt. the number of saved lines might need some
3695 // more adjusting.
3696 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
3697 " Cccccccccccccc cccccccccc,\n"
3698 " Cccccccccccccc cccccccccc,\n"
3699 " Cccccccccccccc cccccccccc,\n"
3700 " Cccccccccccccc cccccccccc);");
3701 verifyFormat(
Manuel Klimek836c2862013-06-21 17:25:42 +00003702 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00003703 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3704 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3705 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);",
Manuel Klimek836c2862013-06-21 17:25:42 +00003706 getGoogleStyle());
Daniel Jasper6728fc12013-04-11 14:29:13 +00003707 verifyFormat(
3708 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
3709 " Cccccccccccccc cccccccccc,\n"
3710 " Cccccccccccccc cccccccccc,\n"
3711 " Cccccccccccccc cccccccccc,\n"
3712 " Cccccccccccccc cccccccccc,\n"
3713 " Cccccccccccccc cccccccccc,\n"
3714 " Cccccccccccccc cccccccccc);");
3715 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
3716 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3717 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3718 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3719 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
Daniel Jasper1b8e76f2013-04-15 22:36:37 +00003720
3721 // Break after multi-line parameters.
3722 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3723 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3724 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3725 " bbbb bbbb);");
Daniel Jasper6c0ee172014-11-14 13:14:45 +00003726 verifyFormat("void SomeLoooooooooooongFunction(\n"
3727 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
3728 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3729 " int bbbbbbbbbbbbb);");
Daniel Jasper6331da02013-07-09 07:43:55 +00003730
3731 // Treat overloaded operators like other functions.
3732 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
3733 "operator>(const SomeLoooooooooooooooooooooooooogType &other);");
Daniel Jasperd215b8b2013-08-28 07:27:35 +00003734 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
3735 "operator>>(const SomeLooooooooooooooooooooooooogType &other);");
Alexander Kornienko86b2dfd2014-03-06 15:13:08 +00003736 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
3737 "operator<<(const SomeLooooooooooooooooooooooooogType &other);");
3738 verifyGoogleFormat(
3739 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n"
3740 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
Daniel Jasper6331da02013-07-09 07:43:55 +00003741 verifyGoogleFormat(
3742 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n"
3743 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
Daniel Jasper126153a2013-12-27 06:39:56 +00003744 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3745 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);");
3746 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n"
3747 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);");
Daniel Jasperea79ea12014-08-15 05:00:39 +00003748 verifyGoogleFormat(
3749 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n"
3750 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3751 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}");
Daniel Jasper88db7602016-02-11 06:43:01 +00003752 verifyGoogleFormat(
3753 "template <typename T>\n"
3754 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3755 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n"
3756 " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);");
Daniel Jasper11309812015-03-18 14:20:13 +00003757
3758 FormatStyle Style = getLLVMStyle();
3759 Style.PointerAlignment = FormatStyle::PAS_Left;
3760 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3761 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}",
3762 Style);
Daniel Jaspera44991332015-04-29 13:06:49 +00003763 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
3764 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
3765 Style);
Daniel Jasper6728fc12013-04-11 14:29:13 +00003766}
3767
Daniel Jasper6cdec7c2013-07-09 14:36:48 +00003768TEST_F(FormatTest, TrailingReturnType) {
3769 verifyFormat("auto foo() -> int;\n");
3770 verifyFormat("struct S {\n"
3771 " auto bar() const -> int;\n"
3772 "};");
3773 verifyFormat("template <size_t Order, typename T>\n"
3774 "auto load_img(const std::string &filename)\n"
3775 " -> alias::tensor<Order, T, mem::tag::cpu> {}");
Daniel Jasperda07a722014-10-17 14:37:40 +00003776 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n"
3777 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}");
Daniel Jasperb52c69e2014-10-22 09:01:12 +00003778 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}");
Daniel Jasper6f2b88a2015-06-05 13:18:09 +00003779 verifyFormat("template <typename T>\n"
3780 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n"
3781 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());");
Daniel Jaspera3501d42013-07-11 14:33:06 +00003782
3783 // Not trailing return types.
3784 verifyFormat("void f() { auto a = b->c(); }");
Daniel Jasper6cdec7c2013-07-09 14:36:48 +00003785}
3786
Daniel Jasper5be31f72013-05-21 09:16:31 +00003787TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) {
Daniel Jasperd8c36d02013-10-18 16:34:40 +00003788 // Avoid breaking before trailing 'const' or other trailing annotations, if
3789 // they are not function-like.
Daniel Jasper13c37b32013-05-22 08:28:26 +00003790 FormatStyle Style = getGoogleStyle();
3791 Style.ColumnLimit = 47;
Daniel Jaspere068ac72014-10-27 17:13:59 +00003792 verifyFormat("void someLongFunction(\n"
3793 " int someLoooooooooooooongParameter) const {\n}",
Daniel Jasper13c37b32013-05-22 08:28:26 +00003794 getLLVMStyleWithColumns(47));
Daniel Jasper13c37b32013-05-22 08:28:26 +00003795 verifyFormat("LoooooongReturnType\n"
3796 "someLoooooooongFunction() const {}",
3797 getLLVMStyleWithColumns(47));
3798 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
3799 " const {}",
3800 Style);
Daniel Jasperd8c36d02013-10-18 16:34:40 +00003801 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
3802 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;");
3803 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
3804 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;");
3805 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
3806 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;");
Daniel Jasper43e6a282013-12-16 15:01:54 +00003807 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n"
3808 " aaaaaaaaaaa aaaaa) const override;");
3809 verifyGoogleFormat(
3810 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
3811 " const override;");
Daniel Jasper5be31f72013-05-21 09:16:31 +00003812
Daniel Jasper5550de62014-02-17 07:57:46 +00003813 // Even if the first parameter has to be wrapped.
3814 verifyFormat("void someLongFunction(\n"
3815 " int someLongParameter) const {}",
Daniel Jasperd8c36d02013-10-18 16:34:40 +00003816 getLLVMStyleWithColumns(46));
Daniel Jasper5550de62014-02-17 07:57:46 +00003817 verifyFormat("void someLongFunction(\n"
3818 " int someLongParameter) const {}",
Daniel Jasperd8c36d02013-10-18 16:34:40 +00003819 Style);
Daniel Jasper5550de62014-02-17 07:57:46 +00003820 verifyFormat("void someLongFunction(\n"
3821 " int someLongParameter) override {}",
3822 Style);
3823 verifyFormat("void someLongFunction(\n"
Daniel Jasperb48d3af2014-04-09 10:01:49 +00003824 " int someLongParameter) OVERRIDE {}",
3825 Style);
3826 verifyFormat("void someLongFunction(\n"
Daniel Jasper5550de62014-02-17 07:57:46 +00003827 " int someLongParameter) final {}",
3828 Style);
3829 verifyFormat("void someLongFunction(\n"
Daniel Jasperb48d3af2014-04-09 10:01:49 +00003830 " int someLongParameter) FINAL {}",
3831 Style);
3832 verifyFormat("void someLongFunction(\n"
Daniel Jasper5550de62014-02-17 07:57:46 +00003833 " int parameter) const override {}",
3834 Style);
3835
Daniel Jaspere3f907f2014-06-02 09:52:08 +00003836 Style.BreakBeforeBraces = FormatStyle::BS_Allman;
3837 verifyFormat("void someLongFunction(\n"
3838 " int someLongParameter) const\n"
3839 "{\n"
3840 "}",
3841 Style);
3842
Daniel Jasper5550de62014-02-17 07:57:46 +00003843 // Unless these are unknown annotations.
Daniel Jasperd8c36d02013-10-18 16:34:40 +00003844 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n"
3845 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3846 " LONG_AND_UGLY_ANNOTATION;");
Daniel Jasper718bd362013-07-11 21:02:56 +00003847
3848 // Breaking before function-like trailing annotations is fine to keep them
3849 // close to their arguments.
Daniel Jasper5be31f72013-05-21 09:16:31 +00003850 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3851 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
3852 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
3853 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
3854 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
3855 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}");
Daniel Jasperf9a09062014-04-09 10:29:11 +00003856 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n"
3857 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);");
Daniel Jasper8b76d602014-07-28 12:08:06 +00003858 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});");
Daniel Jasper5be31f72013-05-21 09:16:31 +00003859
3860 verifyFormat(
3861 "void aaaaaaaaaaaaaaaaaa()\n"
3862 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
3863 " aaaaaaaaaaaaaaaaaaaaaaaaa));");
3864 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3865 " __attribute__((unused));");
Daniel Jasper35ec2b22014-04-14 08:15:20 +00003866 verifyGoogleFormat(
Manuel Klimek836c2862013-06-21 17:25:42 +00003867 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper35ec2b22014-04-14 08:15:20 +00003868 " GUARDED_BY(aaaaaaaaaaaa);");
3869 verifyGoogleFormat(
Daniel Jasper40db06a2013-07-11 12:34:23 +00003870 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper35ec2b22014-04-14 08:15:20 +00003871 " GUARDED_BY(aaaaaaaaaaaa);");
3872 verifyGoogleFormat(
3873 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
3874 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper3ca283a2015-05-15 09:58:11 +00003875 verifyGoogleFormat(
3876 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
3877 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper5be31f72013-05-21 09:16:31 +00003878}
3879
Daniel Jasperf090f032015-05-18 09:47:22 +00003880TEST_F(FormatTest, FunctionAnnotations) {
3881 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
Daniel Jasper788ffd72015-08-24 15:10:01 +00003882 "int OldFunction(const string &parameter) {}");
3883 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
Daniel Jasperf090f032015-05-18 09:47:22 +00003884 "string OldFunction(const string &parameter) {}");
3885 verifyFormat("template <typename T>\n"
3886 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
3887 "string OldFunction(const string &parameter) {}");
Daniel Jasper47bbda02015-05-18 13:47:23 +00003888
3889 // Not function annotations.
3890 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3891 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
Daniel Jasper32739302015-05-27 04:55:47 +00003892 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n"
3893 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}");
Daniel Jasper19bc1d02016-04-06 13:58:09 +00003894 verifyFormat("MACRO(abc).function() // wrap\n"
3895 " << abc;");
3896 verifyFormat("MACRO(abc)->function() // wrap\n"
3897 " << abc;");
3898 verifyFormat("MACRO(abc)::function() // wrap\n"
3899 " << abc;");
Daniel Jasperf090f032015-05-18 09:47:22 +00003900}
3901
Daniel Jasperf7935112012-12-03 18:12:45 +00003902TEST_F(FormatTest, BreaksDesireably) {
3903 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
3904 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003905 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
Daniel Jasper39e27382013-01-23 20:41:06 +00003906 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3907 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
3908 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +00003909
3910 verifyFormat(
3911 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003912 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasperf7935112012-12-03 18:12:45 +00003913
3914 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3915 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3916 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jasper9b155472012-12-04 10:50:12 +00003917
3918 verifyFormat(
Daniel Jasper240527c2017-01-16 13:13:15 +00003919 "aaaaaaaa(aaaaaaaaaaaaa,\n"
3920 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3921 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
Daniel Jasper9b155472012-12-04 10:50:12 +00003922 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3923 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));");
Daniel Jasperaa1c9202012-12-05 14:57:28 +00003924
3925 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3926 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
3927
Daniel Jasper3d0c75c2013-01-02 14:40:02 +00003928 verifyFormat(
Alexander Kornienkoa5151272013-03-12 16:28:18 +00003929 "void f() {\n"
3930 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
3931 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
3932 "}");
Daniel Jasper7a31af12013-01-25 15:43:32 +00003933 verifyFormat(
3934 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3935 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
3936 verifyFormat(
Daniel Jasper21f7dea2017-02-01 09:23:39 +00003937 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3938 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
3939 verifyFormat(
Daniel Jasper240527c2017-01-16 13:13:15 +00003940 "aaaaaa(aaa,\n"
3941 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasper21f7dea2017-02-01 09:23:39 +00003942 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3943 " aaaa);");
Daniel Jaspera44991332015-04-29 13:06:49 +00003944 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3945 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3946 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper3d0c75c2013-01-02 14:40:02 +00003947
Daniel Jasper739b85f2015-06-29 10:42:59 +00003948 // Indent consistently independent of call expression and unary operator.
3949 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
3950 " dddddddddddddddddddddddddddddd));");
3951 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
3952 " dddddddddddddddddddddddddddddd));");
Daniel Jasperf79b0b12013-08-30 08:29:25 +00003953 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
Daniel Jasperf79b0b12013-08-30 08:29:25 +00003954 " dddddddddddddddddddddddddddddd));");
3955
Daniel Jasperaa1c9202012-12-05 14:57:28 +00003956 // This test case breaks on an incorrect memoization, i.e. an optimization not
3957 // taking into account the StopAt value.
3958 verifyFormat(
3959 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
Daniel Jasper2eda23e2012-12-24 13:43:52 +00003960 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
3961 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
3962 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper6d822722012-12-24 16:43:00 +00003963
Daniel Jasper8d1832e2013-01-07 13:26:07 +00003964 verifyFormat("{\n {\n {\n"
3965 " Annotation.SpaceRequiredBefore =\n"
3966 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
3967 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
3968 " }\n }\n}");
Alexander Kornienko4d26b6e2013-06-17 12:59:44 +00003969
3970 // Break on an outer level if there was a break on an inner level.
3971 EXPECT_EQ("f(g(h(a, // comment\n"
3972 " b, c),\n"
3973 " d, e),\n"
3974 " x, y);",
3975 format("f(g(h(a, // comment\n"
3976 " b, c), d, e), x, y);"));
Daniel Jasperee7539a2013-07-08 14:25:23 +00003977
3978 // Prefer breaking similar line breaks.
3979 verifyFormat(
3980 "const int kTrackingOptions = NSTrackingMouseMoved |\n"
3981 " NSTrackingMouseEnteredAndExited |\n"
3982 " NSTrackingActiveAlways;");
Daniel Jasperf7935112012-12-03 18:12:45 +00003983}
3984
Daniel Jasper18210d72014-10-09 09:52:05 +00003985TEST_F(FormatTest, FormatsDeclarationsOnePerLine) {
3986 FormatStyle NoBinPacking = getGoogleStyle();
3987 NoBinPacking.BinPackParameters = false;
3988 NoBinPacking.BinPackArguments = true;
3989 verifyFormat("void f() {\n"
3990 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n"
3991 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
3992 "}",
3993 NoBinPacking);
3994 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n"
3995 " int aaaaaaaaaaaaaaaaaaaa,\n"
3996 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
3997 NoBinPacking);
Daniel Jasper06ca0fc2016-01-11 11:01:05 +00003998
Daniel Jasper00693b082016-01-09 15:56:47 +00003999 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
4000 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4001 " vector<int> bbbbbbbbbbbbbbb);",
4002 NoBinPacking);
Daniel Jasper06ca0fc2016-01-11 11:01:05 +00004003 // FIXME: This behavior difference is probably not wanted. However, currently
4004 // we cannot distinguish BreakBeforeParameter being set because of the wrapped
4005 // template arguments from BreakBeforeParameter being set because of the
4006 // one-per-line formatting.
4007 verifyFormat(
4008 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n"
4009 " aaaaaaaaaa> aaaaaaaaaa);",
4010 NoBinPacking);
4011 verifyFormat(
4012 "void fffffffffff(\n"
4013 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n"
4014 " aaaaaaaaaa);");
Daniel Jasper18210d72014-10-09 09:52:05 +00004015}
4016
Daniel Jasper9278eb92013-01-16 14:59:02 +00004017TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
Daniel Jaspera628c982013-04-03 13:36:17 +00004018 FormatStyle NoBinPacking = getGoogleStyle();
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004019 NoBinPacking.BinPackParameters = false;
Daniel Jasper18210d72014-10-09 09:52:05 +00004020 NoBinPacking.BinPackArguments = false;
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004021 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
4022 " aaaaaaaaaaaaaaaaaaaa,\n"
4023 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);",
4024 NoBinPacking);
4025 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
4026 " aaaaaaaaaaaaa,\n"
4027 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));",
4028 NoBinPacking);
4029 verifyFormat(
Daniel Jasper9278eb92013-01-16 14:59:02 +00004030 "aaaaaaaa(aaaaaaaaaaaaa,\n"
4031 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4032 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
4033 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004034 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));",
4035 NoBinPacking);
4036 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
4037 " .aaaaaaaaaaaaaaaaaa();",
4038 NoBinPacking);
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00004039 verifyFormat("void f() {\n"
4040 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4041 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n"
4042 "}",
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004043 NoBinPacking);
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00004044
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004045 verifyFormat(
Daniel Jaspere941b162013-01-23 10:08:28 +00004046 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4047 " aaaaaaaaaaaa,\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004048 " aaaaaaaaaaaa);",
4049 NoBinPacking);
4050 verifyFormat(
Daniel Jasper9278eb92013-01-16 14:59:02 +00004051 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
4052 " ddddddddddddddddddddddddddddd),\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004053 " test);",
4054 NoBinPacking);
Daniel Jasper9278eb92013-01-16 14:59:02 +00004055
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004056 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
4057 " aaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper253dad232015-11-23 15:55:45 +00004058 " aaaaaaaaaaaaaaaaaaaaaaa>\n"
4059 " aaaaaaaaaaaaaaaaaa;",
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004060 NoBinPacking);
4061 verifyFormat("a(\"a\"\n"
4062 " \"a\",\n"
4063 " a);");
Daniel Jaspere941b162013-01-23 10:08:28 +00004064
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004065 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
Daniel Jasperf7db4332013-01-29 16:03:49 +00004066 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
Daniel Jaspere941b162013-01-23 10:08:28 +00004067 " aaaaaaaaa,\n"
Daniel Jasperf7db4332013-01-29 16:03:49 +00004068 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004069 NoBinPacking);
Daniel Jasper687af3b2013-02-14 14:26:07 +00004070 verifyFormat(
4071 "void f() {\n"
4072 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
4073 " .aaaaaaa();\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00004074 "}",
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004075 NoBinPacking);
Daniel Jasper53e8d852013-05-22 08:55:55 +00004076 verifyFormat(
4077 "template <class SomeType, class SomeOtherType>\n"
4078 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
4079 NoBinPacking);
Daniel Jasper9278eb92013-01-16 14:59:02 +00004080}
4081
Daniel Jasperb10cbc42013-07-10 14:02:49 +00004082TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
4083 FormatStyle Style = getLLVMStyleWithColumns(15);
4084 Style.ExperimentalAutoDetectBinPacking = true;
4085 EXPECT_EQ("aaa(aaaa,\n"
4086 " aaaa,\n"
4087 " aaaa);\n"
4088 "aaa(aaaa,\n"
4089 " aaaa,\n"
4090 " aaaa);",
4091 format("aaa(aaaa,\n" // one-per-line
4092 " aaaa,\n"
4093 " aaaa );\n"
4094 "aaa(aaaa, aaaa, aaaa);", // inconclusive
4095 Style));
4096 EXPECT_EQ("aaa(aaaa, aaaa,\n"
4097 " aaaa);\n"
4098 "aaa(aaaa, aaaa,\n"
4099 " aaaa);",
4100 format("aaa(aaaa, aaaa,\n" // bin-packed
4101 " aaaa );\n"
4102 "aaa(aaaa, aaaa, aaaa);", // inconclusive
4103 Style));
4104}
4105
Daniel Jasper04468962013-01-18 10:56:38 +00004106TEST_F(FormatTest, FormatsBuilderPattern) {
Daniel Jaspera44991332015-04-29 13:06:49 +00004107 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n"
4108 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
4109 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
4110 " .StartsWith(\".init\", ORDER_INIT)\n"
4111 " .StartsWith(\".fini\", ORDER_FINI)\n"
4112 " .StartsWith(\".hash\", ORDER_HASH)\n"
4113 " .Default(ORDER_TEXT);\n");
Daniel Jasperc6fbc212013-05-15 09:35:08 +00004114
Daniel Jaspereb50c672013-02-15 20:33:06 +00004115 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00004116 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
Daniel Jasper9ed9ade2013-02-18 13:24:21 +00004117 verifyFormat(
Daniel Jasper801cdb22016-01-05 13:03:59 +00004118 "aaaaaaa->aaaaaaa\n"
4119 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4120 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
Daniel Jasper9ed9ade2013-02-18 13:24:21 +00004121 " ->aaaaaaaa(aaaaaaaaaaaaaaa);");
Daniel Jaspere53beb22013-02-18 13:52:06 +00004122 verifyFormat(
Daniel Jasperf901a572015-12-07 19:50:48 +00004123 "aaaaaaa->aaaaaaa\n"
4124 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4125 " ->aaaaaaaa(aaaaaaaaaaaaaaa);");
4126 verifyFormat(
Daniel Jaspere53beb22013-02-18 13:52:06 +00004127 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
Daniel Jasperf9a84b52013-03-01 16:48:32 +00004128 " aaaaaaaaaaaaaa);");
Daniel Jaspere53beb22013-02-18 13:52:06 +00004129 verifyFormat(
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004130 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n"
4131 " aaaaaa->aaaaaaaaaaaa()\n"
4132 " ->aaaaaaaaaaaaaaaa(\n"
Daniel Jasper9dedc7752015-04-07 06:41:24 +00004133 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004134 " ->aaaaaaaaaaaaaaaaa();");
Daniel Jasper33b909c2013-10-25 14:29:37 +00004135 verifyGoogleFormat(
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00004136 "void f() {\n"
4137 " someo->Add((new util::filetools::Handler(dir))\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004138 " ->OnEvent1(NewPermanentCallback(\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00004139 " this, &HandlerHolderClass::EventHandlerCBA))\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004140 " ->OnEvent2(NewPermanentCallback(\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00004141 " this, &HandlerHolderClass::EventHandlerCBB))\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004142 " ->OnEvent3(NewPermanentCallback(\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00004143 " this, &HandlerHolderClass::EventHandlerCBC))\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004144 " ->OnEvent5(NewPermanentCallback(\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00004145 " this, &HandlerHolderClass::EventHandlerCBD))\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004146 " ->OnEvent6(NewPermanentCallback(\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00004147 " this, &HandlerHolderClass::EventHandlerCBE)));\n"
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00004148 "}");
Daniel Jasper4c6e0052013-08-27 14:24:43 +00004149
4150 verifyFormat(
4151 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();");
4152 verifyFormat("aaaaaaaaaaaaaaa()\n"
4153 " .aaaaaaaaaaaaaaa()\n"
4154 " .aaaaaaaaaaaaaaa()\n"
4155 " .aaaaaaaaaaaaaaa()\n"
4156 " .aaaaaaaaaaaaaaa();");
4157 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
4158 " .aaaaaaaaaaaaaaa()\n"
4159 " .aaaaaaaaaaaaaaa()\n"
4160 " .aaaaaaaaaaaaaaa();");
4161 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
4162 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
4163 " .aaaaaaaaaaaaaaa();");
Daniel Jasperf8151e92013-08-30 07:12:40 +00004164 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
4165 " ->aaaaaaaaaaaaaae(0)\n"
4166 " ->aaaaaaaaaaaaaaa();");
Daniel Jasper36c28ce2013-09-06 08:54:24 +00004167
Daniel Jasper775954b2015-04-24 10:08:09 +00004168 // Don't linewrap after very short segments.
4169 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4170 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4171 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
4172 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4173 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4174 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
4175 verifyFormat("aaa()\n"
4176 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4177 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4178 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
4179
Daniel Jaspercc3114d2013-10-18 15:23:06 +00004180 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
4181 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4182 " .has<bbbbbbbbbbbbbbbbbbbbb>();");
4183 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
4184 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00004185 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();");
Daniel Jaspercc3114d2013-10-18 15:23:06 +00004186
Daniel Jaspera41aa532014-09-19 08:01:25 +00004187 // Prefer not to break after empty parentheses.
Daniel Jasper36c28ce2013-09-06 08:54:24 +00004188 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
4189 " First->LastNewlineOffset);");
Daniel Jasperf901a572015-12-07 19:50:48 +00004190
4191 // Prefer not to create "hanging" indents.
4192 verifyFormat(
4193 "return !soooooooooooooome_map\n"
4194 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4195 " .second;");
Daniel Jasper00492f92016-01-05 13:03:50 +00004196 verifyFormat(
4197 "return aaaaaaaaaaaaaaaa\n"
4198 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n"
4199 " .aaaa(aaaaaaaaaaaaaa);");
4200 // No hanging indent here.
4201 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n"
4202 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
4203 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n"
4204 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper801cdb22016-01-05 13:03:59 +00004205 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
4206 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4207 getLLVMStyleWithColumns(60));
4208 verifyFormat("aaaaaaaaaaaaaaaaaa\n"
4209 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
4210 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4211 getLLVMStyleWithColumns(59));
Daniel Jasper411af722016-01-05 16:10:39 +00004212 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4213 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4214 " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper04468962013-01-18 10:56:38 +00004215}
4216
Daniel Jasperde5c2072012-12-24 00:13:23 +00004217TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) {
4218 verifyFormat(
4219 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004220 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00004221 verifyFormat(
4222 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n"
4223 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}");
4224
Daniel Jasper8d1832e2013-01-07 13:26:07 +00004225 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004226 " ccccccccccccccccccccccccc) {\n}");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00004227 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n"
4228 " ccccccccccccccccccccccccc) {\n}");
4229
Daniel Jasper8d1832e2013-01-07 13:26:07 +00004230 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004231 " ccccccccccccccccccccccccc) {\n}");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00004232 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n"
4233 " ccccccccccccccccccccccccc) {\n}");
4234
Daniel Jasperde5c2072012-12-24 00:13:23 +00004235 verifyFormat(
4236 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004237 " ccccccccccccccccccccccccc) {\n}");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00004238 verifyFormat(
4239 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n"
4240 " ccccccccccccccccccccccccc) {\n}");
4241
Daniel Jasper400adc62013-02-08 15:28:42 +00004242 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
4243 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
4244 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
4245 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00004246 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n"
4247 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n"
4248 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n"
4249 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
4250
Daniel Jasper400adc62013-02-08 15:28:42 +00004251 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
4252 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
4253 " aaaaaaaaaaaaaaa != aa) {\n}");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00004254 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n"
4255 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n"
4256 " aaaaaaaaaaaaaaa != aa) {\n}");
Daniel Jasperde5c2072012-12-24 00:13:23 +00004257}
4258
Daniel Jasper43b65482013-01-23 12:27:43 +00004259TEST_F(FormatTest, BreaksAfterAssignments) {
Daniel Jasper206df732013-01-07 13:08:40 +00004260 verifyFormat(
Daniel Jasper43b65482013-01-23 12:27:43 +00004261 "unsigned Cost =\n"
4262 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
4263 " SI->getPointerAddressSpaceee());\n");
Daniel Jasper206df732013-01-07 13:08:40 +00004264 verifyFormat(
Daniel Jasper1565eb32013-01-23 15:55:19 +00004265 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
4266 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
Daniel Jaspera836b902013-01-23 16:58:21 +00004267
4268 verifyFormat(
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004269 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
4270 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper7b27a102013-05-27 12:45:09 +00004271 verifyFormat("unsigned OriginalStartColumn =\n"
4272 " SourceMgr.getSpellingColumnNumber(\n"
4273 " Current.FormatTok.getStartOfNonWhitespace()) -\n"
4274 " 1;");
Daniel Jasper206df732013-01-07 13:08:40 +00004275}
4276
Francois Ferrand9976efa2017-05-22 08:28:17 +00004277TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) {
4278 FormatStyle Style = getLLVMStyle();
4279 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
4280 " bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;",
4281 Style);
4282
4283 Style.PenaltyBreakAssignment = 20;
4284 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
4285 " cccccccccccccccccccccccccc;",
4286 Style);
4287}
4288
Daniel Jasper2eda23e2012-12-24 13:43:52 +00004289TEST_F(FormatTest, AlignsAfterAssignments) {
4290 verifyFormat(
4291 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper206df732013-01-07 13:08:40 +00004292 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00004293 verifyFormat(
4294 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper206df732013-01-07 13:08:40 +00004295 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00004296 verifyFormat(
4297 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper206df732013-01-07 13:08:40 +00004298 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00004299 verifyFormat(
4300 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper206df732013-01-07 13:08:40 +00004301 " aaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperee7539a2013-07-08 14:25:23 +00004302 verifyFormat(
4303 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n"
4304 " aaaaaaaaaaaaaaaaaaaaaaaa +\n"
4305 " aaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00004306}
4307
4308TEST_F(FormatTest, AlignsAfterReturn) {
4309 verifyFormat(
4310 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4311 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
4312 verifyFormat(
4313 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4314 " aaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperc238c872013-04-02 14:33:13 +00004315 verifyFormat(
4316 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00004317 " aaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasperc238c872013-04-02 14:33:13 +00004318 verifyFormat(
4319 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00004320 " aaaaaaaaaaaaaaaaaaaaaa());");
4321 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4322 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
4323 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4324 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
4325 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jaspereabede62013-09-30 08:29:03 +00004326 verifyFormat("return\n"
4327 " // true if code is one of a or b.\n"
4328 " code == a || code == b;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00004329}
4330
Daniel Jasper3aa9a6a2014-11-18 23:55:27 +00004331TEST_F(FormatTest, AlignsAfterOpenBracket) {
4332 verifyFormat(
4333 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
4334 " aaaaaaaaa aaaaaaa) {}");
4335 verifyFormat(
4336 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
4337 " aaaaaaaaaaa aaaaaaaaa);");
4338 verifyFormat(
4339 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
4340 " aaaaaaaaaaaaaaaaaaaaa));");
4341 FormatStyle Style = getLLVMStyle();
Daniel Jasper6501f7e2015-10-27 12:38:37 +00004342 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
Daniel Jaspera44991332015-04-29 13:06:49 +00004343 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4344 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}",
4345 Style);
4346 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
4347 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);",
4348 Style);
4349 verifyFormat("SomeLongVariableName->someFunction(\n"
4350 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));",
4351 Style);
Daniel Jasper3aa9a6a2014-11-18 23:55:27 +00004352 verifyFormat(
4353 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
4354 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4355 Style);
4356 verifyFormat(
4357 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
4358 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4359 Style);
4360 verifyFormat(
4361 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
4362 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
4363 Style);
Daniel Jasper870d1bc2015-12-14 08:41:18 +00004364
Daniel Jasper2a9f7202016-02-08 09:52:54 +00004365 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n"
4366 " ccccccc(aaaaaaaaaaaaaaaaa, //\n"
4367 " b));",
4368 Style);
4369
Daniel Jasper870d1bc2015-12-14 08:41:18 +00004370 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
4371 Style.BinPackArguments = false;
4372 Style.BinPackParameters = false;
4373 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4374 " aaaaaaaaaaa aaaaaaaa,\n"
4375 " aaaaaaaaa aaaaaaa,\n"
4376 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4377 Style);
4378 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
4379 " aaaaaaaaaaa aaaaaaaaa,\n"
4380 " aaaaaaaaaaa aaaaaaaaa,\n"
4381 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4382 Style);
Daniel Jasper710f8492016-03-17 12:00:22 +00004383 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n"
4384 " aaaaaaaaaaaaaaa,\n"
4385 " aaaaaaaaaaaaaaaaaaaaa,\n"
4386 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
Daniel Jasper870d1bc2015-12-14 08:41:18 +00004387 Style);
Daniel Jasper710f8492016-03-17 12:00:22 +00004388 verifyFormat(
4389 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n"
4390 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
4391 Style);
4392 verifyFormat(
4393 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n"
4394 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
4395 Style);
4396 verifyFormat(
4397 "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4398 " aaaaaaaaaaaaaaaaaaaaa(\n"
4399 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n"
4400 " aaaaaaaaaaaaaaaa);",
4401 Style);
4402 verifyFormat(
4403 "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4404 " aaaaaaaaaaaaaaaaaaaaa(\n"
4405 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n"
4406 " aaaaaaaaaaaaaaaa);",
4407 Style);
Daniel Jasper3aa9a6a2014-11-18 23:55:27 +00004408}
4409
Daniel Jasper3219e432014-12-02 13:24:51 +00004410TEST_F(FormatTest, ParenthesesAndOperandAlignment) {
4411 FormatStyle Style = getLLVMStyleWithColumns(40);
4412 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
4413 " bbbbbbbbbbbbbbbbbbbbbb);",
4414 Style);
Daniel Jasper6501f7e2015-10-27 12:38:37 +00004415 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
Daniel Jasper3219e432014-12-02 13:24:51 +00004416 Style.AlignOperands = false;
4417 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
4418 " bbbbbbbbbbbbbbbbbbbbbb);",
4419 Style);
Daniel Jasper6501f7e2015-10-27 12:38:37 +00004420 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
Daniel Jasper3219e432014-12-02 13:24:51 +00004421 Style.AlignOperands = true;
4422 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
4423 " bbbbbbbbbbbbbbbbbbbbbb);",
4424 Style);
Daniel Jasper6501f7e2015-10-27 12:38:37 +00004425 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
Daniel Jasper3219e432014-12-02 13:24:51 +00004426 Style.AlignOperands = false;
4427 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
4428 " bbbbbbbbbbbbbbbbbbbbbb);",
4429 Style);
4430}
4431
Daniel Jasper399d24b2013-01-09 07:06:56 +00004432TEST_F(FormatTest, BreaksConditionalExpressions) {
4433 verifyFormat(
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004434 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4435 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4436 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
4437 verifyFormat(
4438 "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
Daniel Jasper22ed2622016-11-29 09:40:32 +00004439 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4440 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper8c5fba92013-01-16 16:23:19 +00004441 verifyFormat(
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004442 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4443 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
4444 verifyFormat(
4445 "aaaa(aaaaaaaaa, aaaaaaaaa,\n"
Daniel Jasper22ed2622016-11-29 09:40:32 +00004446 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4447 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperca6623b2013-01-28 12:45:14 +00004448 verifyFormat(
4449 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
4450 " : aaaaaaaaaaaaa);");
4451 verifyFormat(
4452 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasperaab220f2013-03-20 13:53:11 +00004453 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasperca6623b2013-01-28 12:45:14 +00004454 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4455 " aaaaaaaaaaaaa);");
Daniel Jasperb1ae7342013-08-01 22:05:00 +00004456 verifyFormat(
4457 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4458 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4459 " aaaaaaaaaaaaa);");
Daniel Jasperca6623b2013-01-28 12:45:14 +00004460 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4461 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4462 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4463 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4464 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
4465 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4466 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4467 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4468 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4469 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4470 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4471 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperb1ae7342013-08-01 22:05:00 +00004472 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4473 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4474 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4475 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4476 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper54a86022013-02-15 11:07:25 +00004477 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4478 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4479 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasperc238c872013-04-02 14:33:13 +00004480 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
4481 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4482 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4483 " : aaaaaaaaaaaaaaaa;");
Daniel Jaspercd8599e2013-02-23 21:01:55 +00004484 verifyFormat(
4485 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4486 " ? aaaaaaaaaaaaaaa\n"
4487 " : aaaaaaaaaaaaaaa;");
4488 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00004489 " aaaaaaaaa\n"
Daniel Jaspere7de2a32013-04-08 10:45:44 +00004490 " ? b\n"
4491 " : c);");
Daniel Jasper119ff532014-11-14 12:31:14 +00004492 verifyFormat("return aaaa == bbbb\n"
4493 " // comment\n"
4494 " ? aaaa\n"
4495 " : bbbb;");
Daniel Jaspera44991332015-04-29 13:06:49 +00004496 verifyFormat("unsigned Indent =\n"
Daniel Jasper22ed2622016-11-29 09:40:32 +00004497 " format(TheLine.First,\n"
4498 " IndentForLevel[TheLine.Level] >= 0\n"
4499 " ? IndentForLevel[TheLine.Level]\n"
4500 " : TheLine * 2,\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004501 " TheLine.InPPDirective, PreviousEndOfLineColumn);",
Daniel Jasper22ed2622016-11-29 09:40:32 +00004502 getLLVMStyleWithColumns(60));
Daniel Jasper2c611c02013-05-31 14:56:12 +00004503 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
4504 " ? aaaaaaaaaaaaaaa\n"
4505 " : bbbbbbbbbbbbbbb //\n"
4506 " ? ccccccccccccccc\n"
4507 " : ddddddddddddddd;");
4508 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
4509 " ? aaaaaaaaaaaaaaa\n"
4510 " : (bbbbbbbbbbbbbbb //\n"
4511 " ? ccccccccccccccc\n"
4512 " : ddddddddddddddd);");
Daniel Jasperc0d606a2014-04-14 11:08:45 +00004513 verifyFormat(
4514 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4515 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4516 " aaaaaaaaaaaaaaaaaaaaa +\n"
4517 " aaaaaaaaaaaaaaaaaaaaa\n"
4518 " : aaaaaaaaaa;");
Daniel Jasperfc3861a2014-07-17 12:22:04 +00004519 verifyFormat(
Daniel Jasper240527c2017-01-16 13:13:15 +00004520 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4521 " : aaaaaaaaaaaaaaaaaaaaaa\n"
4522 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper54a86022013-02-15 11:07:25 +00004523
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004524 FormatStyle NoBinPacking = getLLVMStyle();
Daniel Jasper18210d72014-10-09 09:52:05 +00004525 NoBinPacking.BinPackArguments = false;
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004526 verifyFormat(
Daniel Jaspercd8599e2013-02-23 21:01:55 +00004527 "void f() {\n"
4528 " g(aaa,\n"
4529 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
4530 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4531 " ? aaaaaaaaaaaaaaa\n"
4532 " : aaaaaaaaaaaaaaa);\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004533 "}",
4534 NoBinPacking);
Daniel Jasperb1ae7342013-08-01 22:05:00 +00004535 verifyFormat(
4536 "void f() {\n"
4537 " g(aaa,\n"
4538 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
4539 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4540 " ?: aaaaaaaaaaaaaaa);\n"
4541 "}",
4542 NoBinPacking);
Daniel Jasper1a31bab2014-10-16 09:10:11 +00004543
4544 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n"
4545 " // comment.\n"
4546 " ccccccccccccccccccccccccccccccccccccccc\n"
4547 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4548 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);");
Daniel Jasper6c22c442014-11-14 13:03:40 +00004549
4550 // Assignments in conditional expressions. Apparently not uncommon :-(.
4551 verifyFormat("return a != b\n"
4552 " // comment\n"
4553 " ? a = b\n"
4554 " : a = b;");
4555 verifyFormat("return a != b\n"
4556 " // comment\n"
4557 " ? a = a != b\n"
4558 " // comment\n"
4559 " ? a = b\n"
4560 " : a\n"
4561 " : a;\n");
4562 verifyFormat("return a != b\n"
4563 " // comment\n"
4564 " ? a\n"
4565 " : a = a != b\n"
4566 " // comment\n"
4567 " ? a = b\n"
4568 " : a;");
Daniel Jasper399d24b2013-01-09 07:06:56 +00004569}
4570
Daniel Jasper165b29e2013-11-08 00:57:11 +00004571TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) {
4572 FormatStyle Style = getLLVMStyle();
4573 Style.BreakBeforeTernaryOperators = false;
4574 Style.ColumnLimit = 70;
4575 verifyFormat(
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004576 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4577 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4578 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4579 Style);
4580 verifyFormat(
4581 "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
Daniel Jasper22ed2622016-11-29 09:40:32 +00004582 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4583 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
Daniel Jasper165b29e2013-11-08 00:57:11 +00004584 Style);
4585 verifyFormat(
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004586 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4587 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4588 Style);
4589 verifyFormat(
4590 "aaaa(aaaaaaaa, aaaaaaaaaa,\n"
Daniel Jasper22ed2622016-11-29 09:40:32 +00004591 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4592 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
Daniel Jasper165b29e2013-11-08 00:57:11 +00004593 Style);
4594 verifyFormat(
4595 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n"
4596 " aaaaaaaaaaaaa);",
4597 Style);
4598 verifyFormat(
4599 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4600 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4601 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4602 " aaaaaaaaaaaaa);",
4603 Style);
4604 verifyFormat(
4605 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4606 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4607 " aaaaaaaaaaaaa);",
4608 Style);
4609 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4610 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4611 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
4612 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4613 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4614 Style);
4615 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4616 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4617 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4618 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
4619 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4620 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4621 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4622 Style);
4623 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4624 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n"
4625 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4626 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4627 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4628 Style);
4629 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4630 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4631 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4632 Style);
4633 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +00004634 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
Daniel Jasper165b29e2013-11-08 00:57:11 +00004635 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4636 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4637 Style);
4638 verifyFormat(
4639 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4640 " aaaaaaaaaaaaaaa :\n"
4641 " aaaaaaaaaaaaaaa;",
4642 Style);
4643 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
4644 " aaaaaaaaa ?\n"
4645 " b :\n"
4646 " c);",
4647 Style);
Daniel Jasper22ed2622016-11-29 09:40:32 +00004648 verifyFormat("unsigned Indent =\n"
4649 " format(TheLine.First,\n"
4650 " IndentForLevel[TheLine.Level] >= 0 ?\n"
4651 " IndentForLevel[TheLine.Level] :\n"
4652 " TheLine * 2,\n"
4653 " TheLine.InPPDirective, PreviousEndOfLineColumn);",
4654 Style);
Daniel Jasper165b29e2013-11-08 00:57:11 +00004655 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
4656 " aaaaaaaaaaaaaaa :\n"
4657 " bbbbbbbbbbbbbbb ? //\n"
4658 " ccccccccccccccc :\n"
4659 " ddddddddddddddd;",
4660 Style);
4661 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
4662 " aaaaaaaaaaaaaaa :\n"
4663 " (bbbbbbbbbbbbbbb ? //\n"
4664 " ccccccccccccccc :\n"
4665 " ddddddddddddddd);",
4666 Style);
Daniel Jasper45860fa2016-02-03 17:27:10 +00004667 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4668 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n"
4669 " ccccccccccccccccccccccccccc;",
4670 Style);
Daniel Jasper04b4e102016-03-01 04:19:59 +00004671 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4672 " aaaaa :\n"
4673 " bbbbbbbbbbbbbbb + cccccccccccccccc;",
4674 Style);
Daniel Jasper165b29e2013-11-08 00:57:11 +00004675}
4676
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004677TEST_F(FormatTest, DeclarationsOfMultipleVariables) {
4678 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
4679 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();");
4680 verifyFormat("bool a = true, b = false;");
4681
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004682 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Daniel Jaspera628c982013-04-03 13:36:17 +00004683 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004684 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
Daniel Jasperc238c872013-04-02 14:33:13 +00004685 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);");
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004686 verifyFormat(
Daniel Jasper37905f72013-02-21 15:00:29 +00004687 "bool aaaaaaaaaaaaaaaaaaaaa =\n"
Daniel Jaspera628c982013-04-03 13:36:17 +00004688 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
Daniel Jasper37905f72013-02-21 15:00:29 +00004689 " d = e && f;");
Daniel Jasper31c96b92013-04-05 09:38:50 +00004690 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
4691 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;");
4692 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
4693 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;");
4694 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
4695 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;");
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004696
Daniel Jasperbea1ab42015-03-01 18:55:26 +00004697 FormatStyle Style = getGoogleStyle();
4698 Style.PointerAlignment = FormatStyle::PAS_Left;
4699 Style.DerivePointerAlignment = false;
4700 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4701 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
4702 " *b = bbbbbbbbbbbbbbbbbbb;",
4703 Style);
Daniel Jaspera44991332015-04-29 13:06:49 +00004704 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
4705 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;",
4706 Style);
Daniel Jasper3f2cde92016-09-26 15:14:24 +00004707 verifyFormat("vector<int*> a, b;", Style);
Daniel Jasper85d1f0b2016-10-04 20:18:25 +00004708 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style);
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004709}
4710
Nico Weber4a5030c2013-01-12 01:28:06 +00004711TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
4712 verifyFormat("arr[foo ? bar : baz];");
4713 verifyFormat("f()[foo ? bar : baz];");
4714 verifyFormat("(a + b)[foo ? bar : baz];");
4715 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
4716}
4717
Daniel Jasperf7935112012-12-03 18:12:45 +00004718TEST_F(FormatTest, AlignsStringLiterals) {
4719 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
4720 " \"short literal\");");
4721 verifyFormat(
4722 "looooooooooooooooooooooooongFunction(\n"
4723 " \"short literal\"\n"
4724 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00004725 verifyFormat("someFunction(\"Always break between multi-line\"\n"
4726 " \" string literals\",\n"
4727 " and, other, parameters);");
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004728 EXPECT_EQ("fun + \"1243\" /* comment */\n"
4729 " \"5678\";",
Manuel Klimek02f640a2013-02-20 15:25:48 +00004730 format("fun + \"1243\" /* comment */\n"
Daniel Jasper240527c2017-01-16 13:13:15 +00004731 " \"5678\";",
Manuel Klimek02f640a2013-02-20 15:25:48 +00004732 getLLVMStyleWithColumns(28)));
4733 EXPECT_EQ(
4734 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
4735 " \"aaaaaaaaaaaaaaaaaaaaa\"\n"
4736 " \"aaaaaaaaaaaaaaaa\";",
4737 format("aaaaaa ="
4738 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
4739 "aaaaaaaaaaaaaaaaaaaaa\" "
4740 "\"aaaaaaaaaaaaaaaa\";"));
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004741 verifyFormat("a = a + \"a\"\n"
4742 " \"a\"\n"
4743 " \"a\";");
4744 verifyFormat("f(\"a\", \"b\"\n"
4745 " \"c\");");
Daniel Jasperaf5ba0e2013-02-23 07:46:38 +00004746
4747 verifyFormat(
4748 "#define LL_FORMAT \"ll\"\n"
4749 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
4750 " \"d, ddddddddd: %\" LL_FORMAT \"d\");");
Daniel Jasper47a04442013-05-13 20:50:15 +00004751
4752 verifyFormat("#define A(X) \\\n"
4753 " \"aaaaa\" #X \"bbbbbb\" \\\n"
4754 " \"ccccc\"",
4755 getLLVMStyleWithColumns(23));
4756 verifyFormat("#define A \"def\"\n"
4757 "f(\"abc\" A \"ghi\"\n"
4758 " \"jkl\");");
Daniel Jasper04b6a082013-12-20 06:22:01 +00004759
4760 verifyFormat("f(L\"a\"\n"
Daniel Jasper015c7a92015-05-11 15:15:48 +00004761 " L\"b\");");
Daniel Jasper04b6a082013-12-20 06:22:01 +00004762 verifyFormat("#define A(X) \\\n"
4763 " L\"aaaaa\" #X L\"bbbbbb\" \\\n"
4764 " L\"ccccc\"",
4765 getLLVMStyleWithColumns(25));
Daniel Jasper015c7a92015-05-11 15:15:48 +00004766
4767 verifyFormat("f(@\"a\"\n"
4768 " @\"b\");");
4769 verifyFormat("NSString s = @\"a\"\n"
Daniel Jasper09285532015-05-17 08:13:23 +00004770 " @\"b\"\n"
4771 " @\"c\";");
4772 verifyFormat("NSString s = @\"a\"\n"
4773 " \"b\"\n"
4774 " \"c\";");
Daniel Jasperf7935112012-12-03 18:12:45 +00004775}
4776
Zachary Turner448592e2015-12-18 22:20:15 +00004777TEST_F(FormatTest, ReturnTypeBreakingStyle) {
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004778 FormatStyle Style = getLLVMStyle();
Zachary Turner448592e2015-12-18 22:20:15 +00004779 // No declarations or definitions should be moved to own line.
4780 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
4781 verifyFormat("class A {\n"
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004782 " int f() { return 1; }\n"
Zachary Turner448592e2015-12-18 22:20:15 +00004783 " int g();\n"
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004784 "};\n"
Zachary Turner448592e2015-12-18 22:20:15 +00004785 "int f() { return 1; }\n"
4786 "int g();\n",
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004787 Style);
Zachary Turner448592e2015-12-18 22:20:15 +00004788
4789 // All declarations and definitions should have the return type moved to its
4790 // own
4791 // line.
4792 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
4793 verifyFormat("class E {\n"
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004794 " int\n"
4795 " f() {\n"
4796 " return 1;\n"
4797 " }\n"
Zachary Turner448592e2015-12-18 22:20:15 +00004798 " int\n"
4799 " g();\n"
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004800 "};\n"
4801 "int\n"
4802 "f() {\n"
4803 " return 1;\n"
Zachary Turner448592e2015-12-18 22:20:15 +00004804 "}\n"
4805 "int\n"
4806 "g();\n",
4807 Style);
4808
4809 // Top-level definitions, and no kinds of declarations should have the
4810 // return type moved to its own line.
4811 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions;
4812 verifyFormat("class B {\n"
4813 " int f() { return 1; }\n"
4814 " int g();\n"
4815 "};\n"
4816 "int\n"
4817 "f() {\n"
4818 " return 1;\n"
4819 "}\n"
4820 "int g();\n",
4821 Style);
4822
4823 // Top-level definitions and declarations should have the return type moved
4824 // to its own line.
4825 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel;
4826 verifyFormat("class C {\n"
4827 " int f() { return 1; }\n"
4828 " int g();\n"
4829 "};\n"
4830 "int\n"
4831 "f() {\n"
4832 " return 1;\n"
4833 "}\n"
4834 "int\n"
4835 "g();\n",
4836 Style);
4837
4838 // All definitions should have the return type moved to its own line, but no
4839 // kinds of declarations.
4840 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
4841 verifyFormat("class D {\n"
4842 " int\n"
4843 " f() {\n"
4844 " return 1;\n"
4845 " }\n"
4846 " int g();\n"
4847 "};\n"
4848 "int\n"
4849 "f() {\n"
4850 " return 1;\n"
4851 "}\n"
4852 "int g();\n",
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004853 Style);
Daniel Jasperca4ea1c2014-08-05 12:16:31 +00004854 verifyFormat("const char *\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004855 "f(void) {\n" // Break here.
Daniel Jasperca4ea1c2014-08-05 12:16:31 +00004856 " return \"\";\n"
4857 "}\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004858 "const char *bar(void);\n", // No break here.
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004859 Style);
Daniel Jasperdb764792014-08-14 11:36:03 +00004860 verifyFormat("template <class T>\n"
4861 "T *\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004862 "f(T &c) {\n" // Break here.
Daniel Jasperdb764792014-08-14 11:36:03 +00004863 " return NULL;\n"
4864 "}\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004865 "template <class T> T *f(T &c);\n", // No break here.
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004866 Style);
Birunthan Mohanathas525579d2015-07-15 19:11:58 +00004867 verifyFormat("class C {\n"
4868 " int\n"
4869 " operator+() {\n"
4870 " return 1;\n"
4871 " }\n"
4872 " int\n"
4873 " operator()() {\n"
4874 " return 1;\n"
4875 " }\n"
4876 "};\n",
4877 Style);
4878 verifyFormat("void\n"
4879 "A::operator()() {}\n"
4880 "void\n"
4881 "A::operator>>() {}\n"
4882 "void\n"
4883 "A::operator+() {}\n",
4884 Style);
4885 verifyFormat("void *operator new(std::size_t s);", // No break here.
4886 Style);
4887 verifyFormat("void *\n"
4888 "operator new(std::size_t s) {}",
4889 Style);
4890 verifyFormat("void *\n"
4891 "operator delete[](void *ptr) {}",
4892 Style);
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004893 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
Daniel Jasperdb764792014-08-14 11:36:03 +00004894 verifyFormat("const char *\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004895 "f(void)\n" // Break here.
Daniel Jasperdb764792014-08-14 11:36:03 +00004896 "{\n"
4897 " return \"\";\n"
4898 "}\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004899 "const char *bar(void);\n", // No break here.
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004900 Style);
Daniel Jasperdb764792014-08-14 11:36:03 +00004901 verifyFormat("template <class T>\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004902 "T *\n" // Problem here: no line break
4903 "f(T &c)\n" // Break here.
Daniel Jasperdb764792014-08-14 11:36:03 +00004904 "{\n"
4905 " return NULL;\n"
4906 "}\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004907 "template <class T> T *f(T &c);\n", // No break here.
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004908 Style);
Daniel Jasperca4ea1c2014-08-05 12:16:31 +00004909}
4910
Alexander Kornienko58611712013-07-04 12:02:44 +00004911TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) {
4912 FormatStyle NoBreak = getLLVMStyle();
4913 NoBreak.AlwaysBreakBeforeMultilineStrings = false;
4914 FormatStyle Break = getLLVMStyle();
4915 Break.AlwaysBreakBeforeMultilineStrings = true;
Daniel Jasperc834c702013-07-17 15:38:19 +00004916 verifyFormat("aaaa = \"bbbb\"\n"
4917 " \"cccc\";",
4918 NoBreak);
4919 verifyFormat("aaaa =\n"
4920 " \"bbbb\"\n"
4921 " \"cccc\";",
4922 Break);
4923 verifyFormat("aaaa(\"bbbb\"\n"
4924 " \"cccc\");",
4925 NoBreak);
4926 verifyFormat("aaaa(\n"
4927 " \"bbbb\"\n"
4928 " \"cccc\");",
4929 Break);
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004930 verifyFormat("aaaa(qqq, \"bbbb\"\n"
4931 " \"cccc\");",
Daniel Jasperc834c702013-07-17 15:38:19 +00004932 NoBreak);
Daniel Jasper1bf729c2015-06-18 16:05:17 +00004933 verifyFormat("aaaa(qqq,\n"
4934 " \"bbbb\"\n"
4935 " \"cccc\");",
Daniel Jasperc834c702013-07-17 15:38:19 +00004936 Break);
Daniel Jasper1bf729c2015-06-18 16:05:17 +00004937 verifyFormat("aaaa(qqq,\n"
4938 " L\"bbbb\"\n"
4939 " L\"cccc\");",
4940 Break);
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004941 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n"
4942 " \"bbbb\"));",
Daniel Jasper04b6a082013-12-20 06:22:01 +00004943 Break);
Daniel Jasper9fb676a2015-06-19 10:32:28 +00004944 verifyFormat("string s = someFunction(\n"
4945 " \"abc\"\n"
4946 " \"abc\");",
4947 Break);
Daniel Jasperc834c702013-07-17 15:38:19 +00004948
Daniel Jasper3251fff2014-06-10 06:27:23 +00004949 // As we break before unary operators, breaking right after them is bad.
4950 verifyFormat("string foo = abc ? \"x\"\n"
4951 " \"blah blah blah blah blah blah\"\n"
4952 " : \"y\";",
4953 Break);
4954
Daniel Jasperc834c702013-07-17 15:38:19 +00004955 // Don't break if there is no column gain.
4956 verifyFormat("f(\"aaaa\"\n"
4957 " \"bbbb\");",
4958 Break);
4959
4960 // Treat literals with escaped newlines like multi-line string literals.
Alexander Kornienko657c67b2013-07-16 21:06:13 +00004961 EXPECT_EQ("x = \"a\\\n"
4962 "b\\\n"
4963 "c\";",
4964 format("x = \"a\\\n"
4965 "b\\\n"
4966 "c\";",
4967 NoBreak));
Daniel Jasper2aaedd32015-06-18 09:12:47 +00004968 EXPECT_EQ("xxxx =\n"
Alexander Kornienko657c67b2013-07-16 21:06:13 +00004969 " \"a\\\n"
4970 "b\\\n"
4971 "c\";",
Daniel Jasper2aaedd32015-06-18 09:12:47 +00004972 format("xxxx = \"a\\\n"
Alexander Kornienko657c67b2013-07-16 21:06:13 +00004973 "b\\\n"
4974 "c\";",
4975 Break));
Daniel Jasper27943052013-11-09 03:08:25 +00004976
Alexander Kornienkod4fa2e62017-04-11 09:55:00 +00004977 EXPECT_EQ("NSString *const kString =\n"
4978 " @\"aaaa\"\n"
4979 " @\"bbbb\";",
Daniel Jasper27943052013-11-09 03:08:25 +00004980 format("NSString *const kString = @\"aaaa\"\n"
Daniel Jasper015c7a92015-05-11 15:15:48 +00004981 "@\"bbbb\";",
Daniel Jasper27943052013-11-09 03:08:25 +00004982 Break));
Daniel Jasper6fd5d642015-01-20 12:59:20 +00004983
4984 Break.ColumnLimit = 0;
4985 verifyFormat("const char *hello = \"hello llvm\";", Break);
Alexander Kornienko58611712013-07-04 12:02:44 +00004986}
4987
Alexander Kornienko578fdd82012-12-06 18:03:27 +00004988TEST_F(FormatTest, AlignsPipes) {
4989 verifyFormat(
4990 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4991 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4992 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
4993 verifyFormat(
4994 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
4995 " << aaaaaaaaaaaaaaaaaaaa;");
4996 verifyFormat(
4997 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4998 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
4999 verifyFormat(
Daniel Jasper7aacf462016-12-19 11:14:23 +00005000 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5001 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5002 verifyFormat(
Alexander Kornienko578fdd82012-12-06 18:03:27 +00005003 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
5004 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
5005 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";");
5006 verifyFormat(
5007 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5008 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5009 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jaspera44991332015-04-29 13:06:49 +00005010 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5011 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5012 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5013 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
Daniel Jasper2fd16632015-05-17 07:27:09 +00005014 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n"
5015 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);");
Daniel Jasper0e617842014-04-16 12:26:54 +00005016 verifyFormat(
5017 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5018 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper04bbda92017-03-16 07:54:11 +00005019 verifyFormat(
5020 "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n"
5021 " aaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper2603ee02013-02-04 07:34:48 +00005022
Daniel Jasperc0d606a2014-04-14 11:08:45 +00005023 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n"
5024 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();");
Daniel Jasper173504e2015-05-10 21:15:07 +00005025 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5026 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5027 " aaaaaaaaaaaaaaaaaaaaa)\n"
5028 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper5962fa82015-06-03 09:26:03 +00005029 verifyFormat("LOG_IF(aaa == //\n"
5030 " bbb)\n"
5031 " << a << b;");
Daniel Jasperc238c872013-04-02 14:33:13 +00005032
Daniel Jasper467ddb12013-08-12 12:58:05 +00005033 // But sometimes, breaking before the first "<<" is desirable.
Daniel Jasper004177e2013-12-19 16:06:40 +00005034 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
5035 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);");
Daniel Jasper77d5d312013-07-12 15:14:05 +00005036 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
5037 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5038 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper467ddb12013-08-12 12:58:05 +00005039 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
5040 " << BEF << IsTemplate << Description << E->getType();");
Daniel Jasper602a7272016-02-11 13:15:14 +00005041 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
5042 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5043 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5044 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
5045 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5046 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5047 " << aaa;");
Daniel Jasper77d5d312013-07-12 15:14:05 +00005048
Daniel Jasperc238c872013-04-02 14:33:13 +00005049 verifyFormat(
5050 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5051 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper0b1f76b2013-09-29 12:02:57 +00005052
5053 // Incomplete string literal.
5054 EXPECT_EQ("llvm::errs() << \"\n"
5055 " << a;",
5056 format("llvm::errs() << \"\n<<a;"));
Manuel Klimek06c84f22013-11-20 11:20:32 +00005057
5058 verifyFormat("void f() {\n"
5059 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n"
5060 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n"
5061 "}");
Daniel Jasperd05d3a82015-01-08 13:56:57 +00005062
5063 // Handle 'endl'.
Daniel Jasper69963122015-02-17 10:05:15 +00005064 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n"
5065 " << bbbbbbbbbbbbbbbbbbbbbb << endl;");
5066 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;");
Daniel Jasper0a589412016-01-05 13:06:27 +00005067
5068 // Handle '\n'.
5069 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n"
5070 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
5071 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n"
5072 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';");
5073 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n"
5074 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";");
5075 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00005076}
5077
Daniel Jasper7209bb92016-12-13 11:16:42 +00005078TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) {
5079 verifyFormat("return out << \"somepacket = {\\n\"\n"
5080 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
5081 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
5082 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
5083 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
5084 " << \"}\";");
5085
5086 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
5087 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
5088 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;");
5089 verifyFormat(
5090 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
5091 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
5092 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
5093 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
5094 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;");
5095 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
5096 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
5097 verifyFormat(
5098 "void f() {\n"
5099 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n"
5100 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5101 "}");
5102
5103 // Breaking before the first "<<" is generally not desirable.
5104 verifyFormat(
5105 "llvm::errs()\n"
5106 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5107 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5108 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5109 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
5110 getLLVMStyleWithColumns(70));
5111 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
5112 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5113 " << \"aaaaaaaaaaaaaaaaaaa: \"\n"
5114 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5115 " << \"aaaaaaaaaaaaaaaaaaa: \"\n"
5116 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
5117 getLLVMStyleWithColumns(70));
5118
5119 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
5120 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
5121 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;");
5122 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
5123 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
5124 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);");
Daniel Jasperf789f052016-12-20 15:27:46 +00005125 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n"
5126 " (aaaa + aaaa);",
5127 getLLVMStyleWithColumns(40));
5128 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n"
5129 " (aaaaaaa + aaaaa));",
5130 getLLVMStyleWithColumns(40));
Daniel Jasper23888612016-12-22 12:37:06 +00005131 verifyFormat(
5132 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n"
5133 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n"
5134 " bbbbbbbbbbbbbbbbbbbbbbb);");
Daniel Jasper7209bb92016-12-13 11:16:42 +00005135}
5136
Daniel Jasperf7935112012-12-03 18:12:45 +00005137TEST_F(FormatTest, UnderstandsEquals) {
5138 verifyFormat(
5139 "aaaaaaaaaaaaaaaaa =\n"
5140 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5141 verifyFormat(
5142 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00005143 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasperf7935112012-12-03 18:12:45 +00005144 verifyFormat(
5145 "if (a) {\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005146 " f();\n"
Daniel Jasperf7935112012-12-03 18:12:45 +00005147 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00005148 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
5149 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +00005150
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005151 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5152 " 100000000 + 10000000) {\n}");
Daniel Jasperf7935112012-12-03 18:12:45 +00005153}
5154
Daniel Jasper5485d0c2012-12-17 14:34:14 +00005155TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00005156 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
5157 " .looooooooooooooooooooooooooooooooooooooongFunction();");
Daniel Jasper5485d0c2012-12-17 14:34:14 +00005158
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00005159 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
5160 " ->looooooooooooooooooooooooooooooooooooooongFunction();");
Daniel Jasper5485d0c2012-12-17 14:34:14 +00005161
5162 verifyFormat(
5163 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
5164 " Parameter2);");
5165
5166 verifyFormat(
5167 "ShortObject->shortFunction(\n"
5168 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
5169 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);");
5170
5171 verifyFormat("loooooooooooooongFunction(\n"
5172 " LoooooooooooooongObject->looooooooooooooooongFunction());");
5173
5174 verifyFormat(
5175 "function(LoooooooooooooooooooooooooooooooooooongObject\n"
5176 " ->loooooooooooooooooooooooooooooooooooooooongFunction());");
5177
Daniel Jasper687af3b2013-02-14 14:26:07 +00005178 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
5179 " .WillRepeatedly(Return(SomeValue));");
Daniel Jasperd6f17d82014-09-12 16:35:28 +00005180 verifyFormat("void f() {\n"
5181 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
5182 " .Times(2)\n"
5183 " .WillRepeatedly(Return(SomeValue));\n"
5184 "}");
Daniel Jasper4d7a97a2014-01-10 08:40:17 +00005185 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n"
5186 " ccccccccccccccccccccccc);");
Daniel Jasper32a796b2013-05-27 11:50:16 +00005187 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper05cd9292015-03-26 18:46:28 +00005188 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5189 " .aaaaa(aaaaa),\n"
Daniel Jasper32a796b2013-05-27 11:50:16 +00005190 " aaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00005191 verifyFormat("void f() {\n"
5192 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5193 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n"
5194 "}");
Daniel Jaspera44991332015-04-29 13:06:49 +00005195 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5196 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5197 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5198 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5199 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jasperc238c872013-04-02 14:33:13 +00005200 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5201 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5202 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5203 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
5204 "}");
Daniel Jasper687af3b2013-02-14 14:26:07 +00005205
Daniel Jasperc7345cc2013-01-07 07:13:20 +00005206 // Here, it is not necessary to wrap at "." or "->".
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00005207 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00005208 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasperc7345cc2013-01-07 07:13:20 +00005209 verifyFormat(
5210 "aaaaaaaaaaa->aaaaaaaaa(\n"
5211 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5212 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
Daniel Jaspere11095a2013-02-14 15:01:34 +00005213
5214 verifyFormat(
5215 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5216 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
Daniel Jasper8f6ae192013-03-13 15:37:48 +00005217 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
5218 " aaaaaaaaa()->aaaaaa()->aaaaa());");
5219 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
5220 " aaaaaaaaa()->aaaaaa()->aaaaa());");
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00005221
Daniel Jasper9b334242013-03-15 14:57:30 +00005222 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper05cd9292015-03-26 18:46:28 +00005223 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5224 " .a();");
Daniel Jasper9b334242013-03-15 14:57:30 +00005225
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00005226 FormatStyle NoBinPacking = getLLVMStyle();
5227 NoBinPacking.BinPackParameters = false;
5228 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
5229 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
5230 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
5231 " aaaaaaaaaaaaaaaaaaa,\n"
5232 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5233 NoBinPacking);
Daniel Jasperbd058882013-07-09 11:57:27 +00005234
5235 // If there is a subsequent call, change to hanging indentation.
5236 verifyFormat(
5237 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5238 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n"
5239 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5240 verifyFormat(
5241 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5242 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));");
Daniel Jasper96964352013-12-18 10:44:36 +00005243 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5244 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5245 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5246 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5247 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5248 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
Daniel Jasper5485d0c2012-12-17 14:34:14 +00005249}
5250
Daniel Jasperac5c1c22013-01-02 15:08:56 +00005251TEST_F(FormatTest, WrapsTemplateDeclarations) {
5252 verifyFormat("template <typename T>\n"
5253 "virtual void loooooooooooongFunction(int Param1, int Param2);");
Daniel Jasper69bd8fb2013-09-27 07:49:08 +00005254 verifyFormat("template <typename T>\n"
5255 "// T should be one of {A, B}.\n"
5256 "virtual void loooooooooooongFunction(int Param1, int Param2);");
Daniel Jasperac5c1c22013-01-02 15:08:56 +00005257 verifyFormat(
Daniel Jasper04468962013-01-18 10:56:38 +00005258 "template <typename T>\n"
Daniel Jasper400adc62013-02-08 15:28:42 +00005259 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;");
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005260 verifyFormat("template <typename T>\n"
5261 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
5262 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);");
Daniel Jasperac5c1c22013-01-02 15:08:56 +00005263 verifyFormat(
5264 "template <typename T>\n"
5265 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
5266 " int Paaaaaaaaaaaaaaaaaaaaram2);");
Daniel Jasper90e51fd2013-01-02 18:30:06 +00005267 verifyFormat(
5268 "template <typename T>\n"
5269 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
5270 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
5271 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper89058942013-01-09 09:50:48 +00005272 verifyFormat("template <typename T>\n"
5273 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jaspera628c982013-04-03 13:36:17 +00005274 " int aaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperbcab4302013-01-09 10:40:23 +00005275 verifyFormat(
5276 "template <typename T1, typename T2 = char, typename T3 = char,\n"
5277 " typename T4 = char>\n"
5278 "void f();");
Daniel Jasper298c3402013-11-22 07:48:15 +00005279 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n"
5280 " template <typename> class cccccccccccccccccccccc,\n"
5281 " typename ddddddddddddd>\n"
5282 "class C {};");
Daniel Jasper7a31af12013-01-25 15:43:32 +00005283 verifyFormat(
5284 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
5285 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper3a9370c2013-02-04 07:21:18 +00005286
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00005287 verifyFormat("void f() {\n"
5288 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
5289 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n"
5290 "}");
Daniel Jasper61e6bbf2013-05-29 12:07:31 +00005291
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00005292 verifyFormat("template <typename T> class C {};");
Daniel Jasper61e6bbf2013-05-29 12:07:31 +00005293 verifyFormat("template <typename T> void f();");
5294 verifyFormat("template <typename T> void f() {}");
Daniel Jasper0e90c3d2013-07-05 09:14:35 +00005295 verifyFormat(
5296 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
5297 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5298 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
5299 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
5300 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5301 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
5302 " bbbbbbbbbbbbbbbbbbbbbbbb);",
5303 getLLVMStyleWithColumns(72));
Daniel Jasperfcfac102014-07-15 09:00:34 +00005304 EXPECT_EQ("static_cast<A< //\n"
5305 " B> *>(\n"
5306 "\n"
Martin Probst2c1cdae2017-05-15 11:15:29 +00005307 ");",
Daniel Jasperfcfac102014-07-15 09:00:34 +00005308 format("static_cast<A<//\n"
5309 " B>*>(\n"
5310 "\n"
5311 " );"));
Daniel Jasper598dd332014-08-12 13:22:26 +00005312 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5313 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);");
Daniel Jasper5c9e3cd2013-09-14 08:13:22 +00005314
5315 FormatStyle AlwaysBreak = getLLVMStyle();
5316 AlwaysBreak.AlwaysBreakTemplateDeclarations = true;
5317 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
5318 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
5319 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
5320 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5321 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
5322 " ccccccccccccccccccccccccccccccccccccccccccccccc);");
5323 verifyFormat("template <template <typename> class Fooooooo,\n"
5324 " template <typename> class Baaaaaaar>\n"
5325 "struct C {};",
5326 AlwaysBreak);
Daniel Jasperd3e014d2013-10-09 15:06:17 +00005327 verifyFormat("template <typename T> // T can be A, B or C.\n"
5328 "struct C {};",
5329 AlwaysBreak);
Daniel Jaspera7900ad2016-05-08 18:12:22 +00005330 verifyFormat("template <enum E> class A {\n"
5331 "public:\n"
5332 " E *f();\n"
5333 "};");
Daniel Jasperac5c1c22013-01-02 15:08:56 +00005334}
5335
Daniel Jasper2db1b4a2017-02-06 10:55:49 +00005336TEST_F(FormatTest, WrapsTemplateParameters) {
5337 FormatStyle Style = getLLVMStyle();
5338 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5339 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
5340 verifyFormat(
5341 "template <typename... a> struct q {};\n"
5342 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
5343 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
5344 " y;",
5345 Style);
5346 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5347 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
5348 verifyFormat(
5349 "template <typename... a> struct r {};\n"
5350 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
5351 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
5352 " y;",
5353 Style);
5354 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
5355 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
5356 verifyFormat(
5357 "template <typename... a> struct s {};\n"
5358 "extern s<\n"
5359 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
5360 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n"
5361 " y;",
5362 Style);
5363 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
5364 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
5365 verifyFormat(
5366 "template <typename... a> struct t {};\n"
5367 "extern t<\n"
5368 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
5369 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n"
5370 " y;",
5371 Style);
5372}
5373
Daniel Jasper45797022013-01-25 10:57:27 +00005374TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
5375 verifyFormat(
5376 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
5377 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5378 verifyFormat(
5379 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
5380 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5381 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
5382
Daniel Jasper0f0234e2013-05-08 10:00:18 +00005383 // FIXME: Should we have the extra indent after the second break?
Daniel Jasper45797022013-01-25 10:57:27 +00005384 verifyFormat(
5385 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
5386 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
Daniel Jasper0f0234e2013-05-08 10:00:18 +00005387 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper45797022013-01-25 10:57:27 +00005388
Daniel Jasper45797022013-01-25 10:57:27 +00005389 verifyFormat(
5390 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
Daniel Jasper4ad42352013-01-28 07:43:15 +00005391 " cccccccccccccccccccccccccccccccccccccccccccccc());");
Daniel Jasper45797022013-01-25 10:57:27 +00005392
5393 // Breaking at nested name specifiers is generally not desirable.
5394 verifyFormat(
5395 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5396 " aaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperca6623b2013-01-28 12:45:14 +00005397
5398 verifyFormat(
Daniel Jasper240527c2017-01-16 13:13:15 +00005399 "aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n"
5400 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
5401 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasperca6623b2013-01-28 12:45:14 +00005402 " aaaaaaaaaaaaaaaaaaaaa);",
5403 getLLVMStyleWithColumns(74));
Daniel Jasperc238c872013-04-02 14:33:13 +00005404
5405 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
5406 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5407 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper45797022013-01-25 10:57:27 +00005408}
5409
Daniel Jasperf7935112012-12-03 18:12:45 +00005410TEST_F(FormatTest, UnderstandsTemplateParameters) {
5411 verifyFormat("A<int> a;");
Chandler Carruthf8b72662014-03-02 12:37:31 +00005412 verifyFormat("A<A<A<int>>> a;");
Daniel Jasperf7935112012-12-03 18:12:45 +00005413 verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
5414 verifyFormat("bool x = a < 1 || 2 > a;");
5415 verifyFormat("bool x = 5 < f<int>();");
5416 verifyFormat("bool x = f<int>() > 5;");
5417 verifyFormat("bool x = 5 < a<int>::x;");
5418 verifyFormat("bool x = a < 4 ? a > 2 : false;");
5419 verifyFormat("bool x = f() ? a < 2 : a > 2;");
5420
5421 verifyGoogleFormat("A<A<int>> a;");
5422 verifyGoogleFormat("A<A<A<int>>> a;");
5423 verifyGoogleFormat("A<A<A<A<int>>>> a;");
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005424 verifyGoogleFormat("A<A<int> > a;");
5425 verifyGoogleFormat("A<A<A<int> > > a;");
5426 verifyGoogleFormat("A<A<A<A<int> > > > a;");
Daniel Jasperfba84ff2013-10-12 05:16:06 +00005427 verifyGoogleFormat("A<::A<int>> a;");
5428 verifyGoogleFormat("A<::A> a;");
5429 verifyGoogleFormat("A< ::A> a;");
5430 verifyGoogleFormat("A< ::A<int> > a;");
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005431 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
5432 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
Daniel Jasperfba84ff2013-10-12 05:16:06 +00005433 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle()));
5434 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle()));
Daniel Jasper352f0df2015-07-18 16:35:30 +00005435 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };",
5436 format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle()));
Daniel Jasperf7935112012-12-03 18:12:45 +00005437
Nico Weber7533b4d2014-09-24 17:17:32 +00005438 verifyFormat("A<A>> a;", getChromiumStyle(FormatStyle::LK_Cpp));
5439
Daniel Jasperf7935112012-12-03 18:12:45 +00005440 verifyFormat("test >> a >> b;");
5441 verifyFormat("test << a >> b;");
5442
5443 verifyFormat("f<int>();");
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005444 verifyFormat("template <typename T> void f() {}");
Daniel Jasperb13135b2015-01-08 08:48:21 +00005445 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;");
Daniel Jasper112b50e2015-05-06 14:53:50 +00005446 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : "
5447 "sizeof(char)>::type>;");
Daniel Jasperadba2aa2015-05-18 12:52:00 +00005448 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};");
Daniel Jasper0c9772e2016-02-05 14:17:16 +00005449 verifyFormat("f(a.operator()<A>());");
5450 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5451 " .template operator()<A>());",
5452 getLLVMStyleWithColumns(35));
Daniel Jasperd5893912013-06-01 18:56:00 +00005453
5454 // Not template parameters.
5455 verifyFormat("return a < b && c > d;");
5456 verifyFormat("void f() {\n"
5457 " while (a < b && c > d) {\n"
5458 " }\n"
5459 "}");
Daniel Jasper62c0ac02013-07-30 22:37:19 +00005460 verifyFormat("template <typename... Types>\n"
5461 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}");
Daniel Jasper0de8efa2013-09-17 08:15:46 +00005462
5463 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5464 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);",
5465 getLLVMStyleWithColumns(60));
Daniel Jasper6ba16382014-07-28 13:19:58 +00005466 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");");
Daniel Jasper65df5aa2014-08-04 14:51:02 +00005467 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}");
Daniel Jasper4d9ec172015-05-06 08:38:24 +00005468 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <");
Daniel Jasperf7935112012-12-03 18:12:45 +00005469}
5470
Malcolm Parsons6af3f142016-11-03 16:57:30 +00005471TEST_F(FormatTest, BitshiftOperatorWidth) {
5472 EXPECT_EQ("int a = 1 << 2; /* foo\n"
5473 " bar */",
5474 format("int a=1<<2; /* foo\n"
5475 " bar */"));
5476
5477 EXPECT_EQ("int b = 256 >> 1; /* foo\n"
5478 " bar */",
5479 format("int b =256>>1 ; /* foo\n"
5480 " bar */"));
5481}
5482
Daniel Jasperd8ffcfa2013-02-28 09:21:10 +00005483TEST_F(FormatTest, UnderstandsBinaryOperators) {
5484 verifyFormat("COMPARE(a, ==, b);");
Daniel Jasper594be2f2016-06-13 07:49:09 +00005485 verifyFormat("auto s = sizeof...(Ts) - 1;");
Alexander Kornienko674be0a2013-03-20 16:41:56 +00005486}
5487
5488TEST_F(FormatTest, UnderstandsPointersToMembers) {
5489 verifyFormat("int A::*x;");
Daniel Jaspercfda5172013-05-08 14:58:20 +00005490 verifyFormat("int (S::*func)(void *);");
Daniel Jasper37194282013-05-28 08:33:00 +00005491 verifyFormat("void f() { int (S::*func)(void *); }");
Daniel Jasper2f34cac2013-05-08 15:06:58 +00005492 verifyFormat("typedef bool *(Class::*Member)() const;");
Daniel Jaspercfda5172013-05-08 14:58:20 +00005493 verifyFormat("void f() {\n"
5494 " (a->*f)();\n"
5495 " a->*x;\n"
5496 " (a.*f)();\n"
5497 " ((*a).*f)();\n"
5498 " a.*x;\n"
5499 "}");
Daniel Jasper998cabc2013-07-18 14:46:07 +00005500 verifyFormat("void f() {\n"
5501 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
5502 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n"
5503 "}");
Daniel Jasper85bcadc2014-07-09 13:07:57 +00005504 verifyFormat(
5505 "(aaaaaaaaaa->*bbbbbbb)(\n"
5506 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jasper2f34cac2013-05-08 15:06:58 +00005507 FormatStyle Style = getLLVMStyle();
Daniel Jasper553d4872014-06-17 12:40:34 +00005508 Style.PointerAlignment = FormatStyle::PAS_Left;
Daniel Jasper2f34cac2013-05-08 15:06:58 +00005509 verifyFormat("typedef bool* (Class::*Member)() const;", Style);
Daniel Jasperd8ffcfa2013-02-28 09:21:10 +00005510}
5511
Daniel Jasper8dd40472012-12-21 09:41:31 +00005512TEST_F(FormatTest, UnderstandsUnaryOperators) {
Daniel Jasperf7935112012-12-03 18:12:45 +00005513 verifyFormat("int a = -2;");
Daniel Jasper8b529712012-12-04 13:02:32 +00005514 verifyFormat("f(-1, -2, -3);");
5515 verifyFormat("a[-1] = 5;");
5516 verifyFormat("int a = 5 + -2;");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00005517 verifyFormat("if (i == -1) {\n}");
5518 verifyFormat("if (i != -1) {\n}");
5519 verifyFormat("if (i > -1) {\n}");
5520 verifyFormat("if (i < -1) {\n}");
Daniel Jasper26333c32012-12-06 13:16:39 +00005521 verifyFormat("++(a->f());");
5522 verifyFormat("--(a->f());");
Daniel Jasper13f23e12013-01-14 12:18:19 +00005523 verifyFormat("(a->f())++;");
5524 verifyFormat("a[42]++;");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00005525 verifyFormat("if (!(a->f())) {\n}");
Daniel Jasper8dd40472012-12-21 09:41:31 +00005526
5527 verifyFormat("a-- > b;");
5528 verifyFormat("b ? -a : c;");
5529 verifyFormat("n * sizeof char16;");
Alexander Kornienko1e808872013-06-28 12:51:24 +00005530 verifyFormat("n * alignof char16;", getGoogleStyle());
Daniel Jasper8dd40472012-12-21 09:41:31 +00005531 verifyFormat("sizeof(char);");
Alexander Kornienko1e808872013-06-28 12:51:24 +00005532 verifyFormat("alignof(char);", getGoogleStyle());
Daniel Jasperda1c68a2013-01-02 15:26:16 +00005533
5534 verifyFormat("return -1;");
5535 verifyFormat("switch (a) {\n"
5536 "case -1:\n"
5537 " break;\n"
5538 "}");
Daniel Jasper399d1ee2013-03-22 10:44:43 +00005539 verifyFormat("#define X -1");
5540 verifyFormat("#define X -kConstant");
Nico Weber63a54eb2013-01-12 05:41:23 +00005541
Chandler Carruthf8b72662014-03-02 12:37:31 +00005542 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};");
5543 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};");
Daniel Jasper71945272013-01-15 14:27:39 +00005544
5545 verifyFormat("int a = /* confusing comment */ -1;");
5546 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case.
5547 verifyFormat("int a = i /* confusing comment */++;");
Daniel Jasperf7935112012-12-03 18:12:45 +00005548}
5549
Daniel Jasper0c214fa2014-02-05 13:43:04 +00005550TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) {
Daniel Jasperf110e202013-08-21 08:39:01 +00005551 verifyFormat("if (!aaaaaaaaaa( // break\n"
Daniel Jasper0c214fa2014-02-05 13:43:04 +00005552 " aaaaa)) {\n"
Daniel Jasperf110e202013-08-21 08:39:01 +00005553 "}");
5554 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
Daniel Jasper739b85f2015-06-29 10:42:59 +00005555 " aaaaa));");
Daniel Jasper0649d362013-08-23 15:14:03 +00005556 verifyFormat("*aaa = aaaaaaa( // break\n"
5557 " bbbbbb);");
Daniel Jasperf110e202013-08-21 08:39:01 +00005558}
5559
Daniel Jasper8863ada2013-08-26 08:10:17 +00005560TEST_F(FormatTest, UnderstandsOverloadedOperators) {
Daniel Jasper537a2962012-12-24 10:56:04 +00005561 verifyFormat("bool operator<();");
5562 verifyFormat("bool operator>();");
5563 verifyFormat("bool operator=();");
5564 verifyFormat("bool operator==();");
5565 verifyFormat("bool operator!=();");
5566 verifyFormat("int operator+();");
5567 verifyFormat("int operator++();");
Daniel Jasper804a2762016-01-09 15:56:40 +00005568 verifyFormat("bool operator,();");
Daniel Jasper537a2962012-12-24 10:56:04 +00005569 verifyFormat("bool operator();");
5570 verifyFormat("bool operator()();");
5571 verifyFormat("bool operator[]();");
5572 verifyFormat("operator bool();");
Daniel Jasper35d2dc72013-02-11 08:01:18 +00005573 verifyFormat("operator int();");
5574 verifyFormat("operator void *();");
Daniel Jasper537a2962012-12-24 10:56:04 +00005575 verifyFormat("operator SomeType<int>();");
Daniel Jasper35d2dc72013-02-11 08:01:18 +00005576 verifyFormat("operator SomeType<int, int>();");
Chandler Carruthf8b72662014-03-02 12:37:31 +00005577 verifyFormat("operator SomeType<SomeType<int>>();");
Daniel Jasper537a2962012-12-24 10:56:04 +00005578 verifyFormat("void *operator new(std::size_t size);");
5579 verifyFormat("void *operator new[](std::size_t size);");
5580 verifyFormat("void operator delete(void *ptr);");
5581 verifyFormat("void operator delete[](void *ptr);");
Daniel Jasper8f9624b2013-05-10 07:59:58 +00005582 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
5583 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);");
Daniel Jasper804a2762016-01-09 15:56:40 +00005584 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n"
Daniel Jasperdf51f2e62016-01-11 12:55:33 +00005585 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;");
Daniel Jasper35d2dc72013-02-11 08:01:18 +00005586
Daniel Jasper0af92eb2013-02-15 19:24:08 +00005587 verifyFormat(
5588 "ostream &operator<<(ostream &OutputStream,\n"
5589 " SomeReallyLongType WithSomeReallyLongValue);");
Daniel Jasper54ac8202013-04-05 17:21:59 +00005590 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
5591 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
5592 " return left.group < right.group;\n"
5593 "}");
Daniel Jasper6e8f4ed2013-04-11 08:48:20 +00005594 verifyFormat("SomeType &operator=(const SomeType &S);");
Daniel Jasper8835a322014-10-20 13:56:30 +00005595 verifyFormat("f.template operator()<int>();");
Daniel Jasper0af92eb2013-02-15 19:24:08 +00005596
Daniel Jasper35d2dc72013-02-11 08:01:18 +00005597 verifyGoogleFormat("operator void*();");
5598 verifyGoogleFormat("operator SomeType<SomeType<int>>();");
Daniel Jasperedc5f092013-10-29 12:24:23 +00005599 verifyGoogleFormat("operator ::A();");
Daniel Jasper42401c82013-09-02 09:20:39 +00005600
5601 verifyFormat("using A::operator+;");
Daniel Jasper5af04a42015-10-07 03:43:10 +00005602 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n"
5603 "int i;");
Daniel Jasperf7935112012-12-03 18:12:45 +00005604}
5605
Daniel Jasper1c220482015-02-25 10:30:06 +00005606TEST_F(FormatTest, UnderstandsFunctionRefQualification) {
Daniel Jasperaf642c62015-08-25 13:40:51 +00005607 verifyFormat("Deleted &operator=(const Deleted &) & = default;");
5608 verifyFormat("Deleted &operator=(const Deleted &) && = delete;");
5609 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;");
5610 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;");
5611 verifyFormat("Deleted &operator=(const Deleted &) &;");
5612 verifyFormat("Deleted &operator=(const Deleted &) &&;");
5613 verifyFormat("SomeType MemberFunction(const Deleted &) &;");
5614 verifyFormat("SomeType MemberFunction(const Deleted &) &&;");
5615 verifyFormat("SomeType MemberFunction(const Deleted &) && {}");
5616 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}");
5617 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}");
Jacob Bandes-Storch58933c52017-08-10 01:30:22 +00005618 verifyFormat("void Fn(T const &) const &;");
5619 verifyFormat("void Fn(T const volatile &&) const volatile &&;");
Daniel Jasper28b4d512016-11-01 06:23:19 +00005620 verifyFormat("template <typename T>\n"
5621 "void F(T) && = delete;",
5622 getGoogleStyle());
Daniel Jasper1c220482015-02-25 10:30:06 +00005623
Daniel Jasperaf642c62015-08-25 13:40:51 +00005624 FormatStyle AlignLeft = getLLVMStyle();
5625 AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
Daniel Jasper2b4d6ea2016-06-08 08:23:46 +00005626 verifyFormat("void A::b() && {}", AlignLeft);
Daniel Jasperaf642c62015-08-25 13:40:51 +00005627 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft);
5628 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;",
5629 AlignLeft);
5630 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft);
5631 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft);
Daniel Jasperc3ff0cd2016-04-18 11:31:21 +00005632 verifyFormat("auto Function(T t) & -> void {}", AlignLeft);
5633 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft);
5634 verifyFormat("auto Function(T) & -> void {}", AlignLeft);
5635 verifyFormat("auto Function(T) & -> void;", AlignLeft);
Jacob Bandes-Storch58933c52017-08-10 01:30:22 +00005636 verifyFormat("void Fn(T const&) const&;", AlignLeft);
5637 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft);
Daniel Jasper1c220482015-02-25 10:30:06 +00005638
5639 FormatStyle Spaces = getLLVMStyle();
5640 Spaces.SpacesInCStyleCastParentheses = true;
Daniel Jasperaf642c62015-08-25 13:40:51 +00005641 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces);
5642 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces);
5643 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces);
5644 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces);
Daniel Jasper1c220482015-02-25 10:30:06 +00005645
5646 Spaces.SpacesInCStyleCastParentheses = false;
5647 Spaces.SpacesInParentheses = true;
Daniel Jasperaf642c62015-08-25 13:40:51 +00005648 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces);
5649 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", Spaces);
5650 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces);
5651 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces);
Daniel Jasper1c220482015-02-25 10:30:06 +00005652}
5653
Daniel Jasperd6a947f2013-01-11 16:09:04 +00005654TEST_F(FormatTest, UnderstandsNewAndDelete) {
Daniel Jasperba0bda92013-02-23 08:07:18 +00005655 verifyFormat("void f() {\n"
5656 " A *a = new A;\n"
5657 " A *a = new (placement) A;\n"
5658 " delete a;\n"
5659 " delete (A *)a;\n"
5660 "}");
Daniel Jasper71646ec2014-07-30 12:14:10 +00005661 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
5662 " typename aaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper316ab382014-08-06 13:14:58 +00005663 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5664 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
5665 " typename aaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper80222262014-11-02 22:46:42 +00005666 verifyFormat("delete[] h->p;");
Daniel Jasperd6a947f2013-01-11 16:09:04 +00005667}
5668
Daniel Jasper22bcf8a2013-01-02 08:57:10 +00005669TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005670 verifyFormat("int *f(int *a) {}");
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005671 verifyFormat("int main(int argc, char **argv) {}");
Daniel Jasper5065bc42013-02-18 12:44:35 +00005672 verifyFormat("Test::Test(int b) : a(b * b) {}");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005673 verifyIndependentOfContext("f(a, *a);");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005674 verifyFormat("void g() { f(*a); }");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005675 verifyIndependentOfContext("int a = b * 10;");
5676 verifyIndependentOfContext("int a = 10 * b;");
5677 verifyIndependentOfContext("int a = b * c;");
5678 verifyIndependentOfContext("int a += b * c;");
5679 verifyIndependentOfContext("int a -= b * c;");
5680 verifyIndependentOfContext("int a *= b * c;");
5681 verifyIndependentOfContext("int a /= b * c;");
5682 verifyIndependentOfContext("int a = *b;");
5683 verifyIndependentOfContext("int a = *b * c;");
5684 verifyIndependentOfContext("int a = b * *c;");
Daniel Jasper93101662015-05-19 12:29:27 +00005685 verifyIndependentOfContext("int a = b * (10);");
5686 verifyIndependentOfContext("S << b * (10);");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005687 verifyIndependentOfContext("return 10 * b;");
5688 verifyIndependentOfContext("return *b * *c;");
5689 verifyIndependentOfContext("return a & ~b;");
5690 verifyIndependentOfContext("f(b ? *c : *d);");
5691 verifyIndependentOfContext("int a = b ? *c : *d;");
5692 verifyIndependentOfContext("*b = a;");
5693 verifyIndependentOfContext("a * ~b;");
5694 verifyIndependentOfContext("a * !b;");
5695 verifyIndependentOfContext("a * +b;");
5696 verifyIndependentOfContext("a * -b;");
5697 verifyIndependentOfContext("a * ++b;");
5698 verifyIndependentOfContext("a * --b;");
5699 verifyIndependentOfContext("a[4] * b;");
Daniel Jasper8e559272013-02-27 11:43:50 +00005700 verifyIndependentOfContext("a[a * a] = 1;");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005701 verifyIndependentOfContext("f() * b;");
5702 verifyIndependentOfContext("a * [self dostuff];");
Daniel Jasper6e42b1e2013-04-01 17:13:26 +00005703 verifyIndependentOfContext("int x = a * (a + b);");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005704 verifyIndependentOfContext("(a *)(a + b);");
Daniel Jasper942d9712014-04-28 09:19:28 +00005705 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005706 verifyIndependentOfContext("int *pa = (int *)&a;");
Nico Weber44449172013-02-12 16:17:07 +00005707 verifyIndependentOfContext("return sizeof(int **);");
5708 verifyIndependentOfContext("return sizeof(int ******);");
5709 verifyIndependentOfContext("return (int **&)a;");
Daniel Jasper4d03d3b2013-05-28 15:27:10 +00005710 verifyIndependentOfContext("f((*PointerToArray)[10]);");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005711 verifyFormat("void f(Type (*parameter)[10]) {}");
Daniel Jasper4bc013e2015-10-07 01:41:22 +00005712 verifyFormat("void f(Type (&parameter)[10]) {}");
Nico Weber44449172013-02-12 16:17:07 +00005713 verifyGoogleFormat("return sizeof(int**);");
5714 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);");
5715 verifyGoogleFormat("Type** A = static_cast<Type**>(P);");
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00005716 verifyFormat("auto a = [](int **&, int ***) {};");
Daniel Jasperd46e07e2013-10-20 18:15:30 +00005717 verifyFormat("auto PointerBinding = [](const char *S) {};");
Daniel Jasper71665cd2013-09-10 10:26:38 +00005718 verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
Daniel Jasper4ac7de72014-06-11 07:35:16 +00005719 verifyFormat("[](const decltype(*a) &value) {}");
Daniel Jasper033181b2015-08-13 13:43:51 +00005720 verifyFormat("decltype(a * b) F();");
Daniel Jasper99b5a462015-05-12 10:20:32 +00005721 verifyFormat("#define MACRO() [](A *a) { return 1; }");
Daniel Jasperd27df3d2016-02-01 11:21:07 +00005722 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}");
Daniel Jasper3682fcd2013-12-16 08:36:18 +00005723 verifyIndependentOfContext("typedef void (*f)(int *a);");
Daniel Jasper39485162014-05-22 09:00:33 +00005724 verifyIndependentOfContext("int i{a * b};");
Daniel Jasper7d028292014-06-02 11:54:20 +00005725 verifyIndependentOfContext("aaa && aaa->f();");
Daniel Jasper2ac3fdf2014-07-28 12:08:16 +00005726 verifyIndependentOfContext("int x = ~*p;");
Daniel Jasperd127e3b2014-11-14 17:26:49 +00005727 verifyFormat("Constructor() : a(a), area(width * height) {}");
Daniel Jaspere1e348b2014-11-17 18:42:22 +00005728 verifyFormat("Constructor() : a(a), area(a, width * height) {}");
Daniel Jaspere4ab49e2015-04-20 12:54:29 +00005729 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}");
Daniel Jasper6a3fd832014-11-17 13:55:04 +00005730 verifyFormat("void f() { f(a, c * d); }");
Daniel Jasper3a26a8d2015-05-13 12:54:30 +00005731 verifyFormat("void f() { f(new a(), c * d); }");
Daniel Jasperc941e7d2017-01-09 11:04:07 +00005732 verifyFormat("void f(const MyOverride &override);");
5733 verifyFormat("void f(const MyFinal &final);");
5734 verifyIndependentOfContext("bool a = f() && override.f();");
5735 verifyIndependentOfContext("bool a = f() && final.f();");
Daniel Jasper27234032012-12-07 09:52:15 +00005736
Daniel Jasper5b49f472013-01-23 12:10:53 +00005737 verifyIndependentOfContext("InvalidRegions[*R] = 0;");
Daniel Jasper3c2557d2013-01-04 20:46:38 +00005738
Daniel Jasper5b49f472013-01-23 12:10:53 +00005739 verifyIndependentOfContext("A<int *> a;");
5740 verifyIndependentOfContext("A<int **> a;");
5741 verifyIndependentOfContext("A<int *, int *> a;");
Daniel Jasper139d4a32014-04-08 13:07:41 +00005742 verifyIndependentOfContext("A<int *[]> a;");
Daniel Jasperc697ad22013-02-06 10:05:46 +00005743 verifyIndependentOfContext(
5744 "const char *const p = reinterpret_cast<const char *const>(q);");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005745 verifyIndependentOfContext("A<int **, int **> a;");
Daniel Jasper8035b0a2013-02-06 10:57:42 +00005746 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);");
Daniel Jasperae907642013-03-14 10:50:25 +00005747 verifyFormat("for (char **a = b; *a; ++a) {\n}");
Daniel Jasperc37de302013-05-03 14:41:24 +00005748 verifyFormat("for (; a && b;) {\n}");
Daniel Jasperea2d0422014-05-08 08:50:10 +00005749 verifyFormat("bool foo = true && [] { return false; }();");
Daniel Jaspera4396862012-12-10 18:59:13 +00005750
Daniel Jasper66dcb1c2013-01-08 20:03:18 +00005751 verifyFormat(
5752 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5753 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5754
Daniel Jasper1f5d6372016-06-13 14:45:12 +00005755 verifyGoogleFormat("int const* a = &b;");
Daniel Jasper6a968202015-01-07 12:19:53 +00005756 verifyGoogleFormat("**outparam = 1;");
Daniel Jasper75092162015-01-23 19:04:49 +00005757 verifyGoogleFormat("*outparam = a * b;");
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005758 verifyGoogleFormat("int main(int argc, char** argv) {}");
Daniel Jaspera4396862012-12-10 18:59:13 +00005759 verifyGoogleFormat("A<int*> a;");
5760 verifyGoogleFormat("A<int**> a;");
5761 verifyGoogleFormat("A<int*, int*> a;");
5762 verifyGoogleFormat("A<int**, int**> a;");
Daniel Jasper22bcf8a2013-01-02 08:57:10 +00005763 verifyGoogleFormat("f(b ? *c : *d);");
5764 verifyGoogleFormat("int a = b ? *c : *d;");
Daniel Jaspera1dc93a2013-01-16 16:04:06 +00005765 verifyGoogleFormat("Type* t = **x;");
5766 verifyGoogleFormat("Type* t = *++*x;");
5767 verifyGoogleFormat("*++*x;");
5768 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);");
5769 verifyGoogleFormat("Type* t = x++ * y;");
Daniel Jasperc697ad22013-02-06 10:05:46 +00005770 verifyGoogleFormat(
5771 "const char* const p = reinterpret_cast<const char* const>(q);");
Daniel Jasper8184d662014-07-28 12:24:21 +00005772 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);");
Daniel Jasper0bd9a192014-11-10 16:57:30 +00005773 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);");
5774 verifyGoogleFormat("template <typename T>\n"
5775 "void f(int i = 0, SomeType** temps = NULL);");
Manuel Klimek557811f2013-01-14 10:58:01 +00005776
Daniel Jasper1904e9b2014-08-14 10:53:19 +00005777 FormatStyle Left = getLLVMStyle();
5778 Left.PointerAlignment = FormatStyle::PAS_Left;
5779 verifyFormat("x = *a(x) = *a(y);", Left);
Daniel Jasper28b4d512016-11-01 06:23:19 +00005780 verifyFormat("for (;; *a = b) {\n}", Left);
Daniel Jasper95516cd2015-12-23 18:01:29 +00005781 verifyFormat("return *this += 1;", Left);
Manuel Klimek06b575c2017-07-17 15:27:53 +00005782 verifyFormat("throw *x;", Left);
Krasimir Georgiev9b5a89b2017-08-14 11:06:07 +00005783 verifyFormat("delete *x;", Left);
5784 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left);
5785 verifyFormat("[](const decltype(*a)* ptr) {}", Left);
5786 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left);
Daniel Jasper1904e9b2014-08-14 10:53:19 +00005787
Daniel Jasper5b49f472013-01-23 12:10:53 +00005788 verifyIndependentOfContext("a = *(x + y);");
5789 verifyIndependentOfContext("a = &(x + y);");
5790 verifyIndependentOfContext("*(x + y).call();");
5791 verifyIndependentOfContext("&(x + y)->call();");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005792 verifyFormat("void f() { &(*I).first; }");
Daniel Jasper71945272013-01-15 14:27:39 +00005793
Daniel Jasper5b49f472013-01-23 12:10:53 +00005794 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
Daniel Jasper71945272013-01-15 14:27:39 +00005795 verifyFormat(
Daniel Jasperf9fc2152014-04-09 13:18:49 +00005796 "int *MyValues = {\n"
5797 " *A, // Operator detection might be confused by the '{'\n"
5798 " *BB // Operator detection might be confused by previous comment\n"
Daniel Jasper71945272013-01-15 14:27:39 +00005799 "};");
Nico Weber80a82762013-01-17 17:17:19 +00005800
Daniel Jasper5b49f472013-01-23 12:10:53 +00005801 verifyIndependentOfContext("if (int *a = &b)");
5802 verifyIndependentOfContext("if (int &a = *b)");
5803 verifyIndependentOfContext("if (a & b[i])");
5804 verifyIndependentOfContext("if (a::b::c::d & b[i])");
5805 verifyIndependentOfContext("if (*b[i])");
5806 verifyIndependentOfContext("if (int *a = (&b))");
5807 verifyIndependentOfContext("while (int *a = &b)");
Daniel Jasperdf620b22013-09-21 17:31:51 +00005808 verifyIndependentOfContext("size = sizeof *a;");
Daniel Jasperdc4f7252015-03-11 12:59:49 +00005809 verifyIndependentOfContext("if (a && (b = c))");
Daniel Jasper420d7d32013-01-23 12:58:14 +00005810 verifyFormat("void f() {\n"
5811 " for (const int &v : Values) {\n"
5812 " }\n"
5813 "}");
Daniel Jasper5065bc42013-02-18 12:44:35 +00005814 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
5815 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
Daniel Jasper5ca9b712013-09-11 20:37:10 +00005816 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}");
Daniel Jasper0b820602013-01-22 11:46:26 +00005817
Daniel Jaspera98da3d2013-11-07 19:56:07 +00005818 verifyFormat("#define A (!a * b)");
Daniel Jasperb910bbb2013-05-13 07:14:40 +00005819 verifyFormat("#define MACRO \\\n"
5820 " int *i = a * b; \\\n"
5821 " void f(a *b);",
5822 getLLVMStyleWithColumns(19));
5823
Daniel Jasper97b89482013-03-13 07:49:51 +00005824 verifyIndependentOfContext("A = new SomeType *[Length];");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005825 verifyIndependentOfContext("A = new SomeType *[Length]();");
Daniel Jasper6f9c8d22013-07-05 13:30:40 +00005826 verifyIndependentOfContext("T **t = new T *;");
5827 verifyIndependentOfContext("T **t = new T *();");
Daniel Jasper532a0312015-04-23 10:23:53 +00005828 verifyGoogleFormat("A = new SomeType*[Length]();");
5829 verifyGoogleFormat("A = new SomeType*[Length];");
Daniel Jasper6f9c8d22013-07-05 13:30:40 +00005830 verifyGoogleFormat("T** t = new T*;");
5831 verifyGoogleFormat("T** t = new T*();");
Daniel Jasperb910bbb2013-05-13 07:14:40 +00005832
Daniel Jaspera65e8872014-03-25 10:52:45 +00005833 verifyFormat("STATIC_ASSERT((a & b) == 0);");
5834 verifyFormat("STATIC_ASSERT(0 == (a & b));");
Manuel Klimekf81e5c02014-03-27 11:17:36 +00005835 verifyFormat("template <bool a, bool b> "
Daniel Jasper4afc6b32014-06-02 10:57:55 +00005836 "typename t::if<x && y>::type f() {}");
5837 verifyFormat("template <int *y> f() {}");
Manuel Klimekf81e5c02014-03-27 11:17:36 +00005838 verifyFormat("vector<int *> v;");
5839 verifyFormat("vector<int *const> v;");
5840 verifyFormat("vector<int *const **const *> v;");
5841 verifyFormat("vector<int *volatile> v;");
5842 verifyFormat("vector<a * b> v;");
Manuel Klimek1f9d80a2014-03-27 19:00:52 +00005843 verifyFormat("foo<b && false>();");
5844 verifyFormat("foo<b & 1>();");
Daniel Jasper73e171f2014-08-29 12:54:38 +00005845 verifyFormat("decltype(*::std::declval<const T &>()) void F();");
Daniel Jasper13a7f462014-10-28 18:11:52 +00005846 verifyFormat(
Daniel Jasper21f7dea2017-02-01 09:23:39 +00005847 "template <class T, class = typename std::enable_if<\n"
5848 " std::is_integral<T>::value &&\n"
5849 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n"
5850 "void F();",
5851 getLLVMStyleWithColumns(70));
5852 verifyFormat(
Daniel Jasper22ed2622016-11-29 09:40:32 +00005853 "template <class T,\n"
5854 " class = typename std::enable_if<\n"
5855 " std::is_integral<T>::value &&\n"
Daniel Jasper21f7dea2017-02-01 09:23:39 +00005856 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n"
5857 " class U>\n"
Daniel Jasperf0c809a2014-10-28 18:28:22 +00005858 "void F();",
Daniel Jasper22ed2622016-11-29 09:40:32 +00005859 getLLVMStyleWithColumns(70));
Daniel Jasperf0c809a2014-10-28 18:28:22 +00005860 verifyFormat(
5861 "template <class T,\n"
5862 " class = typename ::std::enable_if<\n"
5863 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n"
5864 "void F();",
5865 getGoogleStyleWithColumns(68));
Manuel Klimek1f9d80a2014-03-27 19:00:52 +00005866
Daniel Jaspercc7bf7f2014-04-03 09:00:49 +00005867 verifyIndependentOfContext("MACRO(int *i);");
5868 verifyIndependentOfContext("MACRO(auto *a);");
5869 verifyIndependentOfContext("MACRO(const A *a);");
Daniel Jasper628dd852017-03-08 09:49:12 +00005870 verifyIndependentOfContext("MACRO(A *const a);");
Daniel Jasper91beebd2014-06-30 13:44:47 +00005871 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');");
Daniel Jasperd0d27aa2016-11-01 06:23:14 +00005872 verifyFormat("void f() { f(float{1}, a * a); }");
Daniel Jaspercc7bf7f2014-04-03 09:00:49 +00005873 // FIXME: Is there a way to make this work?
5874 // verifyIndependentOfContext("MACRO(A *a);");
5875
Daniel Jasper32ccb032014-06-23 07:36:18 +00005876 verifyFormat("DatumHandle const *operator->() const { return input_; }");
Daniel Jasper0ea4d792015-10-07 01:41:14 +00005877 verifyFormat("return options != nullptr && operator==(*options);");
Daniel Jasper32ccb032014-06-23 07:36:18 +00005878
Daniel Jasper866468a2014-04-14 13:15:29 +00005879 EXPECT_EQ("#define OP(x) \\\n"
5880 " ostream &operator<<(ostream &s, const A &a) { \\\n"
5881 " return s << a.DebugString(); \\\n"
5882 " }",
5883 format("#define OP(x) \\\n"
5884 " ostream &operator<<(ostream &s, const A &a) { \\\n"
5885 " return s << a.DebugString(); \\\n"
5886 " }",
5887 getLLVMStyleWithColumns(50)));
5888
Manuel Klimek1f9d80a2014-03-27 19:00:52 +00005889 // FIXME: We cannot handle this case yet; we might be able to figure out that
5890 // foo<x> d > v; doesn't make sense.
Daniel Jasper6ba16382014-07-28 13:19:58 +00005891 verifyFormat("foo<a<b && c> d> v;");
Daniel Jasper553d4872014-06-17 12:40:34 +00005892
5893 FormatStyle PointerMiddle = getLLVMStyle();
5894 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
5895 verifyFormat("delete *x;", PointerMiddle);
5896 verifyFormat("int * x;", PointerMiddle);
5897 verifyFormat("template <int * y> f() {}", PointerMiddle);
5898 verifyFormat("int * f(int * a) {}", PointerMiddle);
5899 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle);
5900 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle);
5901 verifyFormat("A<int *> a;", PointerMiddle);
5902 verifyFormat("A<int **> a;", PointerMiddle);
5903 verifyFormat("A<int *, int *> a;", PointerMiddle);
5904 verifyFormat("A<int * []> a;", PointerMiddle);
Daniel Jasper532a0312015-04-23 10:23:53 +00005905 verifyFormat("A = new SomeType *[Length]();", PointerMiddle);
5906 verifyFormat("A = new SomeType *[Length];", PointerMiddle);
Daniel Jasper553d4872014-06-17 12:40:34 +00005907 verifyFormat("T ** t = new T *;", PointerMiddle);
Daniel Jasper3992e2c2015-07-01 21:02:24 +00005908
5909 // Member function reference qualifiers aren't binary operators.
5910 verifyFormat("string // break\n"
Daniel Jasperaf642c62015-08-25 13:40:51 +00005911 "operator()() & {}");
Daniel Jasper3992e2c2015-07-01 21:02:24 +00005912 verifyFormat("string // break\n"
Daniel Jasperaf642c62015-08-25 13:40:51 +00005913 "operator()() && {}");
Daniel Jasper3992e2c2015-07-01 21:02:24 +00005914 verifyGoogleFormat("template <typename T>\n"
Daniel Jasperaf642c62015-08-25 13:40:51 +00005915 "auto x() & -> int {}");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005916}
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005917
Daniel Jasperee6d6502013-07-17 20:25:02 +00005918TEST_F(FormatTest, UnderstandsAttributes) {
5919 verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
Daniel Jasper559b63c2014-01-28 20:13:43 +00005920 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
5921 "aaaaaaaaaaaaaaaaaaaaaaa(int i);");
Daniel Jaspera5fa4d12015-07-06 11:30:34 +00005922 FormatStyle AfterType = getLLVMStyle();
Zachary Turner448592e2015-12-18 22:20:15 +00005923 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
Daniel Jaspera5fa4d12015-07-06 11:30:34 +00005924 verifyFormat("__attribute__((nodebug)) void\n"
5925 "foo() {}\n",
5926 AfterType);
Daniel Jasperee6d6502013-07-17 20:25:02 +00005927}
5928
Daniel Jasper10cd5812013-05-06 06:35:44 +00005929TEST_F(FormatTest, UnderstandsEllipsis) {
5930 verifyFormat("int printf(const char *fmt, ...);");
5931 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
Daniel Jasperbafa6b72013-07-01 09:47:25 +00005932 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}");
5933
5934 FormatStyle PointersLeft = getLLVMStyle();
Daniel Jasper553d4872014-06-17 12:40:34 +00005935 PointersLeft.PointerAlignment = FormatStyle::PAS_Left;
Daniel Jasperbafa6b72013-07-01 09:47:25 +00005936 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft);
Daniel Jasper10cd5812013-05-06 06:35:44 +00005937}
5938
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005939TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005940 EXPECT_EQ("int *a;\n"
5941 "int *a;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005942 "int *a;",
5943 format("int *a;\n"
5944 "int* a;\n"
5945 "int *a;",
5946 getGoogleStyle()));
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005947 EXPECT_EQ("int* a;\n"
5948 "int* a;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005949 "int* a;",
5950 format("int* a;\n"
5951 "int* a;\n"
5952 "int *a;",
5953 getGoogleStyle()));
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005954 EXPECT_EQ("int *a;\n"
5955 "int *a;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005956 "int *a;",
5957 format("int *a;\n"
5958 "int * a;\n"
5959 "int * a;",
5960 getGoogleStyle()));
Daniel Jasper352f0df2015-07-18 16:35:30 +00005961 EXPECT_EQ("auto x = [] {\n"
5962 " int *a;\n"
5963 " int *a;\n"
5964 " int *a;\n"
5965 "};",
5966 format("auto x=[]{int *a;\n"
5967 "int * a;\n"
5968 "int * a;};",
5969 getGoogleStyle()));
Daniel Jasperf7935112012-12-03 18:12:45 +00005970}
5971
Alexander Kornienkoa5151272013-03-12 16:28:18 +00005972TEST_F(FormatTest, UnderstandsRvalueReferences) {
5973 verifyFormat("int f(int &&a) {}");
5974 verifyFormat("int f(int a, char &&b) {}");
5975 verifyFormat("void f() { int &&a = b; }");
5976 verifyGoogleFormat("int f(int a, char&& b) {}");
5977 verifyGoogleFormat("void f() { int&& a = b; }");
5978
Daniel Jasper1eff9082013-05-27 16:36:33 +00005979 verifyIndependentOfContext("A<int &&> a;");
5980 verifyIndependentOfContext("A<int &&, int &&> a;");
5981 verifyGoogleFormat("A<int&&> a;");
5982 verifyGoogleFormat("A<int&&, int&&> a;");
Daniel Jasper8b1c6352013-08-01 17:58:23 +00005983
5984 // Not rvalue references:
5985 verifyFormat("template <bool B, bool C> class A {\n"
5986 " static_assert(B && C, \"Something is wrong\");\n"
5987 "};");
Daniel Jasper29a98cf2013-08-13 09:09:09 +00005988 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))");
5989 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))");
Daniel Jasper72ab43b2014-04-14 12:50:02 +00005990 verifyFormat("#define A(a, b) (a && b)");
Alexander Kornienkoa5151272013-03-12 16:28:18 +00005991}
5992
Manuel Klimekc1237a82013-01-23 14:08:21 +00005993TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
5994 verifyFormat("void f() {\n"
5995 " x[aaaaaaaaa -\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00005996 " b] = 23;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005997 "}",
5998 getLLVMStyleWithColumns(15));
Manuel Klimekc1237a82013-01-23 14:08:21 +00005999}
6000
Daniel Jasperef906a92013-01-13 08:01:36 +00006001TEST_F(FormatTest, FormatsCasts) {
6002 verifyFormat("Type *A = static_cast<Type *>(P);");
6003 verifyFormat("Type *A = (Type *)P;");
6004 verifyFormat("Type *A = (vector<Type *, int *>)P;");
6005 verifyFormat("int a = (int)(2.0f);");
Daniel Jasperda6f2252013-05-31 16:14:28 +00006006 verifyFormat("int a = (int)2.0f;");
6007 verifyFormat("x[(int32)y];");
6008 verifyFormat("x = (int32)y;");
6009 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
6010 verifyFormat("int a = (int)*b;");
6011 verifyFormat("int a = (int)2.0f;");
6012 verifyFormat("int a = (int)~0;");
6013 verifyFormat("int a = (int)++a;");
6014 verifyFormat("int a = (int)sizeof(int);");
6015 verifyFormat("int a = (int)+2;");
6016 verifyFormat("my_int a = (my_int)2.0f;");
6017 verifyFormat("my_int a = (my_int)sizeof(int);");
Daniel Jasper05866372013-06-06 08:20:20 +00006018 verifyFormat("return (my_int)aaa;");
Daniel Jasper49a94482013-07-15 15:04:42 +00006019 verifyFormat("#define x ((int)-1)");
Daniel Jaspera45eb4c2014-10-06 13:16:43 +00006020 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1");
Daniel Jasper49a94482013-07-15 15:04:42 +00006021 verifyFormat("#define p(q) ((int *)&q)");
Daniel Jasper30646202014-07-14 12:38:38 +00006022 verifyFormat("fn(a)(b) + 1;");
Daniel Jasperef906a92013-01-13 08:01:36 +00006023
Dinesh Dwivedi76f98f82014-05-05 13:14:35 +00006024 verifyFormat("void f() { my_int a = (my_int)*b; }");
6025 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }");
6026 verifyFormat("my_int a = (my_int)~0;");
6027 verifyFormat("my_int a = (my_int)++a;");
Daniel Jaspera45eb4c2014-10-06 13:16:43 +00006028 verifyFormat("my_int a = (my_int)-2;");
Dinesh Dwivedi76f98f82014-05-05 13:14:35 +00006029 verifyFormat("my_int a = (my_int)1;");
6030 verifyFormat("my_int a = (my_int *)1;");
6031 verifyFormat("my_int a = (const my_int)-1;");
6032 verifyFormat("my_int a = (const my_int *)-1;");
Daniel Jasper4b3ba212014-08-25 09:36:07 +00006033 verifyFormat("my_int a = (my_int)(my_int)-1;");
Daniel Jasperf5e5ee62015-05-19 11:18:39 +00006034 verifyFormat("my_int a = (ns::my_int)-2;");
Daniel Jasper554e49f2015-06-12 07:15:33 +00006035 verifyFormat("case (my_int)ONE:");
Daniel Jasper94b1bdf2016-04-05 11:46:06 +00006036 verifyFormat("auto x = (X)this;");
Dinesh Dwivedi76f98f82014-05-05 13:14:35 +00006037
6038 // FIXME: single value wrapped with paren will be treated as cast.
6039 verifyFormat("void f(int i = (kValue)*kMask) {}");
Daniel Jasperef906a92013-01-13 08:01:36 +00006040
Dinesh Dwivedi2e92e662014-05-06 11:46:49 +00006041 verifyFormat("{ (void)F; }");
6042
Daniel Jasper998cabc2013-07-18 14:46:07 +00006043 // Don't break after a cast's
6044 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
6045 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
6046 " bbbbbbbbbbbbbbbbbbbbbb);");
6047
Daniel Jasperef906a92013-01-13 08:01:36 +00006048 // These are not casts.
6049 verifyFormat("void f(int *) {}");
Nico Weber4401b2a2013-02-13 04:32:57 +00006050 verifyFormat("f(foo)->b;");
6051 verifyFormat("f(foo).b;");
6052 verifyFormat("f(foo)(b);");
6053 verifyFormat("f(foo)[b];");
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00006054 verifyFormat("[](foo) { return 4; }(bar);");
Nico Weber4401b2a2013-02-13 04:32:57 +00006055 verifyFormat("(*funptr)(foo)[4];");
6056 verifyFormat("funptrs[4](foo)[4];");
Daniel Jasperef906a92013-01-13 08:01:36 +00006057 verifyFormat("void f(int *);");
6058 verifyFormat("void f(int *) = 0;");
6059 verifyFormat("void f(SmallVector<int>) {}");
6060 verifyFormat("void f(SmallVector<int>);");
6061 verifyFormat("void f(SmallVector<int>) = 0;");
Nico Weber06fcec12013-02-09 18:02:07 +00006062 verifyFormat("void f(int i = (kA * kB) & kMask) {}");
Nico Weber4401b2a2013-02-13 04:32:57 +00006063 verifyFormat("int a = sizeof(int) * b;");
Alexander Kornienko1e808872013-06-28 12:51:24 +00006064 verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
Daniel Jasper05866372013-06-06 08:20:20 +00006065 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
6066 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
Aaron Ballman61005bc2015-02-16 14:14:01 +00006067 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00006068
Daniel Jasperba0bda92013-02-23 08:07:18 +00006069 // These are not casts, but at some point were confused with casts.
6070 verifyFormat("virtual void foo(int *) override;");
6071 verifyFormat("virtual void foo(char &) const;");
6072 verifyFormat("virtual void foo(int *a, char *) const;");
Daniel Jasper8a68b952013-03-13 17:13:53 +00006073 verifyFormat("int a = sizeof(int *) + b;");
Alexander Kornienko1e808872013-06-28 12:51:24 +00006074 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
Daniel Jasper9bb30012015-11-23 15:55:50 +00006075 verifyFormat("bool b = f(g<int>) && c;");
Daniel Jasper8e8b4fb2015-11-23 19:11:45 +00006076 verifyFormat("typedef void (*f)(int i) func;");
Daniel Jasper1bc1b502013-07-05 07:58:34 +00006077
6078 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
6079 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
Daniel Jasperaea3bde2013-07-12 11:19:37 +00006080 // FIXME: The indentation here is not ideal.
Daniel Jasper0e90c3d2013-07-05 09:14:35 +00006081 verifyFormat(
Daniel Jasperaea3bde2013-07-12 11:19:37 +00006082 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6083 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
6084 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];");
Daniel Jasperef906a92013-01-13 08:01:36 +00006085}
6086
Daniel Jasperc1fa2812013-01-10 13:08:12 +00006087TEST_F(FormatTest, FormatsFunctionTypes) {
Daniel Jasperc1fa2812013-01-10 13:08:12 +00006088 verifyFormat("A<bool()> a;");
6089 verifyFormat("A<SomeType()> a;");
Daniel Jasper37194282013-05-28 08:33:00 +00006090 verifyFormat("A<void (*)(int, std::string)> a;");
Daniel Jasperb8914dd2013-03-20 09:53:18 +00006091 verifyFormat("A<void *(int)>;");
Daniel Jasper6e42b1e2013-04-01 17:13:26 +00006092 verifyFormat("void *(*a)(int *, SomeType *);");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00006093 verifyFormat("int (*func)(void *);");
Daniel Jasper37194282013-05-28 08:33:00 +00006094 verifyFormat("void f() { int (*func)(void *); }");
Daniel Jasper59036852013-08-12 12:16:34 +00006095 verifyFormat("template <class CallbackClass>\n"
6096 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);");
Daniel Jasperb8914dd2013-03-20 09:53:18 +00006097
Daniel Jasper6e42b1e2013-04-01 17:13:26 +00006098 verifyGoogleFormat("A<void*(int*, SomeType*)>;");
6099 verifyGoogleFormat("void* (*a)(int);");
Daniel Jasper59036852013-08-12 12:16:34 +00006100 verifyGoogleFormat(
6101 "template <class CallbackClass>\n"
6102 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);");
Daniel Jasperabc34212013-05-14 08:34:47 +00006103
Daniel Jasper5dad58e2013-05-15 07:51:51 +00006104 // Other constructs can look somewhat like function types:
Daniel Jasperabc34212013-05-14 08:34:47 +00006105 verifyFormat("A<sizeof(*x)> a;");
Daniel Jasper5dad58e2013-05-15 07:51:51 +00006106 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
Daniel Jasper655d96a2013-07-16 11:37:21 +00006107 verifyFormat("some_var = function(*some_pointer_var)[0];");
6108 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
Daniel Jaspera85c3312015-12-28 07:44:25 +00006109 verifyFormat("int x = f(&h)();");
Daniel Jasper21561662016-06-13 07:49:35 +00006110 verifyFormat("returnsFunction(&param1, &param2)(param);");
Daniel Jaspercab46172017-04-24 14:28:49 +00006111 verifyFormat("std::function<\n"
6112 " LooooooooooongTemplatedType<\n"
6113 " SomeType>*(\n"
6114 " LooooooooooooooooongType type)>\n"
6115 " function;",
6116 getGoogleStyleWithColumns(40));
Daniel Jasperc1fa2812013-01-10 13:08:12 +00006117}
6118
Daniel Jasperbeaa3222015-02-26 11:30:50 +00006119TEST_F(FormatTest, FormatsPointersToArrayTypes) {
6120 verifyFormat("A (*foo_)[6];");
6121 verifyFormat("vector<int> (*foo_)[6];");
6122}
6123
Daniel Jasper4355e7f2014-07-09 07:50:33 +00006124TEST_F(FormatTest, BreaksLongVariableDeclarations) {
6125 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
6126 " LoooooooooooooooooooooooooooooooooooooooongVariable;");
6127 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
6128 " LoooooooooooooooooooooooooooooooooooooooongVariable;");
Daniel Jasperb754a742015-03-12 15:04:53 +00006129 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
6130 " *LoooooooooooooooooooooooooooooooooooooooongVariable;");
Daniel Jasper4355e7f2014-07-09 07:50:33 +00006131
6132 // Different ways of ()-initializiation.
6133 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
6134 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);");
6135 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
6136 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);");
6137 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
6138 " LoooooooooooooooooooooooooooooooooooooooongVariable({});");
Daniel Jasper0faa9132015-04-23 13:58:40 +00006139 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
6140 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);");
Daniel Jasper697a8ec2017-02-07 21:38:16 +00006141
6142 // Lambdas should not confuse the variable declaration heuristic.
6143 verifyFormat("LooooooooooooooooongType\n"
6144 " variable(nullptr, [](A *a) {});",
6145 getLLVMStyleWithColumns(40));
Daniel Jasper4355e7f2014-07-09 07:50:33 +00006146}
6147
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00006148TEST_F(FormatTest, BreaksLongDeclarations) {
Daniel Jasper8e357692013-05-06 08:27:33 +00006149 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00006150 " AnotherNameForTheLongType;");
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00006151 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00006152 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper8e357692013-05-06 08:27:33 +00006153 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00006154 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
Daniel Jasperb754a742015-03-12 15:04:53 +00006155 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n"
6156 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
Daniel Jasper8e357692013-05-06 08:27:33 +00006157 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
6158 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasper2ad0aba2014-10-28 17:06:04 +00006159 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n"
6160 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasperdba1c552013-07-02 09:47:29 +00006161 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
6162 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasperf10a28d2014-05-05 13:48:09 +00006163 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
6164 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasperc3ff0cd2016-04-18 11:31:21 +00006165 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
6166 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);");
6167 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
6168 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}");
Daniel Jasperc75e1ef2014-07-09 08:42:42 +00006169 FormatStyle Indented = getLLVMStyle();
6170 Indented.IndentWrappedFunctionNames = true;
6171 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
6172 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();",
6173 Indented);
6174 verifyFormat(
6175 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
6176 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
6177 Indented);
6178 verifyFormat(
6179 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
6180 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
6181 Indented);
6182 verifyFormat(
6183 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
6184 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
6185 Indented);
Daniel Jasper8e357692013-05-06 08:27:33 +00006186
6187 // FIXME: Without the comment, this breaks after "(".
Manuel Klimek836c2862013-06-21 17:25:42 +00006188 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n"
6189 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();",
6190 getGoogleStyle());
Daniel Jasper8e357692013-05-06 08:27:33 +00006191
Daniel Jasperd2639ef2013-01-28 15:16:31 +00006192 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00006193 " int LoooooooooooooooooooongParam2) {}");
Daniel Jasperd1926a32013-01-02 08:44:14 +00006194 verifyFormat(
Daniel Jasper6728fc12013-04-11 14:29:13 +00006195 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
6196 " SourceLocation L, IdentifierIn *II,\n"
6197 " Type *T) {}");
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00006198 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
Daniel Jasperb754a742015-03-12 15:04:53 +00006199 "ReallyReaaallyLongFunctionName(\n"
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00006200 " const std::string &SomeParameter,\n"
Daniel Jasperb754a742015-03-12 15:04:53 +00006201 " const SomeType<string, SomeOtherTemplateParameter>\n"
6202 " &ReallyReallyLongParameterName,\n"
6203 " const SomeType<string, SomeOtherTemplateParameter>\n"
6204 " &AnotherLongParameterName) {}");
Daniel Jasperc6fbc212013-05-15 09:35:08 +00006205 verifyFormat("template <typename A>\n"
6206 "SomeLoooooooooooooooooooooongType<\n"
6207 " typename some_namespace::SomeOtherType<A>::Type>\n"
6208 "Function() {}");
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00006209
Daniel Jasperd36ef5e2013-01-28 15:40:20 +00006210 verifyGoogleFormat(
Daniel Jasper53643062013-08-19 10:16:18 +00006211 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
6212 " aaaaaaaaaaaaaaaaaaaaaaa;");
6213 verifyGoogleFormat(
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00006214 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
6215 " SourceLocation L) {}");
Daniel Jasperb9caeac2013-02-13 20:33:44 +00006216 verifyGoogleFormat(
6217 "some_namespace::LongReturnType\n"
6218 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00006219 " int first_long_parameter, int second_parameter) {}");
Daniel Jasperb9caeac2013-02-13 20:33:44 +00006220
6221 verifyGoogleFormat("template <typename T>\n"
6222 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00006223 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
Daniel Jasper57d4a582013-02-28 10:06:05 +00006224 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6225 " int aaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper78b45332014-08-14 10:52:56 +00006226
6227 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
Daniel Jasperb754a742015-03-12 15:04:53 +00006228 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6229 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperde7ca752015-05-04 07:39:00 +00006230 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6231 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
6232 " aaaaaaaaaaaaaaaaaaaaaaaa);");
6233 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6234 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
6235 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n"
6236 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Andi-Bogdan Postelnicu67329892017-03-07 14:48:02 +00006237
Andi-Bogdan Postelnicu4743e2d2017-03-07 15:20:31 +00006238 verifyFormat("template <typename T> // Templates on own line.\n"
6239 "static int // Some comment.\n"
Andi-Bogdan Postelnicu67329892017-03-07 14:48:02 +00006240 "MyFunction(int a);",
6241 getLLVMStyle());
Daniel Jasperd1926a32013-01-02 08:44:14 +00006242}
6243
Daniel Jasperaea3bde2013-07-12 11:19:37 +00006244TEST_F(FormatTest, FormatsArrays) {
6245 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
6246 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
Daniel Jasper362a1bf2015-12-23 18:01:43 +00006247 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n"
6248 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;");
Daniel Jaspere1afb9b2015-12-30 12:23:00 +00006249 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n"
6250 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}");
Daniel Jasperaea3bde2013-07-12 11:19:37 +00006251 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6252 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
6253 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6254 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
6255 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6256 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
6257 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
6258 verifyFormat(
6259 "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
6260 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
6261 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
Daniel Jasperf9168de2016-03-01 04:19:55 +00006262 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n"
6263 " .aaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jaspere0ab9e72013-12-06 15:19:50 +00006264
6265 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n"
6266 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];");
Daniel Jasperecaba172014-06-10 13:27:57 +00006267 verifyFormat(
6268 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n"
6269 " .aaaaaaa[0]\n"
6270 " .aaaaaaaaaaaaaaaaaaaaaa();");
Manuel Klimek27f278182016-01-19 14:05:32 +00006271 verifyFormat("a[::b::c];");
Daniel Jasper675b4f82015-01-19 10:51:23 +00006272
6273 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10));
Daniel Jaspera3cd21642016-01-14 13:36:46 +00006274
6275 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0);
6276 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit);
Daniel Jasperaea3bde2013-07-12 11:19:37 +00006277}
6278
Daniel Jaspere9de2602012-12-06 09:56:08 +00006279TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
6280 verifyFormat("(a)->b();");
6281 verifyFormat("--a;");
6282}
6283
Daniel Jasper8b529712012-12-04 13:02:32 +00006284TEST_F(FormatTest, HandlesIncludeDirectives) {
Daniel Jasper2ab0d012013-01-14 15:52:06 +00006285 verifyFormat("#include <string>\n"
6286 "#include <a/b/c.h>\n"
6287 "#include \"a/b/string\"\n"
6288 "#include \"string.h\"\n"
6289 "#include \"string.h\"\n"
Manuel Klimek99c7baa2013-01-15 15:50:27 +00006290 "#include <a-a>\n"
Daniel Jasperaf5ba0e2013-02-23 07:46:38 +00006291 "#include < path with space >\n"
Daniel Jasperfa3f8fb2015-05-19 11:22:29 +00006292 "#include_next <test.h>"
Daniel Jasper4a4be012013-05-06 10:24:51 +00006293 "#include \"abc.h\" // this is included for ABC\n"
Daniel Jasper8bb99e82013-05-16 12:59:13 +00006294 "#include \"some long include\" // with a comment\n"
Daniel Jasperaf5ba0e2013-02-23 07:46:38 +00006295 "#include \"some very long include paaaaaaaaaaaaaaaaaaaaaaath\"",
6296 getLLVMStyleWithColumns(35));
Daniel Jasper98857842013-10-30 13:54:53 +00006297 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\""));
6298 EXPECT_EQ("#include <a>", format("#include<a>"));
Nico Weber8f83ee42012-12-21 18:21:56 +00006299
Daniel Jasper5ef433f2013-01-13 08:12:18 +00006300 verifyFormat("#import <string>");
6301 verifyFormat("#import <a/b/c.h>");
6302 verifyFormat("#import \"a/b/string\"");
6303 verifyFormat("#import \"string.h\"");
6304 verifyFormat("#import \"string.h\"");
Daniel Jaspered8f1c62013-08-28 08:24:04 +00006305 verifyFormat("#if __has_include(<strstream>)\n"
6306 "#include <strstream>\n"
6307 "#endif");
Daniel Jasper47ef6dd2014-01-17 16:21:39 +00006308
Daniel Jasper343643b2014-08-13 08:29:18 +00006309 verifyFormat("#define MY_IMPORT <a/b>");
6310
Nico Weber21088802017-02-10 19:36:52 +00006311 verifyFormat("#if __has_include(<a/b>)");
6312 verifyFormat("#if __has_include_next(<a/b>)");
6313 verifyFormat("#define F __has_include(<a/b>)");
6314 verifyFormat("#define F __has_include_next(<a/b>)");
6315
Daniel Jasper47ef6dd2014-01-17 16:21:39 +00006316 // Protocol buffer definition or missing "#".
6317 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";",
6318 getLLVMStyleWithColumns(30));
Daniel Jasper9509f182014-05-05 08:08:07 +00006319
6320 FormatStyle Style = getLLVMStyle();
6321 Style.AlwaysBreakBeforeMultilineStrings = true;
6322 Style.ColumnLimit = 0;
6323 verifyFormat("#import \"abc.h\"", Style);
Daniel Jasper86ee0b62014-12-04 08:57:27 +00006324
6325 // But 'import' might also be a regular C++ namespace.
6326 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6327 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper8b529712012-12-04 13:02:32 +00006328}
6329
Alexander Kornienko578fdd82012-12-06 18:03:27 +00006330//===----------------------------------------------------------------------===//
6331// Error recovery tests.
6332//===----------------------------------------------------------------------===//
6333
Daniel Jasper66e9dee2013-02-14 09:19:04 +00006334TEST_F(FormatTest, IncompleteParameterLists) {
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00006335 FormatStyle NoBinPacking = getLLVMStyle();
6336 NoBinPacking.BinPackParameters = false;
6337 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
6338 " double *min_x,\n"
6339 " double *max_x,\n"
6340 " double *min_y,\n"
6341 " double *max_y,\n"
6342 " double *min_z,\n"
6343 " double *max_z, ) {}",
6344 NoBinPacking);
Daniel Jasper66e9dee2013-02-14 09:19:04 +00006345}
6346
Daniel Jasper83a54d22013-01-10 09:26:47 +00006347TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
Alexander Kornienkoae6e53c2013-01-16 11:45:16 +00006348 verifyFormat("void f() { return; }\n42");
6349 verifyFormat("void f() {\n"
6350 " if (0)\n"
6351 " return;\n"
6352 "}\n"
6353 "42");
Alexander Kornienko1231e062013-01-16 11:43:46 +00006354 verifyFormat("void f() { return }\n42");
6355 verifyFormat("void f() {\n"
6356 " if (0)\n"
6357 " return\n"
6358 "}\n"
6359 "42");
6360}
6361
6362TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
6363 EXPECT_EQ("void f() { return }", format("void f ( ) { return }"));
6364 EXPECT_EQ("void f() {\n"
6365 " if (a)\n"
6366 " return\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006367 "}",
6368 format("void f ( ) { if ( a ) return }"));
Daniel Jasperabca58c2013-05-15 14:09:55 +00006369 EXPECT_EQ("namespace N {\n"
6370 "void f()\n"
6371 "}",
6372 format("namespace N { void f() }"));
Alexander Kornienko1231e062013-01-16 11:43:46 +00006373 EXPECT_EQ("namespace N {\n"
6374 "void f() {}\n"
6375 "void g()\n"
Krasimir Georgiev9163fe22017-03-02 09:54:44 +00006376 "} // namespace N",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006377 format("namespace N { void f( ) { } void g( ) }"));
Daniel Jasper83a54d22013-01-10 09:26:47 +00006378}
6379
Daniel Jasper2df93312013-01-09 10:16:05 +00006380TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
6381 verifyFormat("int aaaaaaaa =\n"
Alexander Kornienkoffd6d042013-03-27 11:52:18 +00006382 " // Overlylongcomment\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006383 " b;",
6384 getLLVMStyleWithColumns(20));
Daniel Jasper2df93312013-01-09 10:16:05 +00006385 verifyFormat("function(\n"
6386 " ShortArgument,\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006387 " LoooooooooooongArgument);\n",
6388 getLLVMStyleWithColumns(20));
Daniel Jasper2df93312013-01-09 10:16:05 +00006389}
6390
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00006391TEST_F(FormatTest, IncorrectAccessSpecifier) {
6392 verifyFormat("public:");
6393 verifyFormat("class A {\n"
6394 "public\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00006395 " void f() {}\n"
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00006396 "};");
6397 verifyFormat("public\n"
6398 "int qwerty;");
6399 verifyFormat("public\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00006400 "B {}");
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00006401 verifyFormat("public\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00006402 "{}");
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00006403 verifyFormat("public\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00006404 "B { int x; }");
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00006405}
Daniel Jasperf7935112012-12-03 18:12:45 +00006406
Daniel Jasper291f9362013-03-20 15:58:10 +00006407TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
6408 verifyFormat("{");
6409 verifyFormat("#})");
Daniel Jasperd97d5d52015-02-17 09:58:03 +00006410 verifyNoCrash("(/**/[:!] ?[).");
Daniel Jasper291f9362013-03-20 15:58:10 +00006411}
Alexander Kornienko0ea8e102012-12-04 15:40:36 +00006412
6413TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00006414 verifyFormat("do {\n}");
6415 verifyFormat("do {\n}\n"
Alexander Kornienko0ea8e102012-12-04 15:40:36 +00006416 "f();");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00006417 verifyFormat("do {\n}\n"
Alexander Kornienko0ea8e102012-12-04 15:40:36 +00006418 "wheeee(fun);");
6419 verifyFormat("do {\n"
6420 " f();\n"
Manuel Klimek28cacc72013-01-07 18:10:23 +00006421 "}");
Alexander Kornienko0ea8e102012-12-04 15:40:36 +00006422}
6423
Manuel Klimek9fa8d552013-01-11 19:23:05 +00006424TEST_F(FormatTest, IncorrectCodeMissingParens) {
Manuel Klimekadededf2013-01-11 18:28:36 +00006425 verifyFormat("if {\n foo;\n foo();\n}");
Manuel Klimek9fa8d552013-01-11 19:23:05 +00006426 verifyFormat("switch {\n foo;\n foo();\n}");
Manuel Klimekec5c3db2015-05-07 12:26:30 +00006427 verifyIncompleteFormat("for {\n foo;\n foo();\n}");
Manuel Klimek9fa8d552013-01-11 19:23:05 +00006428 verifyFormat("while {\n foo;\n foo();\n}");
6429 verifyFormat("do {\n foo;\n foo();\n} while;");
Manuel Klimekadededf2013-01-11 18:28:36 +00006430}
6431
Daniel Jasperc0880a92013-01-04 18:52:56 +00006432TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
Manuel Klimekec5c3db2015-05-07 12:26:30 +00006433 verifyIncompleteFormat("namespace {\n"
6434 "class Foo { Foo (\n"
6435 "};\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00006436 "} // namespace");
Daniel Jasperc0880a92013-01-04 18:52:56 +00006437}
6438
Alexander Kornienko870f9eb2012-12-04 17:27:50 +00006439TEST_F(FormatTest, IncorrectCodeErrorDetection) {
Daniel Jasperfbc057e2013-10-18 17:20:57 +00006440 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n"));
Manuel Klimeke7d10a12013-01-10 13:24:24 +00006441 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n"));
6442 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n"));
Daniel Jasperfbc057e2013-10-18 17:20:57 +00006443 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n"));
Alexander Kornienko870f9eb2012-12-04 17:27:50 +00006444
Alexander Kornienko870f9eb2012-12-04 17:27:50 +00006445 EXPECT_EQ("{\n"
Daniel Jasperfbc057e2013-10-18 17:20:57 +00006446 " {\n"
6447 " breakme(\n"
6448 " qwe);\n"
6449 " }\n",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006450 format("{\n"
6451 " {\n"
6452 " breakme(qwe);\n"
6453 "}\n",
6454 getLLVMStyleWithColumns(10)));
Alexander Kornienko870f9eb2012-12-04 17:27:50 +00006455}
6456
Manuel Klimek73a2fdf2013-01-10 14:36:46 +00006457TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006458 verifyFormat("int x = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006459 " avariable,\n"
6460 " b(alongervariable)};",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006461 getLLVMStyleWithColumns(25));
Manuel Klimek73a2fdf2013-01-10 14:36:46 +00006462}
6463
Manuel Klimek762dd182013-01-21 10:07:49 +00006464TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
Daniel Jasper4afc6b32014-06-02 10:57:55 +00006465 verifyFormat("return (a)(b){1, 2, 3};");
Manuel Klimek762dd182013-01-21 10:07:49 +00006466}
6467
Daniel Jasperae8e0d82014-04-17 11:32:02 +00006468TEST_F(FormatTest, LayoutCxx11BraceInitializers) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00006469 verifyFormat("vector<int> x{1, 2, 3, 4};");
Daniel Jaspera125d532014-03-21 12:38:57 +00006470 verifyFormat("vector<int> x{\n"
Francois Ferrandd2130f52017-06-30 20:00:02 +00006471 " 1,\n"
6472 " 2,\n"
6473 " 3,\n"
6474 " 4,\n"
Daniel Jaspera125d532014-03-21 12:38:57 +00006475 "};");
Chandler Carruthf8b72662014-03-02 12:37:31 +00006476 verifyFormat("vector<T> x{{}, {}, {}, {}};");
6477 verifyFormat("f({1, 2});");
6478 verifyFormat("auto v = Foo{-1};");
6479 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});");
6480 verifyFormat("Class::Class : member{1, 2, 3} {}");
6481 verifyFormat("new vector<int>{1, 2, 3};");
6482 verifyFormat("new int[3]{1, 2, 3};");
Daniel Jasper7a2d60e2014-05-07 07:59:03 +00006483 verifyFormat("new int{1};");
Chandler Carruthf8b72662014-03-02 12:37:31 +00006484 verifyFormat("return {arg1, arg2};");
6485 verifyFormat("return {arg1, SomeType{parameter}};");
6486 verifyFormat("int count = set<int>{f(), g(), h()}.size();");
6487 verifyFormat("new T{arg1, arg2};");
6488 verifyFormat("f(MyMap[{composite, key}]);");
6489 verifyFormat("class Class {\n"
6490 " T member = {arg1, arg2};\n"
6491 "};");
6492 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};");
Francois Ferrand5f07f442017-06-19 14:41:21 +00006493 verifyFormat("const struct A a = {.a = 1, .b = 2};");
6494 verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
Daniel Jasper91b032a2014-05-22 12:46:38 +00006495 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");");
6496 verifyFormat("int a = std::is_integral<int>{} + 0;");
Daniel Jaspere5777d22013-05-23 10:15:45 +00006497
Daniel Jasper438059e2014-05-22 12:11:13 +00006498 verifyFormat("int foo(int i) { return fo1{}(i); }");
6499 verifyFormat("int foo(int i) { return fo1{}(i); }");
Daniel Jasper4afc6b32014-06-02 10:57:55 +00006500 verifyFormat("auto i = decltype(x){};");
Daniel Jasper610381f2014-08-26 09:37:52 +00006501 verifyFormat("std::vector<int> v = {1, 0 /* comment */};");
Daniel Jasper168c8aa2014-08-27 11:53:26 +00006502 verifyFormat("Node n{1, Node{1000}, //\n"
6503 " 2};");
Daniel Jasperb812e322015-02-26 11:46:29 +00006504 verifyFormat("Aaaa aaaaaaa{\n"
6505 " {\n"
6506 " aaaa,\n"
6507 " },\n"
6508 "};");
Daniel Jaspercec9ffd2015-05-18 14:12:24 +00006509 verifyFormat("class C : public D {\n"
6510 " SomeClass SC{2};\n"
6511 "};");
Daniel Jasper3c883d12015-05-18 14:49:19 +00006512 verifyFormat("class C : public A {\n"
6513 " class D : public B {\n"
6514 " void f() { int i{2}; }\n"
6515 " };\n"
6516 "};");
Daniel Jasperb86e2722015-08-24 13:23:37 +00006517 verifyFormat("#define A {a, a},");
Daniel Jasper438059e2014-05-22 12:11:13 +00006518
Francois Ferrandd2130f52017-06-30 20:00:02 +00006519 // Binpacking only if there is no trailing comma
6520 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n"
6521 " cccccccccc, dddddddddd};",
6522 getLLVMStyleWithColumns(50));
6523 verifyFormat("const Aaaaaa aaaaa = {\n"
6524 " aaaaaaaaaaa,\n"
6525 " bbbbbbbbbbb,\n"
6526 " ccccccccccc,\n"
6527 " ddddddddddd,\n"
6528 "};", getLLVMStyleWithColumns(50));
6529
Daniel Jaspere4ada022016-12-13 10:05:03 +00006530 // Cases where distinguising braced lists and blocks is hard.
6531 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);");
6532 verifyFormat("void f() {\n"
6533 " return; // comment\n"
6534 "}\n"
6535 "SomeType t;");
6536 verifyFormat("void f() {\n"
6537 " if (a) {\n"
6538 " f();\n"
6539 " }\n"
6540 "}\n"
6541 "SomeType t;");
6542
Daniel Jasper08434342015-05-26 07:26:26 +00006543 // In combination with BinPackArguments = false.
Daniel Jasperae8e0d82014-04-17 11:32:02 +00006544 FormatStyle NoBinPacking = getLLVMStyle();
Daniel Jasper08434342015-05-26 07:26:26 +00006545 NoBinPacking.BinPackArguments = false;
Daniel Jasperae8e0d82014-04-17 11:32:02 +00006546 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n"
6547 " bbbbb,\n"
6548 " ccccc,\n"
6549 " ddddd,\n"
6550 " eeeee,\n"
6551 " ffffff,\n"
6552 " ggggg,\n"
6553 " hhhhhh,\n"
6554 " iiiiii,\n"
6555 " jjjjjj,\n"
6556 " kkkkkk};",
6557 NoBinPacking);
6558 verifyFormat("const Aaaaaa aaaaa = {\n"
6559 " aaaaa,\n"
6560 " bbbbb,\n"
6561 " ccccc,\n"
6562 " ddddd,\n"
6563 " eeeee,\n"
6564 " ffffff,\n"
6565 " ggggg,\n"
6566 " hhhhhh,\n"
6567 " iiiiii,\n"
6568 " jjjjjj,\n"
6569 " kkkkkk,\n"
6570 "};",
6571 NoBinPacking);
Daniel Jasper839922e2014-08-13 08:46:21 +00006572 verifyFormat(
6573 "const Aaaaaa aaaaa = {\n"
6574 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n"
6575 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n"
6576 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n"
6577 "};",
6578 NoBinPacking);
Daniel Jasperae8e0d82014-04-17 11:32:02 +00006579
Chandler Carruthf8b72662014-03-02 12:37:31 +00006580 // FIXME: The alignment of these trailing comments might be bad. Then again,
6581 // this might be utterly useless in real code.
6582 verifyFormat("Constructor::Constructor()\n"
Daniel Jasper64a328e2014-11-11 19:34:57 +00006583 " : some_value{ //\n"
6584 " aaaaaaa, //\n"
6585 " bbbbbbb} {}");
Daniel Jasper5a611392013-12-19 21:41:37 +00006586
Chandler Carruthf8b72662014-03-02 12:37:31 +00006587 // In braced lists, the first comment is always assumed to belong to the
6588 // first element. Thus, it can be moved to the next or previous line as
6589 // appropriate.
6590 EXPECT_EQ("function({// First element:\n"
6591 " 1,\n"
6592 " // Second element:\n"
6593 " 2});",
6594 format("function({\n"
6595 " // First element:\n"
6596 " 1,\n"
6597 " // Second element:\n"
6598 " 2});"));
6599 EXPECT_EQ("std::vector<int> MyNumbers{\n"
6600 " // First element:\n"
6601 " 1,\n"
6602 " // Second element:\n"
6603 " 2};",
6604 format("std::vector<int> MyNumbers{// First element:\n"
6605 " 1,\n"
6606 " // Second element:\n"
6607 " 2};",
6608 getLLVMStyleWithColumns(30)));
Francois Ferrandd2130f52017-06-30 20:00:02 +00006609 // A trailing comma should still lead to an enforced line break and no
6610 // binpacking.
Daniel Jasper64a328e2014-11-11 19:34:57 +00006611 EXPECT_EQ("vector<int> SomeVector = {\n"
6612 " // aaa\n"
Francois Ferrandd2130f52017-06-30 20:00:02 +00006613 " 1,\n"
6614 " 2,\n"
Daniel Jasper64a328e2014-11-11 19:34:57 +00006615 "};",
6616 format("vector<int> SomeVector = { // aaa\n"
6617 " 1, 2, };"));
Daniel Jasper5a611392013-12-19 21:41:37 +00006618
Chandler Carruthf8b72662014-03-02 12:37:31 +00006619 FormatStyle ExtraSpaces = getLLVMStyle();
6620 ExtraSpaces.Cpp11BracedListStyle = false;
6621 ExtraSpaces.ColumnLimit = 75;
6622 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces);
6623 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces);
6624 verifyFormat("f({ 1, 2 });", ExtraSpaces);
6625 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces);
6626 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces);
6627 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces);
6628 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces);
6629 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces);
6630 verifyFormat("return { arg1, arg2 };", ExtraSpaces);
6631 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces);
6632 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces);
6633 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces);
6634 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces);
6635 verifyFormat("class Class {\n"
6636 " T member = { arg1, arg2 };\n"
6637 "};",
6638 ExtraSpaces);
6639 verifyFormat(
6640 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6641 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
6642 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
6643 " bbbbbbbbbbbbbbbbbbbb, bbbbb };",
6644 ExtraSpaces);
6645 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces);
Daniel Jasper610381f2014-08-26 09:37:52 +00006646 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });",
Chandler Carruthf8b72662014-03-02 12:37:31 +00006647 ExtraSpaces);
6648 verifyFormat(
6649 "someFunction(OtherParam,\n"
6650 " BracedList{ // comment 1 (Forcing interesting break)\n"
6651 " param1, param2,\n"
6652 " // comment 2\n"
Daniel Jasper11a0ac62014-12-12 09:40:58 +00006653 " param3, param4 });",
Chandler Carruthf8b72662014-03-02 12:37:31 +00006654 ExtraSpaces);
6655 verifyFormat(
6656 "std::this_thread::sleep_for(\n"
6657 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);",
6658 ExtraSpaces);
Daniel Jasperff8d61362016-12-19 08:40:56 +00006659 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n"
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00006660 " aaaaaaa,\n"
6661 " aaaaaaaaaa,\n"
6662 " aaaaa,\n"
6663 " aaaaaaaaaaaaaaa,\n"
6664 " aaa,\n"
6665 " aaaaaaaaaa,\n"
6666 " a,\n"
6667 " aaaaaaaaaaaaaaaaaaaaa,\n"
6668 " aaaaaaaaaaaa,\n"
6669 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n"
6670 " aaaaaaa,\n"
6671 " a};");
Chandler Carruthf8b72662014-03-02 12:37:31 +00006672 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces);
Francois Ferrand5f07f442017-06-19 14:41:21 +00006673 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces);
6674 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces);
Manuel Klimekab419912013-05-23 09:41:43 +00006675}
6676
Daniel Jasper33b909c2013-10-25 14:29:37 +00006677TEST_F(FormatTest, FormatsBracedListsInColumnLayout) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00006678 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6679 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6680 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6681 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6682 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6683 " 1, 22, 333, 4444, 55555, 666666, 7777777};");
Daniel Jasper731dde92015-05-15 09:41:59 +00006684 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006685 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
Daniel Jasper731dde92015-05-15 09:41:59 +00006686 " 1, 22, 333, 4444, 55555, //\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006687 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6688 " 1, 22, 333, 4444, 55555, 666666, 7777777};");
Daniel Jasper8de9ed02013-08-22 15:00:41 +00006689 verifyFormat(
Chandler Carruthf8b72662014-03-02 12:37:31 +00006690 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6691 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6692 " 1, 22, 333, 4444, 55555, 666666, // comment\n"
6693 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
6694 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
6695 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
6696 " 7777777};");
Daniel Jasper8de9ed02013-08-22 15:00:41 +00006697 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006698 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
6699 " X86::R8, X86::R9, X86::R10, X86::R11, 0};");
Daniel Jasper731dde92015-05-15 09:41:59 +00006700 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
6701 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
6702 " // Separating comment.\n"
6703 " X86::R8, X86::R9, X86::R10, X86::R11, 0};");
6704 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
6705 " // Leading comment\n"
6706 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
6707 " X86::R8, X86::R9, X86::R10, X86::R11, 0};");
Chandler Carruthf8b72662014-03-02 12:37:31 +00006708 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
6709 " 1, 1, 1, 1};",
Daniel Jasper8de9ed02013-08-22 15:00:41 +00006710 getLLVMStyleWithColumns(39));
Chandler Carruthf8b72662014-03-02 12:37:31 +00006711 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
6712 " 1, 1, 1, 1};",
Daniel Jasper8de9ed02013-08-22 15:00:41 +00006713 getLLVMStyleWithColumns(38));
6714 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006715 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};",
6716 getLLVMStyleWithColumns(43));
Daniel Jaspere4c16c72015-05-08 13:51:14 +00006717 verifyFormat(
6718 "static unsigned SomeValues[10][3] = {\n"
6719 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n"
6720 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};");
6721 verifyFormat("static auto fields = new vector<string>{\n"
6722 " \"aaaaaaaaaaaaa\",\n"
6723 " \"aaaaaaaaaaaaa\",\n"
6724 " \"aaaaaaaaaaaa\",\n"
6725 " \"aaaaaaaaaaaaaa\",\n"
6726 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
6727 " \"aaaaaaaaaaaa\",\n"
6728 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
6729 "};");
Daniel Jasperd57843d2015-05-11 13:35:40 +00006730 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};");
6731 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n"
6732 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n"
6733 " 3, cccccccccccccccccccccc};",
6734 getLLVMStyleWithColumns(60));
Daniel Jasperf93551c2013-08-23 10:05:49 +00006735
6736 // Trailing commas.
Daniel Jaspera125d532014-03-21 12:38:57 +00006737 verifyFormat("vector<int> x = {\n"
6738 " 1, 1, 1, 1, 1, 1, 1, 1,\n"
6739 "};",
Daniel Jasperf93551c2013-08-23 10:05:49 +00006740 getLLVMStyleWithColumns(39));
Daniel Jasperb175d572014-04-09 09:53:23 +00006741 verifyFormat("vector<int> x = {\n"
6742 " 1, 1, 1, 1, 1, 1, 1, 1, //\n"
Daniel Jasperf93551c2013-08-23 10:05:49 +00006743 "};",
6744 getLLVMStyleWithColumns(39));
Daniel Jasper610381f2014-08-26 09:37:52 +00006745 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
6746 " 1, 1, 1, 1,\n"
6747 " /**/ /**/};",
Daniel Jasper8863ada2013-08-26 08:10:17 +00006748 getLLVMStyleWithColumns(39));
Daniel Jaspere4c16c72015-05-08 13:51:14 +00006749
Daniel Jasper60c27072015-05-13 08:16:00 +00006750 // Trailing comment in the first line.
6751 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n"
6752 " 1111111111, 2222222222, 33333333333, 4444444444, //\n"
6753 " 111111111, 222222222, 3333333333, 444444444, //\n"
6754 " 11111111, 22222222, 333333333, 44444444};");
Daniel Jasper00fb2a12015-07-15 16:26:47 +00006755 // Trailing comment in the last line.
6756 verifyFormat("int aaaaa[] = {\n"
6757 " 1, 2, 3, // comment\n"
6758 " 4, 5, 6 // comment\n"
6759 "};");
Daniel Jasper60c27072015-05-13 08:16:00 +00006760
Daniel Jaspere4c16c72015-05-08 13:51:14 +00006761 // With nested lists, we should either format one item per line or all nested
6762 // lists one on line.
6763 // FIXME: For some nested lists, we can do better.
Chandler Carruthf8b72662014-03-02 12:37:31 +00006764 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
6765 " {aaaaaaaaaaaaaaaaaaa},\n"
6766 " {aaaaaaaaaaaaaaaaaaaaa},\n"
6767 " {aaaaaaaaaaaaaaaaa}};",
Daniel Jaspercb3f0ed2013-08-27 08:43:47 +00006768 getLLVMStyleWithColumns(60));
Daniel Jasper63af7c42013-12-09 14:40:19 +00006769 verifyFormat(
6770 "SomeStruct my_struct_array = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006771 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n"
6772 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n"
6773 " {aaa, aaa},\n"
6774 " {aaa, aaa},\n"
6775 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n"
6776 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n"
6777 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};");
Daniel Jasper01603472014-01-09 13:42:56 +00006778
6779 // No column layout should be used here.
Francois Ferrandd2130f52017-06-30 20:00:02 +00006780 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006781 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};");
Daniel Jasper20e8c3b2015-01-19 10:51:42 +00006782
6783 verifyNoCrash("a<,");
Daniel Jasperabd1f572016-03-02 22:44:03 +00006784
Daniel Jaspereb65e912015-12-21 18:31:15 +00006785 // No braced initializer here.
6786 verifyFormat("void f() {\n"
6787 " struct Dummy {};\n"
6788 " f(v);\n"
6789 "}");
Daniel Jasper55582072016-01-04 07:30:44 +00006790
6791 // Long lists should be formatted in columns even if they are nested.
6792 verifyFormat(
6793 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6794 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6795 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6796 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6797 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6798 " 1, 22, 333, 4444, 55555, 666666, 7777777});");
Daniel Jaspere6169662016-12-19 07:26:11 +00006799
6800 // Allow "single-column" layout even if that violates the column limit. There
6801 // isn't going to be a better way.
6802 verifyFormat("std::vector<int> a = {\n"
6803 " aaaaaaaa,\n"
6804 " aaaaaaaa,\n"
6805 " aaaaaaaa,\n"
6806 " aaaaaaaa,\n"
6807 " aaaaaaaaaa,\n"
6808 " aaaaaaaa,\n"
6809 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};",
6810 getLLVMStyleWithColumns(30));
Daniel Jasper083d1702016-12-21 17:02:06 +00006811 verifyFormat("vector<int> aaaa = {\n"
6812 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6813 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6814 " aaaaaa.aaaaaaa,\n"
6815 " aaaaaa.aaaaaaa,\n"
6816 " aaaaaa.aaaaaaa,\n"
6817 " aaaaaa.aaaaaaa,\n"
6818 "};");
Daniel Jasperd1a9d8acd2017-01-12 19:35:26 +00006819
6820 // Don't create hanging lists.
Daniel Jasper21f7dea2017-02-01 09:23:39 +00006821 verifyFormat("someFunction(Param, {List1, List2,\n"
6822 " List3});",
6823 getLLVMStyleWithColumns(35));
6824 verifyFormat("someFunction(Param, Param,\n"
Daniel Jasperd1a9d8acd2017-01-12 19:35:26 +00006825 " {List1, List2,\n"
6826 " List3});",
6827 getLLVMStyleWithColumns(35));
Daniel Jaspere3710102017-01-12 20:06:28 +00006828 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n"
6829 " aaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper8de9ed02013-08-22 15:00:41 +00006830}
6831
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00006832TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00006833 FormatStyle DoNotMerge = getLLVMStyle();
Daniel Jasperd74cf402014-04-08 12:46:38 +00006834 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00006835
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00006836 verifyFormat("void f() { return 42; }");
6837 verifyFormat("void f() {\n"
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00006838 " return 42;\n"
6839 "}",
6840 DoNotMerge);
6841 verifyFormat("void f() {\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00006842 " // Comment\n"
6843 "}");
6844 verifyFormat("{\n"
6845 "#error {\n"
6846 " int a;\n"
6847 "}");
6848 verifyFormat("{\n"
6849 " int a;\n"
6850 "#error {\n"
6851 "}");
Daniel Jasperf9eb9b12013-05-16 10:17:39 +00006852 verifyFormat("void f() {} // comment");
6853 verifyFormat("void f() { int a; } // comment");
Daniel Jasper92716502013-05-16 16:54:34 +00006854 verifyFormat("void f() {\n"
6855 "} // comment",
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00006856 DoNotMerge);
6857 verifyFormat("void f() {\n"
6858 " int a;\n"
6859 "} // comment",
6860 DoNotMerge);
6861 verifyFormat("void f() {\n"
6862 "} // comment",
Daniel Jasper92716502013-05-16 16:54:34 +00006863 getLLVMStyleWithColumns(15));
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00006864
6865 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
6866 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22));
6867
6868 verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
6869 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
Alexander Kornienko06dd15a2013-12-04 13:58:27 +00006870 verifyFormat("class C {\n"
6871 " C()\n"
6872 " : iiiiiiii(nullptr),\n"
6873 " kkkkkkk(nullptr),\n"
6874 " mmmmmmm(nullptr),\n"
6875 " nnnnnnn(nullptr) {}\n"
6876 "};",
6877 getGoogleStyle());
Alexander Kornienko31e95542013-12-04 12:21:08 +00006878
6879 FormatStyle NoColumnLimit = getLLVMStyle();
6880 NoColumnLimit.ColumnLimit = 0;
6881 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));
6882 EXPECT_EQ("class C {\n"
6883 " A() : b(0) {}\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00006884 "};",
6885 format("class C{A():b(0){}};", NoColumnLimit));
Alexander Kornienko31e95542013-12-04 12:21:08 +00006886 EXPECT_EQ("A()\n"
6887 " : b(0) {\n"
6888 "}",
6889 format("A()\n:b(0)\n{\n}", NoColumnLimit));
6890
6891 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit;
Daniel Jasperd74cf402014-04-08 12:46:38 +00006892 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine =
6893 FormatStyle::SFS_None;
Alexander Kornienko31e95542013-12-04 12:21:08 +00006894 EXPECT_EQ("A()\n"
6895 " : b(0) {\n"
6896 "}",
6897 format("A():b(0){}", DoNotMergeNoColumnLimit));
6898 EXPECT_EQ("A()\n"
6899 " : b(0) {\n"
6900 "}",
6901 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit));
Daniel Jasper64989962014-02-07 13:45:27 +00006902
6903 verifyFormat("#define A \\\n"
6904 " void f() { \\\n"
6905 " int i; \\\n"
6906 " }",
6907 getLLVMStyleWithColumns(20));
6908 verifyFormat("#define A \\\n"
6909 " void f() { int i; }",
6910 getLLVMStyleWithColumns(21));
6911 verifyFormat("#define A \\\n"
6912 " void f() { \\\n"
6913 " int i; \\\n"
6914 " } \\\n"
6915 " int j;",
6916 getLLVMStyleWithColumns(22));
6917 verifyFormat("#define A \\\n"
6918 " void f() { int i; } \\\n"
6919 " int j;",
6920 getLLVMStyleWithColumns(23));
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00006921}
6922
Francois Ferrand2a81ca82017-06-13 07:02:43 +00006923TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) {
6924 FormatStyle MergeEmptyOnly = getLLVMStyle();
6925 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
6926 verifyFormat("class C {\n"
6927 " int f() {}\n"
6928 "};",
6929 MergeEmptyOnly);
6930 verifyFormat("class C {\n"
6931 " int f() {\n"
6932 " return 42;\n"
6933 " }\n"
6934 "};",
6935 MergeEmptyOnly);
6936 verifyFormat("int f() {}", MergeEmptyOnly);
6937 verifyFormat("int f() {\n"
6938 " return 42;\n"
6939 "}",
6940 MergeEmptyOnly);
6941
6942 // Also verify behavior when BraceWrapping.AfterFunction = true
6943 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
6944 MergeEmptyOnly.BraceWrapping.AfterFunction = true;
6945 verifyFormat("int f() {}", MergeEmptyOnly);
6946 verifyFormat("class C {\n"
6947 " int f() {}\n"
6948 "};",
6949 MergeEmptyOnly);
6950}
6951
Daniel Jasperd74cf402014-04-08 12:46:38 +00006952TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) {
6953 FormatStyle MergeInlineOnly = getLLVMStyle();
6954 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
6955 verifyFormat("class C {\n"
6956 " int f() { return 42; }\n"
6957 "};",
6958 MergeInlineOnly);
6959 verifyFormat("int f() {\n"
6960 " return 42;\n"
6961 "}",
6962 MergeInlineOnly);
Francois Ferrand2a81ca82017-06-13 07:02:43 +00006963
6964 // SFS_Inline implies SFS_Empty
6965 verifyFormat("class C {\n"
6966 " int f() {}\n"
6967 "};",
6968 MergeInlineOnly);
6969 verifyFormat("int f() {}", MergeInlineOnly);
6970
6971 // Also verify behavior when BraceWrapping.AfterFunction = true
6972 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
6973 MergeInlineOnly.BraceWrapping.AfterFunction = true;
6974 verifyFormat("class C {\n"
6975 " int f() { return 42; }\n"
6976 "};",
6977 MergeInlineOnly);
6978 verifyFormat("int f()\n"
6979 "{\n"
6980 " return 42;\n"
6981 "}",
6982 MergeInlineOnly);
6983
6984 // SFS_Inline implies SFS_Empty
6985 verifyFormat("int f() {}", MergeInlineOnly);
6986 verifyFormat("class C {\n"
6987 " int f() {}\n"
6988 "};",
6989 MergeInlineOnly);
6990}
6991
Francois Ferrandd3f0e3d2017-06-21 13:56:02 +00006992TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) {
6993 FormatStyle MergeInlineOnly = getLLVMStyle();
6994 MergeInlineOnly.AllowShortFunctionsOnASingleLine =
6995 FormatStyle::SFS_InlineOnly;
6996 verifyFormat("class C {\n"
6997 " int f() { return 42; }\n"
6998 "};",
6999 MergeInlineOnly);
7000 verifyFormat("int f() {\n"
7001 " return 42;\n"
7002 "}",
7003 MergeInlineOnly);
7004
7005 // SFS_InlineOnly does not imply SFS_Empty
7006 verifyFormat("class C {\n"
7007 " int f() {}\n"
7008 "};",
7009 MergeInlineOnly);
7010 verifyFormat("int f() {\n"
7011 "}",
7012 MergeInlineOnly);
7013
7014 // Also verify behavior when BraceWrapping.AfterFunction = true
7015 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
7016 MergeInlineOnly.BraceWrapping.AfterFunction = true;
7017 verifyFormat("class C {\n"
7018 " int f() { return 42; }\n"
7019 "};",
7020 MergeInlineOnly);
7021 verifyFormat("int f()\n"
7022 "{\n"
7023 " return 42;\n"
7024 "}",
7025 MergeInlineOnly);
7026
7027 // SFS_InlineOnly does not imply SFS_Empty
7028 verifyFormat("int f()\n"
7029 "{\n"
7030 "}",
7031 MergeInlineOnly);
7032 verifyFormat("class C {\n"
7033 " int f() {}\n"
7034 "};",
7035 MergeInlineOnly);
7036}
7037
Francois Ferrandad722562017-06-30 20:25:55 +00007038TEST_F(FormatTest, SplitEmptyFunction) {
Francois Ferrand2a81ca82017-06-13 07:02:43 +00007039 FormatStyle Style = getLLVMStyle();
7040 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
7041 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
7042 Style.BraceWrapping.AfterFunction = true;
Francois Ferrandad722562017-06-30 20:25:55 +00007043 Style.BraceWrapping.SplitEmptyFunction = false;
Francois Ferrand2a81ca82017-06-13 07:02:43 +00007044 Style.ColumnLimit = 40;
7045
7046 verifyFormat("int f()\n"
7047 "{}",
7048 Style);
7049 verifyFormat("int f()\n"
7050 "{\n"
7051 " return 42;\n"
7052 "}",
7053 Style);
7054 verifyFormat("int f()\n"
7055 "{\n"
7056 " // some comment\n"
7057 "}",
7058 Style);
7059
7060 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
7061 verifyFormat("int f() {}", Style);
7062 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
7063 "{}",
7064 Style);
7065 verifyFormat("int f()\n"
7066 "{\n"
7067 " return 0;\n"
7068 "}",
7069 Style);
7070
7071 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
7072 verifyFormat("class Foo {\n"
7073 " int f() {}\n"
7074 "};\n",
7075 Style);
7076 verifyFormat("class Foo {\n"
7077 " int f() { return 0; }\n"
7078 "};\n",
7079 Style);
7080 verifyFormat("class Foo {\n"
7081 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
7082 " {}\n"
7083 "};\n",
7084 Style);
7085 verifyFormat("class Foo {\n"
7086 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
7087 " {\n"
7088 " return 0;\n"
7089 " }\n"
7090 "};\n",
7091 Style);
7092
7093 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
7094 verifyFormat("int f() {}", Style);
7095 verifyFormat("int f() { return 0; }", Style);
7096 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
7097 "{}",
7098 Style);
7099 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
7100 "{\n"
7101 " return 0;\n"
7102 "}",
7103 Style);
Daniel Jasperd74cf402014-04-08 12:46:38 +00007104}
7105
Francois Ferrandad722562017-06-30 20:25:55 +00007106TEST_F(FormatTest, SplitEmptyClass) {
7107 FormatStyle Style = getLLVMStyle();
7108 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
7109 Style.BraceWrapping.AfterClass = true;
7110 Style.BraceWrapping.SplitEmptyRecord = false;
7111
7112 verifyFormat("class Foo\n"
7113 "{};",
7114 Style);
7115 verifyFormat("/* something */ class Foo\n"
7116 "{};",
7117 Style);
7118 verifyFormat("template <typename X> class Foo\n"
7119 "{};",
7120 Style);
7121 verifyFormat("class Foo\n"
7122 "{\n"
7123 " Foo();\n"
7124 "};",
7125 Style);
7126 verifyFormat("typedef class Foo\n"
7127 "{\n"
7128 "} Foo_t;",
7129 Style);
7130}
7131
7132TEST_F(FormatTest, SplitEmptyStruct) {
7133 FormatStyle Style = getLLVMStyle();
7134 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
7135 Style.BraceWrapping.AfterStruct = true;
7136 Style.BraceWrapping.SplitEmptyRecord = false;
7137
7138 verifyFormat("struct Foo\n"
7139 "{};",
7140 Style);
7141 verifyFormat("/* something */ struct Foo\n"
7142 "{};",
7143 Style);
7144 verifyFormat("template <typename X> struct Foo\n"
7145 "{};",
7146 Style);
7147 verifyFormat("struct Foo\n"
7148 "{\n"
7149 " Foo();\n"
7150 "};",
7151 Style);
7152 verifyFormat("typedef struct Foo\n"
7153 "{\n"
7154 "} Foo_t;",
7155 Style);
7156 //typedef struct Bar {} Bar_t;
7157}
7158
7159TEST_F(FormatTest, SplitEmptyUnion) {
7160 FormatStyle Style = getLLVMStyle();
7161 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
7162 Style.BraceWrapping.AfterUnion = true;
7163 Style.BraceWrapping.SplitEmptyRecord = false;
7164
7165 verifyFormat("union Foo\n"
7166 "{};",
7167 Style);
7168 verifyFormat("/* something */ union Foo\n"
7169 "{};",
7170 Style);
7171 verifyFormat("union Foo\n"
7172 "{\n"
7173 " A,\n"
7174 "};",
7175 Style);
7176 verifyFormat("typedef union Foo\n"
7177 "{\n"
7178 "} Foo_t;",
7179 Style);
7180}
7181
7182TEST_F(FormatTest, SplitEmptyNamespace) {
7183 FormatStyle Style = getLLVMStyle();
7184 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
7185 Style.BraceWrapping.AfterNamespace = true;
7186 Style.BraceWrapping.SplitEmptyNamespace = false;
7187
7188 verifyFormat("namespace Foo\n"
7189 "{};",
7190 Style);
7191 verifyFormat("/* something */ namespace Foo\n"
7192 "{};",
7193 Style);
7194 verifyFormat("inline namespace Foo\n"
7195 "{};",
7196 Style);
7197 verifyFormat("namespace Foo\n"
7198 "{\n"
7199 "void Bar();\n"
7200 "};",
7201 Style);
7202}
7203
7204TEST_F(FormatTest, NeverMergeShortRecords) {
7205 FormatStyle Style = getLLVMStyle();
7206
7207 verifyFormat("class Foo {\n"
7208 " Foo();\n"
7209 "};",
7210 Style);
7211 verifyFormat("typedef class Foo {\n"
7212 " Foo();\n"
7213 "} Foo_t;",
7214 Style);
7215 verifyFormat("struct Foo {\n"
7216 " Foo();\n"
7217 "};",
7218 Style);
7219 verifyFormat("typedef struct Foo {\n"
7220 " Foo();\n"
7221 "} Foo_t;",
7222 Style);
7223 verifyFormat("union Foo {\n"
7224 " A,\n"
7225 "};",
7226 Style);
7227 verifyFormat("typedef union Foo {\n"
7228 " A,\n"
7229 "} Foo_t;",
7230 Style);
7231 verifyFormat("namespace Foo {\n"
7232 "void Bar();\n"
7233 "};",
7234 Style);
7235
7236 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
7237 Style.BraceWrapping.AfterClass = true;
7238 Style.BraceWrapping.AfterStruct = true;
7239 Style.BraceWrapping.AfterUnion = true;
7240 Style.BraceWrapping.AfterNamespace = true;
7241 verifyFormat("class Foo\n"
7242 "{\n"
7243 " Foo();\n"
7244 "};",
7245 Style);
7246 verifyFormat("typedef class Foo\n"
7247 "{\n"
7248 " Foo();\n"
7249 "} Foo_t;",
7250 Style);
7251 verifyFormat("struct Foo\n"
7252 "{\n"
7253 " Foo();\n"
7254 "};",
7255 Style);
7256 verifyFormat("typedef struct Foo\n"
7257 "{\n"
7258 " Foo();\n"
7259 "} Foo_t;",
7260 Style);
7261 verifyFormat("union Foo\n"
7262 "{\n"
7263 " A,\n"
7264 "};",
7265 Style);
7266 verifyFormat("typedef union Foo\n"
7267 "{\n"
7268 " A,\n"
7269 "} Foo_t;",
7270 Style);
7271 verifyFormat("namespace Foo\n"
7272 "{\n"
7273 "void Bar();\n"
7274 "};",
7275 Style);
7276}
7277
Manuel Klimeke01bab52013-01-15 13:38:33 +00007278TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
7279 // Elaborate type variable declarations.
Chandler Carruthf8b72662014-03-02 12:37:31 +00007280 verifyFormat("struct foo a = {bar};\nint n;");
7281 verifyFormat("class foo a = {bar};\nint n;");
7282 verifyFormat("union foo a = {bar};\nint n;");
Manuel Klimeke01bab52013-01-15 13:38:33 +00007283
7284 // Elaborate types inside function definitions.
7285 verifyFormat("struct foo f() {}\nint n;");
7286 verifyFormat("class foo f() {}\nint n;");
7287 verifyFormat("union foo f() {}\nint n;");
7288
7289 // Templates.
7290 verifyFormat("template <class X> void f() {}\nint n;");
7291 verifyFormat("template <struct X> void f() {}\nint n;");
7292 verifyFormat("template <union X> void f() {}\nint n;");
7293
7294 // Actual definitions...
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00007295 verifyFormat("struct {\n} n;");
7296 verifyFormat(
7297 "template <template <class T, class Y>, class Z> class X {\n} n;");
Manuel Klimeke01bab52013-01-15 13:38:33 +00007298 verifyFormat("union Z {\n int n;\n} x;");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00007299 verifyFormat("class MACRO Z {\n} n;");
7300 verifyFormat("class MACRO(X) Z {\n} n;");
7301 verifyFormat("class __attribute__(X) Z {\n} n;");
7302 verifyFormat("class __declspec(X) Z {\n} n;");
Manuel Klimekd2650902013-02-06 15:57:54 +00007303 verifyFormat("class A##B##C {\n} n;");
Manuel Klimek91e48582013-10-07 09:15:41 +00007304 verifyFormat("class alignas(16) Z {\n} n;");
Daniel Jasper04785d02015-05-06 14:03:02 +00007305 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;");
7306 verifyFormat("class MACROA MACRO(X) Z {\n} n;");
Manuel Klimeke01bab52013-01-15 13:38:33 +00007307
Manuel Klimek3c6b7c72013-01-21 10:17:14 +00007308 // Redefinition from nested context:
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00007309 verifyFormat("class A::B::C {\n} n;");
Manuel Klimek3c6b7c72013-01-21 10:17:14 +00007310
Manuel Klimekcdee74d2013-01-21 13:58:54 +00007311 // Template definitions.
Daniel Jasper6f05e592013-05-15 13:46:48 +00007312 verifyFormat(
7313 "template <typename F>\n"
7314 "Matcher(const Matcher<F> &Other,\n"
7315 " typename enable_if_c<is_base_of<F, T>::value &&\n"
7316 " !is_same<F, T>::value>::type * = 0)\n"
7317 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
7318
Manuel Klimekcdee74d2013-01-21 13:58:54 +00007319 // FIXME: This is still incorrectly handled at the formatter side.
Daniel Jasper62c0ac02013-07-30 22:37:19 +00007320 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
Daniel Jasper6f2b88a2015-06-05 13:18:09 +00007321 verifyFormat("int i = SomeFunction(a<b, a> b);");
Manuel Klimekcdee74d2013-01-21 13:58:54 +00007322
7323 // FIXME:
7324 // This now gets parsed incorrectly as class definition.
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00007325 // verifyFormat("class A<int> f() {\n}\nint n;");
Manuel Klimekcdee74d2013-01-21 13:58:54 +00007326
Manuel Klimeke01bab52013-01-15 13:38:33 +00007327 // Elaborate types where incorrectly parsing the structural element would
7328 // break the indent.
7329 verifyFormat("if (true)\n"
7330 " class X x;\n"
7331 "else\n"
7332 " f();\n");
Daniel Jasper1a32a612013-03-20 15:12:38 +00007333
7334 // This is simply incomplete. Formatting is not important, but must not crash.
Daniel Jaspercdaffa42013-08-13 10:58:30 +00007335 verifyFormat("class A:");
Manuel Klimekd5e5f8f2013-01-11 18:13:04 +00007336}
7337
Manuel Klimek99c7baa2013-01-15 15:50:27 +00007338TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
Manuel Klimek71814b42013-10-11 21:25:45 +00007339 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n",
7340 format("#error Leave all white!!!!! space* alone!\n"));
7341 EXPECT_EQ(
7342 "#warning Leave all white!!!!! space* alone!\n",
7343 format("#warning Leave all white!!!!! space* alone!\n"));
Manuel Klimek99c7baa2013-01-15 15:50:27 +00007344 EXPECT_EQ("#error 1", format(" # error 1"));
7345 EXPECT_EQ("#warning 1", format(" # warning 1"));
7346}
7347
Daniel Jasper4431aa92013-04-23 13:54:04 +00007348TEST_F(FormatTest, FormatHashIfExpressions) {
Daniel Jasper7cfde412014-01-21 08:56:09 +00007349 verifyFormat("#if AAAA && BBBB");
Daniel Jasperd7884572015-08-14 12:44:06 +00007350 verifyFormat("#if (AAAA && BBBB)");
7351 verifyFormat("#elif (AAAA && BBBB)");
Daniel Jasper4431aa92013-04-23 13:54:04 +00007352 // FIXME: Come up with a better indentation for #elif.
7353 verifyFormat(
7354 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n"
7355 " defined(BBBBBBBB)\n"
7356 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n"
7357 " defined(BBBBBBBB)\n"
7358 "#endif",
7359 getLLVMStyleWithColumns(65));
7360}
7361
Manuel Klimekd3b92fa2013-01-18 14:04:34 +00007362TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
7363 FormatStyle AllowsMergedIf = getGoogleStyle();
7364 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true;
7365 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
7366 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
Manuel Klimekda087612013-01-18 14:46:43 +00007367 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf);
7368 EXPECT_EQ("if (true) return 42;",
7369 format("if (true)\nreturn 42;", AllowsMergedIf));
7370 FormatStyle ShortMergedIf = AllowsMergedIf;
7371 ShortMergedIf.ColumnLimit = 25;
Daniel Jasper6fe2f002013-04-25 08:56:26 +00007372 verifyFormat("#define A \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00007373 " if (true) return 42;",
7374 ShortMergedIf);
Daniel Jasper6fe2f002013-04-25 08:56:26 +00007375 verifyFormat("#define A \\\n"
7376 " f(); \\\n"
Manuel Klimekda087612013-01-18 14:46:43 +00007377 " if (true)\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00007378 "#define B",
7379 ShortMergedIf);
Daniel Jasper6fe2f002013-04-25 08:56:26 +00007380 verifyFormat("#define A \\\n"
7381 " f(); \\\n"
Manuel Klimekda087612013-01-18 14:46:43 +00007382 " if (true)\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00007383 "g();",
7384 ShortMergedIf);
Manuel Klimekd5e782b2013-01-21 14:16:56 +00007385 verifyFormat("{\n"
7386 "#ifdef A\n"
7387 " // Comment\n"
7388 " if (true) continue;\n"
7389 "#endif\n"
7390 " // Comment\n"
Manuel Klimek71814b42013-10-11 21:25:45 +00007391 " if (true) continue;\n"
7392 "}",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00007393 ShortMergedIf);
Daniel Jasper6a7d5a72017-06-19 07:40:49 +00007394 ShortMergedIf.ColumnLimit = 33;
7395 verifyFormat("#define A \\\n"
7396 " if constexpr (true) return 42;",
7397 ShortMergedIf);
Daniel Jasper64989962014-02-07 13:45:27 +00007398 ShortMergedIf.ColumnLimit = 29;
7399 verifyFormat("#define A \\\n"
7400 " if (aaaaaaaaaa) return 1; \\\n"
7401 " return 2;",
7402 ShortMergedIf);
7403 ShortMergedIf.ColumnLimit = 28;
7404 verifyFormat("#define A \\\n"
7405 " if (aaaaaaaaaa) \\\n"
7406 " return 1; \\\n"
7407 " return 2;",
7408 ShortMergedIf);
Daniel Jasper6a7d5a72017-06-19 07:40:49 +00007409 verifyFormat("#define A \\\n"
7410 " if constexpr (aaaaaaa) \\\n"
7411 " return 1; \\\n"
7412 " return 2;",
7413 ShortMergedIf);
Manuel Klimekd3b92fa2013-01-18 14:04:34 +00007414}
7415
Manuel Klimekd33516e2013-01-23 10:09:28 +00007416TEST_F(FormatTest, FormatStarDependingOnContext) {
Manuel Klimek0a3a3c92013-01-23 09:32:48 +00007417 verifyFormat("void f(int *a);");
7418 verifyFormat("void f() { f(fint * b); }");
Manuel Klimek39080572013-01-23 11:03:04 +00007419 verifyFormat("class A {\n void f(int *a);\n};");
7420 verifyFormat("class A {\n int *a;\n};");
7421 verifyFormat("namespace a {\n"
7422 "namespace b {\n"
7423 "class A {\n"
7424 " void f() {}\n"
7425 " int *a;\n"
7426 "};\n"
Krasimir Georgiev9163fe22017-03-02 09:54:44 +00007427 "} // namespace b\n"
7428 "} // namespace a");
Manuel Klimek0a3a3c92013-01-23 09:32:48 +00007429}
7430
Manuel Klimekd33516e2013-01-23 10:09:28 +00007431TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
7432 verifyFormat("while");
7433 verifyFormat("operator");
7434}
7435
Daniel Jasperfda47cd2016-10-31 13:23:00 +00007436TEST_F(FormatTest, SkipsDeeplyNestedLines) {
7437 // This code would be painfully slow to format if we didn't skip it.
7438 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
7439 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
7440 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
7441 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
7442 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
7443 "A(1, 1)\n"
7444 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x
7445 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7446 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7447 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7448 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7449 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7450 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7451 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7452 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7453 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n");
7454 // Deeply nested part is untouched, rest is formatted.
7455 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n",
7456 format(std::string("int i;\n") + Code + "int j;\n",
Krasimir Georgievbcda54b2017-04-21 14:35:20 +00007457 getLLVMStyle(), SC_ExpectIncomplete));
Daniel Jasperfda47cd2016-10-31 13:23:00 +00007458}
7459
Nico Weber7e6a7a12013-01-08 17:56:31 +00007460//===----------------------------------------------------------------------===//
7461// Objective-C tests.
7462//===----------------------------------------------------------------------===//
7463
Fariborz Jahanian68a542a2012-12-20 19:54:13 +00007464TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
7465 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
7466 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
7467 format("-(NSUInteger)indexOfObject:(id)anObject;"));
Daniel Jasper8d1832e2013-01-07 13:26:07 +00007468 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
Fariborz Jahanian68a542a2012-12-20 19:54:13 +00007469 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
7470 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
7471 format("-(NSInteger)Method3:(id)anObject;"));
7472 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
7473 format("-(NSInteger)Method4:(id)anObject;"));
7474 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
7475 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
7476 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
7477 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
Daniel Jaspera44991332015-04-29 13:06:49 +00007478 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "
7479 "forAllCells:(BOOL)flag;",
7480 format("- (void)sendAction:(SEL)aSelector to:(id)anObject "
7481 "forAllCells:(BOOL)flag;"));
Fariborz Jahanian9017ec32012-12-21 22:51:18 +00007482
7483 // Very long objectiveC method declaration.
Daniel Jasper55ca6082015-03-12 22:13:45 +00007484 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
7485 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;");
Daniel Jasper1ac3e052013-02-05 10:07:47 +00007486 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
7487 " inRange:(NSRange)range\n"
7488 " outRange:(NSRange)out_range\n"
7489 " outRange1:(NSRange)out_range1\n"
7490 " outRange2:(NSRange)out_range2\n"
7491 " outRange3:(NSRange)out_range3\n"
7492 " outRange4:(NSRange)out_range4\n"
7493 " outRange5:(NSRange)out_range5\n"
7494 " outRange6:(NSRange)out_range6\n"
7495 " outRange7:(NSRange)out_range7\n"
7496 " outRange8:(NSRange)out_range8\n"
7497 " outRange9:(NSRange)out_range9;");
Nico Weberd6f962f2013-01-10 20:18:33 +00007498
Daniel Jaspera2a4d9c2015-05-13 09:38:25 +00007499 // When the function name has to be wrapped.
7500 FormatStyle Style = getLLVMStyle();
7501 Style.IndentWrappedFunctionNames = false;
7502 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
7503 "veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
7504 " anotherName:(NSString)bbbbbbbbbbbbbb {\n"
7505 "}",
7506 Style);
7507 Style.IndentWrappedFunctionNames = true;
7508 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
7509 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
7510 " anotherName:(NSString)bbbbbbbbbbbbbb {\n"
7511 "}",
7512 Style);
7513
Nico Weberd6f962f2013-01-10 20:18:33 +00007514 verifyFormat("- (int)sum:(vector<int>)numbers;");
Nico Weber772fbfd2013-01-17 06:14:50 +00007515 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
Nico Weberd6f962f2013-01-10 20:18:33 +00007516 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
7517 // protocol lists (but not for template classes):
Daniel Jaspera44991332015-04-29 13:06:49 +00007518 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
Nico Weber9efe2912013-01-10 23:11:41 +00007519
Daniel Jasper37194282013-05-28 08:33:00 +00007520 verifyFormat("- (int (*)())foo:(int (*)())f;");
7521 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
Nico Weber9efe2912013-01-10 23:11:41 +00007522
7523 // If there's no return type (very rare in practice!), LLVM and Google style
7524 // agree.
Daniel Jasperdd9276e2013-03-22 16:55:40 +00007525 verifyFormat("- foo;");
Nico Weber9efe2912013-01-10 23:11:41 +00007526 verifyFormat("- foo:(int)f;");
7527 verifyGoogleFormat("- foo:(int)foo;");
Fariborz Jahanian68a542a2012-12-20 19:54:13 +00007528}
7529
Nico Weber0588b502013-02-07 00:19:29 +00007530
Alexander Kornienko64a42b82014-04-15 14:52:43 +00007531TEST_F(FormatTest, BreaksStringLiterals) {
Manuel Klimek1998ea22013-02-20 10:15:13 +00007532 EXPECT_EQ("\"some text \"\n"
7533 "\"other\";",
7534 format("\"some text other\";", getLLVMStyleWithColumns(12)));
Alexander Kornienko9e90b622013-04-17 17:34:05 +00007535 EXPECT_EQ("\"some text \"\n"
7536 "\"other\";",
7537 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
Manuel Klimek1998ea22013-02-20 10:15:13 +00007538 EXPECT_EQ(
7539 "#define A \\\n"
7540 " \"some \" \\\n"
7541 " \"text \" \\\n"
7542 " \"other\";",
7543 format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
7544 EXPECT_EQ(
7545 "#define A \\\n"
7546 " \"so \" \\\n"
7547 " \"text \" \\\n"
7548 " \"other\";",
7549 format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
7550
7551 EXPECT_EQ("\"some text\"",
7552 format("\"some text\"", getLLVMStyleWithColumns(1)));
7553 EXPECT_EQ("\"some text\"",
7554 format("\"some text\"", getLLVMStyleWithColumns(11)));
7555 EXPECT_EQ("\"some \"\n"
7556 "\"text\"",
7557 format("\"some text\"", getLLVMStyleWithColumns(10)));
7558 EXPECT_EQ("\"some \"\n"
7559 "\"text\"",
7560 format("\"some text\"", getLLVMStyleWithColumns(7)));
Manuel Klimekb176cff2013-03-01 13:14:08 +00007561 EXPECT_EQ("\"some\"\n"
Alexander Kornienkocb45bc12013-04-15 14:28:00 +00007562 "\" tex\"\n"
7563 "\"t\"",
Manuel Klimek1998ea22013-02-20 10:15:13 +00007564 format("\"some text\"", getLLVMStyleWithColumns(6)));
Manuel Klimekabf6e032013-03-04 20:03:38 +00007565 EXPECT_EQ("\"some\"\n"
7566 "\" tex\"\n"
7567 "\" and\"",
7568 format("\"some tex and\"", getLLVMStyleWithColumns(6)));
7569 EXPECT_EQ("\"some\"\n"
7570 "\"/tex\"\n"
7571 "\"/and\"",
7572 format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
Manuel Klimek1998ea22013-02-20 10:15:13 +00007573
7574 EXPECT_EQ("variable =\n"
7575 " \"long string \"\n"
7576 " \"literal\";",
7577 format("variable = \"long string literal\";",
7578 getLLVMStyleWithColumns(20)));
7579
7580 EXPECT_EQ("variable = f(\n"
7581 " \"long string \"\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00007582 " \"literal\",\n"
7583 " short,\n"
Manuel Klimek1998ea22013-02-20 10:15:13 +00007584 " loooooooooooooooooooong);",
7585 format("variable = f(\"long string literal\", short, "
7586 "loooooooooooooooooooong);",
7587 getLLVMStyleWithColumns(20)));
Alexander Kornienko4d26b6e2013-06-17 12:59:44 +00007588
Daniel Jaspera44991332015-04-29 13:06:49 +00007589 EXPECT_EQ(
7590 "f(g(\"long string \"\n"
7591 " \"literal\"),\n"
7592 " b);",
7593 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20)));
Alexander Kornienko4d26b6e2013-06-17 12:59:44 +00007594 EXPECT_EQ("f(g(\"long string \"\n"
7595 " \"literal\",\n"
7596 " a),\n"
7597 " b);",
7598 format("f(g(\"long string literal\", a), b);",
7599 getLLVMStyleWithColumns(20)));
Manuel Klimek1998ea22013-02-20 10:15:13 +00007600 EXPECT_EQ(
7601 "f(\"one two\".split(\n"
Daniel Jasperf79b0b12013-08-30 08:29:25 +00007602 " variable));",
Manuel Klimek1998ea22013-02-20 10:15:13 +00007603 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
7604 EXPECT_EQ("f(\"one two three four five six \"\n"
7605 " \"seven\".split(\n"
7606 " really_looooong_variable));",
7607 format("f(\"one two three four five six seven\"."
7608 "split(really_looooong_variable));",
7609 getLLVMStyleWithColumns(33)));
7610
7611 EXPECT_EQ("f(\"some \"\n"
7612 " \"text\",\n"
7613 " other);",
7614 format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
Daniel Jasper5497fce2013-02-26 12:52:34 +00007615
7616 // Only break as a last resort.
7617 verifyFormat(
7618 "aaaaaaaaaaaaaaaaaaaa(\n"
7619 " aaaaaaaaaaaaaaaaaaaa,\n"
7620 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
Manuel Klimekb176cff2013-03-01 13:14:08 +00007621
Daniel Jaspera44991332015-04-29 13:06:49 +00007622 EXPECT_EQ("\"splitmea\"\n"
7623 "\"trandomp\"\n"
7624 "\"oint\"",
7625 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
Manuel Klimeke317d1b2013-03-01 13:29:19 +00007626
Daniel Jaspera44991332015-04-29 13:06:49 +00007627 EXPECT_EQ("\"split/\"\n"
7628 "\"pathat/\"\n"
7629 "\"slashes\"",
7630 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
Daniel Jasper6fe2f002013-04-25 08:56:26 +00007631
Daniel Jaspera44991332015-04-29 13:06:49 +00007632 EXPECT_EQ("\"split/\"\n"
7633 "\"pathat/\"\n"
7634 "\"slashes\"",
7635 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
Alexander Kornienko72852072013-06-19 14:22:47 +00007636 EXPECT_EQ("\"split at \"\n"
7637 "\"spaces/at/\"\n"
7638 "\"slashes.at.any$\"\n"
7639 "\"non-alphanumeric%\"\n"
7640 "\"1111111111characte\"\n"
7641 "\"rs\"",
7642 format("\"split at "
7643 "spaces/at/"
7644 "slashes.at."
7645 "any$non-"
7646 "alphanumeric%"
7647 "1111111111characte"
7648 "rs\"",
7649 getLLVMStyleWithColumns(20)));
7650
Daniel Jasper5aad4e52013-07-12 11:37:05 +00007651 // Verify that splitting the strings understands
7652 // Style::AlwaysBreakBeforeMultilineStrings.
Daniel Jasper2aaedd32015-06-18 09:12:47 +00007653 EXPECT_EQ(
7654 "aaaaaaaaaaaa(\n"
7655 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
7656 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
7657 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
7658 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
7659 "aaaaaaaaaaaaaaaaaaaaaa\");",
7660 getGoogleStyle()));
Daniel Jasper2436fe92013-10-18 16:47:55 +00007661 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
7662 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",
7663 format("return \"aaaaaaaaaaaaaaaaaaaaaa "
7664 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
7665 "aaaaaaaaaaaaaaaaaaaaaa\";",
7666 getGoogleStyle()));
Daniel Jasper3dcd7ec2013-08-02 11:01:15 +00007667 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
7668 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
7669 format("llvm::outs() << "
7670 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
7671 "aaaaaaaaaaaaaaaaaaa\";"));
Daniel Jasperf438cb72013-08-23 11:57:34 +00007672 EXPECT_EQ("ffff(\n"
7673 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
7674 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
7675 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
7676 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
7677 getGoogleStyle()));
Daniel Jasper5aad4e52013-07-12 11:37:05 +00007678
Daniel Jaspere1a7b762016-02-01 11:21:02 +00007679 FormatStyle Style = getLLVMStyleWithColumns(12);
7680 Style.BreakStringLiterals = false;
7681 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style));
7682
Daniel Jasper6fe2f002013-04-25 08:56:26 +00007683 FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +00007684 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
Daniel Jaspera44991332015-04-29 13:06:49 +00007685 EXPECT_EQ("#define A \\\n"
7686 " \"some \" \\\n"
7687 " \"text \" \\\n"
7688 " \"other\";",
7689 format("#define A \"some text other\";", AlignLeft));
Manuel Klimek1998ea22013-02-20 10:15:13 +00007690}
7691
Manuel Klimek9e321992015-07-28 15:50:24 +00007692TEST_F(FormatTest, FullyRemoveEmptyLines) {
7693 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80);
7694 NoEmptyLines.MaxEmptyLinesToKeep = 0;
7695 EXPECT_EQ("int i = a(b());",
7696 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines));
7697}
7698
Alexander Kornienko64a42b82014-04-15 14:52:43 +00007699TEST_F(FormatTest, BreaksStringLiteralsWithTabs) {
7700 EXPECT_EQ(
7701 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
7702 "(\n"
7703 " \"x\t\");",
7704 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
7705 "aaaaaaa("
7706 "\"x\t\");"));
7707}
7708
Daniel Jasper174b0122014-01-09 14:18:12 +00007709TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {
Alexander Kornienko81e32942013-09-16 20:20:49 +00007710 EXPECT_EQ(
7711 "u8\"utf8 string \"\n"
7712 "u8\"literal\";",
7713 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
7714 EXPECT_EQ(
7715 "u\"utf16 string \"\n"
7716 "u\"literal\";",
7717 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
7718 EXPECT_EQ(
7719 "U\"utf32 string \"\n"
7720 "U\"literal\";",
7721 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
7722 EXPECT_EQ("L\"wide string \"\n"
7723 "L\"literal\";",
7724 format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
Daniel Jasper174b0122014-01-09 14:18:12 +00007725 EXPECT_EQ("@\"NSString \"\n"
7726 "@\"literal\";",
Daniel Jasperd07c2ee2014-01-14 09:53:07 +00007727 format("@\"NSString literal\";", getGoogleStyleWithColumns(19)));
Alexander Kornienkod4fa2e62017-04-11 09:55:00 +00007728 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26));
Daniel Jaspere4b48c62015-01-21 19:50:35 +00007729
7730 // This input makes clang-format try to split the incomplete unicode escape
7731 // sequence, which used to lead to a crasher.
7732 verifyNoCrash(
7733 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
7734 getLLVMStyleWithColumns(60));
Alexander Kornienko81e32942013-09-16 20:20:49 +00007735}
7736
Alexander Kornienko732b6bd2014-12-14 20:47:11 +00007737TEST_F(FormatTest, DoesNotBreakRawStringLiterals) {
7738 FormatStyle Style = getGoogleStyleWithColumns(15);
7739 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style));
7740 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style));
7741 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style));
7742 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style));
7743 EXPECT_EQ("u8R\"x(raw literal)x\";",
7744 format("u8R\"x(raw literal)x\";", Style));
Alexander Kornienko81e32942013-09-16 20:20:49 +00007745}
7746
7747TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
7748 FormatStyle Style = getLLVMStyleWithColumns(20);
7749 EXPECT_EQ(
7750 "_T(\"aaaaaaaaaaaaaa\")\n"
7751 "_T(\"aaaaaaaaaaaaaa\")\n"
7752 "_T(\"aaaaaaaaaaaa\")",
7753 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
Krasimir Georgievbc05eba2017-03-08 12:54:50 +00007754 EXPECT_EQ("f(x,\n"
7755 " _T(\"aaaaaaaaaaaa\")\n"
7756 " _T(\"aaa\"),\n"
Alexander Kornienko81e32942013-09-16 20:20:49 +00007757 " z);",
7758 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
7759
7760 // FIXME: Handle embedded spaces in one iteration.
7761 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
7762 // "_T(\"aaaaaaaaaaaaa\")\n"
7763 // "_T(\"aaaaaaaaaaaaa\")\n"
7764 // "_T(\"a\")",
7765 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
7766 // getLLVMStyleWithColumns(20)));
7767 EXPECT_EQ(
7768 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
7769 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
Daniel Jaspere99c72f2015-03-26 14:47:35 +00007770 EXPECT_EQ("f(\n"
7771 "#if !TEST\n"
7772 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
7773 "#endif\n"
Martin Probst2c1cdae2017-05-15 11:15:29 +00007774 ");",
Daniel Jaspere99c72f2015-03-26 14:47:35 +00007775 format("f(\n"
7776 "#if !TEST\n"
7777 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
7778 "#endif\n"
7779 ");"));
7780 EXPECT_EQ("f(\n"
7781 "\n"
7782 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));",
7783 format("f(\n"
7784 "\n"
7785 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));"));
Alexander Kornienko81e32942013-09-16 20:20:49 +00007786}
7787
Krasimir Georgievbc05eba2017-03-08 12:54:50 +00007788TEST_F(FormatTest, BreaksStringLiteralOperands) {
7789 // In a function call with two operands, the second can be broken with no line
7790 // break before it.
7791 EXPECT_EQ("func(a, \"long long \"\n"
7792 " \"long long\");",
7793 format("func(a, \"long long long long\");",
7794 getLLVMStyleWithColumns(24)));
7795 // In a function call with three operands, the second must be broken with a
7796 // line break before it.
7797 EXPECT_EQ("func(a,\n"
7798 " \"long long long \"\n"
7799 " \"long\",\n"
7800 " c);",
7801 format("func(a, \"long long long long\", c);",
7802 getLLVMStyleWithColumns(24)));
7803 // In a function call with three operands, the third must be broken with a
7804 // line break before it.
7805 EXPECT_EQ("func(a, b,\n"
7806 " \"long long long \"\n"
7807 " \"long\");",
7808 format("func(a, b, \"long long long long\");",
7809 getLLVMStyleWithColumns(24)));
7810 // In a function call with three operands, both the second and the third must
7811 // be broken with a line break before them.
7812 EXPECT_EQ("func(a,\n"
7813 " \"long long long \"\n"
7814 " \"long\",\n"
7815 " \"long long long \"\n"
7816 " \"long\");",
7817 format("func(a, \"long long long long\", \"long long long long\");",
7818 getLLVMStyleWithColumns(24)));
7819 // In a chain of << with two operands, the second can be broken with no line
7820 // break before it.
7821 EXPECT_EQ("a << \"line line \"\n"
7822 " \"line\";",
7823 format("a << \"line line line\";",
7824 getLLVMStyleWithColumns(20)));
7825 // In a chain of << with three operands, the second can be broken with no line
7826 // break before it.
7827 EXPECT_EQ("abcde << \"line \"\n"
7828 " \"line line\"\n"
7829 " << c;",
7830 format("abcde << \"line line line\" << c;",
7831 getLLVMStyleWithColumns(20)));
7832 // In a chain of << with three operands, the third must be broken with a line
7833 // break before it.
7834 EXPECT_EQ("a << b\n"
7835 " << \"line line \"\n"
7836 " \"line\";",
7837 format("a << b << \"line line line\";",
7838 getLLVMStyleWithColumns(20)));
7839 // In a chain of << with three operands, the second can be broken with no line
7840 // break before it and the third must be broken with a line break before it.
7841 EXPECT_EQ("abcd << \"line line \"\n"
7842 " \"line\"\n"
7843 " << \"line line \"\n"
7844 " \"line\";",
7845 format("abcd << \"line line line\" << \"line line line\";",
7846 getLLVMStyleWithColumns(20)));
7847 // In a chain of binary operators with two operands, the second can be broken
7848 // with no line break before it.
7849 EXPECT_EQ("abcd + \"line line \"\n"
7850 " \"line line\";",
7851 format("abcd + \"line line line line\";",
7852 getLLVMStyleWithColumns(20)));
7853 // In a chain of binary operators with three operands, the second must be
7854 // broken with a line break before it.
7855 EXPECT_EQ("abcd +\n"
7856 " \"line line \"\n"
7857 " \"line line\" +\n"
7858 " e;",
7859 format("abcd + \"line line line line\" + e;",
7860 getLLVMStyleWithColumns(20)));
7861 // In a function call with two operands, with AlignAfterOpenBracket enabled,
7862 // the first must be broken with a line break before it.
7863 FormatStyle Style = getLLVMStyleWithColumns(25);
7864 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7865 EXPECT_EQ("someFunction(\n"
7866 " \"long long long \"\n"
7867 " \"long\",\n"
7868 " a);",
7869 format("someFunction(\"long long long long\", a);", Style));
7870}
7871
Alexander Kornienko657c67b2013-07-16 21:06:13 +00007872TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
Alexander Kornienkod7b837e2013-08-29 17:32:57 +00007873 EXPECT_EQ(
7874 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
7875 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
7876 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
7877 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
7878 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
7879 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
7880}
7881
7882TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
7883 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
Daniel Jasperc39b56f2013-12-16 07:23:08 +00007884 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle()));
Alexander Kornienkod7b837e2013-08-29 17:32:57 +00007885 EXPECT_EQ("fffffffffff(g(R\"x(\n"
7886 "multiline raw string literal xxxxxxxxxxxxxx\n"
7887 ")x\",\n"
7888 " a),\n"
7889 " b);",
7890 format("fffffffffff(g(R\"x(\n"
7891 "multiline raw string literal xxxxxxxxxxxxxx\n"
7892 ")x\", a), b);",
7893 getGoogleStyleWithColumns(20)));
7894 EXPECT_EQ("fffffffffff(\n"
7895 " g(R\"x(qqq\n"
7896 "multiline raw string literal xxxxxxxxxxxxxx\n"
7897 ")x\",\n"
7898 " a),\n"
7899 " b);",
7900 format("fffffffffff(g(R\"x(qqq\n"
7901 "multiline raw string literal xxxxxxxxxxxxxx\n"
7902 ")x\", a), b);",
7903 getGoogleStyleWithColumns(20)));
7904
7905 EXPECT_EQ("fffffffffff(R\"x(\n"
7906 "multiline raw string literal xxxxxxxxxxxxxx\n"
7907 ")x\");",
7908 format("fffffffffff(R\"x(\n"
7909 "multiline raw string literal xxxxxxxxxxxxxx\n"
7910 ")x\");",
7911 getGoogleStyleWithColumns(20)));
7912 EXPECT_EQ("fffffffffff(R\"x(\n"
7913 "multiline raw string literal xxxxxxxxxxxxxx\n"
Daniel Jasper5d2587d2014-03-27 16:14:13 +00007914 ")x\" + bbbbbb);",
Alexander Kornienkod7b837e2013-08-29 17:32:57 +00007915 format("fffffffffff(R\"x(\n"
7916 "multiline raw string literal xxxxxxxxxxxxxx\n"
Daniel Jasper5d2587d2014-03-27 16:14:13 +00007917 ")x\" + bbbbbb);",
Alexander Kornienkod7b837e2013-08-29 17:32:57 +00007918 getGoogleStyleWithColumns(20)));
Daniel Jasperc39b56f2013-12-16 07:23:08 +00007919 EXPECT_EQ("fffffffffff(\n"
7920 " R\"x(\n"
7921 "multiline raw string literal xxxxxxxxxxxxxx\n"
7922 ")x\" +\n"
7923 " bbbbbb);",
7924 format("fffffffffff(\n"
7925 " R\"x(\n"
7926 "multiline raw string literal xxxxxxxxxxxxxx\n"
7927 ")x\" + bbbbbb);",
7928 getGoogleStyleWithColumns(20)));
Alexander Kornienko657c67b2013-07-16 21:06:13 +00007929}
7930
Alexander Kornienkobe633902013-06-14 11:46:10 +00007931TEST_F(FormatTest, SkipsUnknownStringLiterals) {
Daniel Jasper8369aa52013-07-16 20:28:33 +00007932 verifyFormat("string a = \"unterminated;");
7933 EXPECT_EQ("function(\"unterminated,\n"
7934 " OtherParameter);",
7935 format("function( \"unterminated,\n"
7936 " OtherParameter);"));
Alexander Kornienko1e808872013-06-28 12:51:24 +00007937}
7938
7939TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00007940 FormatStyle Style = getLLVMStyle();
7941 Style.Standard = FormatStyle::LS_Cpp03;
Alexander Kornienko1e808872013-06-28 12:51:24 +00007942 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
Chandler Carruthf8b72662014-03-02 12:37:31 +00007943 format("#define x(_a) printf(\"foo\"_a);", Style));
Alexander Kornienkobe633902013-06-14 11:46:10 +00007944}
7945
Daniel Jaspera44991332015-04-29 13:06:49 +00007946TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }
Daniel Jasper20fd3c62014-04-15 08:49:21 +00007947
Manuel Klimek5ecb5fd2013-05-14 09:04:24 +00007948TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
7949 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
7950 " \"ddeeefff\");",
7951 format("someFunction(\"aaabbbcccdddeeefff\");",
7952 getLLVMStyleWithColumns(25)));
7953 EXPECT_EQ("someFunction1234567890(\n"
7954 " \"aaabbbcccdddeeefff\");",
7955 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
7956 getLLVMStyleWithColumns(26)));
7957 EXPECT_EQ("someFunction1234567890(\n"
7958 " \"aaabbbcccdddeeeff\"\n"
7959 " \"f\");",
7960 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
7961 getLLVMStyleWithColumns(25)));
7962 EXPECT_EQ("someFunction1234567890(\n"
7963 " \"aaabbbcccdddeeeff\"\n"
7964 " \"f\");",
7965 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
7966 getLLVMStyleWithColumns(24)));
Daniel Jasper2739af32013-08-28 10:03:58 +00007967 EXPECT_EQ("someFunction(\"aaabbbcc \"\n"
7968 " \"ddde \"\n"
7969 " \"efff\");",
7970 format("someFunction(\"aaabbbcc ddde efff\");",
Manuel Klimek5ecb5fd2013-05-14 09:04:24 +00007971 getLLVMStyleWithColumns(25)));
7972 EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
7973 " \"ddeeefff\");",
7974 format("someFunction(\"aaabbbccc ddeeefff\");",
7975 getLLVMStyleWithColumns(25)));
7976 EXPECT_EQ("someFunction1234567890(\n"
7977 " \"aaabb \"\n"
7978 " \"cccdddeeefff\");",
7979 format("someFunction1234567890(\"aaabb cccdddeeefff\");",
7980 getLLVMStyleWithColumns(25)));
7981 EXPECT_EQ("#define A \\\n"
7982 " string s = \\\n"
7983 " \"123456789\" \\\n"
7984 " \"0\"; \\\n"
7985 " int i;",
7986 format("#define A string s = \"1234567890\"; int i;",
7987 getLLVMStyleWithColumns(20)));
Daniel Jasper2739af32013-08-28 10:03:58 +00007988 // FIXME: Put additional penalties on breaking at non-whitespace locations.
7989 EXPECT_EQ("someFunction(\"aaabbbcc \"\n"
7990 " \"dddeeeff\"\n"
7991 " \"f\");",
7992 format("someFunction(\"aaabbbcc dddeeefff\");",
7993 getLLVMStyleWithColumns(25)));
Manuel Klimek5ecb5fd2013-05-14 09:04:24 +00007994}
7995
Manuel Klimek5085d9b2013-03-08 18:59:48 +00007996TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
Daniel Jaspera44991332015-04-29 13:06:49 +00007997 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3)));
7998 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2)));
Manuel Klimek5085d9b2013-03-08 18:59:48 +00007999 EXPECT_EQ("\"test\"\n"
8000 "\"\\n\"",
8001 format("\"test\\n\"", getLLVMStyleWithColumns(7)));
8002 EXPECT_EQ("\"tes\\\\\"\n"
8003 "\"n\"",
8004 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
8005 EXPECT_EQ("\"\\\\\\\\\"\n"
8006 "\"\\n\"",
8007 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
Daniel Jaspera44991332015-04-29 13:06:49 +00008008 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
Manuel Klimek5085d9b2013-03-08 18:59:48 +00008009 EXPECT_EQ("\"\\uff01\"\n"
8010 "\"test\"",
8011 format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
8012 EXPECT_EQ("\"\\Uff01ff02\"",
8013 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
8014 EXPECT_EQ("\"\\x000000000001\"\n"
8015 "\"next\"",
8016 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
8017 EXPECT_EQ("\"\\x000000000001next\"",
8018 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
8019 EXPECT_EQ("\"\\x000000000001\"",
8020 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
8021 EXPECT_EQ("\"test\"\n"
8022 "\"\\000000\"\n"
8023 "\"000001\"",
8024 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
8025 EXPECT_EQ("\"test\\000\"\n"
Alexander Kornienkocb45bc12013-04-15 14:28:00 +00008026 "\"00000000\"\n"
8027 "\"1\"",
Manuel Klimek5085d9b2013-03-08 18:59:48 +00008028 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
Manuel Klimek5085d9b2013-03-08 18:59:48 +00008029}
8030
Manuel Klimeka3ff45e2013-04-10 09:52:05 +00008031TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
8032 verifyFormat("void f() {\n"
8033 " return g() {}\n"
8034 " void h() {}");
Daniel Jasper4afc6b32014-06-02 10:57:55 +00008035 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
Daniel Jasper1ec31062013-05-28 18:50:02 +00008036 "g();\n"
Manuel Klimeka3ff45e2013-04-10 09:52:05 +00008037 "}");
8038}
8039
Manuel Klimek421147e2014-01-24 09:25:23 +00008040TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) {
8041 verifyFormat(
Daniel Jasper39485162014-05-22 09:00:33 +00008042 "void f() { return C{param1, param2}.SomeCall(param1, param2); }");
Manuel Klimek421147e2014-01-24 09:25:23 +00008043}
8044
Manuel Klimek13b97d82013-05-13 08:42:42 +00008045TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
8046 verifyFormat("class X {\n"
8047 " void f() {\n"
8048 " }\n"
8049 "};",
8050 getLLVMStyleWithColumns(12));
8051}
8052
8053TEST_F(FormatTest, ConfigurableIndentWidth) {
8054 FormatStyle EightIndent = getLLVMStyleWithColumns(18);
8055 EightIndent.IndentWidth = 8;
Chandler Carruthf8b72662014-03-02 12:37:31 +00008056 EightIndent.ContinuationIndentWidth = 8;
Manuel Klimek13b97d82013-05-13 08:42:42 +00008057 verifyFormat("void f() {\n"
8058 " someFunction();\n"
8059 " if (true) {\n"
8060 " f();\n"
8061 " }\n"
8062 "}",
8063 EightIndent);
8064 verifyFormat("class X {\n"
8065 " void f() {\n"
8066 " }\n"
8067 "};",
8068 EightIndent);
8069 verifyFormat("int x[] = {\n"
8070 " call(),\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00008071 " call()};",
Manuel Klimek13b97d82013-05-13 08:42:42 +00008072 EightIndent);
8073}
8074
Alexander Kornienko34a87e82013-06-22 01:35:36 +00008075TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
Daniel Jaspere068ac72014-10-27 17:13:59 +00008076 verifyFormat("double\n"
Manuel Klimek836c2862013-06-21 17:25:42 +00008077 "f();",
8078 getLLVMStyleWithColumns(8));
8079}
8080
Manuel Klimekb9eae4c2013-05-13 09:22:11 +00008081TEST_F(FormatTest, ConfigurableUseOfTab) {
8082 FormatStyle Tab = getLLVMStyleWithColumns(42);
8083 Tab.IndentWidth = 8;
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00008084 Tab.UseTab = FormatStyle::UT_Always;
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +00008085 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left;
Alexander Kornienkodb4c21f2013-09-27 09:45:40 +00008086
8087 EXPECT_EQ("if (aaaaaaaa && // q\n"
8088 " bb)\t\t// w\n"
8089 "\t;",
8090 format("if (aaaaaaaa &&// q\n"
8091 "bb)// w\n"
8092 ";",
8093 Tab));
8094 EXPECT_EQ("if (aaa && bbb) // w\n"
8095 "\t;",
8096 format("if(aaa&&bbb)// w\n"
8097 ";",
8098 Tab));
8099
Manuel Klimekb9eae4c2013-05-13 09:22:11 +00008100 verifyFormat("class X {\n"
8101 "\tvoid f() {\n"
8102 "\t\tsomeFunction(parameter1,\n"
8103 "\t\t\t parameter2);\n"
8104 "\t}\n"
8105 "};",
8106 Tab);
8107 verifyFormat("#define A \\\n"
8108 "\tvoid f() { \\\n"
8109 "\t\tsomeFunction( \\\n"
8110 "\t\t parameter1, \\\n"
8111 "\t\t parameter2); \\\n"
8112 "\t}",
8113 Tab);
Manuel Klimek34d15152013-05-28 10:01:59 +00008114
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +00008115 Tab.TabWidth = 4;
8116 Tab.IndentWidth = 8;
8117 verifyFormat("class TabWidth4Indent8 {\n"
8118 "\t\tvoid f() {\n"
8119 "\t\t\t\tsomeFunction(parameter1,\n"
8120 "\t\t\t\t\t\t\t parameter2);\n"
8121 "\t\t}\n"
8122 "};",
8123 Tab);
8124
8125 Tab.TabWidth = 4;
8126 Tab.IndentWidth = 4;
8127 verifyFormat("class TabWidth4Indent4 {\n"
8128 "\tvoid f() {\n"
8129 "\t\tsomeFunction(parameter1,\n"
8130 "\t\t\t\t\t parameter2);\n"
8131 "\t}\n"
8132 "};",
8133 Tab);
8134
8135 Tab.TabWidth = 8;
8136 Tab.IndentWidth = 4;
8137 verifyFormat("class TabWidth8Indent4 {\n"
8138 " void f() {\n"
8139 "\tsomeFunction(parameter1,\n"
8140 "\t\t parameter2);\n"
8141 " }\n"
8142 "};",
8143 Tab);
8144
Alexander Kornienko39856b72013-09-10 09:38:25 +00008145 Tab.TabWidth = 8;
8146 Tab.IndentWidth = 8;
8147 EXPECT_EQ("/*\n"
8148 "\t a\t\tcomment\n"
8149 "\t in multiple lines\n"
8150 " */",
8151 format(" /*\t \t \n"
8152 " \t \t a\t\tcomment\t \t\n"
8153 " \t \t in multiple lines\t\n"
8154 " \t */",
8155 Tab));
Alexander Kornienkodb4c21f2013-09-27 09:45:40 +00008156
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00008157 Tab.UseTab = FormatStyle::UT_ForIndentation;
Chandler Carruthf8b72662014-03-02 12:37:31 +00008158 verifyFormat("{\n"
8159 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8160 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8161 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8162 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8163 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8164 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
Alexander Kornienkoe2e03872013-10-14 00:46:35 +00008165 "};",
8166 Tab);
Daniel Jasper411af722016-01-05 16:10:39 +00008167 verifyFormat("enum AA {\n"
Daniel Jasper96972812014-01-05 12:38:10 +00008168 "\ta1, // Force multiple lines\n"
Alexander Kornienkoe2e03872013-10-14 00:46:35 +00008169 "\ta2,\n"
8170 "\ta3\n"
8171 "};",
8172 Tab);
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00008173 EXPECT_EQ("if (aaaaaaaa && // q\n"
8174 " bb) // w\n"
8175 "\t;",
8176 format("if (aaaaaaaa &&// q\n"
8177 "bb)// w\n"
8178 ";",
8179 Tab));
8180 verifyFormat("class X {\n"
8181 "\tvoid f() {\n"
8182 "\t\tsomeFunction(parameter1,\n"
8183 "\t\t parameter2);\n"
8184 "\t}\n"
8185 "};",
8186 Tab);
8187 verifyFormat("{\n"
Daniel Jasper100ffc62015-08-21 11:44:57 +00008188 "\tQ(\n"
8189 "\t {\n"
8190 "\t\t int a;\n"
8191 "\t\t someFunction(aaaaaaaa,\n"
8192 "\t\t bbbbbbb);\n"
8193 "\t },\n"
8194 "\t p);\n"
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00008195 "}",
8196 Tab);
8197 EXPECT_EQ("{\n"
8198 "\t/* aaaa\n"
8199 "\t bbbb */\n"
8200 "}",
8201 format("{\n"
8202 "/* aaaa\n"
8203 " bbbb */\n"
8204 "}",
8205 Tab));
8206 EXPECT_EQ("{\n"
8207 "\t/*\n"
8208 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8209 "\t bbbbbbbbbbbbb\n"
8210 "\t*/\n"
8211 "}",
8212 format("{\n"
8213 "/*\n"
8214 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
8215 "*/\n"
8216 "}",
8217 Tab));
8218 EXPECT_EQ("{\n"
8219 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8220 "\t// bbbbbbbbbbbbb\n"
8221 "}",
8222 format("{\n"
8223 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
8224 "}",
8225 Tab));
8226 EXPECT_EQ("{\n"
8227 "\t/*\n"
8228 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8229 "\t bbbbbbbbbbbbb\n"
8230 "\t*/\n"
8231 "}",
8232 format("{\n"
8233 "\t/*\n"
8234 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
8235 "\t*/\n"
8236 "}",
8237 Tab));
8238 EXPECT_EQ("{\n"
8239 "\t/*\n"
8240 "\n"
8241 "\t*/\n"
8242 "}",
8243 format("{\n"
8244 "\t/*\n"
8245 "\n"
8246 "\t*/\n"
Alexander Kornienko45dc1b22013-09-27 16:40:11 +00008247 "}",
8248 Tab));
8249 EXPECT_EQ("{\n"
8250 "\t/*\n"
8251 " asdf\n"
8252 "\t*/\n"
8253 "}",
8254 format("{\n"
8255 "\t/*\n"
8256 " asdf\n"
8257 "\t*/\n"
8258 "}",
8259 Tab));
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00008260
8261 Tab.UseTab = FormatStyle::UT_Never;
Alexander Kornienko39856b72013-09-10 09:38:25 +00008262 EXPECT_EQ("/*\n"
8263 " a\t\tcomment\n"
8264 " in multiple lines\n"
8265 " */",
8266 format(" /*\t \t \n"
8267 " \t \t a\t\tcomment\t \t\n"
8268 " \t \t in multiple lines\t\n"
8269 " \t */",
8270 Tab));
8271 EXPECT_EQ("/* some\n"
8272 " comment */",
Daniel Jaspera44991332015-04-29 13:06:49 +00008273 format(" \t \t /* some\n"
8274 " \t \t comment */",
8275 Tab));
Alexander Kornienko39856b72013-09-10 09:38:25 +00008276 EXPECT_EQ("int a; /* some\n"
8277 " comment */",
Daniel Jaspera44991332015-04-29 13:06:49 +00008278 format(" \t \t int a; /* some\n"
8279 " \t \t comment */",
8280 Tab));
Manuel Klimek34d15152013-05-28 10:01:59 +00008281
Alexander Kornienko39856b72013-09-10 09:38:25 +00008282 EXPECT_EQ("int a; /* some\n"
8283 "comment */",
Daniel Jaspera44991332015-04-29 13:06:49 +00008284 format(" \t \t int\ta; /* some\n"
8285 " \t \t comment */",
8286 Tab));
Alexander Kornienko39856b72013-09-10 09:38:25 +00008287 EXPECT_EQ("f(\"\t\t\"); /* some\n"
8288 " comment */",
Daniel Jaspera44991332015-04-29 13:06:49 +00008289 format(" \t \t f(\"\t\t\"); /* some\n"
8290 " \t \t comment */",
8291 Tab));
Manuel Klimek34d15152013-05-28 10:01:59 +00008292 EXPECT_EQ("{\n"
8293 " /*\n"
8294 " * Comment\n"
8295 " */\n"
8296 " int i;\n"
8297 "}",
8298 format("{\n"
8299 "\t/*\n"
8300 "\t * Comment\n"
8301 "\t */\n"
8302 "\t int i;\n"
8303 "}"));
Marianne Mailhot-Sarrasin51fe2792016-04-14 14:52:26 +00008304
8305 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
8306 Tab.TabWidth = 8;
8307 Tab.IndentWidth = 8;
8308 EXPECT_EQ("if (aaaaaaaa && // q\n"
8309 " bb) // w\n"
8310 "\t;",
8311 format("if (aaaaaaaa &&// q\n"
8312 "bb)// w\n"
8313 ";",
8314 Tab));
8315 EXPECT_EQ("if (aaa && bbb) // w\n"
8316 "\t;",
8317 format("if(aaa&&bbb)// w\n"
8318 ";",
8319 Tab));
8320 verifyFormat("class X {\n"
8321 "\tvoid f() {\n"
8322 "\t\tsomeFunction(parameter1,\n"
8323 "\t\t\t parameter2);\n"
8324 "\t}\n"
8325 "};",
8326 Tab);
8327 verifyFormat("#define A \\\n"
8328 "\tvoid f() { \\\n"
8329 "\t\tsomeFunction( \\\n"
8330 "\t\t parameter1, \\\n"
8331 "\t\t parameter2); \\\n"
8332 "\t}",
8333 Tab);
8334 Tab.TabWidth = 4;
8335 Tab.IndentWidth = 8;
8336 verifyFormat("class TabWidth4Indent8 {\n"
8337 "\t\tvoid f() {\n"
8338 "\t\t\t\tsomeFunction(parameter1,\n"
8339 "\t\t\t\t\t\t\t parameter2);\n"
8340 "\t\t}\n"
8341 "};",
8342 Tab);
8343 Tab.TabWidth = 4;
8344 Tab.IndentWidth = 4;
8345 verifyFormat("class TabWidth4Indent4 {\n"
8346 "\tvoid f() {\n"
8347 "\t\tsomeFunction(parameter1,\n"
8348 "\t\t\t\t\t parameter2);\n"
8349 "\t}\n"
8350 "};",
8351 Tab);
8352 Tab.TabWidth = 8;
8353 Tab.IndentWidth = 4;
8354 verifyFormat("class TabWidth8Indent4 {\n"
8355 " void f() {\n"
8356 "\tsomeFunction(parameter1,\n"
8357 "\t\t parameter2);\n"
8358 " }\n"
8359 "};",
8360 Tab);
8361 Tab.TabWidth = 8;
8362 Tab.IndentWidth = 8;
8363 EXPECT_EQ("/*\n"
8364 "\t a\t\tcomment\n"
8365 "\t in multiple lines\n"
8366 " */",
8367 format(" /*\t \t \n"
8368 " \t \t a\t\tcomment\t \t\n"
8369 " \t \t in multiple lines\t\n"
8370 " \t */",
8371 Tab));
8372 verifyFormat("{\n"
8373 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8374 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8375 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8376 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8377 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8378 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8379 "};",
8380 Tab);
8381 verifyFormat("enum AA {\n"
8382 "\ta1, // Force multiple lines\n"
8383 "\ta2,\n"
8384 "\ta3\n"
8385 "};",
8386 Tab);
8387 EXPECT_EQ("if (aaaaaaaa && // q\n"
8388 " bb) // w\n"
8389 "\t;",
8390 format("if (aaaaaaaa &&// q\n"
8391 "bb)// w\n"
8392 ";",
8393 Tab));
8394 verifyFormat("class X {\n"
8395 "\tvoid f() {\n"
8396 "\t\tsomeFunction(parameter1,\n"
8397 "\t\t\t parameter2);\n"
8398 "\t}\n"
8399 "};",
8400 Tab);
8401 verifyFormat("{\n"
8402 "\tQ(\n"
8403 "\t {\n"
8404 "\t\t int a;\n"
8405 "\t\t someFunction(aaaaaaaa,\n"
8406 "\t\t\t\t bbbbbbb);\n"
8407 "\t },\n"
8408 "\t p);\n"
8409 "}",
8410 Tab);
8411 EXPECT_EQ("{\n"
8412 "\t/* aaaa\n"
8413 "\t bbbb */\n"
8414 "}",
8415 format("{\n"
8416 "/* aaaa\n"
8417 " bbbb */\n"
8418 "}",
8419 Tab));
8420 EXPECT_EQ("{\n"
8421 "\t/*\n"
8422 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8423 "\t bbbbbbbbbbbbb\n"
8424 "\t*/\n"
8425 "}",
8426 format("{\n"
8427 "/*\n"
8428 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
8429 "*/\n"
8430 "}",
8431 Tab));
8432 EXPECT_EQ("{\n"
8433 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8434 "\t// bbbbbbbbbbbbb\n"
8435 "}",
8436 format("{\n"
8437 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
8438 "}",
8439 Tab));
8440 EXPECT_EQ("{\n"
8441 "\t/*\n"
8442 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8443 "\t bbbbbbbbbbbbb\n"
8444 "\t*/\n"
8445 "}",
8446 format("{\n"
8447 "\t/*\n"
8448 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
8449 "\t*/\n"
8450 "}",
8451 Tab));
8452 EXPECT_EQ("{\n"
8453 "\t/*\n"
8454 "\n"
8455 "\t*/\n"
8456 "}",
8457 format("{\n"
8458 "\t/*\n"
8459 "\n"
8460 "\t*/\n"
8461 "}",
8462 Tab));
8463 EXPECT_EQ("{\n"
8464 "\t/*\n"
8465 " asdf\n"
8466 "\t*/\n"
8467 "}",
8468 format("{\n"
8469 "\t/*\n"
8470 " asdf\n"
8471 "\t*/\n"
8472 "}",
8473 Tab));
8474 EXPECT_EQ("/*\n"
8475 "\t a\t\tcomment\n"
8476 "\t in multiple lines\n"
8477 " */",
8478 format(" /*\t \t \n"
8479 " \t \t a\t\tcomment\t \t\n"
8480 " \t \t in multiple lines\t\n"
8481 " \t */",
8482 Tab));
8483 EXPECT_EQ("/* some\n"
8484 " comment */",
8485 format(" \t \t /* some\n"
8486 " \t \t comment */",
8487 Tab));
8488 EXPECT_EQ("int a; /* some\n"
8489 " comment */",
8490 format(" \t \t int a; /* some\n"
8491 " \t \t comment */",
8492 Tab));
8493 EXPECT_EQ("int a; /* some\n"
8494 "comment */",
8495 format(" \t \t int\ta; /* some\n"
8496 " \t \t comment */",
8497 Tab));
8498 EXPECT_EQ("f(\"\t\t\"); /* some\n"
8499 " comment */",
8500 format(" \t \t f(\"\t\t\"); /* some\n"
8501 " \t \t comment */",
8502 Tab));
8503 EXPECT_EQ("{\n"
8504 " /*\n"
8505 " * Comment\n"
8506 " */\n"
8507 " int i;\n"
8508 "}",
8509 format("{\n"
8510 "\t/*\n"
8511 "\t * Comment\n"
8512 "\t */\n"
8513 "\t int i;\n"
8514 "}"));
8515 Tab.AlignConsecutiveAssignments = true;
8516 Tab.AlignConsecutiveDeclarations = true;
8517 Tab.TabWidth = 4;
8518 Tab.IndentWidth = 4;
8519 verifyFormat("class Assign {\n"
8520 "\tvoid f() {\n"
8521 "\t\tint x = 123;\n"
8522 "\t\tint random = 4;\n"
8523 "\t\tstd::string alphabet =\n"
8524 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
8525 "\t}\n"
8526 "};",
8527 Tab);
Manuel Klimekb9eae4c2013-05-13 09:22:11 +00008528}
8529
Alexander Kornienko917f9e02013-09-10 12:29:48 +00008530TEST_F(FormatTest, CalculatesOriginalColumn) {
8531 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8532 "q\"; /* some\n"
8533 " comment */",
8534 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8535 "q\"; /* some\n"
8536 " comment */",
8537 getLLVMStyle()));
8538 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
8539 "/* some\n"
8540 " comment */",
8541 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
8542 " /* some\n"
8543 " comment */",
8544 getLLVMStyle()));
8545 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8546 "qqq\n"
8547 "/* some\n"
8548 " comment */",
8549 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8550 "qqq\n"
8551 " /* some\n"
8552 " comment */",
8553 getLLVMStyle()));
8554 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8555 "wwww; /* some\n"
8556 " comment */",
8557 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8558 "wwww; /* some\n"
8559 " comment */",
8560 getLLVMStyle()));
8561}
8562
Alexander Kornienkofdca83d2013-12-10 10:18:34 +00008563TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
Daniel Jasperb55acad2013-08-20 12:36:34 +00008564 FormatStyle NoSpace = getLLVMStyle();
Alexander Kornienkofdca83d2013-12-10 10:18:34 +00008565 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never;
Daniel Jasperb55acad2013-08-20 12:36:34 +00008566
8567 verifyFormat("while(true)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008568 " continue;",
8569 NoSpace);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008570 verifyFormat("for(;;)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008571 " continue;",
8572 NoSpace);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008573 verifyFormat("if(true)\n"
8574 " f();\n"
8575 "else if(true)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008576 " f();",
8577 NoSpace);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008578 verifyFormat("do {\n"
8579 " do_something();\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008580 "} while(something());",
8581 NoSpace);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008582 verifyFormat("switch(x) {\n"
8583 "default:\n"
8584 " break;\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008585 "}",
8586 NoSpace);
Chad Rosier0a84f172014-08-05 17:58:54 +00008587 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace);
Daniel Jasper78b194992014-08-06 14:15:41 +00008588 verifyFormat("size_t x = sizeof(x);", NoSpace);
8589 verifyFormat("auto f(int x) -> decltype(x);", NoSpace);
8590 verifyFormat("int f(T x) noexcept(x.create());", NoSpace);
8591 verifyFormat("alignas(128) char a[128];", NoSpace);
8592 verifyFormat("size_t x = alignof(MyType);", NoSpace);
8593 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace);
8594 verifyFormat("int f() throw(Deprecated);", NoSpace);
Anders Waldenborgb09075a2015-05-19 16:54:26 +00008595 verifyFormat("typedef void (*cb)(int);", NoSpace);
Daniel Jaspera804d1e2015-08-11 20:32:24 +00008596 verifyFormat("T A::operator()();", NoSpace);
8597 verifyFormat("X A::operator++(T);", NoSpace);
Alexander Kornienkofdca83d2013-12-10 10:18:34 +00008598
8599 FormatStyle Space = getLLVMStyle();
8600 Space.SpaceBeforeParens = FormatStyle::SBPO_Always;
8601
8602 verifyFormat("int f ();", Space);
8603 verifyFormat("void f (int a, T b) {\n"
8604 " while (true)\n"
8605 " continue;\n"
8606 "}",
8607 Space);
8608 verifyFormat("if (true)\n"
8609 " f ();\n"
8610 "else if (true)\n"
8611 " f ();",
8612 Space);
8613 verifyFormat("do {\n"
8614 " do_something ();\n"
8615 "} while (something ());",
8616 Space);
8617 verifyFormat("switch (x) {\n"
8618 "default:\n"
8619 " break;\n"
8620 "}",
8621 Space);
8622 verifyFormat("A::A () : a (1) {}", Space);
8623 verifyFormat("void f () __attribute__ ((asdf));", Space);
8624 verifyFormat("*(&a + 1);\n"
8625 "&((&a)[1]);\n"
8626 "a[(b + c) * d];\n"
8627 "(((a + 1) * 2) + 3) * 4;",
8628 Space);
8629 verifyFormat("#define A(x) x", Space);
8630 verifyFormat("#define A (x) x", Space);
8631 verifyFormat("#if defined(x)\n"
8632 "#endif",
8633 Space);
Chad Rosier0a84f172014-08-05 17:58:54 +00008634 verifyFormat("auto i = std::make_unique<int> (5);", Space);
Daniel Jasper78b194992014-08-06 14:15:41 +00008635 verifyFormat("size_t x = sizeof (x);", Space);
8636 verifyFormat("auto f (int x) -> decltype (x);", Space);
8637 verifyFormat("int f (T x) noexcept (x.create ());", Space);
8638 verifyFormat("alignas (128) char a[128];", Space);
8639 verifyFormat("size_t x = alignof (MyType);", Space);
8640 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space);
8641 verifyFormat("int f () throw (Deprecated);", Space);
Anders Waldenborgb09075a2015-05-19 16:54:26 +00008642 verifyFormat("typedef void (*cb) (int);", Space);
Daniel Jaspera804d1e2015-08-11 20:32:24 +00008643 verifyFormat("T A::operator() ();", Space);
8644 verifyFormat("X A::operator++ (T);", Space);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008645}
8646
8647TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
8648 FormatStyle Spaces = getLLVMStyle();
8649
8650 Spaces.SpacesInParentheses = true;
8651 verifyFormat("call( x, y, z );", Spaces);
Daniel Jasper92e09822015-03-18 12:59:19 +00008652 verifyFormat("call();", Spaces);
8653 verifyFormat("std::function<void( int, int )> callback;", Spaces);
Daniel Jasper74331d42015-10-26 12:08:47 +00008654 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }",
8655 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008656 verifyFormat("while ( (bool)1 )\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008657 " continue;",
8658 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008659 verifyFormat("for ( ;; )\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008660 " continue;",
8661 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008662 verifyFormat("if ( true )\n"
8663 " f();\n"
8664 "else if ( true )\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008665 " f();",
8666 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008667 verifyFormat("do {\n"
8668 " do_something( (int)i );\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008669 "} while ( something() );",
8670 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008671 verifyFormat("switch ( x ) {\n"
8672 "default:\n"
8673 " break;\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008674 "}",
8675 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008676
8677 Spaces.SpacesInParentheses = false;
8678 Spaces.SpacesInCStyleCastParentheses = true;
8679 verifyFormat("Type *A = ( Type * )P;", Spaces);
8680 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
8681 verifyFormat("x = ( int32 )y;", Spaces);
8682 verifyFormat("int a = ( int )(2.0f);", Spaces);
8683 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
8684 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
8685 verifyFormat("#define x (( int )-1)", Spaces);
8686
Daniel Jasper92e09822015-03-18 12:59:19 +00008687 // Run the first set of tests again with:
Richard Trieucc3949d2016-02-18 22:34:54 +00008688 Spaces.SpacesInParentheses = false;
8689 Spaces.SpaceInEmptyParentheses = true;
Daniel Jasperb55acad2013-08-20 12:36:34 +00008690 Spaces.SpacesInCStyleCastParentheses = true;
8691 verifyFormat("call(x, y, z);", Spaces);
Daniel Jasper92e09822015-03-18 12:59:19 +00008692 verifyFormat("call( );", Spaces);
8693 verifyFormat("std::function<void(int, int)> callback;", Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008694 verifyFormat("while (( bool )1)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008695 " continue;",
8696 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008697 verifyFormat("for (;;)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008698 " continue;",
8699 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008700 verifyFormat("if (true)\n"
8701 " f( );\n"
8702 "else if (true)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008703 " f( );",
8704 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008705 verifyFormat("do {\n"
8706 " do_something(( int )i);\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008707 "} while (something( ));",
8708 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008709 verifyFormat("switch (x) {\n"
8710 "default:\n"
8711 " break;\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008712 "}",
8713 Spaces);
Daniel Jasperdb986eb2014-09-03 07:37:29 +00008714
Daniel Jasper92e09822015-03-18 12:59:19 +00008715 // Run the first set of tests again with:
Daniel Jasperdb986eb2014-09-03 07:37:29 +00008716 Spaces.SpaceAfterCStyleCast = true;
8717 verifyFormat("call(x, y, z);", Spaces);
Daniel Jasper92e09822015-03-18 12:59:19 +00008718 verifyFormat("call( );", Spaces);
8719 verifyFormat("std::function<void(int, int)> callback;", Spaces);
Daniel Jasperdb986eb2014-09-03 07:37:29 +00008720 verifyFormat("while (( bool ) 1)\n"
8721 " continue;",
8722 Spaces);
8723 verifyFormat("for (;;)\n"
8724 " continue;",
8725 Spaces);
8726 verifyFormat("if (true)\n"
8727 " f( );\n"
8728 "else if (true)\n"
8729 " f( );",
8730 Spaces);
8731 verifyFormat("do {\n"
8732 " do_something(( int ) i);\n"
8733 "} while (something( ));",
8734 Spaces);
8735 verifyFormat("switch (x) {\n"
8736 "default:\n"
8737 " break;\n"
8738 "}",
8739 Spaces);
Daniel Jasper92e09822015-03-18 12:59:19 +00008740
8741 // Run subset of tests again with:
Daniel Jasperdb986eb2014-09-03 07:37:29 +00008742 Spaces.SpacesInCStyleCastParentheses = false;
8743 Spaces.SpaceAfterCStyleCast = true;
8744 verifyFormat("while ((bool) 1)\n"
8745 " continue;",
8746 Spaces);
8747 verifyFormat("do {\n"
8748 " do_something((int) i);\n"
8749 "} while (something( ));",
8750 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008751}
8752
Daniel Jasperad981f82014-08-26 11:41:14 +00008753TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) {
8754 verifyFormat("int a[5];");
8755 verifyFormat("a[3] += 42;");
8756
8757 FormatStyle Spaces = getLLVMStyle();
8758 Spaces.SpacesInSquareBrackets = true;
8759 // Lambdas unchanged.
8760 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces);
8761 verifyFormat("return [i, args...] {};", Spaces);
8762
8763 // Not lambdas.
8764 verifyFormat("int a[ 5 ];", Spaces);
8765 verifyFormat("a[ 3 ] += 42;", Spaces);
8766 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces);
8767 verifyFormat("double &operator[](int i) { return 0; }\n"
8768 "int i;",
8769 Spaces);
8770 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces);
8771 verifyFormat("int i = a[ a ][ a ]->f();", Spaces);
8772 verifyFormat("int i = (*b)[ a ]->f();", Spaces);
8773}
8774
Daniel Jasperd94bff32013-09-25 15:15:02 +00008775TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
8776 verifyFormat("int a = 5;");
8777 verifyFormat("a += 42;");
8778 verifyFormat("a or_eq 8;");
8779
8780 FormatStyle Spaces = getLLVMStyle();
8781 Spaces.SpaceBeforeAssignmentOperators = false;
8782 verifyFormat("int a= 5;", Spaces);
8783 verifyFormat("a+= 42;", Spaces);
8784 verifyFormat("a or_eq 8;", Spaces);
8785}
8786
Daniel Jaspera44991332015-04-29 13:06:49 +00008787TEST_F(FormatTest, AlignConsecutiveAssignments) {
8788 FormatStyle Alignment = getLLVMStyle();
8789 Alignment.AlignConsecutiveAssignments = false;
8790 verifyFormat("int a = 5;\n"
8791 "int oneTwoThree = 123;",
8792 Alignment);
8793 verifyFormat("int a = 5;\n"
8794 "int oneTwoThree = 123;",
8795 Alignment);
8796
8797 Alignment.AlignConsecutiveAssignments = true;
8798 verifyFormat("int a = 5;\n"
8799 "int oneTwoThree = 123;",
8800 Alignment);
8801 verifyFormat("int a = method();\n"
8802 "int oneTwoThree = 133;",
8803 Alignment);
8804 verifyFormat("a &= 5;\n"
8805 "bcd *= 5;\n"
8806 "ghtyf += 5;\n"
8807 "dvfvdb -= 5;\n"
8808 "a /= 5;\n"
8809 "vdsvsv %= 5;\n"
8810 "sfdbddfbdfbb ^= 5;\n"
8811 "dvsdsv |= 5;\n"
8812 "int dsvvdvsdvvv = 123;",
8813 Alignment);
8814 verifyFormat("int i = 1, j = 10;\n"
8815 "something = 2000;",
8816 Alignment);
8817 verifyFormat("something = 2000;\n"
8818 "int i = 1, j = 10;\n",
8819 Alignment);
8820 verifyFormat("something = 2000;\n"
8821 "another = 911;\n"
8822 "int i = 1, j = 10;\n"
8823 "oneMore = 1;\n"
8824 "i = 2;",
8825 Alignment);
8826 verifyFormat("int a = 5;\n"
8827 "int one = 1;\n"
8828 "method();\n"
8829 "int oneTwoThree = 123;\n"
8830 "int oneTwo = 12;",
8831 Alignment);
Daniel Jasperbbfd20d2015-09-22 09:32:00 +00008832 verifyFormat("int oneTwoThree = 123;\n"
8833 "int oneTwo = 12;\n"
8834 "method();\n",
8835 Alignment);
Daniel Jaspera44991332015-04-29 13:06:49 +00008836 verifyFormat("int oneTwoThree = 123; // comment\n"
8837 "int oneTwo = 12; // comment",
8838 Alignment);
8839 EXPECT_EQ("int a = 5;\n"
8840 "\n"
8841 "int oneTwoThree = 123;",
8842 format("int a = 5;\n"
8843 "\n"
8844 "int oneTwoThree= 123;",
8845 Alignment));
8846 EXPECT_EQ("int a = 5;\n"
8847 "int one = 1;\n"
8848 "\n"
8849 "int oneTwoThree = 123;",
8850 format("int a = 5;\n"
8851 "int one = 1;\n"
8852 "\n"
8853 "int oneTwoThree = 123;",
8854 Alignment));
8855 EXPECT_EQ("int a = 5;\n"
8856 "int one = 1;\n"
8857 "\n"
8858 "int oneTwoThree = 123;\n"
8859 "int oneTwo = 12;",
8860 format("int a = 5;\n"
8861 "int one = 1;\n"
8862 "\n"
8863 "int oneTwoThree = 123;\n"
8864 "int oneTwo = 12;",
8865 Alignment));
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +00008866 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
8867 verifyFormat("#define A \\\n"
8868 " int aaaa = 12; \\\n"
8869 " int b = 23; \\\n"
8870 " int ccc = 234; \\\n"
8871 " int dddddddddd = 2345;",
8872 Alignment);
8873 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
Daniel Jaspera44991332015-04-29 13:06:49 +00008874 verifyFormat("#define A \\\n"
8875 " int aaaa = 12; \\\n"
8876 " int b = 23; \\\n"
8877 " int ccc = 234; \\\n"
8878 " int dddddddddd = 2345;",
8879 Alignment);
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +00008880 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
Daniel Jaspera44991332015-04-29 13:06:49 +00008881 verifyFormat("#define A "
8882 " \\\n"
8883 " int aaaa = 12; "
8884 " \\\n"
8885 " int b = 23; "
8886 " \\\n"
8887 " int ccc = 234; "
8888 " \\\n"
8889 " int dddddddddd = 2345;",
8890 Alignment);
8891 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
8892 "k = 4, int l = 5,\n"
8893 " int m = 6) {\n"
8894 " int j = 10;\n"
8895 " otherThing = 1;\n"
8896 "}",
8897 Alignment);
8898 verifyFormat("void SomeFunction(int parameter = 0) {\n"
8899 " int i = 1;\n"
8900 " int j = 2;\n"
8901 " int big = 10000;\n"
8902 "}",
8903 Alignment);
8904 verifyFormat("class C {\n"
8905 "public:\n"
Daniel Jasperec90e512015-12-01 12:00:43 +00008906 " int i = 1;\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008907 " virtual void f() = 0;\n"
8908 "};",
8909 Alignment);
8910 verifyFormat("int i = 1;\n"
8911 "if (SomeType t = getSomething()) {\n"
8912 "}\n"
8913 "int j = 2;\n"
8914 "int big = 10000;",
8915 Alignment);
8916 verifyFormat("int j = 7;\n"
8917 "for (int k = 0; k < N; ++k) {\n"
8918 "}\n"
8919 "int j = 2;\n"
8920 "int big = 10000;\n"
8921 "}",
8922 Alignment);
8923 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
8924 verifyFormat("int i = 1;\n"
8925 "LooooooooooongType loooooooooooooooooooooongVariable\n"
8926 " = someLooooooooooooooooongFunction();\n"
8927 "int j = 2;",
8928 Alignment);
8929 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
8930 verifyFormat("int i = 1;\n"
8931 "LooooooooooongType loooooooooooooooooooooongVariable =\n"
8932 " someLooooooooooooooooongFunction();\n"
8933 "int j = 2;",
8934 Alignment);
Daniel Jasper39828252015-10-07 15:03:26 +00008935
8936 verifyFormat("auto lambda = []() {\n"
8937 " auto i = 0;\n"
8938 " return 0;\n"
8939 "};\n"
8940 "int i = 0;\n"
8941 "auto v = type{\n"
8942 " i = 1, //\n"
8943 " (i = 2), //\n"
8944 " i = 3 //\n"
8945 "};",
8946 Alignment);
8947
Daniel Jaspera44991332015-04-29 13:06:49 +00008948 verifyFormat(
8949 "int i = 1;\n"
8950 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
8951 " loooooooooooooooooooooongParameterB);\n"
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00008952 "int j = 2;",
Daniel Jaspera44991332015-04-29 13:06:49 +00008953 Alignment);
Daniel Jasperec90e512015-12-01 12:00:43 +00008954
8955 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
8956 " typename B = very_long_type_name_1,\n"
8957 " typename T_2 = very_long_type_name_2>\n"
8958 "auto foo() {}\n",
8959 Alignment);
8960 verifyFormat("int a, b = 1;\n"
8961 "int c = 2;\n"
8962 "int dd = 3;\n",
8963 Alignment);
8964 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n"
8965 "float b[1][] = {{3.f}};\n",
8966 Alignment);
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00008967 verifyFormat("for (int i = 0; i < 1; i++)\n"
8968 " int x = 1;\n",
8969 Alignment);
8970 verifyFormat("for (i = 0; i < 1; i++)\n"
8971 " x = 1;\n"
8972 "y = 1;\n",
8973 Alignment);
Daniel Jaspera44991332015-04-29 13:06:49 +00008974}
8975
Daniel Jaspere12597c2015-10-01 10:06:54 +00008976TEST_F(FormatTest, AlignConsecutiveDeclarations) {
8977 FormatStyle Alignment = getLLVMStyle();
8978 Alignment.AlignConsecutiveDeclarations = false;
8979 verifyFormat("float const a = 5;\n"
8980 "int oneTwoThree = 123;",
8981 Alignment);
8982 verifyFormat("int a = 5;\n"
8983 "float const oneTwoThree = 123;",
8984 Alignment);
8985
8986 Alignment.AlignConsecutiveDeclarations = true;
8987 verifyFormat("float const a = 5;\n"
8988 "int oneTwoThree = 123;",
8989 Alignment);
8990 verifyFormat("int a = method();\n"
8991 "float const oneTwoThree = 133;",
8992 Alignment);
8993 verifyFormat("int i = 1, j = 10;\n"
8994 "something = 2000;",
8995 Alignment);
8996 verifyFormat("something = 2000;\n"
8997 "int i = 1, j = 10;\n",
8998 Alignment);
8999 verifyFormat("float something = 2000;\n"
9000 "double another = 911;\n"
9001 "int i = 1, j = 10;\n"
9002 "const int *oneMore = 1;\n"
9003 "unsigned i = 2;",
9004 Alignment);
9005 verifyFormat("float a = 5;\n"
9006 "int one = 1;\n"
9007 "method();\n"
9008 "const double oneTwoThree = 123;\n"
9009 "const unsigned int oneTwo = 12;",
9010 Alignment);
9011 verifyFormat("int oneTwoThree{0}; // comment\n"
9012 "unsigned oneTwo; // comment",
9013 Alignment);
9014 EXPECT_EQ("float const a = 5;\n"
9015 "\n"
9016 "int oneTwoThree = 123;",
9017 format("float const a = 5;\n"
9018 "\n"
9019 "int oneTwoThree= 123;",
9020 Alignment));
9021 EXPECT_EQ("float a = 5;\n"
9022 "int one = 1;\n"
9023 "\n"
9024 "unsigned oneTwoThree = 123;",
9025 format("float a = 5;\n"
9026 "int one = 1;\n"
9027 "\n"
9028 "unsigned oneTwoThree = 123;",
9029 Alignment));
9030 EXPECT_EQ("float a = 5;\n"
9031 "int one = 1;\n"
9032 "\n"
9033 "unsigned oneTwoThree = 123;\n"
9034 "int oneTwo = 12;",
9035 format("float a = 5;\n"
9036 "int one = 1;\n"
9037 "\n"
9038 "unsigned oneTwoThree = 123;\n"
9039 "int oneTwo = 12;",
9040 Alignment));
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00009041 // Function prototype alignment
9042 verifyFormat("int a();\n"
9043 "double b();",
9044 Alignment);
9045 verifyFormat("int a(int x);\n"
9046 "double b();",
9047 Alignment);
9048 unsigned OldColumnLimit = Alignment.ColumnLimit;
9049 // We need to set ColumnLimit to zero, in order to stress nested alignments,
9050 // otherwise the function parameters will be re-flowed onto a single line.
9051 Alignment.ColumnLimit = 0;
9052 EXPECT_EQ("int a(int x,\n"
9053 " float y);\n"
9054 "double b(int x,\n"
9055 " double y);",
9056 format("int a(int x,\n"
9057 " float y);\n"
9058 "double b(int x,\n"
9059 " double y);",
9060 Alignment));
9061 // This ensures that function parameters of function declarations are
9062 // correctly indented when their owning functions are indented.
9063 // The failure case here is for 'double y' to not be indented enough.
9064 EXPECT_EQ("double a(int x);\n"
9065 "int b(int y,\n"
9066 " double z);",
9067 format("double a(int x);\n"
9068 "int b(int y,\n"
9069 " double z);",
9070 Alignment));
9071 // Set ColumnLimit low so that we induce wrapping immediately after
9072 // the function name and opening paren.
9073 Alignment.ColumnLimit = 13;
9074 verifyFormat("int function(\n"
9075 " int x,\n"
9076 " bool y);",
9077 Alignment);
9078 Alignment.ColumnLimit = OldColumnLimit;
9079 // Ensure function pointers don't screw up recursive alignment
9080 verifyFormat("int a(int x, void (*fp)(int y));\n"
9081 "double b();",
9082 Alignment);
Daniel Jaspere12597c2015-10-01 10:06:54 +00009083 Alignment.AlignConsecutiveAssignments = true;
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00009084 // Ensure recursive alignment is broken by function braces, so that the
9085 // "a = 1" does not align with subsequent assignments inside the function
9086 // body.
9087 verifyFormat("int func(int a = 1) {\n"
9088 " int b = 2;\n"
9089 " int cc = 3;\n"
9090 "}",
9091 Alignment);
Daniel Jaspere12597c2015-10-01 10:06:54 +00009092 verifyFormat("float something = 2000;\n"
9093 "double another = 911;\n"
9094 "int i = 1, j = 10;\n"
9095 "const int *oneMore = 1;\n"
9096 "unsigned i = 2;",
9097 Alignment);
9098 verifyFormat("int oneTwoThree = {0}; // comment\n"
9099 "unsigned oneTwo = 0; // comment",
9100 Alignment);
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00009101 // Make sure that scope is correctly tracked, in the absence of braces
9102 verifyFormat("for (int i = 0; i < n; i++)\n"
9103 " j = i;\n"
9104 "double x = 1;\n",
9105 Alignment);
9106 verifyFormat("if (int i = 0)\n"
9107 " j = i;\n"
9108 "double x = 1;\n",
9109 Alignment);
9110 // Ensure operator[] and operator() are comprehended
9111 verifyFormat("struct test {\n"
9112 " long long int foo();\n"
9113 " int operator[](int a);\n"
9114 " double bar();\n"
9115 "};\n",
9116 Alignment);
9117 verifyFormat("struct test {\n"
9118 " long long int foo();\n"
9119 " int operator()(int a);\n"
9120 " double bar();\n"
9121 "};\n",
9122 Alignment);
Daniel Jaspere12597c2015-10-01 10:06:54 +00009123 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
9124 " int const i = 1;\n"
9125 " int * j = 2;\n"
9126 " int big = 10000;\n"
9127 "\n"
9128 " unsigned oneTwoThree = 123;\n"
9129 " int oneTwo = 12;\n"
9130 " method();\n"
9131 " float k = 2;\n"
9132 " int ll = 10000;\n"
9133 "}",
9134 format("void SomeFunction(int parameter= 0) {\n"
9135 " int const i= 1;\n"
9136 " int *j=2;\n"
9137 " int big = 10000;\n"
9138 "\n"
9139 "unsigned oneTwoThree =123;\n"
9140 "int oneTwo = 12;\n"
9141 " method();\n"
9142 "float k= 2;\n"
9143 "int ll=10000;\n"
9144 "}",
9145 Alignment));
9146 Alignment.AlignConsecutiveAssignments = false;
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +00009147 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
9148 verifyFormat("#define A \\\n"
9149 " int aaaa = 12; \\\n"
9150 " float b = 23; \\\n"
9151 " const int ccc = 234; \\\n"
9152 " unsigned dddddddddd = 2345;",
9153 Alignment);
9154 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
Daniel Jaspere12597c2015-10-01 10:06:54 +00009155 verifyFormat("#define A \\\n"
9156 " int aaaa = 12; \\\n"
9157 " float b = 23; \\\n"
9158 " const int ccc = 234; \\\n"
9159 " unsigned dddddddddd = 2345;",
9160 Alignment);
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +00009161 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
Daniel Jaspere12597c2015-10-01 10:06:54 +00009162 Alignment.ColumnLimit = 30;
9163 verifyFormat("#define A \\\n"
9164 " int aaaa = 12; \\\n"
9165 " float b = 23; \\\n"
9166 " const int ccc = 234; \\\n"
9167 " int dddddddddd = 2345;",
9168 Alignment);
9169 Alignment.ColumnLimit = 80;
9170 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
9171 "k = 4, int l = 5,\n"
9172 " int m = 6) {\n"
9173 " const int j = 10;\n"
9174 " otherThing = 1;\n"
9175 "}",
9176 Alignment);
9177 verifyFormat("void SomeFunction(int parameter = 0) {\n"
9178 " int const i = 1;\n"
9179 " int * j = 2;\n"
9180 " int big = 10000;\n"
9181 "}",
9182 Alignment);
9183 verifyFormat("class C {\n"
9184 "public:\n"
9185 " int i = 1;\n"
9186 " virtual void f() = 0;\n"
9187 "};",
9188 Alignment);
9189 verifyFormat("float i = 1;\n"
9190 "if (SomeType t = getSomething()) {\n"
9191 "}\n"
9192 "const unsigned j = 2;\n"
9193 "int big = 10000;",
9194 Alignment);
9195 verifyFormat("float j = 7;\n"
9196 "for (int k = 0; k < N; ++k) {\n"
9197 "}\n"
9198 "unsigned j = 2;\n"
9199 "int big = 10000;\n"
9200 "}",
9201 Alignment);
9202 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
9203 verifyFormat("float i = 1;\n"
9204 "LooooooooooongType loooooooooooooooooooooongVariable\n"
9205 " = someLooooooooooooooooongFunction();\n"
9206 "int j = 2;",
9207 Alignment);
9208 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
9209 verifyFormat("int i = 1;\n"
9210 "LooooooooooongType loooooooooooooooooooooongVariable =\n"
9211 " someLooooooooooooooooongFunction();\n"
9212 "int j = 2;",
9213 Alignment);
Daniel Jasper39828252015-10-07 15:03:26 +00009214
9215 Alignment.AlignConsecutiveAssignments = true;
9216 verifyFormat("auto lambda = []() {\n"
9217 " auto ii = 0;\n"
9218 " float j = 0;\n"
9219 " return 0;\n"
9220 "};\n"
9221 "int i = 0;\n"
9222 "float i2 = 0;\n"
9223 "auto v = type{\n"
9224 " i = 1, //\n"
9225 " (i = 2), //\n"
9226 " i = 3 //\n"
9227 "};",
9228 Alignment);
9229 Alignment.AlignConsecutiveAssignments = false;
9230
Daniel Jaspere12597c2015-10-01 10:06:54 +00009231 verifyFormat(
9232 "int i = 1;\n"
9233 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
9234 " loooooooooooooooooooooongParameterB);\n"
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00009235 "int j = 2;",
Daniel Jaspere12597c2015-10-01 10:06:54 +00009236 Alignment);
9237
9238 // Test interactions with ColumnLimit and AlignConsecutiveAssignments:
9239 // We expect declarations and assignments to align, as long as it doesn't
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00009240 // exceed the column limit, starting a new alignment sequence whenever it
Daniel Jaspere12597c2015-10-01 10:06:54 +00009241 // happens.
9242 Alignment.AlignConsecutiveAssignments = true;
9243 Alignment.ColumnLimit = 30;
9244 verifyFormat("float ii = 1;\n"
9245 "unsigned j = 2;\n"
9246 "int someVerylongVariable = 1;\n"
9247 "AnotherLongType ll = 123456;\n"
9248 "VeryVeryLongType k = 2;\n"
9249 "int myvar = 1;",
9250 Alignment);
9251 Alignment.ColumnLimit = 80;
Daniel Jasperec90e512015-12-01 12:00:43 +00009252 Alignment.AlignConsecutiveAssignments = false;
9253
9254 verifyFormat(
9255 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n"
9256 " typename LongType, typename B>\n"
9257 "auto foo() {}\n",
9258 Alignment);
9259 verifyFormat("float a, b = 1;\n"
9260 "int c = 2;\n"
9261 "int dd = 3;\n",
9262 Alignment);
9263 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n"
9264 "float b[1][] = {{3.f}};\n",
9265 Alignment);
9266 Alignment.AlignConsecutiveAssignments = true;
9267 verifyFormat("float a, b = 1;\n"
9268 "int c = 2;\n"
9269 "int dd = 3;\n",
9270 Alignment);
9271 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n"
9272 "float b[1][] = {{3.f}};\n",
9273 Alignment);
9274 Alignment.AlignConsecutiveAssignments = false;
9275
9276 Alignment.ColumnLimit = 30;
9277 Alignment.BinPackParameters = false;
9278 verifyFormat("void foo(float a,\n"
9279 " float b,\n"
9280 " int c,\n"
9281 " uint32_t *d) {\n"
9282 " int * e = 0;\n"
9283 " float f = 0;\n"
9284 " double g = 0;\n"
9285 "}\n"
9286 "void bar(ino_t a,\n"
9287 " int b,\n"
9288 " uint32_t *c,\n"
9289 " bool d) {}\n",
9290 Alignment);
9291 Alignment.BinPackParameters = true;
9292 Alignment.ColumnLimit = 80;
Daniel Jasper4917af62017-08-25 19:14:53 +00009293
9294 // Bug 33507
9295 Alignment.PointerAlignment = FormatStyle::PAS_Middle;
9296 verifyFormat(
9297 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n"
9298 " static const Version verVs2017;\n"
9299 " return true;\n"
9300 "});\n",
9301 Alignment);
9302 Alignment.PointerAlignment = FormatStyle::PAS_Right;
Daniel Jaspere12597c2015-10-01 10:06:54 +00009303}
9304
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009305TEST_F(FormatTest, LinuxBraceBreaking) {
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009306 FormatStyle LinuxBraceStyle = getLLVMStyle();
9307 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009308 verifyFormat("namespace a\n"
9309 "{\n"
9310 "class A\n"
9311 "{\n"
9312 " void f()\n"
9313 " {\n"
9314 " if (true) {\n"
9315 " a();\n"
9316 " b();\n"
Daniel Jasper96cbb502015-12-14 08:33:07 +00009317 " } else {\n"
9318 " a();\n"
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009319 " }\n"
9320 " }\n"
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00009321 " void g() { return; }\n"
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009322 "};\n"
9323 "struct B {\n"
9324 " int x;\n"
9325 "};\n"
9326 "}\n",
9327 LinuxBraceStyle);
9328 verifyFormat("enum X {\n"
9329 " Y = 0,\n"
9330 "}\n",
9331 LinuxBraceStyle);
9332 verifyFormat("struct S {\n"
9333 " int Type;\n"
9334 " union {\n"
9335 " int x;\n"
9336 " double y;\n"
9337 " } Value;\n"
9338 " class C\n"
9339 " {\n"
9340 " MyFavoriteType Value;\n"
9341 " } Class;\n"
9342 "}\n",
9343 LinuxBraceStyle);
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009344}
9345
Birunthan Mohanathas305fa9c2015-07-12 03:13:54 +00009346TEST_F(FormatTest, MozillaBraceBreaking) {
9347 FormatStyle MozillaBraceStyle = getLLVMStyle();
9348 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00009349 MozillaBraceStyle.FixNamespaceComments = false;
Birunthan Mohanathas305fa9c2015-07-12 03:13:54 +00009350 verifyFormat("namespace a {\n"
9351 "class A\n"
9352 "{\n"
9353 " void f()\n"
9354 " {\n"
9355 " if (true) {\n"
9356 " a();\n"
9357 " b();\n"
9358 " }\n"
9359 " }\n"
9360 " void g() { return; }\n"
9361 "};\n"
9362 "enum E\n"
9363 "{\n"
9364 " A,\n"
9365 " // foo\n"
9366 " B,\n"
9367 " C\n"
9368 "};\n"
9369 "struct B\n"
9370 "{\n"
9371 " int x;\n"
9372 "};\n"
9373 "}\n",
9374 MozillaBraceStyle);
9375 verifyFormat("struct S\n"
9376 "{\n"
9377 " int Type;\n"
9378 " union\n"
9379 " {\n"
9380 " int x;\n"
9381 " double y;\n"
9382 " } Value;\n"
9383 " class C\n"
9384 " {\n"
9385 " MyFavoriteType Value;\n"
9386 " } Class;\n"
9387 "}\n",
9388 MozillaBraceStyle);
9389}
9390
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009391TEST_F(FormatTest, StroustrupBraceBreaking) {
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009392 FormatStyle StroustrupBraceStyle = getLLVMStyle();
9393 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009394 verifyFormat("namespace a {\n"
9395 "class A {\n"
9396 " void f()\n"
9397 " {\n"
9398 " if (true) {\n"
9399 " a();\n"
9400 " b();\n"
9401 " }\n"
9402 " }\n"
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00009403 " void g() { return; }\n"
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009404 "};\n"
9405 "struct B {\n"
9406 " int x;\n"
9407 "};\n"
Krasimir Georgiev9163fe22017-03-02 09:54:44 +00009408 "} // namespace a\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009409 StroustrupBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009410
Daniel Jasperd9670872014-08-05 12:06:20 +00009411 verifyFormat("void foo()\n"
9412 "{\n"
9413 " if (a) {\n"
9414 " a();\n"
9415 " }\n"
9416 " else {\n"
9417 " b();\n"
9418 " }\n"
9419 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009420 StroustrupBraceStyle);
Daniel Jasperd9670872014-08-05 12:06:20 +00009421
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009422 verifyFormat("#ifdef _DEBUG\n"
9423 "int foo(int i = 0)\n"
9424 "#else\n"
9425 "int foo(int i = 5)\n"
9426 "#endif\n"
9427 "{\n"
9428 " return i;\n"
9429 "}",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009430 StroustrupBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009431
9432 verifyFormat("void foo() {}\n"
9433 "void bar()\n"
9434 "#ifdef _DEBUG\n"
9435 "{\n"
9436 " foo();\n"
9437 "}\n"
9438 "#else\n"
9439 "{\n"
9440 "}\n"
9441 "#endif",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009442 StroustrupBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009443
9444 verifyFormat("void foobar() { int i = 5; }\n"
9445 "#ifdef _DEBUG\n"
9446 "void bar() {}\n"
9447 "#else\n"
9448 "void bar() { foobar(); }\n"
9449 "#endif",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009450 StroustrupBraceStyle);
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009451}
9452
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00009453TEST_F(FormatTest, AllmanBraceBreaking) {
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009454 FormatStyle AllmanBraceStyle = getLLVMStyle();
9455 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00009456 verifyFormat("namespace a\n"
9457 "{\n"
9458 "class A\n"
9459 "{\n"
9460 " void f()\n"
9461 " {\n"
9462 " if (true)\n"
9463 " {\n"
9464 " a();\n"
9465 " b();\n"
9466 " }\n"
9467 " }\n"
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00009468 " void g() { return; }\n"
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009469 "};\n"
9470 "struct B\n"
9471 "{\n"
9472 " int x;\n"
9473 "};\n"
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00009474 "}",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009475 AllmanBraceStyle);
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00009476
9477 verifyFormat("void f()\n"
9478 "{\n"
9479 " if (true)\n"
9480 " {\n"
9481 " a();\n"
9482 " }\n"
9483 " else if (false)\n"
9484 " {\n"
9485 " b();\n"
9486 " }\n"
9487 " else\n"
9488 " {\n"
9489 " c();\n"
9490 " }\n"
9491 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009492 AllmanBraceStyle);
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00009493
9494 verifyFormat("void f()\n"
9495 "{\n"
9496 " for (int i = 0; i < 10; ++i)\n"
9497 " {\n"
9498 " a();\n"
9499 " }\n"
9500 " while (false)\n"
9501 " {\n"
9502 " b();\n"
9503 " }\n"
9504 " do\n"
9505 " {\n"
9506 " c();\n"
9507 " } while (false)\n"
9508 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009509 AllmanBraceStyle);
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00009510
9511 verifyFormat("void f(int a)\n"
9512 "{\n"
9513 " switch (a)\n"
9514 " {\n"
9515 " case 0:\n"
9516 " break;\n"
9517 " case 1:\n"
9518 " {\n"
9519 " break;\n"
9520 " }\n"
9521 " case 2:\n"
9522 " {\n"
9523 " }\n"
9524 " break;\n"
9525 " default:\n"
9526 " break;\n"
9527 " }\n"
9528 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009529 AllmanBraceStyle);
Manuel Klimeka027f302013-08-07 19:20:45 +00009530
9531 verifyFormat("enum X\n"
9532 "{\n"
9533 " Y = 0,\n"
9534 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009535 AllmanBraceStyle);
Daniel Jaspere18ff372014-06-02 10:17:32 +00009536 verifyFormat("enum X\n"
9537 "{\n"
9538 " Y = 0\n"
9539 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009540 AllmanBraceStyle);
Manuel Klimeka027f302013-08-07 19:20:45 +00009541
Dinesh Dwivediea3aca82014-05-02 17:01:46 +00009542 verifyFormat("@interface BSApplicationController ()\n"
9543 "{\n"
9544 "@private\n"
9545 " id _extraIvar;\n"
9546 "}\n"
9547 "@end\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009548 AllmanBraceStyle);
Dinesh Dwivediea3aca82014-05-02 17:01:46 +00009549
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009550 verifyFormat("#ifdef _DEBUG\n"
9551 "int foo(int i = 0)\n"
9552 "#else\n"
9553 "int foo(int i = 5)\n"
9554 "#endif\n"
9555 "{\n"
9556 " return i;\n"
9557 "}",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009558 AllmanBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009559
9560 verifyFormat("void foo() {}\n"
9561 "void bar()\n"
9562 "#ifdef _DEBUG\n"
9563 "{\n"
9564 " foo();\n"
9565 "}\n"
9566 "#else\n"
9567 "{\n"
9568 "}\n"
9569 "#endif",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009570 AllmanBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009571
9572 verifyFormat("void foobar() { int i = 5; }\n"
9573 "#ifdef _DEBUG\n"
9574 "void bar() {}\n"
9575 "#else\n"
9576 "void bar() { foobar(); }\n"
9577 "#endif",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009578 AllmanBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009579
Daniel Jasperba1b6bb2014-05-26 07:24:34 +00009580 // This shouldn't affect ObjC blocks..
Daniel Jasper565ed5e2014-05-22 13:53:55 +00009581 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +00009582 " // ...\n"
9583 " int i;\n"
Daniel Jasperba1b6bb2014-05-26 07:24:34 +00009584 "}];",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009585 AllmanBraceStyle);
Daniel Jasper565ed5e2014-05-22 13:53:55 +00009586 verifyFormat("void (^block)(void) = ^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +00009587 " // ...\n"
9588 " int i;\n"
Daniel Jasperba1b6bb2014-05-26 07:24:34 +00009589 "};",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009590 AllmanBraceStyle);
Daniel Jasperba1b6bb2014-05-26 07:24:34 +00009591 // .. or dict literals.
9592 verifyFormat("void f()\n"
9593 "{\n"
Alexander Kornienkod4fa2e62017-04-11 09:55:00 +00009594 " // ...\n"
9595 " [object someMethod:@{@\"a\" : @\"b\"}];\n"
9596 "}",
9597 AllmanBraceStyle);
9598 verifyFormat("void f()\n"
9599 "{\n"
9600 " // ...\n"
9601 " [object someMethod:@{a : @\"b\"}];\n"
Daniel Jasperba1b6bb2014-05-26 07:24:34 +00009602 "}",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009603 AllmanBraceStyle);
Daniel Jasper55aed672014-12-07 16:44:49 +00009604 verifyFormat("int f()\n"
9605 "{ // comment\n"
9606 " return 42;\n"
9607 "}",
9608 AllmanBraceStyle);
Daniel Jasper565ed5e2014-05-22 13:53:55 +00009609
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009610 AllmanBraceStyle.ColumnLimit = 19;
9611 verifyFormat("void f() { int i; }", AllmanBraceStyle);
9612 AllmanBraceStyle.ColumnLimit = 18;
Daniel Jasper234379f2013-12-24 13:31:25 +00009613 verifyFormat("void f()\n"
9614 "{\n"
9615 " int i;\n"
9616 "}",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009617 AllmanBraceStyle);
9618 AllmanBraceStyle.ColumnLimit = 80;
Daniel Jasper234379f2013-12-24 13:31:25 +00009619
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009620 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle;
Manuel Klimeka027f302013-08-07 19:20:45 +00009621 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = true;
9622 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
9623 verifyFormat("void f(bool b)\n"
9624 "{\n"
9625 " if (b)\n"
9626 " {\n"
9627 " return;\n"
9628 " }\n"
9629 "}\n",
9630 BreakBeforeBraceShortIfs);
9631 verifyFormat("void f(bool b)\n"
9632 "{\n"
Daniel Jasper6a7d5a72017-06-19 07:40:49 +00009633 " if constexpr (b)\n"
9634 " {\n"
9635 " return;\n"
9636 " }\n"
9637 "}\n",
9638 BreakBeforeBraceShortIfs);
9639 verifyFormat("void f(bool b)\n"
9640 "{\n"
Manuel Klimeka027f302013-08-07 19:20:45 +00009641 " if (b) return;\n"
9642 "}\n",
9643 BreakBeforeBraceShortIfs);
9644 verifyFormat("void f(bool b)\n"
9645 "{\n"
Daniel Jasper6a7d5a72017-06-19 07:40:49 +00009646 " if constexpr (b) return;\n"
9647 "}\n",
9648 BreakBeforeBraceShortIfs);
9649 verifyFormat("void f(bool b)\n"
9650 "{\n"
Manuel Klimeka027f302013-08-07 19:20:45 +00009651 " while (b)\n"
9652 " {\n"
9653 " return;\n"
9654 " }\n"
9655 "}\n",
9656 BreakBeforeBraceShortIfs);
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00009657}
9658
Alexander Kornienko3a33f022013-12-12 09:49:52 +00009659TEST_F(FormatTest, GNUBraceBreaking) {
9660 FormatStyle GNUBraceStyle = getLLVMStyle();
9661 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU;
9662 verifyFormat("namespace a\n"
9663 "{\n"
9664 "class A\n"
9665 "{\n"
9666 " void f()\n"
9667 " {\n"
9668 " int a;\n"
9669 " {\n"
9670 " int b;\n"
9671 " }\n"
9672 " if (true)\n"
9673 " {\n"
9674 " a();\n"
9675 " b();\n"
9676 " }\n"
9677 " }\n"
9678 " void g() { return; }\n"
9679 "}\n"
9680 "}",
9681 GNUBraceStyle);
9682
9683 verifyFormat("void f()\n"
9684 "{\n"
9685 " if (true)\n"
9686 " {\n"
9687 " a();\n"
9688 " }\n"
9689 " else if (false)\n"
9690 " {\n"
9691 " b();\n"
9692 " }\n"
9693 " else\n"
9694 " {\n"
9695 " c();\n"
9696 " }\n"
9697 "}\n",
9698 GNUBraceStyle);
9699
9700 verifyFormat("void f()\n"
9701 "{\n"
9702 " for (int i = 0; i < 10; ++i)\n"
9703 " {\n"
9704 " a();\n"
9705 " }\n"
9706 " while (false)\n"
9707 " {\n"
9708 " b();\n"
9709 " }\n"
9710 " do\n"
9711 " {\n"
9712 " c();\n"
9713 " }\n"
9714 " while (false);\n"
9715 "}\n",
9716 GNUBraceStyle);
9717
9718 verifyFormat("void f(int a)\n"
9719 "{\n"
9720 " switch (a)\n"
9721 " {\n"
9722 " case 0:\n"
9723 " break;\n"
9724 " case 1:\n"
9725 " {\n"
9726 " break;\n"
9727 " }\n"
9728 " case 2:\n"
9729 " {\n"
9730 " }\n"
9731 " break;\n"
9732 " default:\n"
9733 " break;\n"
9734 " }\n"
9735 "}\n",
9736 GNUBraceStyle);
9737
9738 verifyFormat("enum X\n"
9739 "{\n"
9740 " Y = 0,\n"
9741 "}\n",
9742 GNUBraceStyle);
Dinesh Dwivediea3aca82014-05-02 17:01:46 +00009743
9744 verifyFormat("@interface BSApplicationController ()\n"
9745 "{\n"
9746 "@private\n"
9747 " id _extraIvar;\n"
9748 "}\n"
9749 "@end\n",
9750 GNUBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009751
9752 verifyFormat("#ifdef _DEBUG\n"
9753 "int foo(int i = 0)\n"
9754 "#else\n"
9755 "int foo(int i = 5)\n"
9756 "#endif\n"
9757 "{\n"
9758 " return i;\n"
9759 "}",
9760 GNUBraceStyle);
9761
9762 verifyFormat("void foo() {}\n"
9763 "void bar()\n"
9764 "#ifdef _DEBUG\n"
9765 "{\n"
9766 " foo();\n"
9767 "}\n"
9768 "#else\n"
9769 "{\n"
9770 "}\n"
9771 "#endif",
9772 GNUBraceStyle);
9773
9774 verifyFormat("void foobar() { int i = 5; }\n"
9775 "#ifdef _DEBUG\n"
9776 "void bar() {}\n"
9777 "#else\n"
9778 "void bar() { foobar(); }\n"
9779 "#endif",
9780 GNUBraceStyle);
Alexander Kornienko3a33f022013-12-12 09:49:52 +00009781}
Roman Kashitsyn291f64f2015-08-10 13:43:19 +00009782
9783TEST_F(FormatTest, WebKitBraceBreaking) {
9784 FormatStyle WebKitBraceStyle = getLLVMStyle();
9785 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit;
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00009786 WebKitBraceStyle.FixNamespaceComments = false;
Roman Kashitsyn291f64f2015-08-10 13:43:19 +00009787 verifyFormat("namespace a {\n"
9788 "class A {\n"
9789 " void f()\n"
9790 " {\n"
9791 " if (true) {\n"
9792 " a();\n"
9793 " b();\n"
9794 " }\n"
9795 " }\n"
9796 " void g() { return; }\n"
9797 "};\n"
9798 "enum E {\n"
9799 " A,\n"
9800 " // foo\n"
9801 " B,\n"
9802 " C\n"
9803 "};\n"
9804 "struct B {\n"
9805 " int x;\n"
9806 "};\n"
9807 "}\n",
9808 WebKitBraceStyle);
9809 verifyFormat("struct S {\n"
9810 " int Type;\n"
9811 " union {\n"
9812 " int x;\n"
9813 " double y;\n"
9814 " } Value;\n"
9815 " class C {\n"
9816 " MyFavoriteType Value;\n"
9817 " } Class;\n"
9818 "};\n",
9819 WebKitBraceStyle);
9820}
9821
Manuel Klimekd5735502013-08-12 03:51:17 +00009822TEST_F(FormatTest, CatchExceptionReferenceBinding) {
9823 verifyFormat("void f() {\n"
9824 " try {\n"
Daniel Jasper04a71a42014-05-08 11:58:24 +00009825 " } catch (const Exception &e) {\n"
Manuel Klimekd5735502013-08-12 03:51:17 +00009826 " }\n"
9827 "}\n",
9828 getLLVMStyle());
9829}
9830
Daniel Jasper9613c812013-08-07 16:29:23 +00009831TEST_F(FormatTest, UnderstandsPragmas) {
9832 verifyFormat("#pragma omp reduction(| : var)");
9833 verifyFormat("#pragma omp reduction(+ : var)");
Daniel Jasperdc32c1b2014-01-09 13:56:49 +00009834
9835 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
9836 "(including parentheses).",
9837 format("#pragma mark Any non-hyphenated or hyphenated string "
9838 "(including parentheses)."));
Daniel Jasper9613c812013-08-07 16:29:23 +00009839}
9840
Daniel Jasperee4a8a12015-04-22 09:45:42 +00009841TEST_F(FormatTest, UnderstandPragmaOption) {
9842 verifyFormat("#pragma option -C -A");
9843
9844 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A"));
9845}
9846
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009847#define EXPECT_ALL_STYLES_EQUAL(Styles) \
9848 for (size_t i = 1; i < Styles.size(); ++i) \
Daniel Jaspera44991332015-04-29 13:06:49 +00009849 EXPECT_EQ(Styles[0], Styles[i]) << "Style #" << i << " of " << Styles.size() \
9850 << " differs from Style #0"
Alexander Kornienkod6538332013-05-07 15:32:14 +00009851
9852TEST_F(FormatTest, GetsPredefinedStyleByName) {
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009853 SmallVector<FormatStyle, 3> Styles;
9854 Styles.resize(3);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009855
Alexander Kornienko006b5c82013-05-19 00:53:30 +00009856 Styles[0] = getLLVMStyle();
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009857 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
9858 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
9859 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009860
Alexander Kornienko006b5c82013-05-19 00:53:30 +00009861 Styles[0] = getGoogleStyle();
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009862 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
9863 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
9864 EXPECT_ALL_STYLES_EQUAL(Styles);
9865
Nico Weber514ecc82014-02-02 20:50:45 +00009866 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009867 EXPECT_TRUE(
9868 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
9869 EXPECT_TRUE(
9870 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
9871 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009872
Nico Weber514ecc82014-02-02 20:50:45 +00009873 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009874 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
9875 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
9876 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienko006b5c82013-05-19 00:53:30 +00009877
9878 Styles[0] = getMozillaStyle();
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009879 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
9880 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
9881 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienko006b5c82013-05-19 00:53:30 +00009882
Daniel Jasperffefb3d2013-07-24 13:10:59 +00009883 Styles[0] = getWebKitStyle();
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009884 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
9885 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
9886 EXPECT_ALL_STYLES_EQUAL(Styles);
Daniel Jasperffefb3d2013-07-24 13:10:59 +00009887
Alexander Kornienkofe7a57f2013-12-10 15:42:15 +00009888 Styles[0] = getGNUStyle();
9889 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
9890 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
9891 EXPECT_ALL_STYLES_EQUAL(Styles);
9892
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009893 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
9894}
9895
9896TEST_F(FormatTest, GetsCorrectBasedOnStyle) {
9897 SmallVector<FormatStyle, 8> Styles;
9898 Styles.resize(2);
9899
9900 Styles[0] = getGoogleStyle();
9901 Styles[1] = getLLVMStyle();
9902 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
9903 EXPECT_ALL_STYLES_EQUAL(Styles);
9904
9905 Styles.resize(5);
Nico Weber514ecc82014-02-02 20:50:45 +00009906 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009907 Styles[1] = getLLVMStyle();
9908 Styles[1].Language = FormatStyle::LK_JavaScript;
9909 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
9910
9911 Styles[2] = getLLVMStyle();
9912 Styles[2].Language = FormatStyle::LK_JavaScript;
9913 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
9914 "BasedOnStyle: Google",
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00009915 &Styles[2])
9916 .value());
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009917
9918 Styles[3] = getLLVMStyle();
9919 Styles[3].Language = FormatStyle::LK_JavaScript;
9920 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
9921 "Language: JavaScript",
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00009922 &Styles[3])
9923 .value());
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009924
9925 Styles[4] = getLLVMStyle();
9926 Styles[4].Language = FormatStyle::LK_JavaScript;
9927 EXPECT_EQ(0, parseConfiguration("---\n"
9928 "BasedOnStyle: LLVM\n"
9929 "IndentWidth: 123\n"
9930 "---\n"
9931 "BasedOnStyle: Google\n"
9932 "Language: JavaScript",
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00009933 &Styles[4])
9934 .value());
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009935 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009936}
9937
Daniel Jasper91881d92014-09-29 08:07:46 +00009938#define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \
Alexander Kornienkod6538332013-05-07 15:32:14 +00009939 Style.FIELD = false; \
Daniel Jasper91881d92014-09-29 08:07:46 +00009940 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \
Alexander Kornienko006b5c82013-05-19 00:53:30 +00009941 EXPECT_TRUE(Style.FIELD); \
Daniel Jasper91881d92014-09-29 08:07:46 +00009942 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \
Patrik Hagglund76aca642013-05-14 07:53:53 +00009943 EXPECT_FALSE(Style.FIELD);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009944
Daniel Jasper91881d92014-09-29 08:07:46 +00009945#define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
9946
Daniel Jasperc1bc38e2015-09-29 14:57:55 +00009947#define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \
9948 Style.STRUCT.FIELD = false; \
9949 EXPECT_EQ(0, \
9950 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \
9951 .value()); \
9952 EXPECT_TRUE(Style.STRUCT.FIELD); \
9953 EXPECT_EQ(0, \
9954 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \
9955 .value()); \
9956 EXPECT_FALSE(Style.STRUCT.FIELD);
9957
9958#define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \
9959 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD)
9960
Daniel Jasper00853002014-09-16 16:22:30 +00009961#define CHECK_PARSE(TEXT, FIELD, VALUE) \
9962 EXPECT_NE(VALUE, Style.FIELD); \
9963 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \
9964 EXPECT_EQ(VALUE, Style.FIELD)
9965
Alexander Kornienkoc6221a52014-08-14 13:07:35 +00009966TEST_F(FormatTest, ParsesConfigurationBools) {
Alexander Kornienkocabdd732013-11-29 15:19:43 +00009967 FormatStyle Style = {};
9968 Style.Language = FormatStyle::LK_Cpp;
Daniel Jasper3219e432014-12-02 13:24:51 +00009969 CHECK_PARSE_BOOL(AlignOperands);
Daniel Jasper552f4a72013-07-31 23:55:15 +00009970 CHECK_PARSE_BOOL(AlignTrailingComments);
Daniel Jaspera44991332015-04-29 13:06:49 +00009971 CHECK_PARSE_BOOL(AlignConsecutiveAssignments);
Daniel Jaspere12597c2015-10-01 10:06:54 +00009972 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009973 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
Daniel Jasper17605d32014-05-14 09:33:35 +00009974 CHECK_PARSE_BOOL(AllowShortBlocksOnASingleLine);
Daniel Jasperb87899b2014-09-10 13:11:45 +00009975 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009976 CHECK_PARSE_BOOL(AllowShortIfStatementsOnASingleLine);
Daniel Jasper997af662013-05-16 12:16:23 +00009977 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
Daniel Jasper61e6bbf2013-05-29 12:07:31 +00009978 CHECK_PARSE_BOOL(AlwaysBreakTemplateDeclarations);
Daniel Jasper18210d72014-10-09 09:52:05 +00009979 CHECK_PARSE_BOOL(BinPackArguments);
Daniel Jasper6501f7e2015-10-27 12:38:37 +00009980 CHECK_PARSE_BOOL(BinPackParameters);
Daniel Jaspere1a7b762016-02-01 11:21:02 +00009981 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
Daniel Jasper165b29e2013-11-08 00:57:11 +00009982 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
Daniel Jaspere1a7b762016-02-01 11:21:02 +00009983 CHECK_PARSE_BOOL(BreakStringLiterals);
Andi-Bogdan Postelnicu0ef8ee12017-03-10 15:10:37 +00009984 CHECK_PARSE_BOOL(BreakBeforeInheritanceComma)
Francois Ferrande56a8292017-06-14 12:29:47 +00009985 CHECK_PARSE_BOOL(CompactNamespaces);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009986 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
Daniel Jasper553d4872014-06-17 12:40:34 +00009987 CHECK_PARSE_BOOL(DerivePointerAlignment);
Daniel Jasper91881d92014-09-29 08:07:46 +00009988 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
Daniel Jasperda446772015-11-16 12:38:56 +00009989 CHECK_PARSE_BOOL(DisableFormat);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009990 CHECK_PARSE_BOOL(IndentCaseLabels);
Daniel Jasperc75e1ef2014-07-09 08:42:42 +00009991 CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
Daniel Jaspera26fc5c2014-03-21 13:43:14 +00009992 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
Daniel Jaspere9beea22014-01-28 15:20:33 +00009993 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009994 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
Daniel Jasper6ab54682013-07-16 18:22:10 +00009995 CHECK_PARSE_BOOL(Cpp11BracedListStyle);
Daniel Jaspera0a50392015-12-01 13:28:53 +00009996 CHECK_PARSE_BOOL(ReflowComments);
Daniel Jasperda446772015-11-16 12:38:56 +00009997 CHECK_PARSE_BOOL(SortIncludes);
Krasimir Georgievac16a202017-06-23 11:46:03 +00009998 CHECK_PARSE_BOOL(SortUsingDeclarations);
Daniel Jasperb55acad2013-08-20 12:36:34 +00009999 CHECK_PARSE_BOOL(SpacesInParentheses);
Daniel Jasperad981f82014-08-26 11:41:14 +000010000 CHECK_PARSE_BOOL(SpacesInSquareBrackets);
Daniel Jasperdd978ae2013-10-29 14:52:02 +000010001 CHECK_PARSE_BOOL(SpacesInAngles);
Daniel Jasperb55acad2013-08-20 12:36:34 +000010002 CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
Daniel Jasperb2e10a52014-01-15 15:09:08 +000010003 CHECK_PARSE_BOOL(SpacesInContainerLiterals);
Daniel Jasperb55acad2013-08-20 12:36:34 +000010004 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
Daniel Jasperdb986eb2014-09-03 07:37:29 +000010005 CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
Sylvestre Ledru83bbd572016-08-09 14:24:40 +000010006 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
Daniel Jasperd94bff32013-09-25 15:15:02 +000010007 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
Daniel Jasperc1bc38e2015-09-29 14:57:55 +000010008
10009 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass);
10010 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterControlStatement);
10011 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum);
10012 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction);
10013 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace);
10014 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration);
10015 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct);
10016 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion);
Krasimir Georgievd6ce9372017-09-15 11:23:50 +000010017 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock);
Daniel Jasperc1bc38e2015-09-29 14:57:55 +000010018 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch);
10019 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse);
10020 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces);
Francois Ferrandad722562017-06-30 20:25:55 +000010021 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction);
10022 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord);
10023 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace);
Alexander Kornienkoc6221a52014-08-14 13:07:35 +000010024}
Alexander Kornienkod6538332013-05-07 15:32:14 +000010025
Alexander Kornienkoc6221a52014-08-14 13:07:35 +000010026#undef CHECK_PARSE_BOOL
10027
Alexander Kornienkoc6221a52014-08-14 13:07:35 +000010028TEST_F(FormatTest, ParsesConfiguration) {
10029 FormatStyle Style = {};
10030 Style.Language = FormatStyle::LK_Cpp;
Alexander Kornienkod6538332013-05-07 15:32:14 +000010031 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010032 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
10033 ConstructorInitializerIndentWidth, 1234u);
Daniel Jasper50d634b2014-10-28 16:53:38 +000010034 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010035 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
10036 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
Francois Ferrand9976efa2017-05-22 08:28:17 +000010037 CHECK_PARSE("PenaltyBreakAssignment: 1234",
10038 PenaltyBreakAssignment, 1234u);
Daniel Jasper33b909c2013-10-25 14:29:37 +000010039 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
10040 PenaltyBreakBeforeFirstCallParameter, 1234u);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010041 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
10042 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
10043 PenaltyReturnTypeOnItsOwnLine, 1234u);
10044 CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
10045 SpacesBeforeTrailingComments, 1234u);
Manuel Klimek13b97d82013-05-13 08:42:42 +000010046 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
Daniel Jasper6633ab82013-10-18 10:38:14 +000010047 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
Daniel Jasper9c8ff352016-03-21 14:11:27 +000010048 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
Alexander Kornienkod6538332013-05-07 15:32:14 +000010049
Daniel Jasper553d4872014-06-17 12:40:34 +000010050 Style.PointerAlignment = FormatStyle::PAS_Middle;
Daniel Jasperac043c92014-09-15 11:11:00 +000010051 CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
10052 FormatStyle::PAS_Left);
10053 CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
10054 FormatStyle::PAS_Right);
10055 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
10056 FormatStyle::PAS_Middle);
Daniel Jasper00853002014-09-16 16:22:30 +000010057 // For backward compatibility:
10058 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
10059 FormatStyle::PAS_Left);
10060 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
10061 FormatStyle::PAS_Right);
10062 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
10063 FormatStyle::PAS_Middle);
Daniel Jasper553d4872014-06-17 12:40:34 +000010064
Alexander Kornienkod6538332013-05-07 15:32:14 +000010065 Style.Standard = FormatStyle::LS_Auto;
Alexander Kornienkob40cfe42013-09-04 14:09:13 +000010066 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
10067 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Cpp11);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010068 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
10069 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
10070 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
10071
Daniel Jasperac043c92014-09-15 11:11:00 +000010072 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
Daniel Jasperac043c92014-09-15 11:11:00 +000010073 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
10074 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
Daniel Jasperac043c92014-09-15 11:11:00 +000010075 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
10076 FormatStyle::BOS_None);
10077 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
10078 FormatStyle::BOS_All);
Daniel Jasper00853002014-09-16 16:22:30 +000010079 // For backward compatibility:
10080 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
10081 FormatStyle::BOS_None);
10082 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
10083 FormatStyle::BOS_All);
Daniel Jasperac043c92014-09-15 11:11:00 +000010084
Francois Ferranda6b6d512017-05-24 11:36:58 +000010085 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
10086 CHECK_PARSE("BreakConstructorInitializers: BeforeComma",
10087 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
10088 CHECK_PARSE("BreakConstructorInitializers: AfterColon",
10089 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon);
10090 CHECK_PARSE("BreakConstructorInitializers: BeforeColon",
10091 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon);
10092 // For backward compatibility:
10093 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true",
10094 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
10095
Daniel Jasper6501f7e2015-10-27 12:38:37 +000010096 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
10097 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
10098 FormatStyle::BAS_Align);
10099 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket,
10100 FormatStyle::BAS_DontAlign);
10101 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket,
10102 FormatStyle::BAS_AlwaysBreak);
10103 // For backward compatibility:
10104 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
10105 FormatStyle::BAS_DontAlign);
10106 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
10107 FormatStyle::BAS_Align);
10108
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +000010109 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10110 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines,
10111 FormatStyle::ENAS_DontAlign);
10112 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines,
10113 FormatStyle::ENAS_Left);
10114 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines,
10115 FormatStyle::ENAS_Right);
10116 // For backward compatibility:
10117 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines,
10118 FormatStyle::ENAS_Left);
10119 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines,
10120 FormatStyle::ENAS_Right);
10121
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +000010122 Style.UseTab = FormatStyle::UT_ForIndentation;
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +000010123 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
10124 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
10125 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
Marianne Mailhot-Sarrasin51fe2792016-04-14 14:52:26 +000010126 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
10127 FormatStyle::UT_ForContinuationAndIndentation);
Daniel Jasper00853002014-09-16 16:22:30 +000010128 // For backward compatibility:
10129 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
10130 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +000010131
Daniel Jasperd74cf402014-04-08 12:46:38 +000010132 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
Daniel Jasperd74cf402014-04-08 12:46:38 +000010133 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
10134 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
10135 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
10136 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
Daniel Jasper9e709352014-11-26 10:43:58 +000010137 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
10138 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
Daniel Jasperd74cf402014-04-08 12:46:38 +000010139 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
10140 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
Daniel Jasper00853002014-09-16 16:22:30 +000010141 // For backward compatibility:
10142 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
10143 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
10144 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
10145 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
Daniel Jasperd74cf402014-04-08 12:46:38 +000010146
Alexander Kornienkofdca83d2013-12-10 10:18:34 +000010147 Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
10148 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
10149 FormatStyle::SBPO_Never);
10150 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
10151 FormatStyle::SBPO_Always);
10152 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
10153 FormatStyle::SBPO_ControlStatements);
10154 // For backward compatibility:
10155 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
10156 FormatStyle::SBPO_Never);
10157 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
10158 FormatStyle::SBPO_ControlStatements);
10159
Alexander Kornienkod6538332013-05-07 15:32:14 +000010160 Style.ColumnLimit = 123;
10161 FormatStyle BaseStyle = getLLVMStyle();
10162 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
10163 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
10164
Manuel Klimeka8eb9142013-05-13 12:51:40 +000010165 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
10166 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
10167 FormatStyle::BS_Attach);
10168 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
10169 FormatStyle::BS_Linux);
Birunthan Mohanathas305fa9c2015-07-12 03:13:54 +000010170 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces,
10171 FormatStyle::BS_Mozilla);
Manuel Klimeka8eb9142013-05-13 12:51:40 +000010172 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
10173 FormatStyle::BS_Stroustrup);
Alexander Kornienko3a33f022013-12-12 09:49:52 +000010174 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
10175 FormatStyle::BS_Allman);
10176 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
Daniel Jasperc1bc38e2015-09-29 14:57:55 +000010177 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces,
10178 FormatStyle::BS_WebKit);
10179 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces,
10180 FormatStyle::BS_Custom);
Manuel Klimeka8eb9142013-05-13 12:51:40 +000010181
Zachary Turner448592e2015-12-18 22:20:15 +000010182 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
10183 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
10184 FormatStyle::RTBS_None);
10185 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
10186 FormatStyle::RTBS_All);
10187 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",
Zachary Turner6bc7f972015-12-18 22:58:42 +000010188 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel);
Zachary Turner448592e2015-12-18 22:20:15 +000010189 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions",
10190 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions);
10191 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions",
10192 AlwaysBreakAfterReturnType,
10193 FormatStyle::RTBS_TopLevelDefinitions);
10194
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +000010195 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
10196 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None",
10197 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None);
10198 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All",
10199 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All);
10200 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel",
10201 AlwaysBreakAfterDefinitionReturnType,
10202 FormatStyle::DRTBS_TopLevel);
10203
Daniel Jasper65ee3472013-07-31 23:16:02 +000010204 Style.NamespaceIndentation = FormatStyle::NI_All;
10205 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
10206 FormatStyle::NI_None);
10207 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
10208 FormatStyle::NI_Inner);
10209 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
10210 FormatStyle::NI_All);
Daniel Jaspere1e43192014-04-01 12:55:11 +000010211
Daniel Jasper8ce1b8d2015-10-06 11:54:18 +000010212 // FIXME: This is required because parsing a configuration simply overwrites
10213 // the first N elements of the list instead of resetting it.
Daniel Jaspere1e43192014-04-01 12:55:11 +000010214 Style.ForEachMacros.clear();
Aaron Ballman2b9036d2014-04-01 16:30:35 +000010215 std::vector<std::string> BoostForeach;
10216 BoostForeach.push_back("BOOST_FOREACH");
Daniel Jaspere1e43192014-04-01 12:55:11 +000010217 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
Aaron Ballman2b9036d2014-04-01 16:30:35 +000010218 std::vector<std::string> BoostAndQForeach;
10219 BoostAndQForeach.push_back("BOOST_FOREACH");
10220 BoostAndQForeach.push_back("Q_FOREACH");
Daniel Jaspere1e43192014-04-01 12:55:11 +000010221 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
10222 BoostAndQForeach);
Daniel Jasper8ce1b8d2015-10-06 11:54:18 +000010223
10224 Style.IncludeCategories.clear();
10225 std::vector<FormatStyle::IncludeCategory> ExpectedCategories = {{"abc/.*", 2},
10226 {".*", 1}};
10227 CHECK_PARSE("IncludeCategories:\n"
10228 " - Regex: abc/.*\n"
10229 " Priority: 2\n"
10230 " - Regex: .*\n"
10231 " Priority: 1",
10232 IncludeCategories, ExpectedCategories);
Daniel Jasper9c8ff352016-03-21 14:11:27 +000010233 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeIsMainRegex, "abc$");
Alexander Kornienkocabdd732013-11-29 15:19:43 +000010234}
10235
10236TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
10237 FormatStyle Style = {};
10238 Style.Language = FormatStyle::LK_Cpp;
10239 CHECK_PARSE("Language: Cpp\n"
10240 "IndentWidth: 12",
10241 IndentWidth, 12u);
Rafael Espindola1f243172014-06-12 11:35:17 +000010242 EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
10243 "IndentWidth: 34",
10244 &Style),
10245 ParseError::Unsuitable);
Alexander Kornienkocabdd732013-11-29 15:19:43 +000010246 EXPECT_EQ(12u, Style.IndentWidth);
10247 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
10248 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
10249
10250 Style.Language = FormatStyle::LK_JavaScript;
10251 CHECK_PARSE("Language: JavaScript\n"
10252 "IndentWidth: 12",
10253 IndentWidth, 12u);
10254 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
Rafael Espindola1f243172014-06-12 11:35:17 +000010255 EXPECT_EQ(parseConfiguration("Language: Cpp\n"
10256 "IndentWidth: 34",
10257 &Style),
10258 ParseError::Unsuitable);
Alexander Kornienkocabdd732013-11-29 15:19:43 +000010259 EXPECT_EQ(23u, Style.IndentWidth);
10260 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
10261 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
10262
10263 CHECK_PARSE("BasedOnStyle: LLVM\n"
10264 "IndentWidth: 67",
10265 IndentWidth, 67u);
10266
10267 CHECK_PARSE("---\n"
10268 "Language: JavaScript\n"
10269 "IndentWidth: 12\n"
10270 "---\n"
10271 "Language: Cpp\n"
10272 "IndentWidth: 34\n"
10273 "...\n",
10274 IndentWidth, 12u);
10275
10276 Style.Language = FormatStyle::LK_Cpp;
10277 CHECK_PARSE("---\n"
10278 "Language: JavaScript\n"
10279 "IndentWidth: 12\n"
10280 "---\n"
10281 "Language: Cpp\n"
10282 "IndentWidth: 34\n"
10283 "...\n",
10284 IndentWidth, 34u);
10285 CHECK_PARSE("---\n"
10286 "IndentWidth: 78\n"
10287 "---\n"
10288 "Language: JavaScript\n"
10289 "IndentWidth: 56\n"
10290 "...\n",
10291 IndentWidth, 78u);
10292
10293 Style.ColumnLimit = 123;
10294 Style.IndentWidth = 234;
10295 Style.BreakBeforeBraces = FormatStyle::BS_Linux;
10296 Style.TabWidth = 345;
Rafael Espindola3ae06202014-05-31 03:20:52 +000010297 EXPECT_FALSE(parseConfiguration("---\n"
10298 "IndentWidth: 456\n"
10299 "BreakBeforeBraces: Allman\n"
10300 "---\n"
10301 "Language: JavaScript\n"
10302 "IndentWidth: 111\n"
10303 "TabWidth: 111\n"
10304 "---\n"
10305 "Language: Cpp\n"
10306 "BreakBeforeBraces: Stroustrup\n"
10307 "TabWidth: 789\n"
10308 "...\n",
10309 &Style));
Alexander Kornienkocabdd732013-11-29 15:19:43 +000010310 EXPECT_EQ(123u, Style.ColumnLimit);
10311 EXPECT_EQ(456u, Style.IndentWidth);
10312 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
10313 EXPECT_EQ(789u, Style.TabWidth);
10314
Rafael Espindola1f243172014-06-12 11:35:17 +000010315 EXPECT_EQ(parseConfiguration("---\n"
10316 "Language: JavaScript\n"
10317 "IndentWidth: 56\n"
10318 "---\n"
10319 "IndentWidth: 78\n"
10320 "...\n",
10321 &Style),
10322 ParseError::Error);
10323 EXPECT_EQ(parseConfiguration("---\n"
10324 "Language: JavaScript\n"
10325 "IndentWidth: 56\n"
10326 "---\n"
10327 "Language: JavaScript\n"
10328 "IndentWidth: 78\n"
10329 "...\n",
10330 &Style),
10331 ParseError::Error);
Alexander Kornienkocabdd732013-11-29 15:19:43 +000010332
10333 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
10334}
Daniel Jasper65ee3472013-07-31 23:16:02 +000010335
Alexander Kornienkod6bd7472013-12-30 16:11:28 +000010336#undef CHECK_PARSE
Alexander Kornienkod6bd7472013-12-30 16:11:28 +000010337
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010338TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
10339 FormatStyle Style = {};
10340 Style.Language = FormatStyle::LK_JavaScript;
10341 Style.BreakBeforeTernaryOperators = true;
Alexander Kornienkod6bd7472013-12-30 16:11:28 +000010342 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
Daniel Jaspere551bb72014-11-05 17:22:31 +000010343 EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
Alexander Kornienkod6bd7472013-12-30 16:11:28 +000010344
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010345 Style.BreakBeforeTernaryOperators = true;
Alexander Kornienkod6bd7472013-12-30 16:11:28 +000010346 EXPECT_EQ(0, parseConfiguration("---\n"
Daniel Jaspera44991332015-04-29 13:06:49 +000010347 "BasedOnStyle: Google\n"
10348 "---\n"
10349 "Language: JavaScript\n"
10350 "IndentWidth: 76\n"
10351 "...\n",
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +000010352 &Style)
10353 .value());
Daniel Jaspere551bb72014-11-05 17:22:31 +000010354 EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010355 EXPECT_EQ(76u, Style.IndentWidth);
10356 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
10357}
10358
Alexander Kornienkod6538332013-05-07 15:32:14 +000010359TEST_F(FormatTest, ConfigurationRoundTripTest) {
10360 FormatStyle Style = getLLVMStyle();
10361 std::string YAML = configurationAsText(Style);
10362 FormatStyle ParsedStyle = {};
Alexander Kornienkocabdd732013-11-29 15:19:43 +000010363 ParsedStyle.Language = FormatStyle::LK_Cpp;
Alexander Kornienkod6538332013-05-07 15:32:14 +000010364 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
10365 EXPECT_EQ(Style, ParsedStyle);
10366}
10367
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010368TEST_F(FormatTest, WorksFor8bitEncodings) {
10369 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
10370 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
10371 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
10372 "\"\xef\xee\xf0\xf3...\"",
10373 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
10374 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
10375 "\xef\xee\xf0\xf3...\"",
10376 getLLVMStyleWithColumns(12)));
10377}
10378
Alexander Kornienko393e3082013-11-13 14:04:17 +000010379TEST_F(FormatTest, HandlesUTF8BOM) {
10380 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
10381 EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
10382 format("\xef\xbb\xbf#include <iostream>"));
10383 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
10384 format("\xef\xbb\xbf\n#include <iostream>"));
10385}
10386
NAKAMURA Takumi5238eba2013-06-06 01:14:58 +000010387// FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
10388#if !defined(_MSC_VER)
10389
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010390TEST_F(FormatTest, CountsUTF8CharactersProperly) {
10391 verifyFormat("\"Однажды в студёную зимнюю пору...\"",
10392 getLLVMStyleWithColumns(35));
10393 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010394 getLLVMStyleWithColumns(31));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010395 verifyFormat("// Однажды в студёную зимнюю пору...",
10396 getLLVMStyleWithColumns(36));
Daniel Jaspera44991332015-04-29 13:06:49 +000010397 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010398 verifyFormat("/* Однажды в студёную зимнюю пору... */",
10399 getLLVMStyleWithColumns(39));
10400 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010401 getLLVMStyleWithColumns(35));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010402}
10403
10404TEST_F(FormatTest, SplitsUTF8Strings) {
Alexander Kornienko71d95d62013-11-26 10:38:53 +000010405 // Non-printable characters' width is currently considered to be the length in
10406 // bytes in UTF8. The characters can be displayed in very different manner
10407 // (zero-width, single width with a substitution glyph, expanded to their code
10408 // (e.g. "<8d>"), so there's no single correct way to handle them.
10409 EXPECT_EQ("\"aaaaÄ\"\n"
Alexander Kornienkofd1d7002013-11-26 13:31:46 +000010410 "\"\xc2\x8d\";",
10411 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
Alexander Kornienko71d95d62013-11-26 10:38:53 +000010412 EXPECT_EQ("\"aaaaaaaÄ\"\n"
Alexander Kornienkofd1d7002013-11-26 13:31:46 +000010413 "\"\xc2\x8d\";",
10414 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
Daniel Jaspera44991332015-04-29 13:06:49 +000010415 EXPECT_EQ("\"Однажды, в \"\n"
10416 "\"студёную \"\n"
10417 "\"зимнюю \"\n"
10418 "\"пору,\"",
10419 format("\"Однажды, в студёную зимнюю пору,\"",
10420 getLLVMStyleWithColumns(13)));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010421 EXPECT_EQ(
Daniel Jaspera44991332015-04-29 13:06:49 +000010422 "\"一 二 三 \"\n"
10423 "\"四 五六 \"\n"
10424 "\"七 八 九 \"\n"
10425 "\"十\"",
10426 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010427 EXPECT_EQ("\"一\t二 \"\n"
10428 "\"\t三 \"\n"
10429 "\"四 五\t六 \"\n"
10430 "\"\t七 \"\n"
10431 "\"八九十\tqq\"",
10432 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
10433 getLLVMStyleWithColumns(11)));
Daniel Jaspere35c2202015-07-20 23:28:07 +000010434
10435 // UTF8 character in an escape sequence.
10436 EXPECT_EQ("\"aaaaaa\"\n"
10437 "\"\\\xC2\x8D\"",
10438 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10)));
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010439}
10440
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010441TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
10442 EXPECT_EQ("const char *sssss =\n"
10443 " \"一二三四五六七八\\\n"
10444 " 九 十\";",
10445 format("const char *sssss = \"一二三四五六七八\\\n"
10446 " 九 十\";",
10447 getLLVMStyleWithColumns(30)));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010448}
10449
10450TEST_F(FormatTest, SplitsUTF8LineComments) {
Alexander Kornienkofd1d7002013-11-26 13:31:46 +000010451 EXPECT_EQ("// aaaaÄ\xc2\x8d",
10452 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010453 EXPECT_EQ("// Я из лесу\n"
10454 "// вышел; был\n"
10455 "// сильный\n"
10456 "// мороз.",
10457 format("// Я из лесу вышел; был сильный мороз.",
10458 getLLVMStyleWithColumns(13)));
10459 EXPECT_EQ("// 一二三\n"
10460 "// 四五六七\n"
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010461 "// 八 九\n"
10462 "// 十",
10463 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9)));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010464}
10465
10466TEST_F(FormatTest, SplitsUTF8BlockComments) {
10467 EXPECT_EQ("/* Гляжу,\n"
10468 " * поднимается\n"
10469 " * медленно в\n"
10470 " * гору\n"
10471 " * Лошадка,\n"
10472 " * везущая\n"
10473 " * хворосту\n"
10474 " * воз. */",
10475 format("/* Гляжу, поднимается медленно в гору\n"
10476 " * Лошадка, везущая хворосту воз. */",
10477 getLLVMStyleWithColumns(13)));
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010478 EXPECT_EQ(
10479 "/* 一二三\n"
10480 " * 四五六七\n"
10481 " * 八 九\n"
10482 " * 十 */",
10483 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9)));
Alexander Kornienkoff73c202013-06-05 15:08:20 +000010484 EXPECT_EQ("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯\n"
10485 " * 𝕓𝕪𝕥𝕖\n"
10486 " * 𝖀𝕿𝕱-𝟠 */",
10487 format("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯 𝕓𝕪𝕥𝕖 𝖀𝕿𝕱-𝟠 */", getLLVMStyleWithColumns(12)));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010488}
10489
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010490#endif // _MSC_VER
10491
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010492TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
10493 FormatStyle Style = getLLVMStyle();
10494
10495 Style.ConstructorInitializerIndentWidth = 4;
10496 verifyFormat(
10497 "SomeClass::Constructor()\n"
10498 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
10499 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
10500 Style);
10501
10502 Style.ConstructorInitializerIndentWidth = 2;
10503 verifyFormat(
10504 "SomeClass::Constructor()\n"
10505 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
10506 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
10507 Style);
10508
10509 Style.ConstructorInitializerIndentWidth = 0;
10510 verifyFormat(
10511 "SomeClass::Constructor()\n"
10512 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
10513 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
10514 Style);
Daniel Jasperb618a982016-02-02 10:28:11 +000010515 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
10516 verifyFormat(
10517 "SomeLongTemplateVariableName<\n"
10518 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>",
10519 Style);
10520 verifyFormat(
10521 "bool smaller = 1 < bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
10522 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
10523 Style);
Daniel Jasper00853002014-09-16 16:22:30 +000010524}
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010525
Daniel Jasper00853002014-09-16 16:22:30 +000010526TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
10527 FormatStyle Style = getLLVMStyle();
Francois Ferranda6b6d512017-05-24 11:36:58 +000010528 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010529 Style.ConstructorInitializerIndentWidth = 4;
10530 verifyFormat("SomeClass::Constructor()\n"
10531 " : a(a)\n"
10532 " , b(b)\n"
10533 " , c(c) {}",
10534 Style);
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010535 verifyFormat("SomeClass::Constructor()\n"
10536 " : a(a) {}",
10537 Style);
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010538
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010539 Style.ColumnLimit = 0;
10540 verifyFormat("SomeClass::Constructor()\n"
10541 " : a(a) {}",
10542 Style);
Daniel Jasper56ef6ac2016-03-01 21:41:58 +000010543 verifyFormat("SomeClass::Constructor() noexcept\n"
10544 " : a(a) {}",
10545 Style);
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010546 verifyFormat("SomeClass::Constructor()\n"
10547 " : a(a)\n"
10548 " , b(b)\n"
10549 " , c(c) {}",
10550 Style);
10551 verifyFormat("SomeClass::Constructor()\n"
10552 " : a(a) {\n"
10553 " foo();\n"
10554 " bar();\n"
10555 "}",
10556 Style);
10557
Daniel Jasperd74cf402014-04-08 12:46:38 +000010558 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010559 verifyFormat("SomeClass::Constructor()\n"
10560 " : a(a)\n"
10561 " , b(b)\n"
10562 " , c(c) {\n}",
10563 Style);
10564 verifyFormat("SomeClass::Constructor()\n"
10565 " : a(a) {\n}",
10566 Style);
10567
10568 Style.ColumnLimit = 80;
Daniel Jasperd74cf402014-04-08 12:46:38 +000010569 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010570 Style.ConstructorInitializerIndentWidth = 2;
10571 verifyFormat("SomeClass::Constructor()\n"
10572 " : a(a)\n"
10573 " , b(b)\n"
10574 " , c(c) {}",
10575 Style);
10576
10577 Style.ConstructorInitializerIndentWidth = 0;
10578 verifyFormat("SomeClass::Constructor()\n"
10579 ": a(a)\n"
10580 ", b(b)\n"
10581 ", c(c) {}",
10582 Style);
Daniel Jasperec01cd62013-10-08 05:11:18 +000010583
10584 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
10585 Style.ConstructorInitializerIndentWidth = 4;
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010586 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
10587 verifyFormat(
10588 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
10589 Style);
Daniel Jasperec01cd62013-10-08 05:11:18 +000010590 verifyFormat(
10591 "SomeClass::Constructor()\n"
10592 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
10593 Style);
10594 Style.ConstructorInitializerIndentWidth = 4;
10595 Style.ColumnLimit = 60;
10596 verifyFormat("SomeClass::Constructor()\n"
10597 " : aaaaaaaa(aaaaaaaa)\n"
10598 " , aaaaaaaa(aaaaaaaa)\n"
10599 " , aaaaaaaa(aaaaaaaa) {}",
10600 Style);
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010601}
10602
Daniel Jasper38efc132014-10-21 07:51:54 +000010603TEST_F(FormatTest, Destructors) {
10604 verifyFormat("void F(int &i) { i.~int(); }");
10605 verifyFormat("void F(int &i) { i->~int(); }");
10606}
10607
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010608TEST_F(FormatTest, FormatsWithWebKitStyle) {
10609 FormatStyle Style = getWebKitStyle();
10610
10611 // Don't indent in outer namespaces.
10612 verifyFormat("namespace outer {\n"
10613 "int i;\n"
10614 "namespace inner {\n"
Daniel Jasper65ee3472013-07-31 23:16:02 +000010615 " int i;\n"
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010616 "} // namespace inner\n"
10617 "} // namespace outer\n"
10618 "namespace other_outer {\n"
10619 "int i;\n"
10620 "}",
10621 Style);
10622
10623 // Don't indent case labels.
10624 verifyFormat("switch (variable) {\n"
10625 "case 1:\n"
10626 "case 2:\n"
10627 " doSomething();\n"
10628 " break;\n"
10629 "default:\n"
10630 " ++variable;\n"
10631 "}",
10632 Style);
10633
10634 // Wrap before binary operators.
Daniel Jaspera44991332015-04-29 13:06:49 +000010635 EXPECT_EQ("void f()\n"
10636 "{\n"
10637 " if (aaaaaaaaaaaaaaaa\n"
10638 " && bbbbbbbbbbbbbbbbbbbbbbbb\n"
10639 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
10640 " return;\n"
10641 "}",
10642 format("void f() {\n"
10643 "if (aaaaaaaaaaaaaaaa\n"
10644 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
10645 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
10646 "return;\n"
10647 "}",
10648 Style));
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010649
Daniel Jasper35995672014-04-29 14:05:20 +000010650 // Allow functions on a single line.
10651 verifyFormat("void f() { return; }", Style);
10652
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010653 // Constructor initializers are formatted one per line with the "," on the
10654 // new line.
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010655 verifyFormat("Constructor()\n"
10656 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
10657 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
Daniel Jasper3aa9a6a2014-11-18 23:55:27 +000010658 " aaaaaaaaaaaaaa)\n"
Daniel Jasper234379f2013-12-24 13:31:25 +000010659 " , aaaaaaaaaaaaaaaaaaaaaaa()\n"
10660 "{\n"
10661 "}",
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010662 Style);
10663 verifyFormat("SomeClass::Constructor()\n"
10664 " : a(a)\n"
Daniel Jasper234379f2013-12-24 13:31:25 +000010665 "{\n"
10666 "}",
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010667 Style);
Daniel Jasper234379f2013-12-24 13:31:25 +000010668 EXPECT_EQ("SomeClass::Constructor()\n"
10669 " : a(a)\n"
10670 "{\n"
10671 "}",
10672 format("SomeClass::Constructor():a(a){}", Style));
10673 verifyFormat("SomeClass::Constructor()\n"
10674 " : a(a)\n"
10675 " , b(b)\n"
10676 " , c(c)\n"
10677 "{\n"
Daniel Jaspera44991332015-04-29 13:06:49 +000010678 "}",
10679 Style);
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010680 verifyFormat("SomeClass::Constructor()\n"
10681 " : a(a)\n"
10682 "{\n"
10683 " foo();\n"
10684 " bar();\n"
10685 "}",
10686 Style);
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010687
Daniel Jasper65ee3472013-07-31 23:16:02 +000010688 // Access specifiers should be aligned left.
10689 verifyFormat("class C {\n"
10690 "public:\n"
10691 " int i;\n"
10692 "};",
10693 Style);
10694
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010695 // Do not align comments.
Daniel Jasper552f4a72013-07-31 23:55:15 +000010696 verifyFormat("int a; // Do not\n"
10697 "double b; // align comments.",
10698 Style);
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010699
Daniel Jasper3219e432014-12-02 13:24:51 +000010700 // Do not align operands.
10701 EXPECT_EQ("ASSERT(aaaa\n"
10702 " || bbbb);",
10703 format("ASSERT ( aaaa\n||bbbb);", Style));
10704
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010705 // Accept input's line breaks.
10706 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
10707 " || bbbbbbbbbbbbbbb) {\n"
10708 " i++;\n"
10709 "}",
10710 format("if (aaaaaaaaaaaaaaa\n"
10711 "|| bbbbbbbbbbbbbbb) { i++; }",
10712 Style));
10713 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
10714 " i++;\n"
10715 "}",
10716 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
Daniel Jasper98fb6e12013-11-08 17:33:27 +000010717
10718 // Don't automatically break all macro definitions (llvm.org/PR17842).
10719 verifyFormat("#define aNumber 10", Style);
10720 // However, generally keep the line breaks that the user authored.
10721 EXPECT_EQ("#define aNumber \\\n"
10722 " 10",
10723 format("#define aNumber \\\n"
10724 " 10",
10725 Style));
Daniel Jasperaf4fee22014-04-14 12:05:05 +000010726
10727 // Keep empty and one-element array literals on a single line.
Daniel Jasper7f0c5172014-05-19 08:06:34 +000010728 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
10729 " copyItems:YES];",
10730 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
10731 "copyItems:YES];",
10732 Style));
10733 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
10734 " copyItems:YES];",
10735 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
10736 " copyItems:YES];",
10737 Style));
Daniel Jasper335ff262014-05-28 09:11:53 +000010738 // FIXME: This does not seem right, there should be more indentation before
10739 // the array literal's entries. Nested blocks have the same problem.
Daniel Jasperdb8804b2014-04-14 12:11:07 +000010740 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
Daniel Jasper335ff262014-05-28 09:11:53 +000010741 " @\"a\",\n"
10742 " @\"a\"\n"
10743 "]\n"
Daniel Jasperdb8804b2014-04-14 12:11:07 +000010744 " copyItems:YES];",
10745 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
10746 " @\"a\",\n"
10747 " @\"a\"\n"
10748 " ]\n"
10749 " copyItems:YES];",
10750 Style));
Daniel Jasper7f0c5172014-05-19 08:06:34 +000010751 EXPECT_EQ(
Daniel Jasperdb8804b2014-04-14 12:11:07 +000010752 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
10753 " copyItems:YES];",
Daniel Jasper7f0c5172014-05-19 08:06:34 +000010754 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
10755 " copyItems:YES];",
10756 Style));
10757
10758 verifyFormat("[self.a b:c c:d];", Style);
10759 EXPECT_EQ("[self.a b:c\n"
10760 " c:d];",
10761 format("[self.a b:c\n"
10762 "c:d];",
10763 Style));
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010764}
10765
Manuel Klimekffdeb592013-09-03 15:10:01 +000010766TEST_F(FormatTest, FormatsLambdas) {
Daniel Jasper5f3ea472014-05-22 08:36:53 +000010767 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
10768 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
10769 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
10770 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
10771 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
Chandler Carruthf8b72662014-03-02 12:37:31 +000010772 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
Daniel Jasper3ade3be2016-11-01 06:23:05 +000010773 verifyFormat("int x = f(*+[] {});");
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +000010774 verifyFormat("void f() {\n"
10775 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
10776 "}\n");
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +000010777 verifyFormat("void f() {\n"
10778 " other(x.begin(), //\n"
10779 " x.end(), //\n"
Daniel Jasper9a8d48b2013-09-05 10:04:31 +000010780 " [&](int, int) { return 1; });\n"
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +000010781 "}\n");
Daniel Jasper21397a32014-04-09 12:21:48 +000010782 verifyFormat("SomeFunction([]() { // A cool function...\n"
10783 " return 43;\n"
10784 "});");
Daniel Jasper56346192014-10-27 16:31:46 +000010785 EXPECT_EQ("SomeFunction([]() {\n"
10786 "#define A a\n"
10787 " return 43;\n"
10788 "});",
10789 format("SomeFunction([](){\n"
10790 "#define A a\n"
10791 "return 43;\n"
10792 "});"));
Daniel Jasper0e6c51c2014-05-05 12:36:29 +000010793 verifyFormat("void f() {\n"
10794 " SomeFunction([](decltype(x), A *a) {});\n"
10795 "}");
Daniel Jaspera2fb50f2014-06-24 09:15:49 +000010796 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
10797 " [](const aaaaaaaaaa &a) { return a; });");
Daniel Jaspera5621202014-08-08 12:00:13 +000010798 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
10799 " SomeOtherFunctioooooooooooooooooooooooooon();\n"
10800 "});");
Daniel Jasperd6a1cab2015-01-12 10:23:24 +000010801 verifyFormat("Constructor()\n"
10802 " : Field([] { // comment\n"
10803 " int i;\n"
10804 " }) {}");
Daniel Jasper0ad28142015-05-13 08:47:16 +000010805 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
10806 " return some_parameter.size();\n"
10807 "};");
Daniel Jasper9c8a7742016-01-04 07:29:40 +000010808 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n"
10809 " [](const string &s) { return s; };");
Daniel Jasperc4144ea2015-05-13 16:09:21 +000010810 verifyFormat("int i = aaaaaa ? 1 //\n"
10811 " : [] {\n"
10812 " return 2; //\n"
10813 " }();");
10814 verifyFormat("llvm::errs() << \"number of twos is \"\n"
10815 " << std::count_if(v.begin(), v.end(), [](int x) {\n"
10816 " return x == 2; // force break\n"
10817 " });");
Daniel Jasperd9b319e2017-02-20 12:43:48 +000010818 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
10819 " [=](int iiiiiiiiiiii) {\n"
10820 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n"
10821 " aaaaaaaaaaaaaaaaaaaaaaa;\n"
10822 " });",
Daniel Jasperb9edcfb2015-07-07 13:50:50 +000010823 getLLVMStyleWithColumns(60));
Daniel Jasperea40cee2015-07-14 11:26:14 +000010824 verifyFormat("SomeFunction({[&] {\n"
10825 " // comment\n"
10826 " },\n"
10827 " [&] {\n"
10828 " // comment\n"
10829 " }});");
10830 verifyFormat("SomeFunction({[&] {\n"
10831 " // comment\n"
10832 "}});");
Daniel Jasper100ffc62015-08-21 11:44:57 +000010833 verifyFormat("virtual aaaaaaaaaaaaaaaa(std::function<bool()> bbbbbbbbbbbb =\n"
10834 " [&]() { return true; },\n"
10835 " aaaaa aaaaaaaaa);");
Daniel Jasperbf02b2c12013-09-05 11:49:39 +000010836
Daniel Jaspercb51cf42014-01-16 09:11:55 +000010837 // Lambdas with return types.
Daniel Jasper81a20782014-03-10 10:02:02 +000010838 verifyFormat("int c = []() -> int { return 2; }();\n");
Daniel Jasper60ba32d2015-06-12 09:59:16 +000010839 verifyFormat("int c = []() -> int * { return 2; }();\n");
Daniel Jasper81a20782014-03-10 10:02:02 +000010840 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
10841 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
Daniel Jasperbcb55ee2014-11-21 14:08:38 +000010842 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};");
Daniel Jasper3431b752014-12-08 13:22:37 +000010843 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};");
Daniel Jasperbcb55ee2014-11-21 14:08:38 +000010844 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};");
10845 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};");
Daniel Jasper5eaa0092015-08-13 13:37:08 +000010846 verifyFormat("[a, a]() -> a<1> {};");
Daniel Jasper8f59ae52014-03-11 11:03:26 +000010847 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
10848 " int j) -> int {\n"
Daniel Jaspera2fb50f2014-06-24 09:15:49 +000010849 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n"
Daniel Jasper8f59ae52014-03-11 11:03:26 +000010850 "};");
Daniel Jaspere6623162015-03-02 10:35:13 +000010851 verifyFormat(
10852 "aaaaaaaaaaaaaaaaaaaaaa(\n"
10853 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n"
10854 " return aaaaaaaaaaaaaaaaa;\n"
10855 " });",
10856 getLLVMStyleWithColumns(70));
Daniel Jasper87448c52016-06-13 07:48:45 +000010857 verifyFormat("[]() //\n"
10858 " -> int {\n"
10859 " return 1; //\n"
10860 "};");
Daniel Jaspercb51cf42014-01-16 09:11:55 +000010861
Daniel Jasper3ae6f5a2014-04-09 12:08:39 +000010862 // Multiple lambdas in the same parentheses change indentation rules.
Daniel Jasper4b444492014-11-21 13:38:53 +000010863 verifyFormat("SomeFunction(\n"
10864 " []() {\n"
10865 " int i = 42;\n"
10866 " return i;\n"
10867 " },\n"
10868 " []() {\n"
10869 " int j = 43;\n"
10870 " return j;\n"
10871 " });");
Daniel Jasper3ae6f5a2014-04-09 12:08:39 +000010872
Daniel Jasperda18fd82014-06-10 06:39:03 +000010873 // More complex introducers.
10874 verifyFormat("return [i, args...] {};");
10875
Daniel Jasperbf02b2c12013-09-05 11:49:39 +000010876 // Not lambdas.
Chandler Carruthf8b72662014-03-02 12:37:31 +000010877 verifyFormat("constexpr char hello[]{\"hello\"};");
Daniel Jasperb4b99982013-09-06 21:25:51 +000010878 verifyFormat("double &operator[](int i) { return 0; }\n"
10879 "int i;");
Daniel Jasper6b70ec02014-01-22 17:01:47 +000010880 verifyFormat("std::unique_ptr<int[]> foo() {}");
Daniel Jasperd3c7ab92014-03-11 09:59:36 +000010881 verifyFormat("int i = a[a][a]->f();");
Daniel Jaspera58dd5d2014-03-11 10:03:33 +000010882 verifyFormat("int i = (*b)[a]->f();");
Daniel Jasper84a12e12014-03-10 15:06:25 +000010883
10884 // Other corner cases.
10885 verifyFormat("void f() {\n"
10886 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n"
Martin Probst2c1cdae2017-05-15 11:15:29 +000010887 " );\n"
Daniel Jasper84a12e12014-03-10 15:06:25 +000010888 "}");
Daniel Jasperc580af92014-03-11 09:29:46 +000010889
10890 // Lambdas created through weird macros.
10891 verifyFormat("void f() {\n"
10892 " MACRO((const AA &a) { return 1; });\n"
Daniel Jasper54353da2016-01-07 14:36:11 +000010893 " MACRO((AA &a) { return 1; });\n"
Daniel Jasperc580af92014-03-11 09:29:46 +000010894 "}");
Daniel Jasper11a0ac62014-12-12 09:40:58 +000010895
10896 verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
10897 " doo_dah();\n"
10898 " doo_dah();\n"
10899 " })) {\n"
10900 "}");
Daniel Jasper6a7d5a72017-06-19 07:40:49 +000010901 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n"
10902 " doo_dah();\n"
10903 " doo_dah();\n"
10904 " })) {\n"
10905 "}");
Daniel Jasper29d39d52015-02-08 09:34:49 +000010906 verifyFormat("auto lambda = []() {\n"
10907 " int a = 2\n"
10908 "#if A\n"
10909 " + 2\n"
10910 "#endif\n"
10911 " ;\n"
10912 "};");
Daniel Jasperd9b319e2017-02-20 12:43:48 +000010913
10914 // Lambdas with complex multiline introducers.
10915 verifyFormat(
10916 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
10917 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n"
10918 " -> ::std::unordered_set<\n"
10919 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n"
10920 " //\n"
10921 " });");
Manuel Klimekffdeb592013-09-03 15:10:01 +000010922}
10923
Manuel Klimek516e0542013-09-04 13:25:30 +000010924TEST_F(FormatTest, FormatsBlocks) {
Daniel Jasper76284682014-10-22 09:12:44 +000010925 FormatStyle ShortBlocks = getLLVMStyle();
10926 ShortBlocks.AllowShortBlocksOnASingleLine = true;
10927 verifyFormat("int (^Block)(int, int);", ShortBlocks);
10928 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
10929 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
10930 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
10931 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
10932 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
Daniel Jasper31745732014-01-19 07:46:32 +000010933
Daniel Jasper76284682014-10-22 09:12:44 +000010934 verifyFormat("foo(^{ bar(); });", ShortBlocks);
10935 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
10936 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
Daniel Jasper31745732014-01-19 07:46:32 +000010937
Daniel Jasper76284682014-10-22 09:12:44 +000010938 verifyFormat("[operation setCompletionBlock:^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010939 " [self onOperationDone];\n"
Daniel Jasper76284682014-10-22 09:12:44 +000010940 "}];");
10941 verifyFormat("int i = {[operation setCompletionBlock:^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010942 " [self onOperationDone];\n"
Daniel Jasper76284682014-10-22 09:12:44 +000010943 "}]};");
10944 verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010945 " f();\n"
Daniel Jasper76284682014-10-22 09:12:44 +000010946 "}];");
10947 verifyFormat("int a = [operation block:^int(int *i) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010948 " return 1;\n"
Daniel Jasper76284682014-10-22 09:12:44 +000010949 "}];");
Daniel Jaspera225bce2014-01-16 19:14:34 +000010950 verifyFormat("[myObject doSomethingWith:arg1\n"
Daniel Jasper76284682014-10-22 09:12:44 +000010951 " aaa:^int(int *a) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010952 " return 1;\n"
Daniel Jasper76284682014-10-22 09:12:44 +000010953 " }\n"
Daniel Jasper5f3ea472014-05-22 08:36:53 +000010954 " bbb:f(a * bbbbbbbb)];");
Daniel Jasperb88b25f2013-12-23 07:29:06 +000010955
10956 verifyFormat("[operation setCompletionBlock:^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010957 " [self.delegate newDataAvailable];\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000010958 "}];",
10959 getLLVMStyleWithColumns(60));
10960 verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010961 " NSString *path = [self sessionFilePath];\n"
10962 " if (path) {\n"
10963 " // ...\n"
10964 " }\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000010965 "});");
10966 verifyFormat("[[SessionService sharedService]\n"
10967 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010968 " if (window) {\n"
10969 " [self windowDidLoad:window];\n"
10970 " } else {\n"
10971 " [self errorLoadingWindow];\n"
10972 " }\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000010973 " }];");
10974 verifyFormat("void (^largeBlock)(void) = ^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010975 " // ...\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000010976 "};\n",
10977 getLLVMStyleWithColumns(40));
10978 verifyFormat("[[SessionService sharedService]\n"
10979 " loadWindowWithCompletionBlock: //\n"
10980 " ^(SessionWindow *window) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010981 " if (window) {\n"
10982 " [self windowDidLoad:window];\n"
10983 " } else {\n"
10984 " [self errorLoadingWindow];\n"
10985 " }\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000010986 " }];",
10987 getLLVMStyleWithColumns(60));
10988 verifyFormat("[myObject doSomethingWith:arg1\n"
10989 " firstBlock:^(Foo *a) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010990 " // ...\n"
10991 " int i;\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000010992 " }\n"
10993 " secondBlock:^(Bar *b) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010994 " // ...\n"
10995 " int i;\n"
Daniel Jasperc13ee342014-03-27 09:43:54 +000010996 " }\n"
10997 " thirdBlock:^Foo(Bar *b) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010998 " // ...\n"
10999 " int i;\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000011000 " }];");
Daniel Jasperb77105d2014-04-08 14:04:31 +000011001 verifyFormat("[myObject doSomethingWith:arg1\n"
11002 " firstBlock:-1\n"
11003 " secondBlock:^(Bar *b) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011004 " // ...\n"
11005 " int i;\n"
Daniel Jasperb77105d2014-04-08 14:04:31 +000011006 " }];");
Daniel Jasperac7e34e2014-03-13 10:11:17 +000011007
11008 verifyFormat("f(^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011009 " @autoreleasepool {\n"
11010 " if (a) {\n"
11011 " g();\n"
Daniel Jasperac7e34e2014-03-13 10:11:17 +000011012 " }\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011013 " }\n"
Daniel Jasperac7e34e2014-03-13 10:11:17 +000011014 "});");
Daniel Jasperbb86d842014-11-23 19:15:35 +000011015 verifyFormat("Block b = ^int *(A *a, B *b) {}");
Daniel Jaspere31388a2016-09-26 22:19:08 +000011016 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
11017 "};");
Daniel Jasper50d634b2014-10-28 16:53:38 +000011018
11019 FormatStyle FourIndent = getLLVMStyle();
11020 FourIndent.ObjCBlockIndentWidth = 4;
11021 verifyFormat("[operation setCompletionBlock:^{\n"
11022 " [self onOperationDone];\n"
11023 "}];",
11024 FourIndent);
Manuel Klimek516e0542013-09-04 13:25:30 +000011025}
11026
Daniel Jasper289afc02015-04-23 09:23:17 +000011027TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) {
11028 FormatStyle ZeroColumn = getLLVMStyle();
11029 ZeroColumn.ColumnLimit = 0;
11030
11031 verifyFormat("[[SessionService sharedService] "
11032 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
11033 " if (window) {\n"
11034 " [self windowDidLoad:window];\n"
11035 " } else {\n"
11036 " [self errorLoadingWindow];\n"
11037 " }\n"
11038 "}];",
11039 ZeroColumn);
11040 EXPECT_EQ("[[SessionService sharedService]\n"
11041 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
11042 " if (window) {\n"
11043 " [self windowDidLoad:window];\n"
11044 " } else {\n"
11045 " [self errorLoadingWindow];\n"
11046 " }\n"
11047 " }];",
11048 format("[[SessionService sharedService]\n"
11049 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
11050 " if (window) {\n"
11051 " [self windowDidLoad:window];\n"
11052 " } else {\n"
11053 " [self errorLoadingWindow];\n"
11054 " }\n"
11055 "}];",
11056 ZeroColumn));
11057 verifyFormat("[myObject doSomethingWith:arg1\n"
11058 " firstBlock:^(Foo *a) {\n"
11059 " // ...\n"
11060 " int i;\n"
11061 " }\n"
11062 " secondBlock:^(Bar *b) {\n"
11063 " // ...\n"
11064 " int i;\n"
11065 " }\n"
11066 " thirdBlock:^Foo(Bar *b) {\n"
11067 " // ...\n"
11068 " int i;\n"
11069 " }];",
11070 ZeroColumn);
11071 verifyFormat("f(^{\n"
11072 " @autoreleasepool {\n"
11073 " if (a) {\n"
11074 " g();\n"
11075 " }\n"
11076 " }\n"
11077 "});",
11078 ZeroColumn);
11079 verifyFormat("void (^largeBlock)(void) = ^{\n"
11080 " // ...\n"
11081 "};",
11082 ZeroColumn);
11083
11084 ZeroColumn.AllowShortBlocksOnASingleLine = true;
11085 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +000011086 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn));
Daniel Jasper289afc02015-04-23 09:23:17 +000011087 ZeroColumn.AllowShortBlocksOnASingleLine = false;
11088 EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
11089 " int i;\n"
11090 "};",
11091 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn));
11092}
11093
Alexander Kornienko9e649af2013-09-11 12:25:57 +000011094TEST_F(FormatTest, SupportsCRLF) {
11095 EXPECT_EQ("int a;\r\n"
11096 "int b;\r\n"
11097 "int c;\r\n",
11098 format("int a;\r\n"
11099 " int b;\r\n"
11100 " int c;\r\n",
11101 getLLVMStyle()));
11102 EXPECT_EQ("int a;\r\n"
11103 "int b;\r\n"
11104 "int c;\r\n",
11105 format("int a;\r\n"
11106 " int b;\n"
11107 " int c;\r\n",
11108 getLLVMStyle()));
11109 EXPECT_EQ("int a;\n"
11110 "int b;\n"
11111 "int c;\n",
11112 format("int a;\r\n"
11113 " int b;\n"
11114 " int c;\n",
11115 getLLVMStyle()));
11116 EXPECT_EQ("\"aaaaaaa \"\r\n"
11117 "\"bbbbbbb\";\r\n",
11118 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
11119 EXPECT_EQ("#define A \\\r\n"
11120 " b; \\\r\n"
11121 " c; \\\r\n"
11122 " d;\r\n",
11123 format("#define A \\\r\n"
11124 " b; \\\r\n"
11125 " c; d; \r\n",
11126 getGoogleStyle()));
Daniel Jasper580da272013-10-30 07:36:40 +000011127
11128 EXPECT_EQ("/*\r\n"
11129 "multi line block comments\r\n"
11130 "should not introduce\r\n"
11131 "an extra carriage return\r\n"
11132 "*/\r\n",
11133 format("/*\r\n"
11134 "multi line block comments\r\n"
11135 "should not introduce\r\n"
11136 "an extra carriage return\r\n"
11137 "*/\r\n"));
Alexander Kornienko9e649af2013-09-11 12:25:57 +000011138}
11139
Manuel Klimekb212f3b2013-10-12 22:46:56 +000011140TEST_F(FormatTest, MunchSemicolonAfterBlocks) {
11141 verifyFormat("MY_CLASS(C) {\n"
11142 " int i;\n"
11143 " int j;\n"
11144 "};");
11145}
11146
Daniel Jasper6633ab82013-10-18 10:38:14 +000011147TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {
11148 FormatStyle TwoIndent = getLLVMStyleWithColumns(15);
11149 TwoIndent.ContinuationIndentWidth = 2;
11150
11151 EXPECT_EQ("int i =\n"
11152 " longFunction(\n"
11153 " arg);",
11154 format("int i = longFunction(arg);", TwoIndent));
11155
11156 FormatStyle SixIndent = getLLVMStyleWithColumns(20);
11157 SixIndent.ContinuationIndentWidth = 6;
11158
11159 EXPECT_EQ("int i =\n"
11160 " longFunction(\n"
11161 " arg);",
11162 format("int i = longFunction(arg);", SixIndent));
11163}
11164
Daniel Jasperdd978ae2013-10-29 14:52:02 +000011165TEST_F(FormatTest, SpacesInAngles) {
11166 FormatStyle Spaces = getLLVMStyle();
11167 Spaces.SpacesInAngles = true;
11168
11169 verifyFormat("static_cast< int >(arg);", Spaces);
11170 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
11171 verifyFormat("f< int, float >();", Spaces);
11172 verifyFormat("template <> g() {}", Spaces);
11173 verifyFormat("template < std::vector< int > > f() {}", Spaces);
Daniel Jasper74331d42015-10-26 12:08:47 +000011174 verifyFormat("std::function< void(int, int) > fct;", Spaces);
11175 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }",
11176 Spaces);
Daniel Jasperdd978ae2013-10-29 14:52:02 +000011177
11178 Spaces.Standard = FormatStyle::LS_Cpp03;
11179 Spaces.SpacesInAngles = true;
11180 verifyFormat("A< A< int > >();", Spaces);
11181
11182 Spaces.SpacesInAngles = false;
11183 verifyFormat("A<A<int> >();", Spaces);
11184
11185 Spaces.Standard = FormatStyle::LS_Cpp11;
11186 Spaces.SpacesInAngles = true;
11187 verifyFormat("A< A< int > >();", Spaces);
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000011188
Daniel Jasperdd978ae2013-10-29 14:52:02 +000011189 Spaces.SpacesInAngles = false;
11190 verifyFormat("A<A<int>>();", Spaces);
11191}
11192
Sylvestre Ledru83bbd572016-08-09 14:24:40 +000011193TEST_F(FormatTest, SpaceAfterTemplateKeyword) {
11194 FormatStyle Style = getLLVMStyle();
11195 Style.SpaceAfterTemplateKeyword = false;
11196 verifyFormat("template<int> void foo();", Style);
11197}
11198
Jacques Pienaarfc275112015-02-18 23:48:37 +000011199TEST_F(FormatTest, TripleAngleBrackets) {
11200 verifyFormat("f<<<1, 1>>>();");
11201 verifyFormat("f<<<1, 1, 1, s>>>();");
11202 verifyFormat("f<<<a, b, c, d>>>();");
Daniel Jaspera44991332015-04-29 13:06:49 +000011203 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
Jacques Pienaarfc275112015-02-18 23:48:37 +000011204 verifyFormat("f<param><<<1, 1>>>();");
11205 verifyFormat("f<1><<<1, 1>>>();");
Daniel Jaspera44991332015-04-29 13:06:49 +000011206 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
Jacques Pienaarfc275112015-02-18 23:48:37 +000011207 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
11208 "aaaaaaaaaaa<<<\n 1, 1>>>();");
Daniel Jaspera4322082016-11-05 17:43:16 +000011209 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
11210 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();");
Jacques Pienaarfc275112015-02-18 23:48:37 +000011211}
11212
11213TEST_F(FormatTest, MergeLessLessAtEnd) {
Jacques Pienaar68a7dbf2015-02-20 21:09:01 +000011214 verifyFormat("<<");
Jacques Pienaar411b2512015-02-24 23:23:24 +000011215 EXPECT_EQ("< < <", format("\\\n<<<"));
Jacques Pienaarfc275112015-02-18 23:48:37 +000011216 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
11217 "aaallvm::outs() <<");
11218 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
11219 "aaaallvm::outs()\n <<");
11220}
11221
Manuel Klimek819788d2014-03-18 11:22:45 +000011222TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {
11223 std::string code = "#if A\n"
11224 "#if B\n"
11225 "a.\n"
11226 "#endif\n"
11227 " a = 1;\n"
11228 "#else\n"
11229 "#endif\n"
11230 "#if C\n"
11231 "#else\n"
11232 "#endif\n";
11233 EXPECT_EQ(code, format(code));
11234}
11235
Manuel Klimek68b03042014-04-14 09:14:11 +000011236TEST_F(FormatTest, HandleConflictMarkers) {
11237 // Git/SVN conflict markers.
11238 EXPECT_EQ("int a;\n"
11239 "void f() {\n"
11240 " callme(some(parameter1,\n"
11241 "<<<<<<< text by the vcs\n"
11242 " parameter2),\n"
11243 "||||||| text by the vcs\n"
11244 " parameter2),\n"
11245 " parameter3,\n"
11246 "======= text by the vcs\n"
11247 " parameter2, parameter3),\n"
11248 ">>>>>>> text by the vcs\n"
11249 " otherparameter);\n",
11250 format("int a;\n"
11251 "void f() {\n"
11252 " callme(some(parameter1,\n"
11253 "<<<<<<< text by the vcs\n"
11254 " parameter2),\n"
11255 "||||||| text by the vcs\n"
11256 " parameter2),\n"
11257 " parameter3,\n"
11258 "======= text by the vcs\n"
11259 " parameter2,\n"
11260 " parameter3),\n"
11261 ">>>>>>> text by the vcs\n"
11262 " otherparameter);\n"));
11263
11264 // Perforce markers.
11265 EXPECT_EQ("void f() {\n"
11266 " function(\n"
11267 ">>>> text by the vcs\n"
11268 " parameter,\n"
11269 "==== text by the vcs\n"
11270 " parameter,\n"
11271 "==== text by the vcs\n"
11272 " parameter,\n"
11273 "<<<< text by the vcs\n"
11274 " parameter);\n",
11275 format("void f() {\n"
11276 " function(\n"
11277 ">>>> text by the vcs\n"
11278 " parameter,\n"
11279 "==== text by the vcs\n"
11280 " parameter,\n"
11281 "==== text by the vcs\n"
11282 " parameter,\n"
11283 "<<<< text by the vcs\n"
11284 " parameter);\n"));
11285
11286 EXPECT_EQ("<<<<<<<\n"
11287 "|||||||\n"
11288 "=======\n"
11289 ">>>>>>>",
11290 format("<<<<<<<\n"
11291 "|||||||\n"
11292 "=======\n"
11293 ">>>>>>>"));
11294
11295 EXPECT_EQ("<<<<<<<\n"
11296 "|||||||\n"
11297 "int i;\n"
11298 "=======\n"
11299 ">>>>>>>",
11300 format("<<<<<<<\n"
11301 "|||||||\n"
11302 "int i;\n"
11303 "=======\n"
11304 ">>>>>>>"));
11305
11306 // FIXME: Handle parsing of macros around conflict markers correctly:
11307 EXPECT_EQ("#define Macro \\\n"
11308 "<<<<<<<\n"
11309 "Something \\\n"
11310 "|||||||\n"
11311 "Else \\\n"
11312 "=======\n"
11313 "Other \\\n"
11314 ">>>>>>>\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +000011315 " End int i;\n",
Manuel Klimek68b03042014-04-14 09:14:11 +000011316 format("#define Macro \\\n"
11317 "<<<<<<<\n"
11318 " Something \\\n"
11319 "|||||||\n"
11320 " Else \\\n"
11321 "=======\n"
11322 " Other \\\n"
11323 ">>>>>>>\n"
11324 " End\n"
11325 "int i;\n"));
11326}
11327
Daniel Jasper471894432014-08-06 13:40:26 +000011328TEST_F(FormatTest, DisableRegions) {
11329 EXPECT_EQ("int i;\n"
11330 "// clang-format off\n"
11331 " int j;\n"
11332 "// clang-format on\n"
11333 "int k;",
11334 format(" int i;\n"
11335 " // clang-format off\n"
11336 " int j;\n"
11337 " // clang-format on\n"
11338 " int k;"));
Roman Kashitsyn650ecb52014-09-11 14:47:20 +000011339 EXPECT_EQ("int i;\n"
11340 "/* clang-format off */\n"
11341 " int j;\n"
11342 "/* clang-format on */\n"
11343 "int k;",
11344 format(" int i;\n"
11345 " /* clang-format off */\n"
11346 " int j;\n"
11347 " /* clang-format on */\n"
11348 " int k;"));
Krasimir Georgiev91834222017-01-25 13:58:58 +000011349
11350 // Don't reflow comments within disabled regions.
11351 EXPECT_EQ(
11352 "// clang-format off\n"
11353 "// long long long long long long line\n"
11354 "/* clang-format on */\n"
11355 "/* long long long\n"
11356 " * long long long\n"
11357 " * line */\n"
11358 "int i;\n"
11359 "/* clang-format off */\n"
11360 "/* long long long long long long line */\n",
11361 format("// clang-format off\n"
11362 "// long long long long long long line\n"
11363 "/* clang-format on */\n"
11364 "/* long long long long long long line */\n"
11365 "int i;\n"
11366 "/* clang-format off */\n"
11367 "/* long long long long long long line */\n",
11368 getLLVMStyleWithColumns(20)));
Daniel Jasper471894432014-08-06 13:40:26 +000011369}
11370
Manuel Klimekf0c95b32015-06-11 10:14:13 +000011371TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
11372 format("? ) =");
11373 verifyNoCrash("#define a\\\n /**/}");
11374}
Manuel Klimek5f594f82014-08-13 14:00:41 +000011375
Daniel Jasper498f5582015-12-25 08:53:31 +000011376TEST_F(FormatTest, FormatsTableGenCode) {
11377 FormatStyle Style = getLLVMStyle();
11378 Style.Language = FormatStyle::LK_TableGen;
11379 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);
11380}
11381
Nico Weberb2673a12016-11-10 21:49:25 +000011382TEST_F(FormatTest, ArrayOfTemplates) {
11383 EXPECT_EQ("auto a = new unique_ptr<int>[10];",
11384 format("auto a = new unique_ptr<int > [ 10];"));
11385
11386 FormatStyle Spaces = getLLVMStyle();
11387 Spaces.SpacesInSquareBrackets = true;
11388 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];",
11389 format("auto a = new unique_ptr<int > [10];", Spaces));
11390}
11391
11392TEST_F(FormatTest, ArrayAsTemplateType) {
11393 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;",
11394 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;"));
11395
11396 FormatStyle Spaces = getLLVMStyle();
11397 Spaces.SpacesInSquareBrackets = true;
11398 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",
11399 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces));
11400}
11401
Martin Probstc9c51c42017-03-16 10:21:35 +000011402TEST_F(FormatTest, NoSpaceAfterSuper) {
11403 verifyFormat("__super::FooBar();");
11404}
11405
Eric Liu547d8792016-03-24 13:22:42 +000011406TEST(FormatStyle, GetStyleOfFile) {
11407 vfs::InMemoryFileSystem FS;
11408 // Test 1: format file in the same directory.
11409 ASSERT_TRUE(
11410 FS.addFile("/a/.clang-format", 0,
11411 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
11412 ASSERT_TRUE(
11413 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
Daniel Jasper03a04fe2016-12-12 12:42:29 +000011414 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS);
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +000011415 ASSERT_TRUE((bool)Style1);
11416 ASSERT_EQ(*Style1, getLLVMStyle());
Eric Liu547d8792016-03-24 13:22:42 +000011417
Antonio Maiorano7eb75072017-01-20 01:22:42 +000011418 // Test 2.1: fallback to default.
Eric Liu547d8792016-03-24 13:22:42 +000011419 ASSERT_TRUE(
11420 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
Daniel Jasper03a04fe2016-12-12 12:42:29 +000011421 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS);
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +000011422 ASSERT_TRUE((bool)Style2);
11423 ASSERT_EQ(*Style2, getMozillaStyle());
Eric Liu547d8792016-03-24 13:22:42 +000011424
Antonio Maiorano7eb75072017-01-20 01:22:42 +000011425 // Test 2.2: no format on 'none' fallback style.
11426 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
11427 ASSERT_TRUE((bool)Style2);
11428 ASSERT_EQ(*Style2, getNoStyle());
11429
11430 // Test 2.3: format if config is found with no based style while fallback is
11431 // 'none'.
11432 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
11433 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2")));
11434 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
11435 ASSERT_TRUE((bool)Style2);
11436 ASSERT_EQ(*Style2, getLLVMStyle());
11437
11438 // Test 2.4: format if yaml with no based style, while fallback is 'none'.
11439 Style2 = getStyle("{}", "a.h", "none", "", &FS);
11440 ASSERT_TRUE((bool)Style2);
11441 ASSERT_EQ(*Style2, getLLVMStyle());
11442
Eric Liu547d8792016-03-24 13:22:42 +000011443 // Test 3: format file in parent directory.
11444 ASSERT_TRUE(
11445 FS.addFile("/c/.clang-format", 0,
11446 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
11447 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
11448 llvm::MemoryBuffer::getMemBuffer("int i;")));
Daniel Jasper03a04fe2016-12-12 12:42:29 +000011449 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS);
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +000011450 ASSERT_TRUE((bool)Style3);
11451 ASSERT_EQ(*Style3, getGoogleStyle());
11452
11453 // Test 4: error on invalid fallback style
11454 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS);
11455 ASSERT_FALSE((bool)Style4);
11456 llvm::consumeError(Style4.takeError());
11457
11458 // Test 5: error on invalid yaml on command line
11459 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS);
11460 ASSERT_FALSE((bool)Style5);
11461 llvm::consumeError(Style5.takeError());
11462
11463 // Test 6: error on invalid style
11464 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS);
11465 ASSERT_FALSE((bool)Style6);
11466 llvm::consumeError(Style6.takeError());
11467
11468 // Test 7: found config file, error on parsing it
11469 ASSERT_TRUE(
11470 FS.addFile("/d/.clang-format", 0,
11471 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n"
11472 "InvalidKey: InvalidValue")));
11473 ASSERT_TRUE(
11474 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
11475 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS);
11476 ASSERT_FALSE((bool)Style7);
11477 llvm::consumeError(Style7.takeError());
Eric Liu547d8792016-03-24 13:22:42 +000011478}
11479
Manuel Klimekb12e5a52016-03-01 12:37:30 +000011480TEST_F(ReplacementTest, FormatCodeAfterReplacements) {
11481 // Column limit is 20.
11482 std::string Code = "Type *a =\n"
11483 " new Type();\n"
11484 "g(iiiii, 0, jjjjj,\n"
11485 " 0, kkkkk, 0, mm);\n"
11486 "int bad = format ;";
11487 std::string Expected = "auto a = new Type();\n"
11488 "g(iiiii, nullptr,\n"
11489 " jjjjj, nullptr,\n"
11490 " kkkkk, nullptr,\n"
11491 " mm);\n"
11492 "int bad = format ;";
11493 FileID ID = Context.createInMemoryFile("format.cpp", Code);
Eric Liu40ef2fb2016-08-01 10:16:37 +000011494 tooling::Replacements Replaces = toReplacements(
11495 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6,
11496 "auto "),
11497 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1,
11498 "nullptr"),
11499 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1,
11500 "nullptr"),
11501 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1,
11502 "nullptr")});
Manuel Klimekb12e5a52016-03-01 12:37:30 +000011503
11504 format::FormatStyle Style = format::getLLVMStyle();
11505 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility.
Eric Liu4f8d9942016-07-11 13:53:12 +000011506 auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
11507 EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
11508 << llvm::toString(FormattedReplaces.takeError()) << "\n";
11509 auto Result = applyAllReplacements(Code, *FormattedReplaces);
11510 EXPECT_TRUE(static_cast<bool>(Result));
11511 EXPECT_EQ(Expected, *Result);
Manuel Klimekb12e5a52016-03-01 12:37:30 +000011512}
11513
Eric Liubaf58c22016-05-18 13:43:48 +000011514TEST_F(ReplacementTest, SortIncludesAfterReplacement) {
11515 std::string Code = "#include \"a.h\"\n"
11516 "#include \"c.h\"\n"
11517 "\n"
11518 "int main() {\n"
11519 " return 0;\n"
11520 "}";
11521 std::string Expected = "#include \"a.h\"\n"
11522 "#include \"b.h\"\n"
11523 "#include \"c.h\"\n"
11524 "\n"
11525 "int main() {\n"
11526 " return 0;\n"
11527 "}";
11528 FileID ID = Context.createInMemoryFile("fix.cpp", Code);
Eric Liu40ef2fb2016-08-01 10:16:37 +000011529 tooling::Replacements Replaces = toReplacements(
11530 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0,
11531 "#include \"b.h\"\n")});
Eric Liubaf58c22016-05-18 13:43:48 +000011532
11533 format::FormatStyle Style = format::getLLVMStyle();
11534 Style.SortIncludes = true;
Eric Liu4f8d9942016-07-11 13:53:12 +000011535 auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
11536 EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
11537 << llvm::toString(FormattedReplaces.takeError()) << "\n";
11538 auto Result = applyAllReplacements(Code, *FormattedReplaces);
11539 EXPECT_TRUE(static_cast<bool>(Result));
11540 EXPECT_EQ(Expected, *Result);
Eric Liubaf58c22016-05-18 13:43:48 +000011541}
11542
Krasimir Georgievac16a202017-06-23 11:46:03 +000011543TEST_F(FormatTest, FormatSortsUsingDeclarations) {
11544 EXPECT_EQ("using std::cin;\n"
11545 "using std::cout;",
11546 format("using std::cout;\n"
11547 "using std::cin;", getGoogleStyle()));
11548}
11549
Nico Weberdc065182017-04-05 18:10:42 +000011550TEST_F(FormatTest, UTF8CharacterLiteralCpp03) {
11551 format::FormatStyle Style = format::getLLVMStyle();
11552 Style.Standard = FormatStyle::LS_Cpp03;
11553 // cpp03 recognize this string as identifier u8 and literal character 'a'
11554 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style));
11555}
11556
11557TEST_F(FormatTest, UTF8CharacterLiteralCpp11) {
11558 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers
11559 // all modes, including C++11, C++14 and C++17
11560 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';"));
11561}
11562
Krasimir Georgieva2e7d0d2017-08-29 13:51:38 +000011563TEST_F(FormatTest, DoNotFormatLikelyXml) {
11564 EXPECT_EQ("<!-- ;> -->",
11565 format("<!-- ;> -->", getGoogleStyle()));
11566 EXPECT_EQ(" <!-- >; -->",
11567 format(" <!-- >; -->", getGoogleStyle()));
11568}
11569
Marek Kurdejceeb8b92017-09-07 14:28:32 +000011570TEST_F(FormatTest, StructuredBindings) {
11571 // Structured bindings is a C++17 feature.
11572 // all modes, including C++11, C++14 and C++17
11573 verifyFormat("auto [a, b] = f();");
11574 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();"));
11575 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();"));
11576 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();"));
11577 EXPECT_EQ("auto const volatile [a, b] = f();",
11578 format("auto const volatile[a, b] = f();"));
11579 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();"));
11580 EXPECT_EQ("auto & [a, b, c] = f();",
11581 format("auto &[ a , b,c ] = f();"));
11582 EXPECT_EQ("auto && [a, b, c] = f();",
11583 format("auto &&[ a , b,c ] = f();"));
11584 EXPECT_EQ("auto const & [a, b] = f();", format("auto const&[a, b] = f();"));
11585 EXPECT_EQ("auto const volatile && [a, b] = f();",
11586 format("auto const volatile &&[a, b] = f();"));
11587 EXPECT_EQ("auto && [a, b] = f();", format("auto &&[a, b] = f();"));
11588
11589 format::FormatStyle Spaces = format::getLLVMStyle();
11590 Spaces.SpacesInSquareBrackets = true;
11591 verifyFormat("auto [ a, b ] = f();", Spaces);
11592 verifyFormat("auto && [ a, b ] = f();", Spaces);
11593}
11594
Daniel Jasperd246a5a2015-06-15 15:25:11 +000011595} // end namespace
11596} // end namespace format
Daniel Jasper8d1832e2013-01-07 13:26:07 +000011597} // end namespace clang