blob: a216c803f1f64f5dce41191514807c076208d393 [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();
442 AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine = true;
443
444 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = true;
445 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
446
447 verifyFormat("if (true) {}", AllowSimpleBracedStatements);
Daniel Jasper6a7d5a72017-06-19 07:40:49 +0000448 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements);
Daniel Jasper17605d32014-05-14 09:33:35 +0000449 verifyFormat("while (true) {}", AllowSimpleBracedStatements);
450 verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
451 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
Daniel Jasper6a7d5a72017-06-19 07:40:49 +0000452 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements);
Daniel Jasper17605d32014-05-14 09:33:35 +0000453 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
454 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
455 verifyFormat("if (true) { //\n"
456 " f();\n"
457 "}",
458 AllowSimpleBracedStatements);
459 verifyFormat("if (true) {\n"
460 " f();\n"
461 " f();\n"
462 "}",
463 AllowSimpleBracedStatements);
Daniel Jaspere9f53572015-04-30 09:24:17 +0000464 verifyFormat("if (true) {\n"
465 " f();\n"
466 "} else {\n"
467 " f();\n"
468 "}",
469 AllowSimpleBracedStatements);
Daniel Jasper17605d32014-05-14 09:33:35 +0000470
Daniel Jasperf92659e2017-06-19 07:45:41 +0000471 verifyFormat("struct A2 {\n"
472 " int X;\n"
473 "};",
474 AllowSimpleBracedStatements);
475 verifyFormat("typedef struct A2 {\n"
476 " int X;\n"
477 "} A2_t;",
478 AllowSimpleBracedStatements);
Daniel Jasperbd630732014-05-22 13:25:26 +0000479 verifyFormat("template <int> struct A2 {\n"
480 " struct B {};\n"
481 "};",
482 AllowSimpleBracedStatements);
483
Daniel Jasper17605d32014-05-14 09:33:35 +0000484 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = false;
485 verifyFormat("if (true) {\n"
486 " f();\n"
487 "}",
488 AllowSimpleBracedStatements);
Daniel Jaspere9f53572015-04-30 09:24:17 +0000489 verifyFormat("if (true) {\n"
490 " f();\n"
491 "} else {\n"
492 " f();\n"
493 "}",
494 AllowSimpleBracedStatements);
Daniel Jasper17605d32014-05-14 09:33:35 +0000495
496 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
497 verifyFormat("while (true) {\n"
498 " f();\n"
499 "}",
500 AllowSimpleBracedStatements);
501 verifyFormat("for (;;) {\n"
502 " f();\n"
503 "}",
504 AllowSimpleBracedStatements);
505}
506
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000507TEST_F(FormatTest, ParseIfElse) {
508 verifyFormat("if (true)\n"
509 " if (true)\n"
510 " if (true)\n"
511 " f();\n"
512 " else\n"
513 " g();\n"
514 " else\n"
515 " h();\n"
516 "else\n"
517 " i();");
518 verifyFormat("if (true)\n"
519 " if (true)\n"
520 " if (true) {\n"
Daniel Jasper1b750ed2013-01-14 16:24:39 +0000521 " if (true)\n"
522 " f();\n"
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000523 " } else {\n"
524 " g();\n"
525 " }\n"
526 " else\n"
527 " h();\n"
528 "else {\n"
529 " i();\n"
530 "}");
Daniel Jasper6a7d5a72017-06-19 07:40:49 +0000531 verifyFormat("if (true)\n"
532 " if constexpr (true)\n"
533 " if (true) {\n"
534 " if constexpr (true)\n"
535 " f();\n"
536 " } else {\n"
537 " g();\n"
538 " }\n"
539 " else\n"
540 " h();\n"
541 "else {\n"
542 " i();\n"
543 "}");
Daniel Jasper88f92222013-09-17 08:28:05 +0000544 verifyFormat("void f() {\n"
545 " if (a) {\n"
546 " } else {\n"
547 " }\n"
548 "}");
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000549}
550
551TEST_F(FormatTest, ElseIf) {
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000552 verifyFormat("if (a) {\n} else if (b) {\n}");
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000553 verifyFormat("if (a)\n"
554 " f();\n"
555 "else if (b)\n"
556 " g();\n"
557 "else\n"
558 " h();");
Daniel Jasper6a7d5a72017-06-19 07:40:49 +0000559 verifyFormat("if constexpr (a)\n"
560 " f();\n"
561 "else if constexpr (b)\n"
562 " g();\n"
563 "else\n"
564 " h();");
Daniel Jasper16fc7542013-10-30 14:04:10 +0000565 verifyFormat("if (a) {\n"
566 " f();\n"
567 "}\n"
568 "// or else ..\n"
569 "else {\n"
570 " g()\n"
571 "}");
Daniel Jasper8acf8222014-05-07 09:23:05 +0000572
573 verifyFormat("if (a) {\n"
574 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
575 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
576 "}");
Daniel Jaspera42de762015-02-26 09:49:08 +0000577 verifyFormat("if (a) {\n"
578 "} else if (\n"
579 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
580 "}",
581 getLLVMStyleWithColumns(62));
Daniel Jasper6a7d5a72017-06-19 07:40:49 +0000582 verifyFormat("if (a) {\n"
583 "} else if constexpr (\n"
584 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
585 "}",
586 getLLVMStyleWithColumns(62));
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000587}
588
Daniel Jasperf7935112012-12-03 18:12:45 +0000589TEST_F(FormatTest, FormatsForLoop) {
590 verifyFormat(
591 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n"
Alexander Kornienko37d6c942012-12-05 15:06:06 +0000592 " ++VeryVeryLongLoopVariable)\n"
593 " ;");
594 verifyFormat("for (;;)\n"
595 " f();");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000596 verifyFormat("for (;;) {\n}");
Alexander Kornienko37d6c942012-12-05 15:06:06 +0000597 verifyFormat("for (;;) {\n"
598 " f();\n"
599 "}");
Daniel Jasper72463d32013-05-03 14:50:50 +0000600 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}");
Daniel Jasperfbde69e2012-12-21 14:37:20 +0000601
602 verifyFormat(
603 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
604 " E = UnwrappedLines.end();\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000605 " I != E; ++I) {\n}");
Daniel Jasperfbde69e2012-12-21 14:37:20 +0000606
607 verifyFormat(
608 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000609 " ++IIIII) {\n}");
Daniel Jaspera628c982013-04-03 13:36:17 +0000610 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n"
611 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000612 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}");
Daniel Jasper37905f72013-02-21 15:00:29 +0000613 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n"
614 " I = FD->getDeclsInPrototypeScope().begin(),\n"
615 " E = FD->getDeclsInPrototypeScope().end();\n"
616 " I != E; ++I) {\n}");
Daniel Jasperd6e09e82015-05-19 11:51:39 +0000617 verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n"
618 " I = Container.begin(),\n"
619 " E = Container.end();\n"
620 " I != E; ++I) {\n}",
621 getLLVMStyleWithColumns(76));
Daniel Jasper48c62f92013-01-28 17:30:17 +0000622
Daniel Jasper48c62f92013-01-28 17:30:17 +0000623 verifyFormat(
624 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
625 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n"
Daniel Jasper98f8ae32015-03-06 10:57:12 +0000626 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
627 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
Daniel Jasper48c62f92013-01-28 17:30:17 +0000628 " ++aaaaaaaaaaa) {\n}");
Daniel Jasper98f8ae32015-03-06 10:57:12 +0000629 verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
630 " bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n"
631 " ++i) {\n}");
Daniel Jasper2cf17bf2013-02-27 09:47:53 +0000632 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n"
633 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
634 "}");
Daniel Jaspera628c982013-04-03 13:36:17 +0000635 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n"
636 " aaaaaaaaaa);\n"
637 " iter; ++iter) {\n"
638 "}");
Daniel Jasper3bacc4d2015-07-07 16:09:39 +0000639 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
640 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
641 " aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n"
642 " ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {");
Daniel Jasperf7f13c02013-02-04 07:30:30 +0000643
Daniel Jasper2cf17bf2013-02-27 09:47:53 +0000644 FormatStyle NoBinPacking = getLLVMStyle();
645 NoBinPacking.BinPackParameters = false;
646 verifyFormat("for (int aaaaaaaaaaa = 1;\n"
647 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n"
648 " aaaaaaaaaaaaaaaa,\n"
649 " aaaaaaaaaaaaaaaa,\n"
650 " aaaaaaaaaaaaaaaa);\n"
651 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
652 "}",
653 NoBinPacking);
654 verifyFormat(
Daniel Jaspercd8599e2013-02-23 21:01:55 +0000655 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
656 " E = UnwrappedLines.end();\n"
657 " I != E;\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +0000658 " ++I) {\n}",
659 NoBinPacking);
Daniel Jasperf7935112012-12-03 18:12:45 +0000660}
661
Daniel Jasper0b41cbb2013-01-28 13:21:16 +0000662TEST_F(FormatTest, RangeBasedForLoops) {
663 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
664 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
665 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n"
666 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}");
Daniel Jasper16b35622013-02-26 13:18:08 +0000667 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n"
668 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasper9cc3e972014-02-07 10:09:46 +0000669 verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n"
670 " aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}");
Daniel Jasper0b41cbb2013-01-28 13:21:16 +0000671}
672
Daniel Jaspere1e43192014-04-01 12:55:11 +0000673TEST_F(FormatTest, ForEachLoops) {
674 verifyFormat("void f() {\n"
675 " foreach (Item *item, itemlist) {}\n"
676 " Q_FOREACH (Item *item, itemlist) {}\n"
677 " BOOST_FOREACH (Item *item, itemlist) {}\n"
678 " UNKNOWN_FORACH(Item * item, itemlist) {}\n"
679 "}");
Daniel Jasper229628b2015-06-11 08:38:19 +0000680
681 // As function-like macros.
682 verifyFormat("#define foreach(x, y)\n"
683 "#define Q_FOREACH(x, y)\n"
684 "#define BOOST_FOREACH(x, y)\n"
685 "#define UNKNOWN_FOREACH(x, y)\n");
686
687 // Not as function-like macros.
688 verifyFormat("#define foreach (x, y)\n"
689 "#define Q_FOREACH (x, y)\n"
690 "#define BOOST_FOREACH (x, y)\n"
691 "#define UNKNOWN_FOREACH (x, y)\n");
Daniel Jaspere1e43192014-04-01 12:55:11 +0000692}
693
Daniel Jasperf7935112012-12-03 18:12:45 +0000694TEST_F(FormatTest, FormatsWhileLoop) {
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000695 verifyFormat("while (true) {\n}");
Alexander Kornienko37d6c942012-12-05 15:06:06 +0000696 verifyFormat("while (true)\n"
697 " f();");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000698 verifyFormat("while () {\n}");
Alexander Kornienko37d6c942012-12-05 15:06:06 +0000699 verifyFormat("while () {\n"
700 " f();\n"
701 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +0000702}
703
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000704TEST_F(FormatTest, FormatsDoWhile) {
705 verifyFormat("do {\n"
706 " do_something();\n"
707 "} while (something());");
708 verifyFormat("do\n"
709 " do_something();\n"
710 "while (something());");
Daniel Jasperf7935112012-12-03 18:12:45 +0000711}
712
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000713TEST_F(FormatTest, FormatsSwitchStatement) {
Daniel Jasperf7935112012-12-03 18:12:45 +0000714 verifyFormat("switch (x) {\n"
715 "case 1:\n"
716 " f();\n"
717 " break;\n"
718 "case kFoo:\n"
719 "case ns::kBar:\n"
720 "case kBaz:\n"
721 " break;\n"
722 "default:\n"
723 " g();\n"
724 " break;\n"
725 "}");
726 verifyFormat("switch (x) {\n"
727 "case 1: {\n"
728 " f();\n"
729 " break;\n"
730 "}\n"
Daniel Jasper922349c2014-04-04 06:46:23 +0000731 "case 2: {\n"
732 " break;\n"
733 "}\n"
Daniel Jasperf7935112012-12-03 18:12:45 +0000734 "}");
Nico Webera5510af2013-01-18 05:50:57 +0000735 verifyFormat("switch (x) {\n"
736 "case 1: {\n"
737 " f();\n"
738 " {\n"
739 " g();\n"
740 " h();\n"
741 " }\n"
742 " break;\n"
743 "}\n"
744 "}");
745 verifyFormat("switch (x) {\n"
746 "case 1: {\n"
747 " f();\n"
748 " if (foo) {\n"
749 " g();\n"
750 " h();\n"
751 " }\n"
752 " break;\n"
753 "}\n"
754 "}");
755 verifyFormat("switch (x) {\n"
756 "case 1: {\n"
757 " f();\n"
758 " g();\n"
759 "} break;\n"
760 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +0000761 verifyFormat("switch (test)\n"
762 " ;");
Daniel Jasper18104652013-03-12 12:26:55 +0000763 verifyFormat("switch (x) {\n"
764 "default: {\n"
765 " // Do nothing.\n"
Manuel Klimek1a18c402013-04-12 14:13:36 +0000766 "}\n"
Daniel Jasper18104652013-03-12 12:26:55 +0000767 "}");
Daniel Jasper0f8ed9e2013-03-13 15:53:12 +0000768 verifyFormat("switch (x) {\n"
Daniel Jasperb67cc422013-04-09 17:46:55 +0000769 "// comment\n"
Daniel Jasper0f8ed9e2013-03-13 15:53:12 +0000770 "// if 1, do f()\n"
771 "case 1:\n"
772 " f();\n"
773 "}");
Daniel Jasper2bd32ca2013-03-19 18:33:58 +0000774 verifyFormat("switch (x) {\n"
775 "case 1:\n"
776 " // Do amazing stuff\n"
777 " {\n"
778 " f();\n"
779 " g();\n"
780 " }\n"
781 " break;\n"
782 "}");
Daniel Jaspera1275122013-03-20 10:23:53 +0000783 verifyFormat("#define A \\\n"
784 " switch (x) { \\\n"
785 " case a: \\\n"
786 " foo = b; \\\n"
Daniel Jaspera44991332015-04-29 13:06:49 +0000787 " }",
788 getLLVMStyleWithColumns(20));
Daniel Jasper72407622013-09-02 08:26:29 +0000789 verifyFormat("#define OPERATION_CASE(name) \\\n"
790 " case OP_name: \\\n"
791 " return operations::Operation##name\n",
792 getLLVMStyleWithColumns(40));
Daniel Jasper1fe0d5c2015-05-06 15:19:47 +0000793 verifyFormat("switch (x) {\n"
794 "case 1:;\n"
795 "default:;\n"
796 " int i;\n"
797 "}");
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000798
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000799 verifyGoogleFormat("switch (x) {\n"
800 " case 1:\n"
801 " f();\n"
802 " break;\n"
803 " case kFoo:\n"
804 " case ns::kBar:\n"
805 " case kBaz:\n"
806 " break;\n"
807 " default:\n"
808 " g();\n"
809 " break;\n"
810 "}");
811 verifyGoogleFormat("switch (x) {\n"
812 " case 1: {\n"
813 " f();\n"
814 " break;\n"
815 " }\n"
816 "}");
817 verifyGoogleFormat("switch (test)\n"
Daniel Jasper516d7972013-07-25 11:31:57 +0000818 " ;");
819
820 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n"
821 " case OP_name: \\\n"
822 " return operations::Operation##name\n");
823 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n"
824 " // Get the correction operation class.\n"
825 " switch (OpCode) {\n"
826 " CASE(Add);\n"
827 " CASE(Subtract);\n"
828 " default:\n"
829 " return operations::Unknown;\n"
830 " }\n"
831 "#undef OPERATION_CASE\n"
832 "}");
Daniel Jasper1c5d9df2013-09-06 07:54:20 +0000833 verifyFormat("DEBUG({\n"
834 " switch (x) {\n"
835 " case A:\n"
836 " f();\n"
837 " break;\n"
Krasimir Georgieve0926342017-07-12 15:21:43 +0000838 " // fallthrough\n"
Daniel Jasper1c5d9df2013-09-06 07:54:20 +0000839 " case B:\n"
840 " g();\n"
841 " break;\n"
842 " }\n"
843 "});");
Krasimir Georgieve0926342017-07-12 15:21:43 +0000844 EXPECT_EQ("DEBUG({\n"
845 " switch (x) {\n"
846 " case A:\n"
847 " f();\n"
848 " break;\n"
849 " // On B:\n"
850 " case B:\n"
851 " g();\n"
852 " break;\n"
853 " }\n"
854 "});",
855 format("DEBUG({\n"
856 " switch (x) {\n"
857 " case A:\n"
858 " f();\n"
859 " break;\n"
860 " // On B:\n"
861 " case B:\n"
862 " g();\n"
863 " break;\n"
864 " }\n"
865 "});",
866 getLLVMStyle()));
Daniel Jasper031e2402014-04-28 07:48:36 +0000867 verifyFormat("switch (a) {\n"
868 "case (b):\n"
869 " return;\n"
870 "}");
Daniel Jasperd39312ec2014-05-28 10:09:11 +0000871
872 verifyFormat("switch (a) {\n"
873 "case some_namespace::\n"
874 " some_constant:\n"
875 " return;\n"
876 "}",
877 getLLVMStyleWithColumns(34));
Daniel Jasperf7935112012-12-03 18:12:45 +0000878}
879
Daniel Jasper2d0cd492013-10-20 16:56:16 +0000880TEST_F(FormatTest, CaseRanges) {
881 verifyFormat("switch (x) {\n"
882 "case 'A' ... 'Z':\n"
883 "case 1 ... 5:\n"
Daniel Jaspere2fab132016-05-19 06:19:17 +0000884 "case a ... b:\n"
Daniel Jasper2d0cd492013-10-20 16:56:16 +0000885 " break;\n"
886 "}");
887}
888
Daniel Jasperb87899b2014-09-10 13:11:45 +0000889TEST_F(FormatTest, ShortCaseLabels) {
890 FormatStyle Style = getLLVMStyle();
891 Style.AllowShortCaseLabelsOnASingleLine = true;
892 verifyFormat("switch (a) {\n"
893 "case 1: x = 1; break;\n"
894 "case 2: return;\n"
895 "case 3:\n"
896 "case 4:\n"
897 "case 5: return;\n"
Daniel Jasperd081e882014-11-21 12:36:25 +0000898 "case 6: // comment\n"
899 " return;\n"
900 "case 7:\n"
901 " // comment\n"
902 " return;\n"
Daniel Jasper368369b2015-09-21 09:50:01 +0000903 "case 8:\n"
904 " x = 8; // comment\n"
905 " break;\n"
Daniel Jasperb87899b2014-09-10 13:11:45 +0000906 "default: y = 1; break;\n"
907 "}",
908 Style);
909 verifyFormat("switch (a) {\n"
Francois Ferranda64ba702017-07-28 07:56:18 +0000910 "case 0: return; // comment\n"
911 "case 1: break; // comment\n"
912 "case 2: return;\n"
913 "// comment\n"
914 "case 3: return;\n"
915 "// comment 1\n"
916 "// comment 2\n"
917 "// comment 3\n"
918 "case 4: break; /* comment */\n"
919 "case 5:\n"
920 " // comment\n"
921 " break;\n"
922 "case 6: /* comment */ x = 1; break;\n"
923 "case 7: x = /* comment */ 1; break;\n"
924 "case 8:\n"
925 " x = 1; /* comment */\n"
926 " break;\n"
927 "case 9:\n"
928 " break; // comment line 1\n"
929 " // comment line 2\n"
930 "}",
931 Style);
932 EXPECT_EQ("switch (a) {\n"
933 "case 1:\n"
934 " x = 8;\n"
935 " // fall through\n"
936 "case 2: x = 8;\n"
937 "// comment\n"
938 "case 3:\n"
939 " return; /* comment line 1\n"
940 " * comment line 2 */\n"
941 "case 4: i = 8;\n"
942 "// something else\n"
943 "#if FOO\n"
944 "case 5: break;\n"
945 "#endif\n"
946 "}",
947 format("switch (a) {\n"
948 "case 1: x = 8;\n"
949 " // fall through\n"
950 "case 2:\n"
951 " x = 8;\n"
952 "// comment\n"
953 "case 3:\n"
954 " return; /* comment line 1\n"
955 " * comment line 2 */\n"
956 "case 4:\n"
957 " i = 8;\n"
958 "// something else\n"
959 "#if FOO\n"
960 "case 5: break;\n"
961 "#endif\n"
962 "}",
963 Style));
964 EXPECT_EQ("switch (a) {\n" "case 0:\n"
965 " return; // long long long long long long long long long long long long comment\n"
966 " // line\n" "}",
967 format("switch (a) {\n"
968 "case 0: return; // long long long long long long long long long long long long comment line\n"
969 "}",
970 Style));
971 EXPECT_EQ("switch (a) {\n"
972 "case 0:\n"
973 " return; /* long long long long long long long long long long long long comment\n"
974 " line */\n"
975 "}",
976 format("switch (a) {\n"
977 "case 0: return; /* long long long long long long long long long long long long comment line */\n"
978 "}",
979 Style));
980 verifyFormat("switch (a) {\n"
Daniel Jasper79f226e2014-11-23 21:45:03 +0000981 "#if FOO\n"
982 "case 0: return 0;\n"
983 "#endif\n"
984 "}",
985 Style);
986 verifyFormat("switch (a) {\n"
Daniel Jasperb87899b2014-09-10 13:11:45 +0000987 "case 1: {\n"
988 "}\n"
989 "case 2: {\n"
990 " return;\n"
991 "}\n"
992 "case 3: {\n"
993 " x = 1;\n"
994 " return;\n"
995 "}\n"
996 "case 4:\n"
997 " if (x)\n"
998 " return;\n"
999 "}",
1000 Style);
1001 Style.ColumnLimit = 21;
1002 verifyFormat("switch (a) {\n"
1003 "case 1: x = 1; break;\n"
1004 "case 2: return;\n"
1005 "case 3:\n"
1006 "case 4:\n"
1007 "case 5: return;\n"
1008 "default:\n"
1009 " y = 1;\n"
1010 " break;\n"
1011 "}",
1012 Style);
1013}
1014
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001015TEST_F(FormatTest, FormatsLabels) {
Daniel Jasperf7935112012-12-03 18:12:45 +00001016 verifyFormat("void f() {\n"
1017 " some_code();\n"
1018 "test_label:\n"
1019 " some_other_code();\n"
1020 " {\n"
1021 " some_more_code();\n"
1022 " another_label:\n"
1023 " some_more_code();\n"
1024 " }\n"
1025 "}");
Daniel Jasper676e5162015-04-07 14:36:33 +00001026 verifyFormat("{\n"
1027 " some_code();\n"
Daniel Jasperf7935112012-12-03 18:12:45 +00001028 "test_label:\n"
Daniel Jasper676e5162015-04-07 14:36:33 +00001029 " some_other_code();\n"
1030 "}");
Daniel Jasper1fe0d5c2015-05-06 15:19:47 +00001031 verifyFormat("{\n"
1032 " some_code();\n"
1033 "test_label:;\n"
1034 " int i = 0;\n"
1035 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +00001036}
1037
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001038//===----------------------------------------------------------------------===//
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001039// Tests for classes, namespaces, etc.
1040//===----------------------------------------------------------------------===//
1041
1042TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) {
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001043 verifyFormat("class A {};");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001044}
1045
1046TEST_F(FormatTest, UnderstandsAccessSpecifiers) {
1047 verifyFormat("class A {\n"
1048 "public:\n"
Daniel Jasperc04baae2013-04-10 09:49:49 +00001049 "public: // comment\n"
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001050 "protected:\n"
1051 "private:\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00001052 " void f() {}\n"
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001053 "};");
1054 verifyGoogleFormat("class A {\n"
1055 " public:\n"
1056 " protected:\n"
1057 " private:\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00001058 " void f() {}\n"
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001059 "};");
Daniel Jasper84c47a12013-11-23 17:53:41 +00001060 verifyFormat("class A {\n"
1061 "public slots:\n"
Daniel Jaspera00de632015-12-01 12:05:04 +00001062 " void f1() {}\n"
Daniel Jasper1556b592013-11-29 08:51:56 +00001063 "public Q_SLOTS:\n"
Daniel Jaspera00de632015-12-01 12:05:04 +00001064 " void f2() {}\n"
1065 "protected slots:\n"
1066 " void f3() {}\n"
1067 "protected Q_SLOTS:\n"
1068 " void f4() {}\n"
1069 "private slots:\n"
1070 " void f5() {}\n"
1071 "private Q_SLOTS:\n"
1072 " void f6() {}\n"
Daniel Jasper53395402015-04-07 15:04:40 +00001073 "signals:\n"
Daniel Jaspera00de632015-12-01 12:05:04 +00001074 " void g1();\n"
1075 "Q_SIGNALS:\n"
1076 " void g2();\n"
Daniel Jasper84c47a12013-11-23 17:53:41 +00001077 "};");
Daniel Jasperde0d1f32015-04-24 07:50:34 +00001078
1079 // Don't interpret 'signals' the wrong way.
1080 verifyFormat("signals.set();");
1081 verifyFormat("for (Signals signals : f()) {\n}");
Daniel Jasper03618142015-05-06 19:21:23 +00001082 verifyFormat("{\n"
1083 " signals.set(); // This needs indentation.\n"
1084 "}");
Daniel Jasper31343832016-07-27 10:13:24 +00001085 verifyFormat("void f() {\n"
1086 "label:\n"
1087 " signals.baz();\n"
1088 "}");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001089}
1090
Alexander Kornienkofd433362013-03-27 17:08:02 +00001091TEST_F(FormatTest, SeparatesLogicalBlocks) {
1092 EXPECT_EQ("class A {\n"
1093 "public:\n"
1094 " void f();\n"
1095 "\n"
1096 "private:\n"
1097 " void g() {}\n"
1098 " // test\n"
1099 "protected:\n"
1100 " int h;\n"
1101 "};",
1102 format("class A {\n"
1103 "public:\n"
1104 "void f();\n"
1105 "private:\n"
1106 "void g() {}\n"
1107 "// test\n"
1108 "protected:\n"
1109 "int h;\n"
1110 "};"));
Daniel Jasper320997e2013-10-06 11:40:08 +00001111 EXPECT_EQ("class A {\n"
1112 "protected:\n"
1113 "public:\n"
1114 " void f();\n"
1115 "};",
1116 format("class A {\n"
1117 "protected:\n"
1118 "\n"
1119 "public:\n"
1120 "\n"
1121 " void f();\n"
1122 "};"));
Daniel Jasperac5c97e32015-03-09 08:13:55 +00001123
1124 // Even ensure proper spacing inside macros.
1125 EXPECT_EQ("#define B \\\n"
1126 " class A { \\\n"
1127 " protected: \\\n"
1128 " public: \\\n"
1129 " void f(); \\\n"
1130 " };",
1131 format("#define B \\\n"
1132 " class A { \\\n"
1133 " protected: \\\n"
1134 " \\\n"
1135 " public: \\\n"
1136 " \\\n"
1137 " void f(); \\\n"
1138 " };",
1139 getGoogleStyle()));
1140 // But don't remove empty lines after macros ending in access specifiers.
1141 EXPECT_EQ("#define A private:\n"
1142 "\n"
1143 "int i;",
1144 format("#define A private:\n"
1145 "\n"
1146 "int i;"));
Alexander Kornienkofd433362013-03-27 17:08:02 +00001147}
1148
Daniel Jasper83193602013-04-05 17:22:09 +00001149TEST_F(FormatTest, FormatsClasses) {
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001150 verifyFormat("class A : public B {};");
1151 verifyFormat("class A : public ::B {};");
Daniel Jaspereead02b2013-02-14 08:42:54 +00001152
1153 verifyFormat(
1154 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001155 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
Daniel Jaspera61aefb2013-05-06 06:45:09 +00001156 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
1157 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001158 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
Daniel Jaspereead02b2013-02-14 08:42:54 +00001159 verifyFormat(
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001160 "class A : public B, public C, public D, public E, public F {};");
Daniel Jaspereead02b2013-02-14 08:42:54 +00001161 verifyFormat("class AAAAAAAAAAAA : public B,\n"
1162 " public C,\n"
1163 " public D,\n"
1164 " public E,\n"
1165 " public F,\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001166 " public G {};");
Daniel Jasper83193602013-04-05 17:22:09 +00001167
1168 verifyFormat("class\n"
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00001169 " ReallyReallyLongClassName {\n"
1170 " int i;\n"
1171 "};",
Daniel Jasper83193602013-04-05 17:22:09 +00001172 getLLVMStyleWithColumns(32));
Daniel Jasperf9a5e402013-10-08 16:24:07 +00001173 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n"
1174 " aaaaaaaaaaaaaaaa> {};");
1175 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n"
1176 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n"
1177 " aaaaaaaaaaaaaaaaaaaaaa> {};");
Daniel Jasper3a122c02014-02-14 18:22:40 +00001178 verifyFormat("template <class R, class C>\n"
1179 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n"
1180 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};");
Manuel Klimek45bf56c2014-07-31 07:19:30 +00001181 verifyFormat("class ::A::B {};");
Daniel Jasperf7935112012-12-03 18:12:45 +00001182}
1183
Andi-Bogdan Postelnicu0ef8ee12017-03-10 15:10:37 +00001184TEST_F(FormatTest, BreakBeforeInheritanceComma) {
1185 FormatStyle StyleWithInheritanceBreak = getLLVMStyle();
1186 StyleWithInheritanceBreak.BreakBeforeInheritanceComma = true;
1187
1188 verifyFormat("class MyClass : public X {};", StyleWithInheritanceBreak);
1189 verifyFormat("class MyClass\n"
1190 " : public X\n"
1191 " , public Y {};",
1192 StyleWithInheritanceBreak);
1193}
1194
Manuel Klimek28cacc72013-01-07 18:10:23 +00001195TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) {
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00001196 verifyFormat("class A {\n} a, b;");
1197 verifyFormat("struct A {\n} a, b;");
1198 verifyFormat("union A {\n} a;");
Manuel Klimek28cacc72013-01-07 18:10:23 +00001199}
1200
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001201TEST_F(FormatTest, FormatsEnum) {
Alexander Kornienkob7076a22012-12-04 14:46:19 +00001202 verifyFormat("enum {\n"
1203 " Zero,\n"
1204 " One = 1,\n"
1205 " Two = One + 1,\n"
1206 " Three = (One + Two),\n"
1207 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1208 " Five = (One, Two, Three, Four, 5)\n"
1209 "};");
Daniel Jasper015ed022013-09-13 09:20:45 +00001210 verifyGoogleFormat("enum {\n"
1211 " Zero,\n"
1212 " One = 1,\n"
1213 " Two = One + 1,\n"
1214 " Three = (One + Two),\n"
1215 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1216 " Five = (One, Two, Three, Four, 5)\n"
1217 "};");
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001218 verifyFormat("enum Enum {};");
1219 verifyFormat("enum {};");
Daniel Jasper015ed022013-09-13 09:20:45 +00001220 verifyFormat("enum X E {} d;");
1221 verifyFormat("enum __attribute__((...)) E {} d;");
1222 verifyFormat("enum __declspec__((...)) E {} d;");
Daniel Jasper015ed022013-09-13 09:20:45 +00001223 verifyFormat("enum {\n"
1224 " Bar = Foo<int, int>::value\n"
Daniel Jasper96972812014-01-05 12:38:10 +00001225 "};",
1226 getLLVMStyleWithColumns(30));
1227
1228 verifyFormat("enum ShortEnum { A, B, C };");
Daniel Jasper1a148b42014-01-05 13:23:23 +00001229 verifyGoogleFormat("enum ShortEnum { A, B, C };");
Daniel Jaspera69ca9b2014-06-04 12:40:57 +00001230
1231 EXPECT_EQ("enum KeepEmptyLines {\n"
1232 " ONE,\n"
1233 "\n"
1234 " TWO,\n"
1235 "\n"
1236 " THREE\n"
1237 "}",
1238 format("enum KeepEmptyLines {\n"
1239 " ONE,\n"
1240 "\n"
1241 " TWO,\n"
1242 "\n"
1243 "\n"
1244 " THREE\n"
1245 "}"));
Daniel Jasper90818052014-06-10 10:42:26 +00001246 verifyFormat("enum E { // comment\n"
1247 " ONE,\n"
1248 " TWO\n"
Daniel Jasper502fac32014-11-05 10:55:36 +00001249 "};\n"
1250 "int i;");
Daniel Jasper47721ac2015-06-18 15:45:17 +00001251 // Not enums.
1252 verifyFormat("enum X f() {\n"
1253 " a();\n"
1254 " return 42;\n"
1255 "}");
Daniel Jasperb5a0b852015-06-19 08:17:32 +00001256 verifyFormat("enum X Type::f() {\n"
1257 " a();\n"
1258 " return 42;\n"
1259 "}");
Daniel Jasper47721ac2015-06-18 15:45:17 +00001260 verifyFormat("enum ::X f() {\n"
1261 " a();\n"
1262 " return 42;\n"
1263 "}");
1264 verifyFormat("enum ns::X f() {\n"
1265 " a();\n"
1266 " return 42;\n"
1267 "}");
Alexander Kornienkob7076a22012-12-04 14:46:19 +00001268}
1269
Daniel Jasperb7150872013-08-30 10:10:19 +00001270TEST_F(FormatTest, FormatsEnumsWithErrors) {
1271 verifyFormat("enum Type {\n"
Daniel Jasper96972812014-01-05 12:38:10 +00001272 " One = 0; // These semicolons should be commas.\n"
Daniel Jasperb7150872013-08-30 10:10:19 +00001273 " Two = 1;\n"
1274 "};");
1275 verifyFormat("namespace n {\n"
1276 "enum Type {\n"
1277 " One,\n"
Daniel Jasper96972812014-01-05 12:38:10 +00001278 " Two, // missing };\n"
Daniel Jasperb7150872013-08-30 10:10:19 +00001279 " int i;\n"
1280 "}\n"
1281 "void g() {}");
1282}
1283
Daniel Jasper2b41a822013-08-20 12:42:50 +00001284TEST_F(FormatTest, FormatsEnumStruct) {
1285 verifyFormat("enum struct {\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 "};");
1293 verifyFormat("enum struct Enum {};");
1294 verifyFormat("enum struct {};");
Daniel Jasper015ed022013-09-13 09:20:45 +00001295 verifyFormat("enum struct X E {} d;");
1296 verifyFormat("enum struct __attribute__((...)) E {} d;");
1297 verifyFormat("enum struct __declspec__((...)) E {} d;");
Daniel Jasper2b41a822013-08-20 12:42:50 +00001298 verifyFormat("enum struct X f() {\n a();\n return 42;\n}");
1299}
1300
1301TEST_F(FormatTest, FormatsEnumClass) {
1302 verifyFormat("enum class {\n"
1303 " Zero,\n"
1304 " One = 1,\n"
1305 " Two = One + 1,\n"
1306 " Three = (One + Two),\n"
1307 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1308 " Five = (One, Two, Three, Four, 5)\n"
1309 "};");
1310 verifyFormat("enum class Enum {};");
1311 verifyFormat("enum class {};");
Daniel Jasper015ed022013-09-13 09:20:45 +00001312 verifyFormat("enum class X E {} d;");
1313 verifyFormat("enum class __attribute__((...)) E {} d;");
1314 verifyFormat("enum class __declspec__((...)) E {} d;");
Daniel Jasper2b41a822013-08-20 12:42:50 +00001315 verifyFormat("enum class X f() {\n a();\n return 42;\n}");
1316}
1317
Manuel Klimek9a53c7f2013-09-05 15:34:55 +00001318TEST_F(FormatTest, FormatsEnumTypes) {
1319 verifyFormat("enum X : int {\n"
Daniel Jasper96972812014-01-05 12:38:10 +00001320 " A, // Force multiple lines.\n"
Manuel Klimek9a53c7f2013-09-05 15:34:55 +00001321 " B\n"
1322 "};");
Daniel Jasper96972812014-01-05 12:38:10 +00001323 verifyFormat("enum X : int { A, B };");
1324 verifyFormat("enum X : std::uint32_t { A, B };");
Manuel Klimek9a53c7f2013-09-05 15:34:55 +00001325}
1326
Krasimir Georgiev81341d72017-08-29 13:32:30 +00001327TEST_F(FormatTest, FormatsTypedefEnum) {
1328 FormatStyle Style = getLLVMStyle();
1329 Style.ColumnLimit = 40;
1330 verifyFormat("typedef enum {} EmptyEnum;");
1331 verifyFormat("typedef enum { A, B, C } ShortEnum;");
1332 verifyFormat("typedef enum {\n"
1333 " ZERO = 0,\n"
1334 " ONE = 1,\n"
1335 " TWO = 2,\n"
1336 " THREE = 3\n"
1337 "} LongEnum;",
1338 Style);
1339 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
1340 Style.BraceWrapping.AfterEnum = true;
1341 verifyFormat("typedef enum {} EmptyEnum;");
1342 verifyFormat("typedef enum { A, B, C } ShortEnum;");
1343 verifyFormat("typedef enum\n"
1344 "{\n"
1345 " ZERO = 0,\n"
1346 " ONE = 1,\n"
1347 " TWO = 2,\n"
1348 " THREE = 3\n"
1349 "} LongEnum;",
1350 Style);
1351}
1352
Daniel Jaspera88f80a2014-01-30 14:38:37 +00001353TEST_F(FormatTest, FormatsNSEnums) {
1354 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }");
1355 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n"
1356 " // Information about someDecentlyLongValue.\n"
1357 " someDecentlyLongValue,\n"
1358 " // Information about anotherDecentlyLongValue.\n"
1359 " anotherDecentlyLongValue,\n"
1360 " // Information about aThirdDecentlyLongValue.\n"
1361 " aThirdDecentlyLongValue\n"
1362 "};");
Daniel Jasper31f6c542014-12-05 10:42:21 +00001363 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n"
1364 " a = 1,\n"
1365 " b = 2,\n"
1366 " c = 3,\n"
1367 "};");
1368 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n"
1369 " a = 1,\n"
1370 " b = 2,\n"
1371 " c = 3,\n"
1372 "};");
1373 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n"
1374 " a = 1,\n"
1375 " b = 2,\n"
1376 " c = 3,\n"
1377 "};");
Daniel Jaspera88f80a2014-01-30 14:38:37 +00001378}
1379
Nico Weber7769a902013-01-14 05:49:49 +00001380TEST_F(FormatTest, FormatsBitfields) {
1381 verifyFormat("struct Bitfields {\n"
1382 " unsigned sClass : 8;\n"
1383 " unsigned ValueKind : 2;\n"
1384 "};");
Alexander Kornienko60d1b042013-10-10 13:36:20 +00001385 verifyFormat("struct A {\n"
1386 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n"
1387 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n"
1388 "};");
Daniel Jasper676e5162015-04-07 14:36:33 +00001389 verifyFormat("struct MyStruct {\n"
1390 " uchar data;\n"
1391 " uchar : 8;\n"
1392 " uchar : 8;\n"
1393 " uchar other;\n"
1394 "};");
Nico Weber7769a902013-01-14 05:49:49 +00001395}
1396
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001397TEST_F(FormatTest, FormatsNamespaces) {
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001398 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
1399 LLVMWithNoNamespaceFix.FixNamespaceComments = false;
1400
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001401 verifyFormat("namespace some_namespace {\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001402 "class A {};\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00001403 "void f() { f(); }\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001404 "}",
1405 LLVMWithNoNamespaceFix);
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001406 verifyFormat("namespace {\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001407 "class A {};\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00001408 "void f() { f(); }\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001409 "}",
1410 LLVMWithNoNamespaceFix);
Dmitri Gribenko58d64e22012-12-30 21:27:25 +00001411 verifyFormat("inline namespace X {\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001412 "class A {};\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00001413 "void f() { f(); }\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001414 "}",
1415 LLVMWithNoNamespaceFix);
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001416 verifyFormat("using namespace some_namespace;\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001417 "class A {};\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001418 "void f() { f(); }",
1419 LLVMWithNoNamespaceFix);
Manuel Klimek046b9302013-02-06 16:08:09 +00001420
1421 // This code is more common than we thought; if we
1422 // layout this correctly the semicolon will go into
Alp Tokerf6a24ce2013-12-05 16:25:25 +00001423 // its own line, which is undesirable.
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001424 verifyFormat("namespace {};",
1425 LLVMWithNoNamespaceFix);
Manuel Klimek046b9302013-02-06 16:08:09 +00001426 verifyFormat("namespace {\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001427 "class A {};\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001428 "};",
1429 LLVMWithNoNamespaceFix);
Daniel Jasper251b3c92013-07-01 11:22:57 +00001430
1431 verifyFormat("namespace {\n"
1432 "int SomeVariable = 0; // comment\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001433 "} // namespace",
1434 LLVMWithNoNamespaceFix);
Daniel Jasper251b3c92013-07-01 11:22:57 +00001435 EXPECT_EQ("#ifndef HEADER_GUARD\n"
1436 "#define HEADER_GUARD\n"
1437 "namespace my_namespace {\n"
1438 "int i;\n"
1439 "} // my_namespace\n"
1440 "#endif // HEADER_GUARD",
1441 format("#ifndef HEADER_GUARD\n"
1442 " #define HEADER_GUARD\n"
1443 " namespace my_namespace {\n"
1444 "int i;\n"
1445 "} // my_namespace\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001446 "#endif // HEADER_GUARD",
1447 LLVMWithNoNamespaceFix));
Daniel Jasper65ee3472013-07-31 23:16:02 +00001448
Saleem Abdulrasool328085f2015-10-30 05:07:56 +00001449 EXPECT_EQ("namespace A::B {\n"
1450 "class C {};\n"
1451 "}",
1452 format("namespace A::B {\n"
1453 "class C {};\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001454 "}",
1455 LLVMWithNoNamespaceFix));
Saleem Abdulrasool328085f2015-10-30 05:07:56 +00001456
Daniel Jasper65ee3472013-07-31 23:16:02 +00001457 FormatStyle Style = getLLVMStyle();
1458 Style.NamespaceIndentation = FormatStyle::NI_All;
1459 EXPECT_EQ("namespace out {\n"
1460 " int i;\n"
1461 " namespace in {\n"
1462 " int i;\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001463 " } // namespace in\n"
1464 "} // namespace out",
Daniel Jasper65ee3472013-07-31 23:16:02 +00001465 format("namespace out {\n"
1466 "int i;\n"
1467 "namespace in {\n"
1468 "int i;\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001469 "} // namespace in\n"
1470 "} // namespace out",
Daniel Jasper65ee3472013-07-31 23:16:02 +00001471 Style));
1472
1473 Style.NamespaceIndentation = FormatStyle::NI_Inner;
1474 EXPECT_EQ("namespace out {\n"
1475 "int i;\n"
1476 "namespace in {\n"
1477 " int i;\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001478 "} // namespace in\n"
1479 "} // namespace out",
Daniel Jasper65ee3472013-07-31 23:16:02 +00001480 format("namespace out {\n"
1481 "int i;\n"
1482 "namespace in {\n"
1483 "int i;\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001484 "} // namespace in\n"
1485 "} // namespace out",
Daniel Jasper65ee3472013-07-31 23:16:02 +00001486 Style));
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001487}
1488
Francois Ferrande56a8292017-06-14 12:29:47 +00001489TEST_F(FormatTest, FormatsCompactNamespaces) {
1490 FormatStyle Style = getLLVMStyle();
1491 Style.CompactNamespaces = true;
1492
1493 verifyFormat("namespace A { namespace B {\n"
1494 "}} // namespace A::B",
1495 Style);
1496
1497 EXPECT_EQ("namespace out { namespace in {\n"
1498 "}} // namespace out::in",
1499 format("namespace out {\n"
1500 "namespace in {\n"
1501 "} // namespace in\n"
1502 "} // namespace out",
1503 Style));
1504
1505 // Only namespaces which have both consecutive opening and end get compacted
1506 EXPECT_EQ("namespace out {\n"
1507 "namespace in1 {\n"
1508 "} // namespace in1\n"
1509 "namespace in2 {\n"
1510 "} // namespace in2\n"
1511 "} // namespace out",
1512 format("namespace out {\n"
1513 "namespace in1 {\n"
1514 "} // namespace in1\n"
1515 "namespace in2 {\n"
1516 "} // namespace in2\n"
1517 "} // namespace out",
1518 Style));
1519
1520 EXPECT_EQ("namespace out {\n"
1521 "int i;\n"
1522 "namespace in {\n"
1523 "int j;\n"
1524 "} // namespace in\n"
1525 "int k;\n"
1526 "} // namespace out",
1527 format("namespace out { int i;\n"
1528 "namespace in { int j; } // namespace in\n"
1529 "int k; } // namespace out",
1530 Style));
1531
1532 EXPECT_EQ("namespace A { namespace B { namespace C {\n"
1533 "}}} // namespace A::B::C\n",
1534 format("namespace A { namespace B {\n"
1535 "namespace C {\n"
1536 "}} // namespace B::C\n"
1537 "} // namespace A\n",
1538 Style));
1539
1540 Style.ColumnLimit = 40;
1541 EXPECT_EQ("namespace aaaaaaaaaa {\n"
1542 "namespace bbbbbbbbbb {\n"
1543 "}} // namespace aaaaaaaaaa::bbbbbbbbbb",
1544 format("namespace aaaaaaaaaa {\n"
1545 "namespace bbbbbbbbbb {\n"
1546 "} // namespace bbbbbbbbbb\n"
1547 "} // namespace aaaaaaaaaa",
1548 Style));
1549
1550 EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n"
1551 "namespace cccccc {\n"
1552 "}}} // namespace aaaaaa::bbbbbb::cccccc",
1553 format("namespace aaaaaa {\n"
1554 "namespace bbbbbb {\n"
1555 "namespace cccccc {\n"
1556 "} // namespace cccccc\n"
1557 "} // namespace bbbbbb\n"
1558 "} // namespace aaaaaa",
1559 Style));
1560 Style.ColumnLimit = 80;
1561
1562 // Extra semicolon after 'inner' closing brace prevents merging
1563 EXPECT_EQ("namespace out { namespace in {\n"
1564 "}; } // namespace out::in",
1565 format("namespace out {\n"
1566 "namespace in {\n"
1567 "}; // namespace in\n"
1568 "} // namespace out",
1569 Style));
1570
1571 // Extra semicolon after 'outer' closing brace is conserved
1572 EXPECT_EQ("namespace out { namespace in {\n"
1573 "}}; // namespace out::in",
1574 format("namespace out {\n"
1575 "namespace in {\n"
1576 "} // namespace in\n"
1577 "}; // namespace out",
1578 Style));
1579
1580 Style.NamespaceIndentation = FormatStyle::NI_All;
1581 EXPECT_EQ("namespace out { namespace in {\n"
1582 " int i;\n"
1583 "}} // namespace out::in",
1584 format("namespace out {\n"
1585 "namespace in {\n"
1586 "int i;\n"
1587 "} // namespace in\n"
1588 "} // namespace out",
1589 Style));
1590 EXPECT_EQ("namespace out { namespace mid {\n"
1591 " namespace in {\n"
1592 " int j;\n"
1593 " } // namespace in\n"
1594 " int k;\n"
1595 "}} // namespace out::mid",
1596 format("namespace out { namespace mid {\n"
1597 "namespace in { int j; } // namespace in\n"
1598 "int k; }} // namespace out::mid",
1599 Style));
1600
1601 Style.NamespaceIndentation = FormatStyle::NI_Inner;
1602 EXPECT_EQ("namespace out { namespace in {\n"
1603 " int i;\n"
1604 "}} // namespace out::in",
1605 format("namespace out {\n"
1606 "namespace in {\n"
1607 "int i;\n"
1608 "} // namespace in\n"
1609 "} // namespace out",
1610 Style));
1611 EXPECT_EQ("namespace out { namespace mid { namespace in {\n"
1612 " int i;\n"
1613 "}}} // namespace out::mid::in",
1614 format("namespace out {\n"
1615 "namespace mid {\n"
1616 "namespace in {\n"
1617 "int i;\n"
1618 "} // namespace in\n"
1619 "} // namespace mid\n"
1620 "} // namespace out",
1621 Style));
1622}
1623
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001624TEST_F(FormatTest, FormatsExternC) { verifyFormat("extern \"C\" {\nint a;"); }
Manuel Klimekae610d12013-01-21 14:32:05 +00001625
Daniel Jasper40aacf42013-03-14 13:45:21 +00001626TEST_F(FormatTest, FormatsInlineASM) {
1627 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));");
Daniel Jasperb23e20b2014-09-16 16:36:57 +00001628 verifyFormat("asm(\"nop\" ::: \"memory\");");
Daniel Jasper40aacf42013-03-14 13:45:21 +00001629 verifyFormat(
1630 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
1631 " \"cpuid\\n\\t\"\n"
1632 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
Daniel Jasper5dad58e2013-05-15 07:51:51 +00001633 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n"
Daniel Jasper40aacf42013-03-14 13:45:21 +00001634 " : \"a\"(value));");
Daniel Jasper8f463652014-08-26 23:15:12 +00001635 EXPECT_EQ(
1636 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n"
Daniel Jasper2337f282015-01-12 10:14:56 +00001637 " __asm {\n"
Daniel Jasper8f463652014-08-26 23:15:12 +00001638 " mov edx,[that] // vtable in edx\n"
1639 " mov eax,methodIndex\n"
1640 " call [edx][eax*4] // stdcall\n"
Daniel Jasper2337f282015-01-12 10:14:56 +00001641 " }\n"
Daniel Jasper8f463652014-08-26 23:15:12 +00001642 "}",
1643 format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n"
1644 " __asm {\n"
1645 " mov edx,[that] // vtable in edx\n"
1646 " mov eax,methodIndex\n"
1647 " call [edx][eax*4] // stdcall\n"
1648 " }\n"
1649 "}"));
Daniel Jasperc6366072015-05-10 08:42:04 +00001650 EXPECT_EQ("_asm {\n"
1651 " xor eax, eax;\n"
1652 " cpuid;\n"
1653 "}",
1654 format("_asm {\n"
1655 " xor eax, eax;\n"
1656 " cpuid;\n"
1657 "}"));
Daniel Jasper2337f282015-01-12 10:14:56 +00001658 verifyFormat("void function() {\n"
1659 " // comment\n"
1660 " asm(\"\");\n"
1661 "}");
Daniel Jasper790d4f92015-05-11 11:59:46 +00001662 EXPECT_EQ("__asm {\n"
1663 "}\n"
1664 "int i;",
1665 format("__asm {\n"
1666 "}\n"
1667 "int i;"));
Daniel Jasper40aacf42013-03-14 13:45:21 +00001668}
1669
Nico Weberd5650bd2013-01-07 16:36:17 +00001670TEST_F(FormatTest, FormatTryCatch) {
1671 verifyFormat("try {\n"
1672 " throw a * b;\n"
Daniel Jasper04a71a42014-05-08 11:58:24 +00001673 "} catch (int a) {\n"
Nico Weberd5650bd2013-01-07 16:36:17 +00001674 " // Do nothing.\n"
Daniel Jasper04a71a42014-05-08 11:58:24 +00001675 "} catch (...) {\n"
Nico Weberd5650bd2013-01-07 16:36:17 +00001676 " exit(42);\n"
1677 "}");
1678
1679 // Function-level try statements.
Daniel Jasper04a71a42014-05-08 11:58:24 +00001680 verifyFormat("int f() try { return 4; } catch (...) {\n"
Nico Weberd5650bd2013-01-07 16:36:17 +00001681 " return 5;\n"
1682 "}");
1683 verifyFormat("class A {\n"
1684 " int a;\n"
Daniel Jasper04a71a42014-05-08 11:58:24 +00001685 " A() try : a(0) {\n"
1686 " } catch (...) {\n"
Nico Weberd5650bd2013-01-07 16:36:17 +00001687 " throw;\n"
1688 " }\n"
1689 "};\n");
Daniel Jasper2bd7a642015-01-19 10:50:51 +00001690
1691 // Incomplete try-catch blocks.
Manuel Klimekec5c3db2015-05-07 12:26:30 +00001692 verifyIncompleteFormat("try {} catch (");
Nico Weberd5650bd2013-01-07 16:36:17 +00001693}
1694
Nico Weberfac23712015-02-04 15:26:27 +00001695TEST_F(FormatTest, FormatSEHTryCatch) {
1696 verifyFormat("__try {\n"
1697 " int a = b * c;\n"
1698 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n"
1699 " // Do nothing.\n"
1700 "}");
1701
1702 verifyFormat("__try {\n"
1703 " int a = b * c;\n"
1704 "} __finally {\n"
1705 " // Do nothing.\n"
1706 "}");
1707
1708 verifyFormat("DEBUG({\n"
1709 " __try {\n"
1710 " } __finally {\n"
1711 " }\n"
1712 "});\n");
1713}
1714
Daniel Jasper04a71a42014-05-08 11:58:24 +00001715TEST_F(FormatTest, IncompleteTryCatchBlocks) {
1716 verifyFormat("try {\n"
1717 " f();\n"
1718 "} catch {\n"
1719 " g();\n"
1720 "}");
1721 verifyFormat("try {\n"
1722 " f();\n"
1723 "} catch (A a) MACRO(x) {\n"
1724 " g();\n"
1725 "} catch (B b) MACRO(x) {\n"
1726 " g();\n"
1727 "}");
1728}
1729
1730TEST_F(FormatTest, FormatTryCatchBraceStyles) {
1731 FormatStyle Style = getLLVMStyle();
Daniel Jasper55bbe662015-10-07 04:06:10 +00001732 for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla,
1733 FormatStyle::BS_WebKit}) {
Roman Kashitsyn291f64f2015-08-10 13:43:19 +00001734 Style.BreakBeforeBraces = BraceStyle;
1735 verifyFormat("try {\n"
1736 " // something\n"
1737 "} catch (...) {\n"
1738 " // something\n"
1739 "}",
1740 Style);
1741 }
Daniel Jasper04a71a42014-05-08 11:58:24 +00001742 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
1743 verifyFormat("try {\n"
1744 " // something\n"
1745 "}\n"
1746 "catch (...) {\n"
1747 " // something\n"
1748 "}",
1749 Style);
Nico Weberfac23712015-02-04 15:26:27 +00001750 verifyFormat("__try {\n"
1751 " // something\n"
1752 "}\n"
1753 "__finally {\n"
1754 " // something\n"
1755 "}",
1756 Style);
Nico Weber33381f52015-02-07 01:57:32 +00001757 verifyFormat("@try {\n"
1758 " // something\n"
1759 "}\n"
1760 "@finally {\n"
1761 " // something\n"
1762 "}",
1763 Style);
Daniel Jasper04a71a42014-05-08 11:58:24 +00001764 Style.BreakBeforeBraces = FormatStyle::BS_Allman;
1765 verifyFormat("try\n"
1766 "{\n"
1767 " // something\n"
1768 "}\n"
1769 "catch (...)\n"
1770 "{\n"
1771 " // something\n"
1772 "}",
1773 Style);
1774 Style.BreakBeforeBraces = FormatStyle::BS_GNU;
1775 verifyFormat("try\n"
1776 " {\n"
1777 " // something\n"
1778 " }\n"
1779 "catch (...)\n"
1780 " {\n"
1781 " // something\n"
1782 " }",
1783 Style);
Daniel Jasper55bbe662015-10-07 04:06:10 +00001784 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
1785 Style.BraceWrapping.BeforeCatch = true;
1786 verifyFormat("try {\n"
1787 " // something\n"
1788 "}\n"
1789 "catch (...) {\n"
1790 " // something\n"
1791 "}",
1792 Style);
Daniel Jasper04a71a42014-05-08 11:58:24 +00001793}
1794
Daniel Jaspere25509f2012-12-17 11:29:41 +00001795TEST_F(FormatTest, StaticInitializers) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00001796 verifyFormat("static SomeClass SC = {1, 'a'};");
Daniel Jaspere25509f2012-12-17 11:29:41 +00001797
Daniel Jaspera44991332015-04-29 13:06:49 +00001798 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n"
1799 " 100000000, "
1800 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};");
Manuel Klimek0ddd57a2013-01-10 15:58:26 +00001801
Daniel Jasper473c62c2013-05-17 09:35:01 +00001802 // Here, everything other than the "}" would fit on a line.
1803 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00001804 " 10000000000000000000000000};");
Daniel Jaspera69ca9b2014-06-04 12:40:57 +00001805 EXPECT_EQ("S s = {a,\n"
1806 "\n"
1807 " b};",
1808 format("S s = {\n"
1809 " a,\n"
1810 "\n"
1811 " b\n"
1812 "};"));
Daniel Jasper473c62c2013-05-17 09:35:01 +00001813
1814 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first
1815 // line. However, the formatting looks a bit off and this probably doesn't
1816 // happen often in practice.
1817 verifyFormat("static int Variable[1] = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00001818 " {1000000000000000000000000000000000000}};",
Daniel Jasper473c62c2013-05-17 09:35:01 +00001819 getLLVMStyleWithColumns(40));
Daniel Jaspere25509f2012-12-17 11:29:41 +00001820}
1821
Daniel Jasperbca4bbe2013-05-28 11:30:49 +00001822TEST_F(FormatTest, DesignatedInitializers) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00001823 verifyFormat("const struct A a = {.a = 1, .b = 2};");
1824 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n"
1825 " .bbbbbbbbbb = 2,\n"
1826 " .cccccccccc = 3,\n"
1827 " .dddddddddd = 4,\n"
1828 " .eeeeeeeeee = 5};");
Daniel Jasperbca4bbe2013-05-28 11:30:49 +00001829 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00001830 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n"
1831 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n"
1832 " .ccccccccccccccccccccccccccc = 3,\n"
1833 " .ddddddddddddddddddddddddddd = 4,\n"
1834 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};");
Daniel Jasperbca4bbe2013-05-28 11:30:49 +00001835
1836 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};");
Francois Ferrand5f07f442017-06-19 14:41:21 +00001837
1838 verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
1839 verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n"
1840 " [2] = bbbbbbbbbb,\n"
1841 " [3] = cccccccccc,\n"
1842 " [4] = dddddddddd,\n"
1843 " [5] = eeeeeeeeee};");
1844 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
1845 " [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
1846 " [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
1847 " [3] = cccccccccccccccccccccccccccccccccccccc,\n"
1848 " [4] = dddddddddddddddddddddddddddddddddddddd,\n"
1849 " [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};");
Daniel Jasperbca4bbe2013-05-28 11:30:49 +00001850}
1851
Manuel Klimeka54d1a92013-01-14 16:41:43 +00001852TEST_F(FormatTest, NestedStaticInitializers) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00001853 verifyFormat("static A x = {{{}}};\n");
1854 verifyFormat("static A x = {{{init1, init2, init3, init4},\n"
1855 " {init1, init2, init3, init4}}};",
1856 getLLVMStyleWithColumns(50));
Daniel Jasper9278eb92013-01-16 14:59:02 +00001857
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001858 verifyFormat("somes Status::global_reps[3] = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00001859 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
1860 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
1861 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};",
1862 getLLVMStyleWithColumns(60));
Daniel Jaspere5777d22013-05-23 10:15:45 +00001863 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n"
Daniel Jasper6ab54682013-07-16 18:22:10 +00001864 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
1865 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
1866 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};");
Daniel Jaspera44991332015-04-29 13:06:49 +00001867 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n"
1868 " {rect.fRight - rect.fLeft, rect.fBottom - "
1869 "rect.fTop}};");
Manuel Klimeka54d1a92013-01-14 16:41:43 +00001870
Daniel Jasper8a8ce242013-01-31 14:59:26 +00001871 verifyFormat(
Chandler Carruthf8b72662014-03-02 12:37:31 +00001872 "SomeArrayOfSomeType a = {\n"
1873 " {{1, 2, 3},\n"
1874 " {1, 2, 3},\n"
1875 " {111111111111111111111111111111, 222222222222222222222222222222,\n"
1876 " 333333333333333333333333333333},\n"
1877 " {1, 2, 3},\n"
1878 " {1, 2, 3}}};");
Daniel Jasper1ca05cc2013-02-03 18:07:15 +00001879 verifyFormat(
Daniel Jasper6ab54682013-07-16 18:22:10 +00001880 "SomeArrayOfSomeType a = {\n"
Daniel Jasper01603472014-01-09 13:42:56 +00001881 " {{1, 2, 3}},\n"
1882 " {{1, 2, 3}},\n"
Daniel Jasper6ab54682013-07-16 18:22:10 +00001883 " {{111111111111111111111111111111, 222222222222222222222222222222,\n"
1884 " 333333333333333333333333333333}},\n"
Daniel Jasper01603472014-01-09 13:42:56 +00001885 " {{1, 2, 3}},\n"
1886 " {{1, 2, 3}}};");
Daniel Jasper8a8ce242013-01-31 14:59:26 +00001887
Daniel Jaspera44991332015-04-29 13:06:49 +00001888 verifyFormat("struct {\n"
1889 " unsigned bit;\n"
1890 " const char *const name;\n"
1891 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n"
1892 " {kOsWin, \"Windows\"},\n"
1893 " {kOsLinux, \"Linux\"},\n"
1894 " {kOsCrOS, \"Chrome OS\"}};");
1895 verifyFormat("struct {\n"
1896 " unsigned bit;\n"
1897 " const char *const name;\n"
1898 "} kBitsToOs[] = {\n"
1899 " {kOsMac, \"Mac\"},\n"
1900 " {kOsWin, \"Windows\"},\n"
1901 " {kOsLinux, \"Linux\"},\n"
1902 " {kOsCrOS, \"Chrome OS\"},\n"
1903 "};");
Manuel Klimeka54d1a92013-01-14 16:41:43 +00001904}
1905
Manuel Klimeka71e5d82013-01-02 16:30:12 +00001906TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) {
1907 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("
1908 " \\\n"
1909 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)");
1910}
1911
Daniel Jasperda16db32013-01-07 10:48:50 +00001912TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) {
Alexander Kornienko384b40b2013-10-11 21:43:05 +00001913 verifyFormat("virtual void write(ELFWriter *writerrr,\n"
1914 " OwningPtr<FileOutputBuffer> &buffer) = 0;");
Daniel Jaspercaf84fe2015-04-23 12:59:09 +00001915
1916 // Do break defaulted and deleted functions.
1917 verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
1918 " default;",
1919 getLLVMStyleWithColumns(40));
1920 verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
1921 " delete;",
1922 getLLVMStyleWithColumns(40));
Alexander Kornienko384b40b2013-10-11 21:43:05 +00001923}
1924
1925TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) {
1926 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3",
1927 getLLVMStyleWithColumns(40));
1928 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
1929 getLLVMStyleWithColumns(40));
1930 EXPECT_EQ("#define Q \\\n"
1931 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n"
1932 " \"aaaaaaaa.cpp\"",
1933 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
1934 getLLVMStyleWithColumns(40)));
1935}
1936
1937TEST_F(FormatTest, UnderstandsLinePPDirective) {
1938 EXPECT_EQ("# 123 \"A string literal\"",
1939 format(" # 123 \"A string literal\""));
Daniel Jasperda16db32013-01-07 10:48:50 +00001940}
1941
Manuel Klimek591b5802013-01-31 15:58:48 +00001942TEST_F(FormatTest, LayoutUnknownPPDirective) {
Manuel Klimek591b5802013-01-31 15:58:48 +00001943 EXPECT_EQ("#;", format("#;"));
Manuel Klimek78725712013-01-07 10:03:37 +00001944 verifyFormat("#\n;\n;\n;");
Manuel Klimeka71e5d82013-01-02 16:30:12 +00001945}
1946
1947TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) {
1948 EXPECT_EQ("#line 42 \"test\"\n",
1949 format("# \\\n line \\\n 42 \\\n \"test\"\n"));
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001950 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n",
1951 getLLVMStyleWithColumns(12)));
Manuel Klimeka71e5d82013-01-02 16:30:12 +00001952}
1953
1954TEST_F(FormatTest, EndOfFileEndsPPDirective) {
1955 EXPECT_EQ("#line 42 \"test\"",
1956 format("# \\\n line \\\n 42 \\\n \"test\""));
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001957 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B"));
Manuel Klimeka71e5d82013-01-02 16:30:12 +00001958}
1959
Daniel Jasper877615c2013-10-11 19:45:02 +00001960TEST_F(FormatTest, DoesntRemoveUnknownTokens) {
1961 verifyFormat("#define A \\x20");
1962 verifyFormat("#define A \\ x20");
1963 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20"));
1964 verifyFormat("#define A ''");
1965 verifyFormat("#define A ''qqq");
1966 verifyFormat("#define A `qqq");
1967 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");
Daniel Jasperda353cd2014-03-12 08:24:47 +00001968 EXPECT_EQ("const char *c = STRINGIFY(\n"
1969 "\\na : b);",
1970 format("const char * c = STRINGIFY(\n"
1971 "\\na : b);"));
Daniel Jasper30029c62015-02-05 11:05:31 +00001972
1973 verifyFormat("a\r\\");
1974 verifyFormat("a\v\\");
1975 verifyFormat("a\f\\");
Daniel Jasper877615c2013-10-11 19:45:02 +00001976}
1977
Manuel Klimekb69e3c62013-01-02 18:33:23 +00001978TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {
Daniel Jasperc22f5b42013-02-28 11:05:57 +00001979 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
1980 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12));
Manuel Klimekb69e3c62013-01-02 18:33:23 +00001981 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12));
Daniel Jasperc22f5b42013-02-28 11:05:57 +00001982 // FIXME: We never break before the macro name.
Daniel Jaspera49393f2013-08-28 09:07:32 +00001983 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12));
Daniel Jasper39825ea2013-01-14 15:40:57 +00001984
1985 verifyFormat("#define A A\n#define A A");
1986 verifyFormat("#define A(X) A\n#define A A");
1987
Daniel Jasperc22f5b42013-02-28 11:05:57 +00001988 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
1989 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22));
Manuel Klimekb69e3c62013-01-02 18:33:23 +00001990}
1991
1992TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {
Alexander Kornienkoefd98382013-03-28 18:40:55 +00001993 EXPECT_EQ("// somecomment\n"
Manuel Klimek1abf7892013-01-04 23:34:14 +00001994 "#include \"a.h\"\n"
Daniel Jasperc22f5b42013-02-28 11:05:57 +00001995 "#define A( \\\n"
1996 " A, B)\n"
Manuel Klimek1abf7892013-01-04 23:34:14 +00001997 "#include \"b.h\"\n"
Alexander Kornienkoffd6d042013-03-27 11:52:18 +00001998 "// somecomment\n",
Alexander Kornienkoefd98382013-03-28 18:40:55 +00001999 format(" // somecomment\n"
Manuel Klimek1abf7892013-01-04 23:34:14 +00002000 " #include \"a.h\"\n"
2001 "#define A(A,\\\n"
2002 " B)\n"
2003 " #include \"b.h\"\n"
Alexander Kornienkoffd6d042013-03-27 11:52:18 +00002004 " // somecomment\n",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002005 getLLVMStyleWithColumns(13)));
Manuel Klimekb69e3c62013-01-02 18:33:23 +00002006}
2007
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002008TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
Manuel Klimek1abf7892013-01-04 23:34:14 +00002009
2010TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
2011 EXPECT_EQ("#define A \\\n"
2012 " c; \\\n"
2013 " e;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002014 "f;",
2015 format("#define A c; e;\n"
2016 "f;",
2017 getLLVMStyleWithColumns(14)));
Manuel Klimek1abf7892013-01-04 23:34:14 +00002018}
2019
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002020TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
Manuel Klimek1abf7892013-01-04 23:34:14 +00002021
Manuel Klimek1abf7892013-01-04 23:34:14 +00002022TEST_F(FormatTest, MacroDefinitionInsideStatement) {
Manuel Klimek52b15152013-01-09 15:25:02 +00002023 EXPECT_EQ("int x,\n"
2024 "#define A\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002025 " y;",
2026 format("int x,\n#define A\ny;"));
Manuel Klimek1abf7892013-01-04 23:34:14 +00002027}
2028
Manuel Klimek09e07972013-01-05 21:34:55 +00002029TEST_F(FormatTest, HashInMacroDefinition) {
Alexander Kornienkod8d47fa2013-09-10 13:41:43 +00002030 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle()));
Manuel Klimek09e07972013-01-05 21:34:55 +00002031 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11));
Daniel Jaspera49393f2013-08-28 09:07:32 +00002032 verifyFormat("#define A \\\n"
2033 " { \\\n"
2034 " f(#c); \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002035 " }",
2036 getLLVMStyleWithColumns(11));
Daniel Jasper4f397152013-01-08 16:17:54 +00002037
2038 verifyFormat("#define A(X) \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002039 " void function##X()",
2040 getLLVMStyleWithColumns(22));
Daniel Jasper4f397152013-01-08 16:17:54 +00002041
2042 verifyFormat("#define A(a, b, c) \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002043 " void a##b##c()",
2044 getLLVMStyleWithColumns(22));
Daniel Jasper4f397152013-01-08 16:17:54 +00002045
Daniel Jasper39825ea2013-01-14 15:40:57 +00002046 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
Manuel Klimek09e07972013-01-05 21:34:55 +00002047}
2048
Manuel Klimekd053c5b2013-01-23 14:37:36 +00002049TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) {
Alexander Kornienkofdca83d2013-12-10 10:18:34 +00002050 EXPECT_EQ("#define A (x)", format("#define A (x)"));
2051 EXPECT_EQ("#define A(x)", format("#define A(x)"));
Manuel Klimekd053c5b2013-01-23 14:37:36 +00002052}
2053
Manuel Klimek0c137952013-02-11 12:33:24 +00002054TEST_F(FormatTest, EmptyLinesInMacroDefinitions) {
2055 EXPECT_EQ("#define A b;", format("#define A \\\n"
2056 " \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002057 " b;",
2058 getLLVMStyleWithColumns(25)));
Manuel Klimek0c137952013-02-11 12:33:24 +00002059 EXPECT_EQ("#define A \\\n"
2060 " \\\n"
2061 " a; \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002062 " b;",
2063 format("#define A \\\n"
2064 " \\\n"
2065 " a; \\\n"
2066 " b;",
2067 getLLVMStyleWithColumns(11)));
Manuel Klimek0c137952013-02-11 12:33:24 +00002068 EXPECT_EQ("#define A \\\n"
2069 " a; \\\n"
2070 " \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002071 " b;",
2072 format("#define A \\\n"
2073 " a; \\\n"
2074 " \\\n"
2075 " b;",
2076 getLLVMStyleWithColumns(11)));
Manuel Klimek0c137952013-02-11 12:33:24 +00002077}
2078
Daniel Jasper00475962013-02-19 17:14:38 +00002079TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
Manuel Klimekec5c3db2015-05-07 12:26:30 +00002080 verifyIncompleteFormat("#define A :");
Daniel Jasper00475962013-02-19 17:14:38 +00002081 verifyFormat("#define SOMECASES \\\n"
Daniel Jaspera1275122013-03-20 10:23:53 +00002082 " case 1: \\\n"
Daniel Jasper00475962013-02-19 17:14:38 +00002083 " case 2\n",
2084 getLLVMStyleWithColumns(20));
Daniel Jasper451544a2016-05-19 06:30:48 +00002085 verifyFormat("#define MACRO(a) \\\n"
2086 " if (a) \\\n"
2087 " f(); \\\n"
2088 " else \\\n"
2089 " g()",
2090 getLLVMStyleWithColumns(18));
Daniel Jasper00475962013-02-19 17:14:38 +00002091 verifyFormat("#define A template <typename T>");
Manuel Klimekec5c3db2015-05-07 12:26:30 +00002092 verifyIncompleteFormat("#define STR(x) #x\n"
2093 "f(STR(this_is_a_string_literal{));");
Daniel Jasper96df37a2013-08-28 09:17:37 +00002094 verifyFormat("#pragma omp threadprivate( \\\n"
2095 " y)), // expected-warning",
2096 getLLVMStyleWithColumns(28));
Daniel Jasperb1567c12015-01-19 10:50:08 +00002097 verifyFormat("#d, = };");
Daniel Jasper9d22bcc2015-01-19 10:51:05 +00002098 verifyFormat("#if \"a");
Manuel Klimekec5c3db2015-05-07 12:26:30 +00002099 verifyIncompleteFormat("({\n"
Manuel Klimek3d3ea842015-05-12 09:23:57 +00002100 "#define b \\\n"
2101 " } \\\n"
Manuel Klimekec5c3db2015-05-07 12:26:30 +00002102 " a\n"
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00002103 "a",
2104 getLLVMStyleWithColumns(15));
Daniel Jasper9ecb0e92015-03-13 13:32:11 +00002105 verifyFormat("#define A \\\n"
2106 " { \\\n"
2107 " {\n"
2108 "#define B \\\n"
2109 " } \\\n"
2110 " }",
2111 getLLVMStyleWithColumns(15));
Daniel Jasperfd725c02015-01-21 17:35:29 +00002112 verifyNoCrash("#if a\na(\n#else\n#endif\n{a");
Daniel Jasperd1debfc2015-01-21 18:04:02 +00002113 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}");
Daniel Jasper04b979d2015-01-21 18:35:47 +00002114 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};");
Daniel Jasperd1c13732015-01-23 19:37:25 +00002115 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}");
Daniel Jasper00475962013-02-19 17:14:38 +00002116}
2117
Daniel Jasper40e19212013-05-29 13:16:10 +00002118TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) {
2119 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
2120 EXPECT_EQ("class A : public QObject {\n"
2121 " Q_OBJECT\n"
2122 "\n"
2123 " A() {}\n"
2124 "};",
2125 format("class A : public QObject {\n"
2126 " Q_OBJECT\n"
2127 "\n"
2128 " A() {\n}\n"
2129 "} ;"));
Daniel Jaspere60cba12015-05-13 11:35:53 +00002130 EXPECT_EQ("MACRO\n"
2131 "/*static*/ int i;",
2132 format("MACRO\n"
2133 " /*static*/ int i;"));
Daniel Jasper41a0f782013-05-29 14:09:17 +00002134 EXPECT_EQ("SOME_MACRO\n"
2135 "namespace {\n"
2136 "void f();\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00002137 "} // namespace",
Daniel Jasper41a0f782013-05-29 14:09:17 +00002138 format("SOME_MACRO\n"
2139 " namespace {\n"
2140 "void f( );\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00002141 "} // namespace"));
Daniel Jasper40e19212013-05-29 13:16:10 +00002142 // Only if the identifier contains at least 5 characters.
Daniel Jaspera44991332015-04-29 13:06:49 +00002143 EXPECT_EQ("HTTP f();", format("HTTP\nf();"));
2144 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();"));
Daniel Jasper40e19212013-05-29 13:16:10 +00002145 // Only if everything is upper case.
2146 EXPECT_EQ("class A : public QObject {\n"
2147 " Q_Object A() {}\n"
2148 "};",
2149 format("class A : public QObject {\n"
2150 " Q_Object\n"
Daniel Jasper40e19212013-05-29 13:16:10 +00002151 " A() {\n}\n"
2152 "} ;"));
Daniel Jasper680b09b2014-11-05 10:48:04 +00002153
2154 // Only if the next line can actually start an unwrapped line.
2155 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;",
2156 format("SOME_WEIRD_LOG_MACRO\n"
2157 "<< SomeThing;"));
Nico Weber23846262014-12-09 23:22:35 +00002158
2159 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), "
Daniel Jaspera44991332015-04-29 13:06:49 +00002160 "(n, buffers))\n",
2161 getChromiumStyle(FormatStyle::LK_Cpp));
Daniel Jasper40e19212013-05-29 13:16:10 +00002162}
2163
Alexander Kornienkode644272013-04-08 22:16:06 +00002164TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) {
2165 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
2166 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
2167 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00002168 "class X {};\n"
Alexander Kornienkode644272013-04-08 22:16:06 +00002169 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
2170 "int *createScopDetectionPass() { return 0; }",
2171 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
2172 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
2173 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
2174 " class X {};\n"
2175 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
2176 " int *createScopDetectionPass() { return 0; }"));
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002177 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as
2178 // braces, so that inner block is indented one level more.
2179 EXPECT_EQ("int q() {\n"
2180 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
2181 " IPC_MESSAGE_HANDLER(xxx, qqq)\n"
2182 " IPC_END_MESSAGE_MAP()\n"
2183 "}",
2184 format("int q() {\n"
2185 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
2186 " IPC_MESSAGE_HANDLER(xxx, qqq)\n"
2187 " IPC_END_MESSAGE_MAP()\n"
2188 "}"));
Daniel Jasper545c6522013-09-17 09:26:07 +00002189
Daniel Jasper352dae12014-01-03 11:50:46 +00002190 // Same inside macros.
2191 EXPECT_EQ("#define LIST(L) \\\n"
2192 " L(A) \\\n"
2193 " L(B) \\\n"
2194 " L(C)",
2195 format("#define LIST(L) \\\n"
2196 " L(A) \\\n"
2197 " L(B) \\\n"
2198 " L(C)",
2199 getGoogleStyle()));
2200
Daniel Jasper545c6522013-09-17 09:26:07 +00002201 // These must not be recognized as macros.
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002202 EXPECT_EQ("int q() {\n"
2203 " f(x);\n"
2204 " f(x) {}\n"
2205 " f(x)->g();\n"
2206 " f(x)->*g();\n"
2207 " f(x).g();\n"
2208 " f(x) = x;\n"
2209 " f(x) += x;\n"
2210 " f(x) -= x;\n"
2211 " f(x) *= x;\n"
2212 " f(x) /= x;\n"
2213 " f(x) %= x;\n"
2214 " f(x) &= x;\n"
2215 " f(x) |= x;\n"
2216 " f(x) ^= x;\n"
2217 " f(x) >>= x;\n"
2218 " f(x) <<= x;\n"
2219 " f(x)[y].z();\n"
2220 " LOG(INFO) << x;\n"
2221 " ifstream(x) >> x;\n"
2222 "}\n",
2223 format("int q() {\n"
2224 " f(x)\n;\n"
2225 " f(x)\n {}\n"
2226 " f(x)\n->g();\n"
2227 " f(x)\n->*g();\n"
2228 " f(x)\n.g();\n"
2229 " f(x)\n = x;\n"
2230 " f(x)\n += x;\n"
2231 " f(x)\n -= x;\n"
2232 " f(x)\n *= x;\n"
2233 " f(x)\n /= x;\n"
2234 " f(x)\n %= x;\n"
2235 " f(x)\n &= x;\n"
2236 " f(x)\n |= x;\n"
2237 " f(x)\n ^= x;\n"
2238 " f(x)\n >>= x;\n"
2239 " f(x)\n <<= x;\n"
2240 " f(x)\n[y].z();\n"
2241 " LOG(INFO)\n << x;\n"
2242 " ifstream(x)\n >> x;\n"
2243 "}\n"));
2244 EXPECT_EQ("int q() {\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002245 " F(x)\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002246 " if (1) {\n"
2247 " }\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002248 " F(x)\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002249 " while (1) {\n"
2250 " }\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002251 " F(x)\n"
2252 " G(x);\n"
2253 " F(x)\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002254 " try {\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002255 " Q();\n"
Daniel Jasper04a71a42014-05-08 11:58:24 +00002256 " } catch (...) {\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002257 " }\n"
2258 "}\n",
2259 format("int q() {\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002260 "F(x)\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002261 "if (1) {}\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002262 "F(x)\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002263 "while (1) {}\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002264 "F(x)\n"
2265 "G(x);\n"
2266 "F(x)\n"
2267 "try { Q(); } catch (...) {}\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002268 "}\n"));
2269 EXPECT_EQ("class A {\n"
2270 " A() : t(0) {}\n"
Daniel Jasper5ebb2f32014-05-21 13:08:17 +00002271 " A(int i) noexcept() : {}\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002272 " A(X x)\n" // FIXME: function-level try blocks are broken.
2273 " try : t(0) {\n"
Daniel Jasper04a71a42014-05-08 11:58:24 +00002274 " } catch (...) {\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002275 " }\n"
2276 "};",
2277 format("class A {\n"
2278 " A()\n : t(0) {}\n"
Daniel Jasper5ebb2f32014-05-21 13:08:17 +00002279 " A(int i)\n noexcept() : {}\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002280 " A(X x)\n"
2281 " try : t(0) {} catch (...) {}\n"
2282 "};"));
Daniel Jaspera44991332015-04-29 13:06:49 +00002283 EXPECT_EQ("class SomeClass {\n"
2284 "public:\n"
2285 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
2286 "};",
2287 format("class SomeClass {\n"
2288 "public:\n"
2289 " SomeClass()\n"
2290 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
2291 "};"));
2292 EXPECT_EQ("class SomeClass {\n"
2293 "public:\n"
2294 " SomeClass()\n"
2295 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
2296 "};",
2297 format("class SomeClass {\n"
2298 "public:\n"
2299 " SomeClass()\n"
2300 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
2301 "};",
2302 getLLVMStyleWithColumns(40)));
Daniel Jasper7fa524b2015-11-20 15:26:50 +00002303
2304 verifyFormat("MACRO(>)");
Alexander Kornienkode644272013-04-08 22:16:06 +00002305}
2306
Manuel Klimek4fe43002013-05-22 12:51:29 +00002307TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) {
2308 verifyFormat("#define A \\\n"
2309 " f({ \\\n"
2310 " g(); \\\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00002311 " });",
2312 getLLVMStyleWithColumns(11));
Manuel Klimek4fe43002013-05-22 12:51:29 +00002313}
2314
Manuel Klimekef2cfb12013-01-05 22:14:16 +00002315TEST_F(FormatTest, IndentPreprocessorDirectivesAtZero) {
2316 EXPECT_EQ("{\n {\n#define A\n }\n}", format("{{\n#define A\n}}"));
2317}
2318
Manuel Klimek52d0fd82013-01-05 22:56:06 +00002319TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) {
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00002320 verifyFormat("{\n { a #c; }\n}");
Manuel Klimek52d0fd82013-01-05 22:56:06 +00002321}
2322
Manuel Klimek1058d982013-01-06 20:07:31 +00002323TEST_F(FormatTest, FormatUnbalancedStructuralElements) {
2324 EXPECT_EQ("#define A \\\n { \\\n {\nint i;",
2325 format("#define A { {\nint i;", getLLVMStyleWithColumns(11)));
2326 EXPECT_EQ("#define A \\\n } \\\n }\nint i;",
2327 format("#define A } }\nint i;", getLLVMStyleWithColumns(11)));
2328}
Manuel Klimek1abf7892013-01-04 23:34:14 +00002329
Daniel Jaspere2408e32015-05-06 11:16:43 +00002330TEST_F(FormatTest, EscapedNewlines) {
Daniel Jasper8d1832e2013-01-07 13:26:07 +00002331 EXPECT_EQ(
2332 "#define A \\\n int i; \\\n int j;",
2333 format("#define A \\\nint i;\\\n int j;", getLLVMStyleWithColumns(11)));
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00002334 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;"));
Alexander Kornienkoee4ca9b2013-06-07 17:45:07 +00002335 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
Krasimir Georgievbb99a362017-02-16 12:39:31 +00002336 EXPECT_EQ("/* \\ \\ \\\n */", format("\\\n/* \\ \\ \\\n */"));
Daniel Jaspere2408e32015-05-06 11:16:43 +00002337 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>"));
Jacob Bandes-Storchd6a7e982017-08-10 00:15:31 +00002338
2339 FormatStyle DontAlign = getLLVMStyle();
2340 DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
2341 DontAlign.MaxEmptyLinesToKeep = 3;
2342 // FIXME: can't use verifyFormat here because the newline before
2343 // "public:" is not inserted the first time it's reformatted
2344 EXPECT_EQ("#define A \\\n"
2345 " class Foo { \\\n"
2346 " void bar(); \\\n"
2347 "\\\n"
2348 "\\\n"
2349 "\\\n"
2350 " public: \\\n"
2351 " void baz(); \\\n"
2352 " };",
2353 format("#define A \\\n"
2354 " class Foo { \\\n"
2355 " void bar(); \\\n"
2356 "\\\n"
2357 "\\\n"
2358 "\\\n"
2359 " public: \\\n"
2360 " void baz(); \\\n"
2361 " };", DontAlign));
Alexander Kornienkobe633902013-06-14 11:46:10 +00002362}
2363
Manuel Klimek38ba11e2013-01-07 09:24:17 +00002364TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) {
2365 verifyFormat("#define A \\\n"
2366 " int v( \\\n"
2367 " a); \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002368 " int i;",
2369 getLLVMStyleWithColumns(11));
Manuel Klimek38ba11e2013-01-07 09:24:17 +00002370}
2371
Manuel Klimeka71e5d82013-01-02 16:30:12 +00002372TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) {
Manuel Klimek1abf7892013-01-04 23:34:14 +00002373 EXPECT_EQ(
2374 "#define ALooooooooooooooooooooooooooooooooooooooongMacro("
2375 " \\\n"
2376 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
2377 "\n"
2378 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
2379 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n",
2380 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro("
2381 "\\\n"
2382 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
2383 " \n"
2384 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
2385 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n"));
Manuel Klimeka71e5d82013-01-02 16:30:12 +00002386}
2387
Manuel Klimek52b15152013-01-09 15:25:02 +00002388TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {
2389 EXPECT_EQ("int\n"
2390 "#define A\n"
Daniel Jasper8e357692013-05-06 08:27:33 +00002391 " a;",
Daniel Jasper4355e7f2014-07-09 07:50:33 +00002392 format("int\n#define A\na;"));
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002393 verifyFormat("functionCallTo(\n"
2394 " someOtherFunction(\n"
2395 " withSomeParameters, whichInSequence,\n"
2396 " areLongerThanALine(andAnotherCall,\n"
2397 "#define A B\n"
2398 " withMoreParamters,\n"
2399 " whichStronglyInfluenceTheLayout),\n"
Daniel Jasper37905f72013-02-21 15:00:29 +00002400 " andMoreParameters),\n"
2401 " trailing);",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002402 getLLVMStyleWithColumns(69));
Daniel Jasperfb81b092013-09-17 09:52:48 +00002403 verifyFormat("Foo::Foo()\n"
2404 "#ifdef BAR\n"
2405 " : baz(0)\n"
2406 "#endif\n"
2407 "{\n"
2408 "}");
Manuel Klimek71814b42013-10-11 21:25:45 +00002409 verifyFormat("void f() {\n"
2410 " if (true)\n"
2411 "#ifdef A\n"
2412 " f(42);\n"
2413 " x();\n"
2414 "#else\n"
2415 " g();\n"
2416 " x();\n"
2417 "#endif\n"
2418 "}");
2419 verifyFormat("void f(param1, param2,\n"
2420 " param3,\n"
2421 "#ifdef A\n"
2422 " param4(param5,\n"
2423 "#ifdef A1\n"
2424 " param6,\n"
2425 "#ifdef A2\n"
2426 " param7),\n"
2427 "#else\n"
2428 " param8),\n"
2429 " param9,\n"
2430 "#endif\n"
2431 " param10,\n"
2432 "#endif\n"
2433 " param11)\n"
2434 "#else\n"
2435 " param12)\n"
2436 "#endif\n"
2437 "{\n"
2438 " x();\n"
2439 "}",
2440 getLLVMStyleWithColumns(28));
Daniel Jasper53bd1672013-10-12 13:32:56 +00002441 verifyFormat("#if 1\n"
2442 "int i;");
Daniel Jaspera44991332015-04-29 13:06:49 +00002443 verifyFormat("#if 1\n"
2444 "#endif\n"
2445 "#if 1\n"
2446 "#else\n"
2447 "#endif\n");
Daniel Jasper472da862013-10-24 15:23:11 +00002448 verifyFormat("DEBUG({\n"
2449 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2450 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
2451 "});\n"
2452 "#if a\n"
2453 "#else\n"
2454 "#endif");
Daniel Jasper193cdd32015-01-19 10:52:16 +00002455
Manuel Klimekec5c3db2015-05-07 12:26:30 +00002456 verifyIncompleteFormat("void f(\n"
2457 "#if A\n"
Martin Probst2c1cdae2017-05-15 11:15:29 +00002458 ");\n"
Manuel Klimekec5c3db2015-05-07 12:26:30 +00002459 "#else\n"
2460 "#endif");
Manuel Klimek52b15152013-01-09 15:25:02 +00002461}
2462
Manuel Klimek14bd9172014-01-29 08:49:02 +00002463TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) {
2464 verifyFormat("#endif\n"
2465 "#if B");
2466}
2467
Manuel Klimek88033d72013-10-21 08:11:15 +00002468TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) {
2469 FormatStyle SingleLine = getLLVMStyle();
2470 SingleLine.AllowShortIfStatementsOnASingleLine = true;
Daniel Jaspera44991332015-04-29 13:06:49 +00002471 verifyFormat("#if 0\n"
2472 "#elif 1\n"
2473 "#endif\n"
2474 "void foo() {\n"
2475 " if (test) foo2();\n"
2476 "}",
2477 SingleLine);
Manuel Klimek88033d72013-10-21 08:11:15 +00002478}
2479
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00002480TEST_F(FormatTest, LayoutBlockInsideParens) {
Daniel Jasperacf67e32015-04-07 08:20:35 +00002481 verifyFormat("functionCall({ int i; });");
2482 verifyFormat("functionCall({\n"
2483 " int i;\n"
2484 " int j;\n"
2485 "});");
Daniel Jasper100ffc62015-08-21 11:44:57 +00002486 verifyFormat("functionCall(\n"
2487 " {\n"
2488 " int i;\n"
2489 " int j;\n"
2490 " },\n"
2491 " aaaa, bbbb, cccc);");
Daniel Jasperacf67e32015-04-07 08:20:35 +00002492 verifyFormat("functionA(functionB({\n"
2493 " int i;\n"
2494 " int j;\n"
2495 " }),\n"
2496 " aaaa, bbbb, cccc);");
2497 verifyFormat("functionCall(\n"
2498 " {\n"
2499 " int i;\n"
2500 " int j;\n"
2501 " },\n"
2502 " aaaa, bbbb, // comment\n"
2503 " cccc);");
2504 verifyFormat("functionA(functionB({\n"
2505 " int i;\n"
2506 " int j;\n"
2507 " }),\n"
2508 " aaaa, bbbb, // comment\n"
2509 " cccc);");
2510 verifyFormat("functionCall(aaaa, bbbb, { int i; });");
2511 verifyFormat("functionCall(aaaa, bbbb, {\n"
2512 " int i;\n"
2513 " int j;\n"
2514 "});");
Daniel Jasper393564f2013-05-31 14:56:29 +00002515 verifyFormat(
Daniel Jaspera44991332015-04-29 13:06:49 +00002516 "Aaa(\n" // FIXME: There shouldn't be a linebreak here.
Daniel Jasper4b444492014-11-21 13:38:53 +00002517 " {\n"
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00002518 " int i; // break\n"
2519 " },\n"
Daniel Jasper393564f2013-05-31 14:56:29 +00002520 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
2521 " ccccccccccccccccc));");
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00002522 verifyFormat("DEBUG({\n"
2523 " if (a)\n"
2524 " f();\n"
2525 "});");
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00002526}
2527
2528TEST_F(FormatTest, LayoutBlockInsideStatement) {
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00002529 EXPECT_EQ("SOME_MACRO { int i; }\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002530 "int i;",
2531 format(" SOME_MACRO {int i;} int i;"));
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00002532}
2533
2534TEST_F(FormatTest, LayoutNestedBlocks) {
2535 verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
2536 " struct s {\n"
2537 " int i;\n"
2538 " };\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00002539 " s kBitsToOs[] = {{10}};\n"
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00002540 " for (int i = 0; i < 10; ++i)\n"
2541 " return;\n"
2542 "}");
Daniel Jasper1c5d9df2013-09-06 07:54:20 +00002543 verifyFormat("call(parameter, {\n"
2544 " something();\n"
2545 " // Comment using all columns.\n"
2546 " somethingelse();\n"
2547 "});",
2548 getLLVMStyleWithColumns(40));
Daniel Jaspere40caf92013-11-29 08:46:20 +00002549 verifyFormat("DEBUG( //\n"
2550 " { f(); }, a);");
2551 verifyFormat("DEBUG( //\n"
2552 " {\n"
2553 " f(); //\n"
2554 " },\n"
2555 " a);");
2556
Daniel Jasper1c5d9df2013-09-06 07:54:20 +00002557 EXPECT_EQ("call(parameter, {\n"
2558 " something();\n"
2559 " // Comment too\n"
2560 " // looooooooooong.\n"
2561 " somethingElse();\n"
2562 "});",
2563 format("call(parameter, {\n"
2564 " something();\n"
2565 " // Comment too looooooooooong.\n"
2566 " somethingElse();\n"
2567 "});",
2568 getLLVMStyleWithColumns(29)));
Daniel Jasper9b246e02013-09-08 14:07:57 +00002569 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });"));
Daniel Jasperdcd5da12013-10-20 17:28:32 +00002570 EXPECT_EQ("DEBUG({ // comment\n"
2571 " int i;\n"
2572 "});",
2573 format("DEBUG({ // comment\n"
2574 "int i;\n"
2575 "});"));
Daniel Jasper9b246e02013-09-08 14:07:57 +00002576 EXPECT_EQ("DEBUG({\n"
2577 " int i;\n"
2578 "\n"
2579 " // comment\n"
2580 " int j;\n"
2581 "});",
2582 format("DEBUG({\n"
2583 " int i;\n"
2584 "\n"
2585 " // comment\n"
2586 " int j;\n"
2587 "});"));
Daniel Jasperbbf5c1c2013-11-05 19:10:03 +00002588
2589 verifyFormat("DEBUG({\n"
2590 " if (a)\n"
2591 " return;\n"
2592 "});");
2593 verifyGoogleFormat("DEBUG({\n"
2594 " if (a) return;\n"
2595 "});");
2596 FormatStyle Style = getGoogleStyle();
2597 Style.ColumnLimit = 45;
Daniel Jasper100ffc62015-08-21 11:44:57 +00002598 verifyFormat("Debug(aaaaa,\n"
2599 " {\n"
2600 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n"
2601 " },\n"
2602 " a);",
Daniel Jasper4b444492014-11-21 13:38:53 +00002603 Style);
Daniel Jasper47b35ae2015-01-29 10:47:14 +00002604
Daniel Jaspera87af7a2015-06-30 11:32:22 +00002605 verifyFormat("SomeFunction({MACRO({ return output; }), b});");
2606
Daniel Jasper47b35ae2015-01-29 10:47:14 +00002607 verifyNoCrash("^{v^{a}}");
Daniel Jasper9c199562013-11-28 15:58:55 +00002608}
2609
Daniel Jasper5fc133e2015-05-12 10:16:02 +00002610TEST_F(FormatTest, FormatNestedBlocksInMacros) {
2611 EXPECT_EQ("#define MACRO() \\\n"
2612 " Debug(aaa, /* force line break */ \\\n"
2613 " { \\\n"
2614 " int i; \\\n"
2615 " int j; \\\n"
2616 " })",
2617 format("#define MACRO() Debug(aaa, /* force line break */ \\\n"
2618 " { int i; int j; })",
2619 getGoogleStyle()));
Daniel Jasper1a028222015-05-26 07:03:42 +00002620
2621 EXPECT_EQ("#define A \\\n"
2622 " [] { \\\n"
2623 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
2624 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n"
2625 " }",
2626 format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
2627 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }",
2628 getGoogleStyle()));
Daniel Jasper5fc133e2015-05-12 10:16:02 +00002629}
2630
Manuel Klimeke7d10a12013-01-10 13:24:24 +00002631TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) {
2632 EXPECT_EQ("{}", format("{}"));
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00002633 verifyFormat("enum E {};");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00002634 verifyFormat("enum E {}");
Manuel Klimeke7d10a12013-01-10 13:24:24 +00002635}
2636
Birunthan Mohanathasb001a0b2015-07-03 17:25:16 +00002637TEST_F(FormatTest, FormatBeginBlockEndMacros) {
2638 FormatStyle Style = getLLVMStyle();
2639 Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$";
2640 Style.MacroBlockEnd = "^[A-Z_]+_END$";
2641 verifyFormat("FOO_BEGIN\n"
2642 " FOO_ENTRY\n"
2643 "FOO_END", Style);
2644 verifyFormat("FOO_BEGIN\n"
2645 " NESTED_FOO_BEGIN\n"
2646 " NESTED_FOO_ENTRY\n"
2647 " NESTED_FOO_END\n"
2648 "FOO_END", Style);
2649 verifyFormat("FOO_BEGIN(Foo, Bar)\n"
2650 " int x;\n"
2651 " x = 1;\n"
2652 "FOO_END(Baz)", Style);
2653}
2654
Alexander Kornienko578fdd82012-12-06 18:03:27 +00002655//===----------------------------------------------------------------------===//
2656// Line break tests.
2657//===----------------------------------------------------------------------===//
2658
Daniel Jasperf79b0b12013-08-30 08:29:25 +00002659TEST_F(FormatTest, PreventConfusingIndents) {
Alexander Kornienko578fdd82012-12-06 18:03:27 +00002660 verifyFormat(
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00002661 "void f() {\n"
2662 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n"
2663 " parameter, parameter, parameter)),\n"
2664 " SecondLongCall(parameter));\n"
2665 "}");
Daniel Jasper7b5773e92013-01-28 07:35:34 +00002666 verifyFormat(
2667 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2668 " aaaaaaaaaaaaaaaaaaaaaaaa(\n"
2669 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
2670 " aaaaaaaaaaaaaaaaaaaaaaaa);");
2671 verifyFormat(
Daniel Jasperaea3bde2013-07-12 11:19:37 +00002672 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2673 " [aaaaaaaaaaaaaaaaaaaaaaaa\n"
2674 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
2675 " [aaaaaaaaaaaaaaaaaaaaaaaa]];");
Daniel Jasper7b5773e92013-01-28 07:35:34 +00002676 verifyFormat(
2677 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
2678 " aaaaaaaaaaaaaaaaaaaaaaaa<\n"
2679 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n"
2680 " aaaaaaaaaaaaaaaaaaaaaaaa>;");
Daniel Jasper240527c2017-01-16 13:13:15 +00002681 verifyFormat("int a = bbbb && ccc &&\n"
2682 " fffff(\n"
Daniel Jasper20b09ef2013-01-28 09:35:24 +00002683 "#define A Just forcing a new line\n"
Daniel Jasper240527c2017-01-16 13:13:15 +00002684 " ddd);");
Daniel Jasper7b5773e92013-01-28 07:35:34 +00002685}
2686
Daniel Jasperd69fc772013-05-08 14:12:04 +00002687TEST_F(FormatTest, LineBreakingInBinaryExpressions) {
2688 verifyFormat(
2689 "bool aaaaaaa =\n"
2690 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n"
2691 " bbbbbbbb();");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00002692 verifyFormat(
2693 "bool aaaaaaa =\n"
2694 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n"
2695 " bbbbbbbb();");
2696
Daniel Jasperd69fc772013-05-08 14:12:04 +00002697 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
2698 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n"
2699 " ccccccccc == ddddddddddd;");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00002700 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
2701 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n"
2702 " ccccccccc == ddddddddddd;");
2703 verifyFormat(
2704 "bool aaaaaaaaaaaaaaaaaaaaa =\n"
2705 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n"
2706 " ccccccccc == ddddddddddd;");
Daniel Jasperd69fc772013-05-08 14:12:04 +00002707
2708 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
2709 " aaaaaa) &&\n"
2710 " bbbbbb && cccccc;");
Daniel Jasper9f82df22013-05-28 07:42:44 +00002711 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
2712 " aaaaaa) >>\n"
2713 " bbbbbb;");
Daniel Jasperf901a572015-12-07 19:50:48 +00002714 verifyFormat("aa = Whitespaces.addUntouchableComment(\n"
Daniel Jasperd69fc772013-05-08 14:12:04 +00002715 " SourceMgr.getSpellingColumnNumber(\n"
2716 " TheLine.Last->FormatTok.Tok.getLocation()) -\n"
2717 " 1);");
Daniel Jasper571f1af2013-05-14 20:39:56 +00002718
Daniel Jasper68d888c2013-06-03 08:42:05 +00002719 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
2720 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n"
2721 " cccccc) {\n}");
Daniel Jasper6a7d5a72017-06-19 07:40:49 +00002722 verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
2723 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
2724 " cccccc) {\n}");
Daniel Jasper3eb341c2014-11-11 23:04:51 +00002725 verifyFormat("b = a &&\n"
2726 " // Comment\n"
2727 " b.c && d;");
Daniel Jasper68d888c2013-06-03 08:42:05 +00002728
Daniel Jasper7ae41cd2013-07-03 10:34:47 +00002729 // If the LHS of a comparison is not a binary expression itself, the
2730 // additional linebreak confuses many people.
2731 verifyFormat(
2732 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2733 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n"
2734 "}");
2735 verifyFormat(
2736 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2737 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
2738 "}");
Daniel Jasper562ecd42013-09-06 08:08:14 +00002739 verifyFormat(
2740 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n"
2741 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
2742 "}");
Daniel Jasper7ae41cd2013-07-03 10:34:47 +00002743 // Even explicit parentheses stress the precedence enough to make the
2744 // additional break unnecessary.
Daniel Jaspera44991332015-04-29 13:06:49 +00002745 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2746 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
2747 "}");
Daniel Jasper7ae41cd2013-07-03 10:34:47 +00002748 // This cases is borderline, but with the indentation it is still readable.
2749 verifyFormat(
2750 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2751 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2752 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
2753 "}",
2754 getLLVMStyleWithColumns(75));
2755
2756 // If the LHS is a binary expression, we should still use the additional break
2757 // as otherwise the formatting hides the operator precedence.
Daniel Jaspera44991332015-04-29 13:06:49 +00002758 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2759 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2760 " 5) {\n"
2761 "}");
Daniel Jasper7ae41cd2013-07-03 10:34:47 +00002762
Daniel Jasper571f1af2013-05-14 20:39:56 +00002763 FormatStyle OnePerLine = getLLVMStyle();
2764 OnePerLine.BinPackParameters = false;
2765 verifyFormat(
2766 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
2767 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
2768 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}",
2769 OnePerLine);
Daniel Jaspere61f9f92017-01-13 23:18:16 +00002770
2771 verifyFormat("int i = someFunction(aaaaaaa, 0)\n"
2772 " .aaa(aaaaaaaaaaaaa) *\n"
2773 " aaaaaaa +\n"
2774 " aaaaaaa;",
2775 getLLVMStyleWithColumns(40));
Daniel Jasperd69fc772013-05-08 14:12:04 +00002776}
2777
Daniel Jasper6bee6822013-04-08 20:33:42 +00002778TEST_F(FormatTest, ExpressionIndentation) {
2779 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2780 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2781 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2782 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2783 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
2784 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n"
2785 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2786 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n"
2787 " ccccccccccccccccccccccccccccccccccccccccc;");
2788 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2789 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2790 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2791 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
2792 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2793 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2794 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2795 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
2796 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2797 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2798 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2799 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
Daniel Jasper6dcecb62013-06-06 09:11:58 +00002800 verifyFormat("if () {\n"
Daniel Jasper21f7dea2017-02-01 09:23:39 +00002801 "} else if (aaaaa && bbbbb > // break\n"
2802 " ccccc) {\n"
2803 "}");
2804 verifyFormat("if () {\n"
Daniel Jasper5c332652014-04-03 12:00:33 +00002805 "} else if (aaaaa &&\n"
2806 " bbbbb > // break\n"
Daniel Jasper21f7dea2017-02-01 09:23:39 +00002807 " ccccc &&\n"
2808 " ddddd) {\n"
Daniel Jasper6dcecb62013-06-06 09:11:58 +00002809 "}");
Alexander Kornienkoafaa8f52013-06-17 13:19:53 +00002810
2811 // Presence of a trailing comment used to change indentation of b.
2812 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
2813 " b;\n"
2814 "return aaaaaaaaaaaaaaaaaaa +\n"
2815 " b; //",
2816 getLLVMStyleWithColumns(30));
Daniel Jasper6bee6822013-04-08 20:33:42 +00002817}
2818
Daniel Jaspere33d4af2013-07-26 16:56:36 +00002819TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) {
2820 // Not sure what the best system is here. Like this, the LHS can be found
2821 // immediately above an operator (everything with the same or a higher
2822 // indent). The RHS is aligned right of the operator and so compasses
2823 // everything until something with the same indent as the operator is found.
2824 // FIXME: Is this a good system?
2825 FormatStyle Style = getLLVMStyle();
Daniel Jasperac043c92014-09-15 11:11:00 +00002826 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
Daniel Jaspere33d4af2013-07-26 16:56:36 +00002827 verifyFormat(
2828 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00002829 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2830 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2831 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2832 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
2833 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
Daniel Jaspere33d4af2013-07-26 16:56:36 +00002834 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00002835 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2836 " > ccccccccccccccccccccccccccccccccccccccccc;",
Daniel Jaspere33d4af2013-07-26 16:56:36 +00002837 Style);
2838 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00002839 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2840 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jaspere33d4af2013-07-26 16:56:36 +00002841 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
2842 Style);
2843 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00002844 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2845 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jaspere33d4af2013-07-26 16:56:36 +00002846 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
2847 Style);
2848 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2849 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00002850 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2851 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
Daniel Jaspere33d4af2013-07-26 16:56:36 +00002852 Style);
2853 verifyFormat("if () {\n"
Daniel Jasperc0d606a2014-04-14 11:08:45 +00002854 "} else if (aaaaa\n"
2855 " && bbbbb // break\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00002856 " > ccccc) {\n"
Daniel Jaspere33d4af2013-07-26 16:56:36 +00002857 "}",
2858 Style);
Daniel Jasper119ff532014-11-14 12:31:14 +00002859 verifyFormat("return (a)\n"
2860 " // comment\n"
2861 " + b;",
2862 Style);
Daniel Jaspera44991332015-04-29 13:06:49 +00002863 verifyFormat(
2864 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2865 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
2866 " + cc;",
2867 Style);
Daniel Jasper9e5ede02013-11-08 19:56:28 +00002868
Daniel Jaspere92bf6f2015-05-06 14:23:38 +00002869 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2870 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
2871 Style);
2872
Daniel Jasper9e5ede02013-11-08 19:56:28 +00002873 // Forced by comments.
2874 verifyFormat(
2875 "unsigned ContentSize =\n"
2876 " sizeof(int16_t) // DWARF ARange version number\n"
2877 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
2878 " + sizeof(int8_t) // Pointer Size (in bytes)\n"
2879 " + sizeof(int8_t); // Segment Size (in bytes)");
Daniel Jasper446d1cd2013-11-23 14:45:49 +00002880
2881 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
2882 " == boost::fusion::at_c<1>(iiii).second;",
2883 Style);
Daniel Jasper0a1e5ac2014-05-13 08:01:47 +00002884
2885 Style.ColumnLimit = 60;
2886 verifyFormat("zzzzzzzzzz\n"
2887 " = bbbbbbbbbbbbbbbbb\n"
2888 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
2889 Style);
Daniel Jaspere33d4af2013-07-26 16:56:36 +00002890}
2891
Daniel Jasperb1270392017-02-01 23:27:37 +00002892TEST_F(FormatTest, EnforcedOperatorWraps) {
2893 // Here we'd like to wrap after the || operators, but a comment is forcing an
2894 // earlier wrap.
2895 verifyFormat("bool x = aaaaa //\n"
2896 " || bbbbb\n"
2897 " //\n"
2898 " || cccc;");
2899}
2900
Daniel Jasper3219e432014-12-02 13:24:51 +00002901TEST_F(FormatTest, NoOperandAlignment) {
2902 FormatStyle Style = getLLVMStyle();
2903 Style.AlignOperands = false;
Daniel Jasperc3aa05c2017-02-02 08:30:21 +00002904 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n"
2905 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2906 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
2907 Style);
Daniel Jasper3219e432014-12-02 13:24:51 +00002908 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
Daniel Jaspera44991332015-04-29 13:06:49 +00002909 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2910 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2911 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2912 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2913 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
2914 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
2915 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2916 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2917 " > ccccccccccccccccccccccccccccccccccccccccc;",
2918 Style);
Daniel Jasper3219e432014-12-02 13:24:51 +00002919
2920 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2921 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
2922 " + cc;",
2923 Style);
2924 verifyFormat("int a = aa\n"
2925 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
Daniel Jasper21f7dea2017-02-01 09:23:39 +00002926 " * cccccccccccccccccccccccccccccccccccc;\n",
Daniel Jasper3219e432014-12-02 13:24:51 +00002927 Style);
Daniel Jasperc0956632014-12-03 14:02:59 +00002928
Daniel Jasper6501f7e2015-10-27 12:38:37 +00002929 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
Daniel Jasperc0956632014-12-03 14:02:59 +00002930 verifyFormat("return (a > b\n"
2931 " // comment1\n"
2932 " // comment2\n"
2933 " || c);",
2934 Style);
Daniel Jasper3219e432014-12-02 13:24:51 +00002935}
2936
Daniel Jasperac043c92014-09-15 11:11:00 +00002937TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) {
2938 FormatStyle Style = getLLVMStyle();
2939 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
2940 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
2941 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper3219e432014-12-02 13:24:51 +00002942 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
2943 Style);
Daniel Jasperac043c92014-09-15 11:11:00 +00002944}
2945
Daniel Jasper988e7e42017-05-08 15:07:52 +00002946TEST_F(FormatTest, AllowBinPackingInsideArguments) {
2947 FormatStyle Style = getLLVMStyle();
2948 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
2949 Style.BinPackArguments = false;
2950 Style.ColumnLimit = 40;
2951 verifyFormat("void test() {\n"
2952 " someFunction(\n"
2953 " this + argument + is + quite\n"
2954 " + long + so + it + gets + wrapped\n"
2955 " + but + remains + bin - packed);\n"
2956 "}",
2957 Style);
2958 verifyFormat("void test() {\n"
2959 " someFunction(arg1,\n"
2960 " this + argument + is\n"
2961 " + quite + long + so\n"
2962 " + it + gets + wrapped\n"
2963 " + but + remains + bin\n"
2964 " - packed,\n"
2965 " arg3);\n"
2966 "}",
2967 Style);
2968 verifyFormat("void test() {\n"
2969 " someFunction(\n"
2970 " arg1,\n"
2971 " this + argument + has\n"
2972 " + anotherFunc(nested,\n"
2973 " calls + whose\n"
2974 " + arguments\n"
2975 " + are + also\n"
2976 " + wrapped,\n"
2977 " in + addition)\n"
2978 " + to + being + bin - packed,\n"
2979 " arg3);\n"
2980 "}",
2981 Style);
2982
2983 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
2984 verifyFormat("void test() {\n"
2985 " someFunction(\n"
2986 " arg1,\n"
2987 " this + argument + has +\n"
2988 " anotherFunc(nested,\n"
2989 " calls + whose +\n"
2990 " arguments +\n"
2991 " are + also +\n"
2992 " wrapped,\n"
2993 " in + addition) +\n"
2994 " to + being + bin - packed,\n"
2995 " arg3);\n"
2996 "}",
2997 Style);
2998}
2999
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003000TEST_F(FormatTest, ConstructorInitializers) {
Manuel Klimeke7d10a12013-01-10 13:24:24 +00003001 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
Daniel Jasper2408a8c2013-01-11 11:37:55 +00003002 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
3003 getLLVMStyleWithColumns(45));
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003004 verifyFormat("Constructor()\n"
3005 " : Inttializer(FitsOnTheLine) {}",
Daniel Jasper2408a8c2013-01-11 11:37:55 +00003006 getLLVMStyleWithColumns(44));
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003007 verifyFormat("Constructor()\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003008 " : Inttializer(FitsOnTheLine) {}",
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003009 getLLVMStyleWithColumns(43));
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003010
Daniel Jasper7b259cd2015-08-27 11:59:31 +00003011 verifyFormat("template <typename T>\n"
3012 "Constructor() : Initializer(FitsOnTheLine) {}",
3013 getLLVMStyleWithColumns(45));
3014
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003015 verifyFormat(
3016 "SomeClass::Constructor()\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003017 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003018
3019 verifyFormat(
3020 "SomeClass::Constructor()\n"
Daniel Jasper2408a8c2013-01-11 11:37:55 +00003021 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003022 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}");
Daniel Jasper2408a8c2013-01-11 11:37:55 +00003023 verifyFormat(
3024 "SomeClass::Constructor()\n"
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003025 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003026 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
Daniel Jasper7b259cd2015-08-27 11:59:31 +00003027 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3028 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3029 " : aaaaaaaaaa(aaaaaa) {}");
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003030
3031 verifyFormat("Constructor()\n"
3032 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3033 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3034 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003035 " aaaaaaaaaaaaaaaaaaaaaaa() {}");
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003036
Daniel Jasper65585ed2013-01-28 13:31:35 +00003037 verifyFormat("Constructor()\n"
3038 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003039 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasper65585ed2013-01-28 13:31:35 +00003040
Daniel Jasper62e68172013-02-25 15:59:54 +00003041 verifyFormat("Constructor(int Parameter = 0)\n"
3042 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
3043 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}");
Daniel Jasper87f18f12013-09-06 21:46:41 +00003044 verifyFormat("Constructor()\n"
3045 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
3046 "}",
3047 getLLVMStyleWithColumns(60));
Daniel Jasper4fcc8b92013-11-07 17:52:51 +00003048 verifyFormat("Constructor()\n"
3049 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3050 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}");
Daniel Jasper62e68172013-02-25 15:59:54 +00003051
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003052 // Here a line could be saved by splitting the second initializer onto two
Alp Tokerf6a24ce2013-12-05 16:25:25 +00003053 // lines, but that is not desirable.
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003054 verifyFormat("Constructor()\n"
3055 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
3056 " aaaaaaaaaaa(aaaaaaaaaaa),\n"
3057 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003058
Daniel Jasper23e8e0c2013-02-15 16:49:44 +00003059 FormatStyle OnePerLine = getLLVMStyle();
3060 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
Daniel Jasper7bec87c2016-01-07 18:11:54 +00003061 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false;
Daniel Jasper23e8e0c2013-02-15 16:49:44 +00003062 verifyFormat("SomeClass::Constructor()\n"
3063 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
3064 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003065 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003066 OnePerLine);
Daniel Jasper23e8e0c2013-02-15 16:49:44 +00003067 verifyFormat("SomeClass::Constructor()\n"
3068 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
3069 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003070 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003071 OnePerLine);
Daniel Jasper23e8e0c2013-02-15 16:49:44 +00003072 verifyFormat("MyClass::MyClass(int var)\n"
3073 " : some_var_(var), // 4 space indent\n"
3074 " some_other_var_(var + 1) { // lined up\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003075 "}",
3076 OnePerLine);
Daniel Jasperead41b62013-02-28 09:39:12 +00003077 verifyFormat("Constructor()\n"
3078 " : aaaaa(aaaaaa),\n"
3079 " aaaaa(aaaaaa),\n"
3080 " aaaaa(aaaaaa),\n"
3081 " aaaaa(aaaaaa),\n"
3082 " aaaaa(aaaaaa) {}",
3083 OnePerLine);
Daniel Jaspercc960fa2013-04-22 07:59:53 +00003084 verifyFormat("Constructor()\n"
3085 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
3086 " aaaaaaaaaaaaaaaaaaaaaa) {}",
3087 OnePerLine);
Daniel Jasper7bec87c2016-01-07 18:11:54 +00003088 OnePerLine.BinPackParameters = false;
3089 verifyFormat(
3090 "Constructor()\n"
3091 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n"
3092 " aaaaaaaaaaa().aaa(),\n"
3093 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
3094 OnePerLine);
Daniel Jasperbd73bcf2015-10-27 13:42:08 +00003095 OnePerLine.ColumnLimit = 60;
3096 verifyFormat("Constructor()\n"
3097 " : aaaaaaaaaaaaaaaaaaaa(a),\n"
3098 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
3099 OnePerLine);
Daniel Jasperf6c7c182014-01-13 14:10:04 +00003100
3101 EXPECT_EQ("Constructor()\n"
3102 " : // Comment forcing unwanted break.\n"
3103 " aaaa(aaaa) {}",
3104 format("Constructor() :\n"
3105 " // Comment forcing unwanted break.\n"
3106 " aaaa(aaaa) {}"));
Daniel Jaspere3c0e012013-04-25 13:31:51 +00003107}
3108
Francois Ferranda6b6d512017-05-24 11:36:58 +00003109TEST_F(FormatTest, BreakConstructorInitializersAfterColon) {
3110 FormatStyle Style = getLLVMStyle();
3111 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
3112
3113 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
3114 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}",
3115 getStyleWithColumns(Style, 45));
3116 verifyFormat("Constructor() :\n"
3117 " Initializer(FitsOnTheLine) {}",
3118 getStyleWithColumns(Style, 44));
3119 verifyFormat("Constructor() :\n"
3120 " Initializer(FitsOnTheLine) {}",
3121 getStyleWithColumns(Style, 43));
3122
3123 verifyFormat("template <typename T>\n"
3124 "Constructor() : Initializer(FitsOnTheLine) {}",
3125 getStyleWithColumns(Style, 50));
3126
3127 verifyFormat(
3128 "SomeClass::Constructor() :\n"
3129 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
3130 Style);
3131
3132 verifyFormat(
3133 "SomeClass::Constructor() :\n"
3134 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
3135 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
3136 Style);
3137 verifyFormat(
3138 "SomeClass::Constructor() :\n"
3139 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3140 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
3141 Style);
3142 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3143 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
3144 " aaaaaaaaaa(aaaaaa) {}",
3145 Style);
3146
3147 verifyFormat("Constructor() :\n"
3148 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3149 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3150 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3151 " aaaaaaaaaaaaaaaaaaaaaaa() {}",
3152 Style);
3153
3154 verifyFormat("Constructor() :\n"
3155 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3156 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
3157 Style);
3158
3159 verifyFormat("Constructor(int Parameter = 0) :\n"
3160 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
3161 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}",
3162 Style);
3163 verifyFormat("Constructor() :\n"
3164 " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
3165 "}",
3166 getStyleWithColumns(Style, 60));
3167 verifyFormat("Constructor() :\n"
3168 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3169 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}",
3170 Style);
3171
3172 // Here a line could be saved by splitting the second initializer onto two
3173 // lines, but that is not desirable.
3174 verifyFormat("Constructor() :\n"
3175 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
3176 " aaaaaaaaaaa(aaaaaaaaaaa),\n"
3177 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
3178 Style);
3179
3180 FormatStyle OnePerLine = Style;
3181 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
3182 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false;
3183 verifyFormat("SomeClass::Constructor() :\n"
3184 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
3185 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
3186 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
3187 OnePerLine);
3188 verifyFormat("SomeClass::Constructor() :\n"
3189 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
3190 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
3191 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
3192 OnePerLine);
3193 verifyFormat("MyClass::MyClass(int var) :\n"
3194 " some_var_(var), // 4 space indent\n"
3195 " some_other_var_(var + 1) { // lined up\n"
3196 "}",
3197 OnePerLine);
3198 verifyFormat("Constructor() :\n"
3199 " aaaaa(aaaaaa),\n"
3200 " aaaaa(aaaaaa),\n"
3201 " aaaaa(aaaaaa),\n"
3202 " aaaaa(aaaaaa),\n"
3203 " aaaaa(aaaaaa) {}",
3204 OnePerLine);
3205 verifyFormat("Constructor() :\n"
3206 " aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
3207 " aaaaaaaaaaaaaaaaaaaaaa) {}",
3208 OnePerLine);
3209 OnePerLine.BinPackParameters = false;
3210 verifyFormat(
3211 "Constructor() :\n"
3212 " aaaaaaaaaaaaaaaaaaaaaaaa(\n"
3213 " aaaaaaaaaaa().aaa(),\n"
3214 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
3215 OnePerLine);
3216 OnePerLine.ColumnLimit = 60;
3217 verifyFormat("Constructor() :\n"
3218 " aaaaaaaaaaaaaaaaaaaa(a),\n"
3219 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
3220 OnePerLine);
3221
3222 EXPECT_EQ("Constructor() :\n"
3223 " // Comment forcing unwanted break.\n"
3224 " aaaa(aaaa) {}",
3225 format("Constructor() :\n"
3226 " // Comment forcing unwanted break.\n"
3227 " aaaa(aaaa) {}",
3228 Style));
3229
3230 Style.ColumnLimit = 0;
3231 verifyFormat("SomeClass::Constructor() :\n"
3232 " a(a) {}",
3233 Style);
3234 verifyFormat("SomeClass::Constructor() noexcept :\n"
3235 " a(a) {}",
3236 Style);
3237 verifyFormat("SomeClass::Constructor() :\n"
3238 " a(a), b(b), c(c) {}",
3239 Style);
3240 verifyFormat("SomeClass::Constructor() :\n"
3241 " a(a) {\n"
3242 " foo();\n"
3243 " bar();\n"
3244 "}",
3245 Style);
3246
3247 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
3248 verifyFormat("SomeClass::Constructor() :\n"
3249 " a(a), b(b), c(c) {\n"
3250 "}",
3251 Style);
3252 verifyFormat("SomeClass::Constructor() :\n"
3253 " a(a) {\n"
3254 "}",
3255 Style);
3256
3257 Style.ColumnLimit = 80;
3258 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
3259 Style.ConstructorInitializerIndentWidth = 2;
3260 verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}",
3261 Style);
3262 verifyFormat("SomeClass::Constructor() :\n"
3263 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3264 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}",
3265 Style);
3266}
3267
Daniel Jaspere3c0e012013-04-25 13:31:51 +00003268TEST_F(FormatTest, MemoizationTests) {
3269 // This breaks if the memoization lookup does not take \c Indent and
3270 // \c LastSpace into account.
3271 verifyFormat(
3272 "extern CFRunLoopTimerRef\n"
3273 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
3274 " CFTimeInterval interval, CFOptionFlags flags,\n"
3275 " CFIndex order, CFRunLoopTimerCallBack callout,\n"
Daniel Jasper8e357692013-05-06 08:27:33 +00003276 " CFRunLoopTimerContext *context) {}");
Daniel Jaspere3c0e012013-04-25 13:31:51 +00003277
3278 // Deep nesting somewhat works around our memoization.
3279 verifyFormat(
3280 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
3281 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
3282 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
3283 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
3284 " aaaaa())))))))))))))))))))))))))))))))))))))));",
3285 getLLVMStyleWithColumns(65));
Daniel Jaspercc3044c2013-05-13 09:19:24 +00003286 verifyFormat(
3287 "aaaaa(\n"
3288 " aaaaa,\n"
3289 " aaaaa(\n"
3290 " aaaaa,\n"
3291 " aaaaa(\n"
3292 " aaaaa,\n"
3293 " aaaaa(\n"
3294 " aaaaa,\n"
3295 " aaaaa(\n"
3296 " aaaaa,\n"
3297 " aaaaa(\n"
3298 " aaaaa,\n"
3299 " aaaaa(\n"
3300 " aaaaa,\n"
3301 " aaaaa(\n"
3302 " aaaaa,\n"
3303 " aaaaa(\n"
3304 " aaaaa,\n"
3305 " aaaaa(\n"
3306 " aaaaa,\n"
3307 " aaaaa(\n"
3308 " aaaaa,\n"
3309 " aaaaa(\n"
3310 " aaaaa,\n"
3311 " aaaaa))))))))))));",
3312 getLLVMStyleWithColumns(65));
Daniel Jasperf8114cf2013-05-22 05:27:42 +00003313 verifyFormat(
3314 "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"
3315 " a),\n"
3316 " a),\n"
3317 " a),\n"
3318 " a),\n"
3319 " a),\n"
3320 " a),\n"
3321 " a),\n"
3322 " a),\n"
3323 " a),\n"
3324 " a),\n"
3325 " a),\n"
3326 " a),\n"
3327 " a),\n"
3328 " a),\n"
3329 " a),\n"
3330 " a),\n"
3331 " a)",
3332 getLLVMStyleWithColumns(65));
Daniel Jasper7b7877a2013-01-12 07:36:22 +00003333
3334 // This test takes VERY long when memoization is broken.
Daniel Jaspere3c0e012013-04-25 13:31:51 +00003335 FormatStyle OnePerLine = getLLVMStyle();
3336 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003337 OnePerLine.BinPackParameters = false;
Daniel Jasper9278eb92013-01-16 14:59:02 +00003338 std::string input = "Constructor()\n"
Daniel Jasper7a31af12013-01-25 15:43:32 +00003339 " : aaaa(a,\n";
Daniel Jasper9278eb92013-01-16 14:59:02 +00003340 for (unsigned i = 0, e = 80; i != e; ++i) {
3341 input += " a,\n";
3342 }
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003343 input += " a) {}";
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003344 verifyFormat(input, OnePerLine);
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003345}
3346
Alexander Kornienko578fdd82012-12-06 18:03:27 +00003347TEST_F(FormatTest, BreaksAsHighAsPossible) {
3348 verifyFormat(
Alexander Kornienkoa5151272013-03-12 16:28:18 +00003349 "void f() {\n"
3350 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
3351 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
3352 " f();\n"
3353 "}");
Daniel Jasper70bc8742013-02-26 13:59:14 +00003354 verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00003355 " Intervals[i - 1].getRange().getLast()) {\n}");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00003356}
3357
Daniel Jasper6728fc12013-04-11 14:29:13 +00003358TEST_F(FormatTest, BreaksFunctionDeclarations) {
3359 // Principially, we break function declarations in a certain order:
3360 // 1) break amongst arguments.
3361 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
3362 " Cccccccccccccc cccccccccccccc);");
Daniel Jaspera44991332015-04-29 13:06:49 +00003363 verifyFormat("template <class TemplateIt>\n"
3364 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n"
3365 " TemplateIt *stop) {}");
Daniel Jasper6728fc12013-04-11 14:29:13 +00003366
3367 // 2) break after return type.
Daniel Jasper8e357692013-05-06 08:27:33 +00003368 verifyFormat(
Manuel Klimek836c2862013-06-21 17:25:42 +00003369 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00003370 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);",
Manuel Klimek836c2862013-06-21 17:25:42 +00003371 getGoogleStyle());
Daniel Jasper6728fc12013-04-11 14:29:13 +00003372
3373 // 3) break after (.
3374 verifyFormat(
3375 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
Manuel Klimek836c2862013-06-21 17:25:42 +00003376 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);",
3377 getGoogleStyle());
Daniel Jasper6728fc12013-04-11 14:29:13 +00003378
3379 // 4) break before after nested name specifiers.
3380 verifyFormat(
3381 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00003382 "SomeClasssssssssssssssssssssssssssssssssssssss::\n"
3383 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);",
Manuel Klimek836c2862013-06-21 17:25:42 +00003384 getGoogleStyle());
Daniel Jasper6728fc12013-04-11 14:29:13 +00003385
3386 // However, there are exceptions, if a sufficient amount of lines can be
3387 // saved.
3388 // FIXME: The precise cut-offs wrt. the number of saved lines might need some
3389 // more adjusting.
3390 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
3391 " Cccccccccccccc cccccccccc,\n"
3392 " Cccccccccccccc cccccccccc,\n"
3393 " Cccccccccccccc cccccccccc,\n"
3394 " Cccccccccccccc cccccccccc);");
3395 verifyFormat(
Manuel Klimek836c2862013-06-21 17:25:42 +00003396 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00003397 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3398 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3399 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);",
Manuel Klimek836c2862013-06-21 17:25:42 +00003400 getGoogleStyle());
Daniel Jasper6728fc12013-04-11 14:29:13 +00003401 verifyFormat(
3402 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
3403 " Cccccccccccccc cccccccccc,\n"
3404 " Cccccccccccccc cccccccccc,\n"
3405 " Cccccccccccccc cccccccccc,\n"
3406 " Cccccccccccccc cccccccccc,\n"
3407 " Cccccccccccccc cccccccccc,\n"
3408 " Cccccccccccccc cccccccccc);");
3409 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
3410 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3411 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3412 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3413 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
Daniel Jasper1b8e76f2013-04-15 22:36:37 +00003414
3415 // Break after multi-line parameters.
3416 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3417 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3418 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3419 " bbbb bbbb);");
Daniel Jasper6c0ee172014-11-14 13:14:45 +00003420 verifyFormat("void SomeLoooooooooooongFunction(\n"
3421 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
3422 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3423 " int bbbbbbbbbbbbb);");
Daniel Jasper6331da02013-07-09 07:43:55 +00003424
3425 // Treat overloaded operators like other functions.
3426 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
3427 "operator>(const SomeLoooooooooooooooooooooooooogType &other);");
Daniel Jasperd215b8b2013-08-28 07:27:35 +00003428 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
3429 "operator>>(const SomeLooooooooooooooooooooooooogType &other);");
Alexander Kornienko86b2dfd2014-03-06 15:13:08 +00003430 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
3431 "operator<<(const SomeLooooooooooooooooooooooooogType &other);");
3432 verifyGoogleFormat(
3433 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n"
3434 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
Daniel Jasper6331da02013-07-09 07:43:55 +00003435 verifyGoogleFormat(
3436 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n"
3437 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
Daniel Jasper126153a2013-12-27 06:39:56 +00003438 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3439 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);");
3440 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n"
3441 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);");
Daniel Jasperea79ea12014-08-15 05:00:39 +00003442 verifyGoogleFormat(
3443 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n"
3444 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3445 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}");
Daniel Jasper88db7602016-02-11 06:43:01 +00003446 verifyGoogleFormat(
3447 "template <typename T>\n"
3448 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3449 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n"
3450 " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);");
Daniel Jasper11309812015-03-18 14:20:13 +00003451
3452 FormatStyle Style = getLLVMStyle();
3453 Style.PointerAlignment = FormatStyle::PAS_Left;
3454 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3455 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}",
3456 Style);
Daniel Jaspera44991332015-04-29 13:06:49 +00003457 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
3458 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
3459 Style);
Daniel Jasper6728fc12013-04-11 14:29:13 +00003460}
3461
Daniel Jasper6cdec7c2013-07-09 14:36:48 +00003462TEST_F(FormatTest, TrailingReturnType) {
3463 verifyFormat("auto foo() -> int;\n");
3464 verifyFormat("struct S {\n"
3465 " auto bar() const -> int;\n"
3466 "};");
3467 verifyFormat("template <size_t Order, typename T>\n"
3468 "auto load_img(const std::string &filename)\n"
3469 " -> alias::tensor<Order, T, mem::tag::cpu> {}");
Daniel Jasperda07a722014-10-17 14:37:40 +00003470 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n"
3471 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}");
Daniel Jasperb52c69e2014-10-22 09:01:12 +00003472 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}");
Daniel Jasper6f2b88a2015-06-05 13:18:09 +00003473 verifyFormat("template <typename T>\n"
3474 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n"
3475 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());");
Daniel Jaspera3501d42013-07-11 14:33:06 +00003476
3477 // Not trailing return types.
3478 verifyFormat("void f() { auto a = b->c(); }");
Daniel Jasper6cdec7c2013-07-09 14:36:48 +00003479}
3480
Daniel Jasper5be31f72013-05-21 09:16:31 +00003481TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) {
Daniel Jasperd8c36d02013-10-18 16:34:40 +00003482 // Avoid breaking before trailing 'const' or other trailing annotations, if
3483 // they are not function-like.
Daniel Jasper13c37b32013-05-22 08:28:26 +00003484 FormatStyle Style = getGoogleStyle();
3485 Style.ColumnLimit = 47;
Daniel Jaspere068ac72014-10-27 17:13:59 +00003486 verifyFormat("void someLongFunction(\n"
3487 " int someLoooooooooooooongParameter) const {\n}",
Daniel Jasper13c37b32013-05-22 08:28:26 +00003488 getLLVMStyleWithColumns(47));
Daniel Jasper13c37b32013-05-22 08:28:26 +00003489 verifyFormat("LoooooongReturnType\n"
3490 "someLoooooooongFunction() const {}",
3491 getLLVMStyleWithColumns(47));
3492 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
3493 " const {}",
3494 Style);
Daniel Jasperd8c36d02013-10-18 16:34:40 +00003495 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
3496 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;");
3497 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
3498 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;");
3499 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
3500 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;");
Daniel Jasper43e6a282013-12-16 15:01:54 +00003501 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n"
3502 " aaaaaaaaaaa aaaaa) const override;");
3503 verifyGoogleFormat(
3504 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
3505 " const override;");
Daniel Jasper5be31f72013-05-21 09:16:31 +00003506
Daniel Jasper5550de62014-02-17 07:57:46 +00003507 // Even if the first parameter has to be wrapped.
3508 verifyFormat("void someLongFunction(\n"
3509 " int someLongParameter) const {}",
Daniel Jasperd8c36d02013-10-18 16:34:40 +00003510 getLLVMStyleWithColumns(46));
Daniel Jasper5550de62014-02-17 07:57:46 +00003511 verifyFormat("void someLongFunction(\n"
3512 " int someLongParameter) const {}",
Daniel Jasperd8c36d02013-10-18 16:34:40 +00003513 Style);
Daniel Jasper5550de62014-02-17 07:57:46 +00003514 verifyFormat("void someLongFunction(\n"
3515 " int someLongParameter) override {}",
3516 Style);
3517 verifyFormat("void someLongFunction(\n"
Daniel Jasperb48d3af2014-04-09 10:01:49 +00003518 " int someLongParameter) OVERRIDE {}",
3519 Style);
3520 verifyFormat("void someLongFunction(\n"
Daniel Jasper5550de62014-02-17 07:57:46 +00003521 " int someLongParameter) final {}",
3522 Style);
3523 verifyFormat("void someLongFunction(\n"
Daniel Jasperb48d3af2014-04-09 10:01:49 +00003524 " int someLongParameter) FINAL {}",
3525 Style);
3526 verifyFormat("void someLongFunction(\n"
Daniel Jasper5550de62014-02-17 07:57:46 +00003527 " int parameter) const override {}",
3528 Style);
3529
Daniel Jaspere3f907f2014-06-02 09:52:08 +00003530 Style.BreakBeforeBraces = FormatStyle::BS_Allman;
3531 verifyFormat("void someLongFunction(\n"
3532 " int someLongParameter) const\n"
3533 "{\n"
3534 "}",
3535 Style);
3536
Daniel Jasper5550de62014-02-17 07:57:46 +00003537 // Unless these are unknown annotations.
Daniel Jasperd8c36d02013-10-18 16:34:40 +00003538 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n"
3539 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3540 " LONG_AND_UGLY_ANNOTATION;");
Daniel Jasper718bd362013-07-11 21:02:56 +00003541
3542 // Breaking before function-like trailing annotations is fine to keep them
3543 // close to their arguments.
Daniel Jasper5be31f72013-05-21 09:16:31 +00003544 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3545 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
3546 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
3547 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
3548 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
3549 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}");
Daniel Jasperf9a09062014-04-09 10:29:11 +00003550 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n"
3551 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);");
Daniel Jasper8b76d602014-07-28 12:08:06 +00003552 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});");
Daniel Jasper5be31f72013-05-21 09:16:31 +00003553
3554 verifyFormat(
3555 "void aaaaaaaaaaaaaaaaaa()\n"
3556 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
3557 " aaaaaaaaaaaaaaaaaaaaaaaaa));");
3558 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3559 " __attribute__((unused));");
Daniel Jasper35ec2b22014-04-14 08:15:20 +00003560 verifyGoogleFormat(
Manuel Klimek836c2862013-06-21 17:25:42 +00003561 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper35ec2b22014-04-14 08:15:20 +00003562 " GUARDED_BY(aaaaaaaaaaaa);");
3563 verifyGoogleFormat(
Daniel Jasper40db06a2013-07-11 12:34:23 +00003564 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper35ec2b22014-04-14 08:15:20 +00003565 " GUARDED_BY(aaaaaaaaaaaa);");
3566 verifyGoogleFormat(
3567 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
3568 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper3ca283a2015-05-15 09:58:11 +00003569 verifyGoogleFormat(
3570 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
3571 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper5be31f72013-05-21 09:16:31 +00003572}
3573
Daniel Jasperf090f032015-05-18 09:47:22 +00003574TEST_F(FormatTest, FunctionAnnotations) {
3575 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
Daniel Jasper788ffd72015-08-24 15:10:01 +00003576 "int OldFunction(const string &parameter) {}");
3577 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
Daniel Jasperf090f032015-05-18 09:47:22 +00003578 "string OldFunction(const string &parameter) {}");
3579 verifyFormat("template <typename T>\n"
3580 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
3581 "string OldFunction(const string &parameter) {}");
Daniel Jasper47bbda02015-05-18 13:47:23 +00003582
3583 // Not function annotations.
3584 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3585 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
Daniel Jasper32739302015-05-27 04:55:47 +00003586 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n"
3587 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}");
Daniel Jasper19bc1d02016-04-06 13:58:09 +00003588 verifyFormat("MACRO(abc).function() // wrap\n"
3589 " << abc;");
3590 verifyFormat("MACRO(abc)->function() // wrap\n"
3591 " << abc;");
3592 verifyFormat("MACRO(abc)::function() // wrap\n"
3593 " << abc;");
Daniel Jasperf090f032015-05-18 09:47:22 +00003594}
3595
Daniel Jasperf7935112012-12-03 18:12:45 +00003596TEST_F(FormatTest, BreaksDesireably) {
3597 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
3598 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003599 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
Daniel Jasper39e27382013-01-23 20:41:06 +00003600 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3601 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
3602 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +00003603
3604 verifyFormat(
3605 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003606 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasperf7935112012-12-03 18:12:45 +00003607
3608 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3609 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3610 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jasper9b155472012-12-04 10:50:12 +00003611
3612 verifyFormat(
Daniel Jasper240527c2017-01-16 13:13:15 +00003613 "aaaaaaaa(aaaaaaaaaaaaa,\n"
3614 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3615 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
Daniel Jasper9b155472012-12-04 10:50:12 +00003616 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3617 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));");
Daniel Jasperaa1c9202012-12-05 14:57:28 +00003618
3619 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3620 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
3621
Daniel Jasper3d0c75c2013-01-02 14:40:02 +00003622 verifyFormat(
Alexander Kornienkoa5151272013-03-12 16:28:18 +00003623 "void f() {\n"
3624 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
3625 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
3626 "}");
Daniel Jasper7a31af12013-01-25 15:43:32 +00003627 verifyFormat(
3628 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3629 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
3630 verifyFormat(
Daniel Jasper21f7dea2017-02-01 09:23:39 +00003631 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3632 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
3633 verifyFormat(
Daniel Jasper240527c2017-01-16 13:13:15 +00003634 "aaaaaa(aaa,\n"
3635 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasper21f7dea2017-02-01 09:23:39 +00003636 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3637 " aaaa);");
Daniel Jaspera44991332015-04-29 13:06:49 +00003638 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3639 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3640 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper3d0c75c2013-01-02 14:40:02 +00003641
Daniel Jasper739b85f2015-06-29 10:42:59 +00003642 // Indent consistently independent of call expression and unary operator.
3643 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
3644 " dddddddddddddddddddddddddddddd));");
3645 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
3646 " dddddddddddddddddddddddddddddd));");
Daniel Jasperf79b0b12013-08-30 08:29:25 +00003647 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
Daniel Jasperf79b0b12013-08-30 08:29:25 +00003648 " dddddddddddddddddddddddddddddd));");
3649
Daniel Jasperaa1c9202012-12-05 14:57:28 +00003650 // This test case breaks on an incorrect memoization, i.e. an optimization not
3651 // taking into account the StopAt value.
3652 verifyFormat(
3653 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
Daniel Jasper2eda23e2012-12-24 13:43:52 +00003654 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
3655 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
3656 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper6d822722012-12-24 16:43:00 +00003657
Daniel Jasper8d1832e2013-01-07 13:26:07 +00003658 verifyFormat("{\n {\n {\n"
3659 " Annotation.SpaceRequiredBefore =\n"
3660 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
3661 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
3662 " }\n }\n}");
Alexander Kornienko4d26b6e2013-06-17 12:59:44 +00003663
3664 // Break on an outer level if there was a break on an inner level.
3665 EXPECT_EQ("f(g(h(a, // comment\n"
3666 " b, c),\n"
3667 " d, e),\n"
3668 " x, y);",
3669 format("f(g(h(a, // comment\n"
3670 " b, c), d, e), x, y);"));
Daniel Jasperee7539a2013-07-08 14:25:23 +00003671
3672 // Prefer breaking similar line breaks.
3673 verifyFormat(
3674 "const int kTrackingOptions = NSTrackingMouseMoved |\n"
3675 " NSTrackingMouseEnteredAndExited |\n"
3676 " NSTrackingActiveAlways;");
Daniel Jasperf7935112012-12-03 18:12:45 +00003677}
3678
Daniel Jasper18210d72014-10-09 09:52:05 +00003679TEST_F(FormatTest, FormatsDeclarationsOnePerLine) {
3680 FormatStyle NoBinPacking = getGoogleStyle();
3681 NoBinPacking.BinPackParameters = false;
3682 NoBinPacking.BinPackArguments = true;
3683 verifyFormat("void f() {\n"
3684 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n"
3685 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
3686 "}",
3687 NoBinPacking);
3688 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n"
3689 " int aaaaaaaaaaaaaaaaaaaa,\n"
3690 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
3691 NoBinPacking);
Daniel Jasper06ca0fc2016-01-11 11:01:05 +00003692
Daniel Jasper00693b082016-01-09 15:56:47 +00003693 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
3694 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3695 " vector<int> bbbbbbbbbbbbbbb);",
3696 NoBinPacking);
Daniel Jasper06ca0fc2016-01-11 11:01:05 +00003697 // FIXME: This behavior difference is probably not wanted. However, currently
3698 // we cannot distinguish BreakBeforeParameter being set because of the wrapped
3699 // template arguments from BreakBeforeParameter being set because of the
3700 // one-per-line formatting.
3701 verifyFormat(
3702 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n"
3703 " aaaaaaaaaa> aaaaaaaaaa);",
3704 NoBinPacking);
3705 verifyFormat(
3706 "void fffffffffff(\n"
3707 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n"
3708 " aaaaaaaaaa);");
Daniel Jasper18210d72014-10-09 09:52:05 +00003709}
3710
Daniel Jasper9278eb92013-01-16 14:59:02 +00003711TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
Daniel Jaspera628c982013-04-03 13:36:17 +00003712 FormatStyle NoBinPacking = getGoogleStyle();
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003713 NoBinPacking.BinPackParameters = false;
Daniel Jasper18210d72014-10-09 09:52:05 +00003714 NoBinPacking.BinPackArguments = false;
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003715 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
3716 " aaaaaaaaaaaaaaaaaaaa,\n"
3717 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);",
3718 NoBinPacking);
3719 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
3720 " aaaaaaaaaaaaa,\n"
3721 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));",
3722 NoBinPacking);
3723 verifyFormat(
Daniel Jasper9278eb92013-01-16 14:59:02 +00003724 "aaaaaaaa(aaaaaaaaaaaaa,\n"
3725 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3726 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
3727 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003728 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));",
3729 NoBinPacking);
3730 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
3731 " .aaaaaaaaaaaaaaaaaa();",
3732 NoBinPacking);
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00003733 verifyFormat("void f() {\n"
3734 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3735 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n"
3736 "}",
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003737 NoBinPacking);
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003738
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003739 verifyFormat(
Daniel Jaspere941b162013-01-23 10:08:28 +00003740 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3741 " aaaaaaaaaaaa,\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003742 " aaaaaaaaaaaa);",
3743 NoBinPacking);
3744 verifyFormat(
Daniel Jasper9278eb92013-01-16 14:59:02 +00003745 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
3746 " ddddddddddddddddddddddddddddd),\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003747 " test);",
3748 NoBinPacking);
Daniel Jasper9278eb92013-01-16 14:59:02 +00003749
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003750 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
3751 " aaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper253dad232015-11-23 15:55:45 +00003752 " aaaaaaaaaaaaaaaaaaaaaaa>\n"
3753 " aaaaaaaaaaaaaaaaaa;",
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003754 NoBinPacking);
3755 verifyFormat("a(\"a\"\n"
3756 " \"a\",\n"
3757 " a);");
Daniel Jaspere941b162013-01-23 10:08:28 +00003758
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003759 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
Daniel Jasperf7db4332013-01-29 16:03:49 +00003760 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
Daniel Jaspere941b162013-01-23 10:08:28 +00003761 " aaaaaaaaa,\n"
Daniel Jasperf7db4332013-01-29 16:03:49 +00003762 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003763 NoBinPacking);
Daniel Jasper687af3b2013-02-14 14:26:07 +00003764 verifyFormat(
3765 "void f() {\n"
3766 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
3767 " .aaaaaaa();\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003768 "}",
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003769 NoBinPacking);
Daniel Jasper53e8d852013-05-22 08:55:55 +00003770 verifyFormat(
3771 "template <class SomeType, class SomeOtherType>\n"
3772 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
3773 NoBinPacking);
Daniel Jasper9278eb92013-01-16 14:59:02 +00003774}
3775
Daniel Jasperb10cbc42013-07-10 14:02:49 +00003776TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
3777 FormatStyle Style = getLLVMStyleWithColumns(15);
3778 Style.ExperimentalAutoDetectBinPacking = true;
3779 EXPECT_EQ("aaa(aaaa,\n"
3780 " aaaa,\n"
3781 " aaaa);\n"
3782 "aaa(aaaa,\n"
3783 " aaaa,\n"
3784 " aaaa);",
3785 format("aaa(aaaa,\n" // one-per-line
3786 " aaaa,\n"
3787 " aaaa );\n"
3788 "aaa(aaaa, aaaa, aaaa);", // inconclusive
3789 Style));
3790 EXPECT_EQ("aaa(aaaa, aaaa,\n"
3791 " aaaa);\n"
3792 "aaa(aaaa, aaaa,\n"
3793 " aaaa);",
3794 format("aaa(aaaa, aaaa,\n" // bin-packed
3795 " aaaa );\n"
3796 "aaa(aaaa, aaaa, aaaa);", // inconclusive
3797 Style));
3798}
3799
Daniel Jasper04468962013-01-18 10:56:38 +00003800TEST_F(FormatTest, FormatsBuilderPattern) {
Daniel Jaspera44991332015-04-29 13:06:49 +00003801 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n"
3802 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
3803 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
3804 " .StartsWith(\".init\", ORDER_INIT)\n"
3805 " .StartsWith(\".fini\", ORDER_FINI)\n"
3806 " .StartsWith(\".hash\", ORDER_HASH)\n"
3807 " .Default(ORDER_TEXT);\n");
Daniel Jasperc6fbc212013-05-15 09:35:08 +00003808
Daniel Jaspereb50c672013-02-15 20:33:06 +00003809 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00003810 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
Daniel Jasper9ed9ade2013-02-18 13:24:21 +00003811 verifyFormat(
Daniel Jasper801cdb22016-01-05 13:03:59 +00003812 "aaaaaaa->aaaaaaa\n"
3813 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3814 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
Daniel Jasper9ed9ade2013-02-18 13:24:21 +00003815 " ->aaaaaaaa(aaaaaaaaaaaaaaa);");
Daniel Jaspere53beb22013-02-18 13:52:06 +00003816 verifyFormat(
Daniel Jasperf901a572015-12-07 19:50:48 +00003817 "aaaaaaa->aaaaaaa\n"
3818 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3819 " ->aaaaaaaa(aaaaaaaaaaaaaaa);");
3820 verifyFormat(
Daniel Jaspere53beb22013-02-18 13:52:06 +00003821 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
Daniel Jasperf9a84b52013-03-01 16:48:32 +00003822 " aaaaaaaaaaaaaa);");
Daniel Jaspere53beb22013-02-18 13:52:06 +00003823 verifyFormat(
Daniel Jasperb27c4b72013-08-27 11:09:05 +00003824 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n"
3825 " aaaaaa->aaaaaaaaaaaa()\n"
3826 " ->aaaaaaaaaaaaaaaa(\n"
Daniel Jasper9dedc7752015-04-07 06:41:24 +00003827 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00003828 " ->aaaaaaaaaaaaaaaaa();");
Daniel Jasper33b909c2013-10-25 14:29:37 +00003829 verifyGoogleFormat(
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00003830 "void f() {\n"
3831 " someo->Add((new util::filetools::Handler(dir))\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00003832 " ->OnEvent1(NewPermanentCallback(\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00003833 " this, &HandlerHolderClass::EventHandlerCBA))\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00003834 " ->OnEvent2(NewPermanentCallback(\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00003835 " this, &HandlerHolderClass::EventHandlerCBB))\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00003836 " ->OnEvent3(NewPermanentCallback(\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00003837 " this, &HandlerHolderClass::EventHandlerCBC))\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00003838 " ->OnEvent5(NewPermanentCallback(\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00003839 " this, &HandlerHolderClass::EventHandlerCBD))\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00003840 " ->OnEvent6(NewPermanentCallback(\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00003841 " this, &HandlerHolderClass::EventHandlerCBE)));\n"
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00003842 "}");
Daniel Jasper4c6e0052013-08-27 14:24:43 +00003843
3844 verifyFormat(
3845 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();");
3846 verifyFormat("aaaaaaaaaaaaaaa()\n"
3847 " .aaaaaaaaaaaaaaa()\n"
3848 " .aaaaaaaaaaaaaaa()\n"
3849 " .aaaaaaaaaaaaaaa()\n"
3850 " .aaaaaaaaaaaaaaa();");
3851 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
3852 " .aaaaaaaaaaaaaaa()\n"
3853 " .aaaaaaaaaaaaaaa()\n"
3854 " .aaaaaaaaaaaaaaa();");
3855 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
3856 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
3857 " .aaaaaaaaaaaaaaa();");
Daniel Jasperf8151e92013-08-30 07:12:40 +00003858 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
3859 " ->aaaaaaaaaaaaaae(0)\n"
3860 " ->aaaaaaaaaaaaaaa();");
Daniel Jasper36c28ce2013-09-06 08:54:24 +00003861
Daniel Jasper775954b2015-04-24 10:08:09 +00003862 // Don't linewrap after very short segments.
3863 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
3864 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
3865 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
3866 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
3867 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
3868 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
3869 verifyFormat("aaa()\n"
3870 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
3871 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
3872 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
3873
Daniel Jaspercc3114d2013-10-18 15:23:06 +00003874 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
3875 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
3876 " .has<bbbbbbbbbbbbbbbbbbbbb>();");
3877 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
3878 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00003879 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();");
Daniel Jaspercc3114d2013-10-18 15:23:06 +00003880
Daniel Jaspera41aa532014-09-19 08:01:25 +00003881 // Prefer not to break after empty parentheses.
Daniel Jasper36c28ce2013-09-06 08:54:24 +00003882 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
3883 " First->LastNewlineOffset);");
Daniel Jasperf901a572015-12-07 19:50:48 +00003884
3885 // Prefer not to create "hanging" indents.
3886 verifyFormat(
3887 "return !soooooooooooooome_map\n"
3888 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3889 " .second;");
Daniel Jasper00492f92016-01-05 13:03:50 +00003890 verifyFormat(
3891 "return aaaaaaaaaaaaaaaa\n"
3892 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n"
3893 " .aaaa(aaaaaaaaaaaaaa);");
3894 // No hanging indent here.
3895 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n"
3896 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
3897 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n"
3898 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper801cdb22016-01-05 13:03:59 +00003899 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
3900 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
3901 getLLVMStyleWithColumns(60));
3902 verifyFormat("aaaaaaaaaaaaaaaaaa\n"
3903 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
3904 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
3905 getLLVMStyleWithColumns(59));
Daniel Jasper411af722016-01-05 16:10:39 +00003906 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3907 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3908 " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper04468962013-01-18 10:56:38 +00003909}
3910
Daniel Jasperde5c2072012-12-24 00:13:23 +00003911TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) {
3912 verifyFormat(
3913 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003914 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00003915 verifyFormat(
3916 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n"
3917 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}");
3918
Daniel Jasper8d1832e2013-01-07 13:26:07 +00003919 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003920 " ccccccccccccccccccccccccc) {\n}");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00003921 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n"
3922 " ccccccccccccccccccccccccc) {\n}");
3923
Daniel Jasper8d1832e2013-01-07 13:26:07 +00003924 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003925 " ccccccccccccccccccccccccc) {\n}");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00003926 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n"
3927 " ccccccccccccccccccccccccc) {\n}");
3928
Daniel Jasperde5c2072012-12-24 00:13:23 +00003929 verifyFormat(
3930 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003931 " ccccccccccccccccccccccccc) {\n}");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00003932 verifyFormat(
3933 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n"
3934 " ccccccccccccccccccccccccc) {\n}");
3935
Daniel Jasper400adc62013-02-08 15:28:42 +00003936 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
3937 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
3938 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
3939 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00003940 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n"
3941 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n"
3942 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n"
3943 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
3944
Daniel Jasper400adc62013-02-08 15:28:42 +00003945 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
3946 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
3947 " aaaaaaaaaaaaaaa != aa) {\n}");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00003948 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n"
3949 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n"
3950 " aaaaaaaaaaaaaaa != aa) {\n}");
Daniel Jasperde5c2072012-12-24 00:13:23 +00003951}
3952
Daniel Jasper43b65482013-01-23 12:27:43 +00003953TEST_F(FormatTest, BreaksAfterAssignments) {
Daniel Jasper206df732013-01-07 13:08:40 +00003954 verifyFormat(
Daniel Jasper43b65482013-01-23 12:27:43 +00003955 "unsigned Cost =\n"
3956 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
3957 " SI->getPointerAddressSpaceee());\n");
Daniel Jasper206df732013-01-07 13:08:40 +00003958 verifyFormat(
Daniel Jasper1565eb32013-01-23 15:55:19 +00003959 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
3960 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
Daniel Jaspera836b902013-01-23 16:58:21 +00003961
3962 verifyFormat(
Daniel Jasperb27c4b72013-08-27 11:09:05 +00003963 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
3964 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper7b27a102013-05-27 12:45:09 +00003965 verifyFormat("unsigned OriginalStartColumn =\n"
3966 " SourceMgr.getSpellingColumnNumber(\n"
3967 " Current.FormatTok.getStartOfNonWhitespace()) -\n"
3968 " 1;");
Daniel Jasper206df732013-01-07 13:08:40 +00003969}
3970
Francois Ferrand9976efa2017-05-22 08:28:17 +00003971TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) {
3972 FormatStyle Style = getLLVMStyle();
3973 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
3974 " bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;",
3975 Style);
3976
3977 Style.PenaltyBreakAssignment = 20;
3978 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
3979 " cccccccccccccccccccccccccc;",
3980 Style);
3981}
3982
Daniel Jasper2eda23e2012-12-24 13:43:52 +00003983TEST_F(FormatTest, AlignsAfterAssignments) {
3984 verifyFormat(
3985 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper206df732013-01-07 13:08:40 +00003986 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00003987 verifyFormat(
3988 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper206df732013-01-07 13:08:40 +00003989 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00003990 verifyFormat(
3991 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper206df732013-01-07 13:08:40 +00003992 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00003993 verifyFormat(
3994 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper206df732013-01-07 13:08:40 +00003995 " aaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperee7539a2013-07-08 14:25:23 +00003996 verifyFormat(
3997 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n"
3998 " aaaaaaaaaaaaaaaaaaaaaaaa +\n"
3999 " aaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00004000}
4001
4002TEST_F(FormatTest, AlignsAfterReturn) {
4003 verifyFormat(
4004 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4005 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
4006 verifyFormat(
4007 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4008 " aaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperc238c872013-04-02 14:33:13 +00004009 verifyFormat(
4010 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00004011 " aaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasperc238c872013-04-02 14:33:13 +00004012 verifyFormat(
4013 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00004014 " aaaaaaaaaaaaaaaaaaaaaa());");
4015 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4016 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
4017 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4018 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
4019 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jaspereabede62013-09-30 08:29:03 +00004020 verifyFormat("return\n"
4021 " // true if code is one of a or b.\n"
4022 " code == a || code == b;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00004023}
4024
Daniel Jasper3aa9a6a2014-11-18 23:55:27 +00004025TEST_F(FormatTest, AlignsAfterOpenBracket) {
4026 verifyFormat(
4027 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
4028 " aaaaaaaaa aaaaaaa) {}");
4029 verifyFormat(
4030 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
4031 " aaaaaaaaaaa aaaaaaaaa);");
4032 verifyFormat(
4033 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
4034 " aaaaaaaaaaaaaaaaaaaaa));");
4035 FormatStyle Style = getLLVMStyle();
Daniel Jasper6501f7e2015-10-27 12:38:37 +00004036 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
Daniel Jaspera44991332015-04-29 13:06:49 +00004037 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4038 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}",
4039 Style);
4040 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
4041 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);",
4042 Style);
4043 verifyFormat("SomeLongVariableName->someFunction(\n"
4044 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));",
4045 Style);
Daniel Jasper3aa9a6a2014-11-18 23:55:27 +00004046 verifyFormat(
4047 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
4048 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4049 Style);
4050 verifyFormat(
4051 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
4052 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4053 Style);
4054 verifyFormat(
4055 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
4056 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
4057 Style);
Daniel Jasper870d1bc2015-12-14 08:41:18 +00004058
Daniel Jasper2a9f7202016-02-08 09:52:54 +00004059 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n"
4060 " ccccccc(aaaaaaaaaaaaaaaaa, //\n"
4061 " b));",
4062 Style);
4063
Daniel Jasper870d1bc2015-12-14 08:41:18 +00004064 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
4065 Style.BinPackArguments = false;
4066 Style.BinPackParameters = false;
4067 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4068 " aaaaaaaaaaa aaaaaaaa,\n"
4069 " aaaaaaaaa aaaaaaa,\n"
4070 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4071 Style);
4072 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
4073 " aaaaaaaaaaa aaaaaaaaa,\n"
4074 " aaaaaaaaaaa aaaaaaaaa,\n"
4075 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4076 Style);
Daniel Jasper710f8492016-03-17 12:00:22 +00004077 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n"
4078 " aaaaaaaaaaaaaaa,\n"
4079 " aaaaaaaaaaaaaaaaaaaaa,\n"
4080 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
Daniel Jasper870d1bc2015-12-14 08:41:18 +00004081 Style);
Daniel Jasper710f8492016-03-17 12:00:22 +00004082 verifyFormat(
4083 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n"
4084 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
4085 Style);
4086 verifyFormat(
4087 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n"
4088 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
4089 Style);
4090 verifyFormat(
4091 "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4092 " aaaaaaaaaaaaaaaaaaaaa(\n"
4093 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n"
4094 " aaaaaaaaaaaaaaaa);",
4095 Style);
4096 verifyFormat(
4097 "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4098 " aaaaaaaaaaaaaaaaaaaaa(\n"
4099 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n"
4100 " aaaaaaaaaaaaaaaa);",
4101 Style);
Daniel Jasper3aa9a6a2014-11-18 23:55:27 +00004102}
4103
Daniel Jasper3219e432014-12-02 13:24:51 +00004104TEST_F(FormatTest, ParenthesesAndOperandAlignment) {
4105 FormatStyle Style = getLLVMStyleWithColumns(40);
4106 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
4107 " bbbbbbbbbbbbbbbbbbbbbb);",
4108 Style);
Daniel Jasper6501f7e2015-10-27 12:38:37 +00004109 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
Daniel Jasper3219e432014-12-02 13:24:51 +00004110 Style.AlignOperands = false;
4111 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
4112 " bbbbbbbbbbbbbbbbbbbbbb);",
4113 Style);
Daniel Jasper6501f7e2015-10-27 12:38:37 +00004114 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
Daniel Jasper3219e432014-12-02 13:24:51 +00004115 Style.AlignOperands = true;
4116 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
4117 " bbbbbbbbbbbbbbbbbbbbbb);",
4118 Style);
Daniel Jasper6501f7e2015-10-27 12:38:37 +00004119 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
Daniel Jasper3219e432014-12-02 13:24:51 +00004120 Style.AlignOperands = false;
4121 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
4122 " bbbbbbbbbbbbbbbbbbbbbb);",
4123 Style);
4124}
4125
Daniel Jasper399d24b2013-01-09 07:06:56 +00004126TEST_F(FormatTest, BreaksConditionalExpressions) {
4127 verifyFormat(
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004128 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4129 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4130 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
4131 verifyFormat(
4132 "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
Daniel Jasper22ed2622016-11-29 09:40:32 +00004133 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4134 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper8c5fba92013-01-16 16:23:19 +00004135 verifyFormat(
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004136 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4137 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
4138 verifyFormat(
4139 "aaaa(aaaaaaaaa, aaaaaaaaa,\n"
Daniel Jasper22ed2622016-11-29 09:40:32 +00004140 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4141 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperca6623b2013-01-28 12:45:14 +00004142 verifyFormat(
4143 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
4144 " : aaaaaaaaaaaaa);");
4145 verifyFormat(
4146 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasperaab220f2013-03-20 13:53:11 +00004147 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasperca6623b2013-01-28 12:45:14 +00004148 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4149 " aaaaaaaaaaaaa);");
Daniel Jasperb1ae7342013-08-01 22:05:00 +00004150 verifyFormat(
4151 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4152 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4153 " aaaaaaaaaaaaa);");
Daniel Jasperca6623b2013-01-28 12:45:14 +00004154 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4155 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4156 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4157 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4158 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
4159 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4160 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4161 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4162 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4163 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4164 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4165 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperb1ae7342013-08-01 22:05:00 +00004166 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4167 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4168 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4169 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4170 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper54a86022013-02-15 11:07:25 +00004171 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4172 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4173 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasperc238c872013-04-02 14:33:13 +00004174 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
4175 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4176 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4177 " : aaaaaaaaaaaaaaaa;");
Daniel Jaspercd8599e2013-02-23 21:01:55 +00004178 verifyFormat(
4179 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4180 " ? aaaaaaaaaaaaaaa\n"
4181 " : aaaaaaaaaaaaaaa;");
4182 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00004183 " aaaaaaaaa\n"
Daniel Jaspere7de2a32013-04-08 10:45:44 +00004184 " ? b\n"
4185 " : c);");
Daniel Jasper119ff532014-11-14 12:31:14 +00004186 verifyFormat("return aaaa == bbbb\n"
4187 " // comment\n"
4188 " ? aaaa\n"
4189 " : bbbb;");
Daniel Jaspera44991332015-04-29 13:06:49 +00004190 verifyFormat("unsigned Indent =\n"
Daniel Jasper22ed2622016-11-29 09:40:32 +00004191 " format(TheLine.First,\n"
4192 " IndentForLevel[TheLine.Level] >= 0\n"
4193 " ? IndentForLevel[TheLine.Level]\n"
4194 " : TheLine * 2,\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004195 " TheLine.InPPDirective, PreviousEndOfLineColumn);",
Daniel Jasper22ed2622016-11-29 09:40:32 +00004196 getLLVMStyleWithColumns(60));
Daniel Jasper2c611c02013-05-31 14:56:12 +00004197 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
4198 " ? aaaaaaaaaaaaaaa\n"
4199 " : bbbbbbbbbbbbbbb //\n"
4200 " ? ccccccccccccccc\n"
4201 " : ddddddddddddddd;");
4202 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
4203 " ? aaaaaaaaaaaaaaa\n"
4204 " : (bbbbbbbbbbbbbbb //\n"
4205 " ? ccccccccccccccc\n"
4206 " : ddddddddddddddd);");
Daniel Jasperc0d606a2014-04-14 11:08:45 +00004207 verifyFormat(
4208 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4209 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4210 " aaaaaaaaaaaaaaaaaaaaa +\n"
4211 " aaaaaaaaaaaaaaaaaaaaa\n"
4212 " : aaaaaaaaaa;");
Daniel Jasperfc3861a2014-07-17 12:22:04 +00004213 verifyFormat(
Daniel Jasper240527c2017-01-16 13:13:15 +00004214 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4215 " : aaaaaaaaaaaaaaaaaaaaaa\n"
4216 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper54a86022013-02-15 11:07:25 +00004217
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004218 FormatStyle NoBinPacking = getLLVMStyle();
Daniel Jasper18210d72014-10-09 09:52:05 +00004219 NoBinPacking.BinPackArguments = false;
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004220 verifyFormat(
Daniel Jaspercd8599e2013-02-23 21:01:55 +00004221 "void f() {\n"
4222 " g(aaa,\n"
4223 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
4224 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4225 " ? aaaaaaaaaaaaaaa\n"
4226 " : aaaaaaaaaaaaaaa);\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004227 "}",
4228 NoBinPacking);
Daniel Jasperb1ae7342013-08-01 22:05:00 +00004229 verifyFormat(
4230 "void f() {\n"
4231 " g(aaa,\n"
4232 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
4233 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4234 " ?: aaaaaaaaaaaaaaa);\n"
4235 "}",
4236 NoBinPacking);
Daniel Jasper1a31bab2014-10-16 09:10:11 +00004237
4238 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n"
4239 " // comment.\n"
4240 " ccccccccccccccccccccccccccccccccccccccc\n"
4241 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4242 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);");
Daniel Jasper6c22c442014-11-14 13:03:40 +00004243
4244 // Assignments in conditional expressions. Apparently not uncommon :-(.
4245 verifyFormat("return a != b\n"
4246 " // comment\n"
4247 " ? a = b\n"
4248 " : a = b;");
4249 verifyFormat("return a != b\n"
4250 " // comment\n"
4251 " ? a = a != b\n"
4252 " // comment\n"
4253 " ? a = b\n"
4254 " : a\n"
4255 " : a;\n");
4256 verifyFormat("return a != b\n"
4257 " // comment\n"
4258 " ? a\n"
4259 " : a = a != b\n"
4260 " // comment\n"
4261 " ? a = b\n"
4262 " : a;");
Daniel Jasper399d24b2013-01-09 07:06:56 +00004263}
4264
Daniel Jasper165b29e2013-11-08 00:57:11 +00004265TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) {
4266 FormatStyle Style = getLLVMStyle();
4267 Style.BreakBeforeTernaryOperators = false;
4268 Style.ColumnLimit = 70;
4269 verifyFormat(
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004270 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4271 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4272 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4273 Style);
4274 verifyFormat(
4275 "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
Daniel Jasper22ed2622016-11-29 09:40:32 +00004276 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4277 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
Daniel Jasper165b29e2013-11-08 00:57:11 +00004278 Style);
4279 verifyFormat(
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004280 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4281 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4282 Style);
4283 verifyFormat(
4284 "aaaa(aaaaaaaa, aaaaaaaaaa,\n"
Daniel Jasper22ed2622016-11-29 09:40:32 +00004285 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4286 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
Daniel Jasper165b29e2013-11-08 00:57:11 +00004287 Style);
4288 verifyFormat(
4289 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n"
4290 " aaaaaaaaaaaaa);",
4291 Style);
4292 verifyFormat(
4293 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4294 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4295 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4296 " aaaaaaaaaaaaa);",
4297 Style);
4298 verifyFormat(
4299 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4300 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4301 " aaaaaaaaaaaaa);",
4302 Style);
4303 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4304 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4305 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
4306 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4307 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4308 Style);
4309 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4310 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4311 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4312 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
4313 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4314 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4315 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4316 Style);
4317 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4318 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n"
4319 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4320 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4321 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4322 Style);
4323 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4324 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4325 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4326 Style);
4327 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +00004328 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
Daniel Jasper165b29e2013-11-08 00:57:11 +00004329 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4330 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4331 Style);
4332 verifyFormat(
4333 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4334 " aaaaaaaaaaaaaaa :\n"
4335 " aaaaaaaaaaaaaaa;",
4336 Style);
4337 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
4338 " aaaaaaaaa ?\n"
4339 " b :\n"
4340 " c);",
4341 Style);
Daniel Jasper22ed2622016-11-29 09:40:32 +00004342 verifyFormat("unsigned Indent =\n"
4343 " format(TheLine.First,\n"
4344 " IndentForLevel[TheLine.Level] >= 0 ?\n"
4345 " IndentForLevel[TheLine.Level] :\n"
4346 " TheLine * 2,\n"
4347 " TheLine.InPPDirective, PreviousEndOfLineColumn);",
4348 Style);
Daniel Jasper165b29e2013-11-08 00:57:11 +00004349 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
4350 " aaaaaaaaaaaaaaa :\n"
4351 " bbbbbbbbbbbbbbb ? //\n"
4352 " ccccccccccccccc :\n"
4353 " ddddddddddddddd;",
4354 Style);
4355 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
4356 " aaaaaaaaaaaaaaa :\n"
4357 " (bbbbbbbbbbbbbbb ? //\n"
4358 " ccccccccccccccc :\n"
4359 " ddddddddddddddd);",
4360 Style);
Daniel Jasper45860fa2016-02-03 17:27:10 +00004361 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4362 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n"
4363 " ccccccccccccccccccccccccccc;",
4364 Style);
Daniel Jasper04b4e102016-03-01 04:19:59 +00004365 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4366 " aaaaa :\n"
4367 " bbbbbbbbbbbbbbb + cccccccccccccccc;",
4368 Style);
Daniel Jasper165b29e2013-11-08 00:57:11 +00004369}
4370
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004371TEST_F(FormatTest, DeclarationsOfMultipleVariables) {
4372 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
4373 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();");
4374 verifyFormat("bool a = true, b = false;");
4375
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004376 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Daniel Jaspera628c982013-04-03 13:36:17 +00004377 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004378 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
Daniel Jasperc238c872013-04-02 14:33:13 +00004379 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);");
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004380 verifyFormat(
Daniel Jasper37905f72013-02-21 15:00:29 +00004381 "bool aaaaaaaaaaaaaaaaaaaaa =\n"
Daniel Jaspera628c982013-04-03 13:36:17 +00004382 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
Daniel Jasper37905f72013-02-21 15:00:29 +00004383 " d = e && f;");
Daniel Jasper31c96b92013-04-05 09:38:50 +00004384 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
4385 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;");
4386 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
4387 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;");
4388 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
4389 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;");
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004390
Daniel Jasperbea1ab42015-03-01 18:55:26 +00004391 FormatStyle Style = getGoogleStyle();
4392 Style.PointerAlignment = FormatStyle::PAS_Left;
4393 Style.DerivePointerAlignment = false;
4394 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4395 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
4396 " *b = bbbbbbbbbbbbbbbbbbb;",
4397 Style);
Daniel Jaspera44991332015-04-29 13:06:49 +00004398 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
4399 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;",
4400 Style);
Daniel Jasper3f2cde92016-09-26 15:14:24 +00004401 verifyFormat("vector<int*> a, b;", Style);
Daniel Jasper85d1f0b2016-10-04 20:18:25 +00004402 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style);
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004403}
4404
Nico Weber4a5030c2013-01-12 01:28:06 +00004405TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
4406 verifyFormat("arr[foo ? bar : baz];");
4407 verifyFormat("f()[foo ? bar : baz];");
4408 verifyFormat("(a + b)[foo ? bar : baz];");
4409 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
4410}
4411
Daniel Jasperf7935112012-12-03 18:12:45 +00004412TEST_F(FormatTest, AlignsStringLiterals) {
4413 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
4414 " \"short literal\");");
4415 verifyFormat(
4416 "looooooooooooooooooooooooongFunction(\n"
4417 " \"short literal\"\n"
4418 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00004419 verifyFormat("someFunction(\"Always break between multi-line\"\n"
4420 " \" string literals\",\n"
4421 " and, other, parameters);");
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004422 EXPECT_EQ("fun + \"1243\" /* comment */\n"
4423 " \"5678\";",
Manuel Klimek02f640a2013-02-20 15:25:48 +00004424 format("fun + \"1243\" /* comment */\n"
Daniel Jasper240527c2017-01-16 13:13:15 +00004425 " \"5678\";",
Manuel Klimek02f640a2013-02-20 15:25:48 +00004426 getLLVMStyleWithColumns(28)));
4427 EXPECT_EQ(
4428 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
4429 " \"aaaaaaaaaaaaaaaaaaaaa\"\n"
4430 " \"aaaaaaaaaaaaaaaa\";",
4431 format("aaaaaa ="
4432 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
4433 "aaaaaaaaaaaaaaaaaaaaa\" "
4434 "\"aaaaaaaaaaaaaaaa\";"));
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004435 verifyFormat("a = a + \"a\"\n"
4436 " \"a\"\n"
4437 " \"a\";");
4438 verifyFormat("f(\"a\", \"b\"\n"
4439 " \"c\");");
Daniel Jasperaf5ba0e2013-02-23 07:46:38 +00004440
4441 verifyFormat(
4442 "#define LL_FORMAT \"ll\"\n"
4443 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
4444 " \"d, ddddddddd: %\" LL_FORMAT \"d\");");
Daniel Jasper47a04442013-05-13 20:50:15 +00004445
4446 verifyFormat("#define A(X) \\\n"
4447 " \"aaaaa\" #X \"bbbbbb\" \\\n"
4448 " \"ccccc\"",
4449 getLLVMStyleWithColumns(23));
4450 verifyFormat("#define A \"def\"\n"
4451 "f(\"abc\" A \"ghi\"\n"
4452 " \"jkl\");");
Daniel Jasper04b6a082013-12-20 06:22:01 +00004453
4454 verifyFormat("f(L\"a\"\n"
Daniel Jasper015c7a92015-05-11 15:15:48 +00004455 " L\"b\");");
Daniel Jasper04b6a082013-12-20 06:22:01 +00004456 verifyFormat("#define A(X) \\\n"
4457 " L\"aaaaa\" #X L\"bbbbbb\" \\\n"
4458 " L\"ccccc\"",
4459 getLLVMStyleWithColumns(25));
Daniel Jasper015c7a92015-05-11 15:15:48 +00004460
4461 verifyFormat("f(@\"a\"\n"
4462 " @\"b\");");
4463 verifyFormat("NSString s = @\"a\"\n"
Daniel Jasper09285532015-05-17 08:13:23 +00004464 " @\"b\"\n"
4465 " @\"c\";");
4466 verifyFormat("NSString s = @\"a\"\n"
4467 " \"b\"\n"
4468 " \"c\";");
Daniel Jasperf7935112012-12-03 18:12:45 +00004469}
4470
Zachary Turner448592e2015-12-18 22:20:15 +00004471TEST_F(FormatTest, ReturnTypeBreakingStyle) {
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004472 FormatStyle Style = getLLVMStyle();
Zachary Turner448592e2015-12-18 22:20:15 +00004473 // No declarations or definitions should be moved to own line.
4474 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
4475 verifyFormat("class A {\n"
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004476 " int f() { return 1; }\n"
Zachary Turner448592e2015-12-18 22:20:15 +00004477 " int g();\n"
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004478 "};\n"
Zachary Turner448592e2015-12-18 22:20:15 +00004479 "int f() { return 1; }\n"
4480 "int g();\n",
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004481 Style);
Zachary Turner448592e2015-12-18 22:20:15 +00004482
4483 // All declarations and definitions should have the return type moved to its
4484 // own
4485 // line.
4486 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
4487 verifyFormat("class E {\n"
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004488 " int\n"
4489 " f() {\n"
4490 " return 1;\n"
4491 " }\n"
Zachary Turner448592e2015-12-18 22:20:15 +00004492 " int\n"
4493 " g();\n"
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004494 "};\n"
4495 "int\n"
4496 "f() {\n"
4497 " return 1;\n"
Zachary Turner448592e2015-12-18 22:20:15 +00004498 "}\n"
4499 "int\n"
4500 "g();\n",
4501 Style);
4502
4503 // Top-level definitions, and no kinds of declarations should have the
4504 // return type moved to its own line.
4505 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions;
4506 verifyFormat("class B {\n"
4507 " int f() { return 1; }\n"
4508 " int g();\n"
4509 "};\n"
4510 "int\n"
4511 "f() {\n"
4512 " return 1;\n"
4513 "}\n"
4514 "int g();\n",
4515 Style);
4516
4517 // Top-level definitions and declarations should have the return type moved
4518 // to its own line.
4519 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel;
4520 verifyFormat("class C {\n"
4521 " int f() { return 1; }\n"
4522 " int g();\n"
4523 "};\n"
4524 "int\n"
4525 "f() {\n"
4526 " return 1;\n"
4527 "}\n"
4528 "int\n"
4529 "g();\n",
4530 Style);
4531
4532 // All definitions should have the return type moved to its own line, but no
4533 // kinds of declarations.
4534 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
4535 verifyFormat("class D {\n"
4536 " int\n"
4537 " f() {\n"
4538 " return 1;\n"
4539 " }\n"
4540 " int g();\n"
4541 "};\n"
4542 "int\n"
4543 "f() {\n"
4544 " return 1;\n"
4545 "}\n"
4546 "int g();\n",
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004547 Style);
Daniel Jasperca4ea1c2014-08-05 12:16:31 +00004548 verifyFormat("const char *\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004549 "f(void) {\n" // Break here.
Daniel Jasperca4ea1c2014-08-05 12:16:31 +00004550 " return \"\";\n"
4551 "}\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004552 "const char *bar(void);\n", // No break here.
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004553 Style);
Daniel Jasperdb764792014-08-14 11:36:03 +00004554 verifyFormat("template <class T>\n"
4555 "T *\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004556 "f(T &c) {\n" // Break here.
Daniel Jasperdb764792014-08-14 11:36:03 +00004557 " return NULL;\n"
4558 "}\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004559 "template <class T> T *f(T &c);\n", // No break here.
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004560 Style);
Birunthan Mohanathas525579d2015-07-15 19:11:58 +00004561 verifyFormat("class C {\n"
4562 " int\n"
4563 " operator+() {\n"
4564 " return 1;\n"
4565 " }\n"
4566 " int\n"
4567 " operator()() {\n"
4568 " return 1;\n"
4569 " }\n"
4570 "};\n",
4571 Style);
4572 verifyFormat("void\n"
4573 "A::operator()() {}\n"
4574 "void\n"
4575 "A::operator>>() {}\n"
4576 "void\n"
4577 "A::operator+() {}\n",
4578 Style);
4579 verifyFormat("void *operator new(std::size_t s);", // No break here.
4580 Style);
4581 verifyFormat("void *\n"
4582 "operator new(std::size_t s) {}",
4583 Style);
4584 verifyFormat("void *\n"
4585 "operator delete[](void *ptr) {}",
4586 Style);
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004587 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
Daniel Jasperdb764792014-08-14 11:36:03 +00004588 verifyFormat("const char *\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004589 "f(void)\n" // Break here.
Daniel Jasperdb764792014-08-14 11:36:03 +00004590 "{\n"
4591 " return \"\";\n"
4592 "}\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004593 "const char *bar(void);\n", // No break here.
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004594 Style);
Daniel Jasperdb764792014-08-14 11:36:03 +00004595 verifyFormat("template <class T>\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004596 "T *\n" // Problem here: no line break
4597 "f(T &c)\n" // Break here.
Daniel Jasperdb764792014-08-14 11:36:03 +00004598 "{\n"
4599 " return NULL;\n"
4600 "}\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004601 "template <class T> T *f(T &c);\n", // No break here.
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004602 Style);
Daniel Jasperca4ea1c2014-08-05 12:16:31 +00004603}
4604
Alexander Kornienko58611712013-07-04 12:02:44 +00004605TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) {
4606 FormatStyle NoBreak = getLLVMStyle();
4607 NoBreak.AlwaysBreakBeforeMultilineStrings = false;
4608 FormatStyle Break = getLLVMStyle();
4609 Break.AlwaysBreakBeforeMultilineStrings = true;
Daniel Jasperc834c702013-07-17 15:38:19 +00004610 verifyFormat("aaaa = \"bbbb\"\n"
4611 " \"cccc\";",
4612 NoBreak);
4613 verifyFormat("aaaa =\n"
4614 " \"bbbb\"\n"
4615 " \"cccc\";",
4616 Break);
4617 verifyFormat("aaaa(\"bbbb\"\n"
4618 " \"cccc\");",
4619 NoBreak);
4620 verifyFormat("aaaa(\n"
4621 " \"bbbb\"\n"
4622 " \"cccc\");",
4623 Break);
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004624 verifyFormat("aaaa(qqq, \"bbbb\"\n"
4625 " \"cccc\");",
Daniel Jasperc834c702013-07-17 15:38:19 +00004626 NoBreak);
Daniel Jasper1bf729c2015-06-18 16:05:17 +00004627 verifyFormat("aaaa(qqq,\n"
4628 " \"bbbb\"\n"
4629 " \"cccc\");",
Daniel Jasperc834c702013-07-17 15:38:19 +00004630 Break);
Daniel Jasper1bf729c2015-06-18 16:05:17 +00004631 verifyFormat("aaaa(qqq,\n"
4632 " L\"bbbb\"\n"
4633 " L\"cccc\");",
4634 Break);
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004635 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n"
4636 " \"bbbb\"));",
Daniel Jasper04b6a082013-12-20 06:22:01 +00004637 Break);
Daniel Jasper9fb676a2015-06-19 10:32:28 +00004638 verifyFormat("string s = someFunction(\n"
4639 " \"abc\"\n"
4640 " \"abc\");",
4641 Break);
Daniel Jasperc834c702013-07-17 15:38:19 +00004642
Daniel Jasper3251fff2014-06-10 06:27:23 +00004643 // As we break before unary operators, breaking right after them is bad.
4644 verifyFormat("string foo = abc ? \"x\"\n"
4645 " \"blah blah blah blah blah blah\"\n"
4646 " : \"y\";",
4647 Break);
4648
Daniel Jasperc834c702013-07-17 15:38:19 +00004649 // Don't break if there is no column gain.
4650 verifyFormat("f(\"aaaa\"\n"
4651 " \"bbbb\");",
4652 Break);
4653
4654 // Treat literals with escaped newlines like multi-line string literals.
Alexander Kornienko657c67b2013-07-16 21:06:13 +00004655 EXPECT_EQ("x = \"a\\\n"
4656 "b\\\n"
4657 "c\";",
4658 format("x = \"a\\\n"
4659 "b\\\n"
4660 "c\";",
4661 NoBreak));
Daniel Jasper2aaedd32015-06-18 09:12:47 +00004662 EXPECT_EQ("xxxx =\n"
Alexander Kornienko657c67b2013-07-16 21:06:13 +00004663 " \"a\\\n"
4664 "b\\\n"
4665 "c\";",
Daniel Jasper2aaedd32015-06-18 09:12:47 +00004666 format("xxxx = \"a\\\n"
Alexander Kornienko657c67b2013-07-16 21:06:13 +00004667 "b\\\n"
4668 "c\";",
4669 Break));
Daniel Jasper27943052013-11-09 03:08:25 +00004670
Alexander Kornienkod4fa2e62017-04-11 09:55:00 +00004671 EXPECT_EQ("NSString *const kString =\n"
4672 " @\"aaaa\"\n"
4673 " @\"bbbb\";",
Daniel Jasper27943052013-11-09 03:08:25 +00004674 format("NSString *const kString = @\"aaaa\"\n"
Daniel Jasper015c7a92015-05-11 15:15:48 +00004675 "@\"bbbb\";",
Daniel Jasper27943052013-11-09 03:08:25 +00004676 Break));
Daniel Jasper6fd5d642015-01-20 12:59:20 +00004677
4678 Break.ColumnLimit = 0;
4679 verifyFormat("const char *hello = \"hello llvm\";", Break);
Alexander Kornienko58611712013-07-04 12:02:44 +00004680}
4681
Alexander Kornienko578fdd82012-12-06 18:03:27 +00004682TEST_F(FormatTest, AlignsPipes) {
4683 verifyFormat(
4684 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4685 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4686 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
4687 verifyFormat(
4688 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
4689 " << aaaaaaaaaaaaaaaaaaaa;");
4690 verifyFormat(
4691 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4692 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
4693 verifyFormat(
Daniel Jasper7aacf462016-12-19 11:14:23 +00004694 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4695 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
4696 verifyFormat(
Alexander Kornienko578fdd82012-12-06 18:03:27 +00004697 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
4698 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
4699 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";");
4700 verifyFormat(
4701 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4702 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4703 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jaspera44991332015-04-29 13:06:49 +00004704 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4705 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4706 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4707 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
Daniel Jasper2fd16632015-05-17 07:27:09 +00004708 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n"
4709 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);");
Daniel Jasper0e617842014-04-16 12:26:54 +00004710 verifyFormat(
4711 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4712 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper04bbda92017-03-16 07:54:11 +00004713 verifyFormat(
4714 "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n"
4715 " aaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper2603ee02013-02-04 07:34:48 +00004716
Daniel Jasperc0d606a2014-04-14 11:08:45 +00004717 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n"
4718 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();");
Daniel Jasper173504e2015-05-10 21:15:07 +00004719 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4720 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4721 " aaaaaaaaaaaaaaaaaaaaa)\n"
4722 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper5962fa82015-06-03 09:26:03 +00004723 verifyFormat("LOG_IF(aaa == //\n"
4724 " bbb)\n"
4725 " << a << b;");
Daniel Jasperc238c872013-04-02 14:33:13 +00004726
Daniel Jasper467ddb12013-08-12 12:58:05 +00004727 // But sometimes, breaking before the first "<<" is desirable.
Daniel Jasper004177e2013-12-19 16:06:40 +00004728 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
4729 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);");
Daniel Jasper77d5d312013-07-12 15:14:05 +00004730 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
4731 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4732 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper467ddb12013-08-12 12:58:05 +00004733 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
4734 " << BEF << IsTemplate << Description << E->getType();");
Daniel Jasper602a7272016-02-11 13:15:14 +00004735 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
4736 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4737 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
4738 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
4739 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4740 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4741 " << aaa;");
Daniel Jasper77d5d312013-07-12 15:14:05 +00004742
Daniel Jasperc238c872013-04-02 14:33:13 +00004743 verifyFormat(
4744 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4745 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper0b1f76b2013-09-29 12:02:57 +00004746
4747 // Incomplete string literal.
4748 EXPECT_EQ("llvm::errs() << \"\n"
4749 " << a;",
4750 format("llvm::errs() << \"\n<<a;"));
Manuel Klimek06c84f22013-11-20 11:20:32 +00004751
4752 verifyFormat("void f() {\n"
4753 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n"
4754 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n"
4755 "}");
Daniel Jasperd05d3a82015-01-08 13:56:57 +00004756
4757 // Handle 'endl'.
Daniel Jasper69963122015-02-17 10:05:15 +00004758 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n"
4759 " << bbbbbbbbbbbbbbbbbbbbbb << endl;");
4760 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;");
Daniel Jasper0a589412016-01-05 13:06:27 +00004761
4762 // Handle '\n'.
4763 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n"
4764 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
4765 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n"
4766 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';");
4767 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n"
4768 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";");
4769 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00004770}
4771
Daniel Jasper7209bb92016-12-13 11:16:42 +00004772TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) {
4773 verifyFormat("return out << \"somepacket = {\\n\"\n"
4774 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
4775 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
4776 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
4777 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
4778 " << \"}\";");
4779
4780 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
4781 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
4782 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;");
4783 verifyFormat(
4784 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
4785 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
4786 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
4787 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
4788 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;");
4789 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
4790 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
4791 verifyFormat(
4792 "void f() {\n"
4793 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n"
4794 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
4795 "}");
4796
4797 // Breaking before the first "<<" is generally not desirable.
4798 verifyFormat(
4799 "llvm::errs()\n"
4800 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4801 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4802 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4803 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4804 getLLVMStyleWithColumns(70));
4805 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
4806 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4807 " << \"aaaaaaaaaaaaaaaaaaa: \"\n"
4808 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4809 " << \"aaaaaaaaaaaaaaaaaaa: \"\n"
4810 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4811 getLLVMStyleWithColumns(70));
4812
4813 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
4814 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
4815 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;");
4816 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
4817 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
4818 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);");
Daniel Jasperf789f052016-12-20 15:27:46 +00004819 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n"
4820 " (aaaa + aaaa);",
4821 getLLVMStyleWithColumns(40));
4822 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n"
4823 " (aaaaaaa + aaaaa));",
4824 getLLVMStyleWithColumns(40));
Daniel Jasper23888612016-12-22 12:37:06 +00004825 verifyFormat(
4826 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n"
4827 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n"
4828 " bbbbbbbbbbbbbbbbbbbbbbb);");
Daniel Jasper7209bb92016-12-13 11:16:42 +00004829}
4830
Daniel Jasperf7935112012-12-03 18:12:45 +00004831TEST_F(FormatTest, UnderstandsEquals) {
4832 verifyFormat(
4833 "aaaaaaaaaaaaaaaaa =\n"
4834 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
4835 verifyFormat(
4836 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004837 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasperf7935112012-12-03 18:12:45 +00004838 verifyFormat(
4839 "if (a) {\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00004840 " f();\n"
Daniel Jasperf7935112012-12-03 18:12:45 +00004841 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004842 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
4843 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +00004844
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00004845 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
4846 " 100000000 + 10000000) {\n}");
Daniel Jasperf7935112012-12-03 18:12:45 +00004847}
4848
Daniel Jasper5485d0c2012-12-17 14:34:14 +00004849TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00004850 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
4851 " .looooooooooooooooooooooooooooooooooooooongFunction();");
Daniel Jasper5485d0c2012-12-17 14:34:14 +00004852
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00004853 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
4854 " ->looooooooooooooooooooooooooooooooooooooongFunction();");
Daniel Jasper5485d0c2012-12-17 14:34:14 +00004855
4856 verifyFormat(
4857 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
4858 " Parameter2);");
4859
4860 verifyFormat(
4861 "ShortObject->shortFunction(\n"
4862 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
4863 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);");
4864
4865 verifyFormat("loooooooooooooongFunction(\n"
4866 " LoooooooooooooongObject->looooooooooooooooongFunction());");
4867
4868 verifyFormat(
4869 "function(LoooooooooooooooooooooooooooooooooooongObject\n"
4870 " ->loooooooooooooooooooooooooooooooooooooooongFunction());");
4871
Daniel Jasper687af3b2013-02-14 14:26:07 +00004872 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
4873 " .WillRepeatedly(Return(SomeValue));");
Daniel Jasperd6f17d82014-09-12 16:35:28 +00004874 verifyFormat("void f() {\n"
4875 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
4876 " .Times(2)\n"
4877 " .WillRepeatedly(Return(SomeValue));\n"
4878 "}");
Daniel Jasper4d7a97a2014-01-10 08:40:17 +00004879 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n"
4880 " ccccccccccccccccccccccc);");
Daniel Jasper32a796b2013-05-27 11:50:16 +00004881 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper05cd9292015-03-26 18:46:28 +00004882 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4883 " .aaaaa(aaaaa),\n"
Daniel Jasper32a796b2013-05-27 11:50:16 +00004884 " aaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00004885 verifyFormat("void f() {\n"
4886 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4887 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n"
4888 "}");
Daniel Jaspera44991332015-04-29 13:06:49 +00004889 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4890 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4891 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4892 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4893 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jasperc238c872013-04-02 14:33:13 +00004894 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4895 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4896 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4897 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
4898 "}");
Daniel Jasper687af3b2013-02-14 14:26:07 +00004899
Daniel Jasperc7345cc2013-01-07 07:13:20 +00004900 // Here, it is not necessary to wrap at "." or "->".
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00004901 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004902 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasperc7345cc2013-01-07 07:13:20 +00004903 verifyFormat(
4904 "aaaaaaaaaaa->aaaaaaaaa(\n"
4905 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4906 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
Daniel Jaspere11095a2013-02-14 15:01:34 +00004907
4908 verifyFormat(
4909 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4910 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
Daniel Jasper8f6ae192013-03-13 15:37:48 +00004911 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
4912 " aaaaaaaaa()->aaaaaa()->aaaaa());");
4913 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
4914 " aaaaaaaaa()->aaaaaa()->aaaaa());");
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004915
Daniel Jasper9b334242013-03-15 14:57:30 +00004916 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper05cd9292015-03-26 18:46:28 +00004917 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4918 " .a();");
Daniel Jasper9b334242013-03-15 14:57:30 +00004919
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004920 FormatStyle NoBinPacking = getLLVMStyle();
4921 NoBinPacking.BinPackParameters = false;
4922 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
4923 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
4924 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
4925 " aaaaaaaaaaaaaaaaaaa,\n"
4926 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4927 NoBinPacking);
Daniel Jasperbd058882013-07-09 11:57:27 +00004928
4929 // If there is a subsequent call, change to hanging indentation.
4930 verifyFormat(
4931 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4932 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n"
4933 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
4934 verifyFormat(
4935 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4936 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));");
Daniel Jasper96964352013-12-18 10:44:36 +00004937 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4938 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4939 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
4940 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4941 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4942 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
Daniel Jasper5485d0c2012-12-17 14:34:14 +00004943}
4944
Daniel Jasperac5c1c22013-01-02 15:08:56 +00004945TEST_F(FormatTest, WrapsTemplateDeclarations) {
4946 verifyFormat("template <typename T>\n"
4947 "virtual void loooooooooooongFunction(int Param1, int Param2);");
Daniel Jasper69bd8fb2013-09-27 07:49:08 +00004948 verifyFormat("template <typename T>\n"
4949 "// T should be one of {A, B}.\n"
4950 "virtual void loooooooooooongFunction(int Param1, int Param2);");
Daniel Jasperac5c1c22013-01-02 15:08:56 +00004951 verifyFormat(
Daniel Jasper04468962013-01-18 10:56:38 +00004952 "template <typename T>\n"
Daniel Jasper400adc62013-02-08 15:28:42 +00004953 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;");
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00004954 verifyFormat("template <typename T>\n"
4955 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
4956 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);");
Daniel Jasperac5c1c22013-01-02 15:08:56 +00004957 verifyFormat(
4958 "template <typename T>\n"
4959 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
4960 " int Paaaaaaaaaaaaaaaaaaaaram2);");
Daniel Jasper90e51fd2013-01-02 18:30:06 +00004961 verifyFormat(
4962 "template <typename T>\n"
4963 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
4964 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
4965 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper89058942013-01-09 09:50:48 +00004966 verifyFormat("template <typename T>\n"
4967 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jaspera628c982013-04-03 13:36:17 +00004968 " int aaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperbcab4302013-01-09 10:40:23 +00004969 verifyFormat(
4970 "template <typename T1, typename T2 = char, typename T3 = char,\n"
4971 " typename T4 = char>\n"
4972 "void f();");
Daniel Jasper298c3402013-11-22 07:48:15 +00004973 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n"
4974 " template <typename> class cccccccccccccccccccccc,\n"
4975 " typename ddddddddddddd>\n"
4976 "class C {};");
Daniel Jasper7a31af12013-01-25 15:43:32 +00004977 verifyFormat(
4978 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
4979 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper3a9370c2013-02-04 07:21:18 +00004980
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00004981 verifyFormat("void f() {\n"
4982 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
4983 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n"
4984 "}");
Daniel Jasper61e6bbf2013-05-29 12:07:31 +00004985
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00004986 verifyFormat("template <typename T> class C {};");
Daniel Jasper61e6bbf2013-05-29 12:07:31 +00004987 verifyFormat("template <typename T> void f();");
4988 verifyFormat("template <typename T> void f() {}");
Daniel Jasper0e90c3d2013-07-05 09:14:35 +00004989 verifyFormat(
4990 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
4991 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4992 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
4993 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
4994 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4995 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
4996 " bbbbbbbbbbbbbbbbbbbbbbbb);",
4997 getLLVMStyleWithColumns(72));
Daniel Jasperfcfac102014-07-15 09:00:34 +00004998 EXPECT_EQ("static_cast<A< //\n"
4999 " B> *>(\n"
5000 "\n"
Martin Probst2c1cdae2017-05-15 11:15:29 +00005001 ");",
Daniel Jasperfcfac102014-07-15 09:00:34 +00005002 format("static_cast<A<//\n"
5003 " B>*>(\n"
5004 "\n"
5005 " );"));
Daniel Jasper598dd332014-08-12 13:22:26 +00005006 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5007 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);");
Daniel Jasper5c9e3cd2013-09-14 08:13:22 +00005008
5009 FormatStyle AlwaysBreak = getLLVMStyle();
5010 AlwaysBreak.AlwaysBreakTemplateDeclarations = true;
5011 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
5012 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
5013 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
5014 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5015 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
5016 " ccccccccccccccccccccccccccccccccccccccccccccccc);");
5017 verifyFormat("template <template <typename> class Fooooooo,\n"
5018 " template <typename> class Baaaaaaar>\n"
5019 "struct C {};",
5020 AlwaysBreak);
Daniel Jasperd3e014d2013-10-09 15:06:17 +00005021 verifyFormat("template <typename T> // T can be A, B or C.\n"
5022 "struct C {};",
5023 AlwaysBreak);
Daniel Jaspera7900ad2016-05-08 18:12:22 +00005024 verifyFormat("template <enum E> class A {\n"
5025 "public:\n"
5026 " E *f();\n"
5027 "};");
Daniel Jasperac5c1c22013-01-02 15:08:56 +00005028}
5029
Daniel Jasper2db1b4a2017-02-06 10:55:49 +00005030TEST_F(FormatTest, WrapsTemplateParameters) {
5031 FormatStyle Style = getLLVMStyle();
5032 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5033 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
5034 verifyFormat(
5035 "template <typename... a> struct q {};\n"
5036 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
5037 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
5038 " y;",
5039 Style);
5040 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5041 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
5042 verifyFormat(
5043 "template <typename... a> struct r {};\n"
5044 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
5045 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
5046 " y;",
5047 Style);
5048 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
5049 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
5050 verifyFormat(
5051 "template <typename... a> struct s {};\n"
5052 "extern s<\n"
5053 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
5054 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n"
5055 " y;",
5056 Style);
5057 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
5058 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
5059 verifyFormat(
5060 "template <typename... a> struct t {};\n"
5061 "extern t<\n"
5062 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
5063 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n"
5064 " y;",
5065 Style);
5066}
5067
Daniel Jasper45797022013-01-25 10:57:27 +00005068TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
5069 verifyFormat(
5070 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
5071 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5072 verifyFormat(
5073 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
5074 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5075 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
5076
Daniel Jasper0f0234e2013-05-08 10:00:18 +00005077 // FIXME: Should we have the extra indent after the second break?
Daniel Jasper45797022013-01-25 10:57:27 +00005078 verifyFormat(
5079 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
5080 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
Daniel Jasper0f0234e2013-05-08 10:00:18 +00005081 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper45797022013-01-25 10:57:27 +00005082
Daniel Jasper45797022013-01-25 10:57:27 +00005083 verifyFormat(
5084 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
Daniel Jasper4ad42352013-01-28 07:43:15 +00005085 " cccccccccccccccccccccccccccccccccccccccccccccc());");
Daniel Jasper45797022013-01-25 10:57:27 +00005086
5087 // Breaking at nested name specifiers is generally not desirable.
5088 verifyFormat(
5089 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5090 " aaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperca6623b2013-01-28 12:45:14 +00005091
5092 verifyFormat(
Daniel Jasper240527c2017-01-16 13:13:15 +00005093 "aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n"
5094 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
5095 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasperca6623b2013-01-28 12:45:14 +00005096 " aaaaaaaaaaaaaaaaaaaaa);",
5097 getLLVMStyleWithColumns(74));
Daniel Jasperc238c872013-04-02 14:33:13 +00005098
5099 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
5100 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5101 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper45797022013-01-25 10:57:27 +00005102}
5103
Daniel Jasperf7935112012-12-03 18:12:45 +00005104TEST_F(FormatTest, UnderstandsTemplateParameters) {
5105 verifyFormat("A<int> a;");
Chandler Carruthf8b72662014-03-02 12:37:31 +00005106 verifyFormat("A<A<A<int>>> a;");
Daniel Jasperf7935112012-12-03 18:12:45 +00005107 verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
5108 verifyFormat("bool x = a < 1 || 2 > a;");
5109 verifyFormat("bool x = 5 < f<int>();");
5110 verifyFormat("bool x = f<int>() > 5;");
5111 verifyFormat("bool x = 5 < a<int>::x;");
5112 verifyFormat("bool x = a < 4 ? a > 2 : false;");
5113 verifyFormat("bool x = f() ? a < 2 : a > 2;");
5114
5115 verifyGoogleFormat("A<A<int>> a;");
5116 verifyGoogleFormat("A<A<A<int>>> a;");
5117 verifyGoogleFormat("A<A<A<A<int>>>> a;");
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005118 verifyGoogleFormat("A<A<int> > a;");
5119 verifyGoogleFormat("A<A<A<int> > > a;");
5120 verifyGoogleFormat("A<A<A<A<int> > > > a;");
Daniel Jasperfba84ff2013-10-12 05:16:06 +00005121 verifyGoogleFormat("A<::A<int>> a;");
5122 verifyGoogleFormat("A<::A> a;");
5123 verifyGoogleFormat("A< ::A> a;");
5124 verifyGoogleFormat("A< ::A<int> > a;");
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005125 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
5126 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
Daniel Jasperfba84ff2013-10-12 05:16:06 +00005127 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle()));
5128 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle()));
Daniel Jasper352f0df2015-07-18 16:35:30 +00005129 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };",
5130 format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle()));
Daniel Jasperf7935112012-12-03 18:12:45 +00005131
Nico Weber7533b4d2014-09-24 17:17:32 +00005132 verifyFormat("A<A>> a;", getChromiumStyle(FormatStyle::LK_Cpp));
5133
Daniel Jasperf7935112012-12-03 18:12:45 +00005134 verifyFormat("test >> a >> b;");
5135 verifyFormat("test << a >> b;");
5136
5137 verifyFormat("f<int>();");
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005138 verifyFormat("template <typename T> void f() {}");
Daniel Jasperb13135b2015-01-08 08:48:21 +00005139 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;");
Daniel Jasper112b50e2015-05-06 14:53:50 +00005140 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : "
5141 "sizeof(char)>::type>;");
Daniel Jasperadba2aa2015-05-18 12:52:00 +00005142 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};");
Daniel Jasper0c9772e2016-02-05 14:17:16 +00005143 verifyFormat("f(a.operator()<A>());");
5144 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5145 " .template operator()<A>());",
5146 getLLVMStyleWithColumns(35));
Daniel Jasperd5893912013-06-01 18:56:00 +00005147
5148 // Not template parameters.
5149 verifyFormat("return a < b && c > d;");
5150 verifyFormat("void f() {\n"
5151 " while (a < b && c > d) {\n"
5152 " }\n"
5153 "}");
Daniel Jasper62c0ac02013-07-30 22:37:19 +00005154 verifyFormat("template <typename... Types>\n"
5155 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}");
Daniel Jasper0de8efa2013-09-17 08:15:46 +00005156
5157 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5158 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);",
5159 getLLVMStyleWithColumns(60));
Daniel Jasper6ba16382014-07-28 13:19:58 +00005160 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");");
Daniel Jasper65df5aa2014-08-04 14:51:02 +00005161 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}");
Daniel Jasper4d9ec172015-05-06 08:38:24 +00005162 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <");
Daniel Jasperf7935112012-12-03 18:12:45 +00005163}
5164
Malcolm Parsons6af3f142016-11-03 16:57:30 +00005165TEST_F(FormatTest, BitshiftOperatorWidth) {
5166 EXPECT_EQ("int a = 1 << 2; /* foo\n"
5167 " bar */",
5168 format("int a=1<<2; /* foo\n"
5169 " bar */"));
5170
5171 EXPECT_EQ("int b = 256 >> 1; /* foo\n"
5172 " bar */",
5173 format("int b =256>>1 ; /* foo\n"
5174 " bar */"));
5175}
5176
Daniel Jasperd8ffcfa2013-02-28 09:21:10 +00005177TEST_F(FormatTest, UnderstandsBinaryOperators) {
5178 verifyFormat("COMPARE(a, ==, b);");
Daniel Jasper594be2f2016-06-13 07:49:09 +00005179 verifyFormat("auto s = sizeof...(Ts) - 1;");
Alexander Kornienko674be0a2013-03-20 16:41:56 +00005180}
5181
5182TEST_F(FormatTest, UnderstandsPointersToMembers) {
5183 verifyFormat("int A::*x;");
Daniel Jaspercfda5172013-05-08 14:58:20 +00005184 verifyFormat("int (S::*func)(void *);");
Daniel Jasper37194282013-05-28 08:33:00 +00005185 verifyFormat("void f() { int (S::*func)(void *); }");
Daniel Jasper2f34cac2013-05-08 15:06:58 +00005186 verifyFormat("typedef bool *(Class::*Member)() const;");
Daniel Jaspercfda5172013-05-08 14:58:20 +00005187 verifyFormat("void f() {\n"
5188 " (a->*f)();\n"
5189 " a->*x;\n"
5190 " (a.*f)();\n"
5191 " ((*a).*f)();\n"
5192 " a.*x;\n"
5193 "}");
Daniel Jasper998cabc2013-07-18 14:46:07 +00005194 verifyFormat("void f() {\n"
5195 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
5196 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n"
5197 "}");
Daniel Jasper85bcadc2014-07-09 13:07:57 +00005198 verifyFormat(
5199 "(aaaaaaaaaa->*bbbbbbb)(\n"
5200 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jasper2f34cac2013-05-08 15:06:58 +00005201 FormatStyle Style = getLLVMStyle();
Daniel Jasper553d4872014-06-17 12:40:34 +00005202 Style.PointerAlignment = FormatStyle::PAS_Left;
Daniel Jasper2f34cac2013-05-08 15:06:58 +00005203 verifyFormat("typedef bool* (Class::*Member)() const;", Style);
Daniel Jasperd8ffcfa2013-02-28 09:21:10 +00005204}
5205
Daniel Jasper8dd40472012-12-21 09:41:31 +00005206TEST_F(FormatTest, UnderstandsUnaryOperators) {
Daniel Jasperf7935112012-12-03 18:12:45 +00005207 verifyFormat("int a = -2;");
Daniel Jasper8b529712012-12-04 13:02:32 +00005208 verifyFormat("f(-1, -2, -3);");
5209 verifyFormat("a[-1] = 5;");
5210 verifyFormat("int a = 5 + -2;");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00005211 verifyFormat("if (i == -1) {\n}");
5212 verifyFormat("if (i != -1) {\n}");
5213 verifyFormat("if (i > -1) {\n}");
5214 verifyFormat("if (i < -1) {\n}");
Daniel Jasper26333c32012-12-06 13:16:39 +00005215 verifyFormat("++(a->f());");
5216 verifyFormat("--(a->f());");
Daniel Jasper13f23e12013-01-14 12:18:19 +00005217 verifyFormat("(a->f())++;");
5218 verifyFormat("a[42]++;");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00005219 verifyFormat("if (!(a->f())) {\n}");
Daniel Jasper8dd40472012-12-21 09:41:31 +00005220
5221 verifyFormat("a-- > b;");
5222 verifyFormat("b ? -a : c;");
5223 verifyFormat("n * sizeof char16;");
Alexander Kornienko1e808872013-06-28 12:51:24 +00005224 verifyFormat("n * alignof char16;", getGoogleStyle());
Daniel Jasper8dd40472012-12-21 09:41:31 +00005225 verifyFormat("sizeof(char);");
Alexander Kornienko1e808872013-06-28 12:51:24 +00005226 verifyFormat("alignof(char);", getGoogleStyle());
Daniel Jasperda1c68a2013-01-02 15:26:16 +00005227
5228 verifyFormat("return -1;");
5229 verifyFormat("switch (a) {\n"
5230 "case -1:\n"
5231 " break;\n"
5232 "}");
Daniel Jasper399d1ee2013-03-22 10:44:43 +00005233 verifyFormat("#define X -1");
5234 verifyFormat("#define X -kConstant");
Nico Weber63a54eb2013-01-12 05:41:23 +00005235
Chandler Carruthf8b72662014-03-02 12:37:31 +00005236 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};");
5237 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};");
Daniel Jasper71945272013-01-15 14:27:39 +00005238
5239 verifyFormat("int a = /* confusing comment */ -1;");
5240 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case.
5241 verifyFormat("int a = i /* confusing comment */++;");
Daniel Jasperf7935112012-12-03 18:12:45 +00005242}
5243
Daniel Jasper0c214fa2014-02-05 13:43:04 +00005244TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) {
Daniel Jasperf110e202013-08-21 08:39:01 +00005245 verifyFormat("if (!aaaaaaaaaa( // break\n"
Daniel Jasper0c214fa2014-02-05 13:43:04 +00005246 " aaaaa)) {\n"
Daniel Jasperf110e202013-08-21 08:39:01 +00005247 "}");
5248 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
Daniel Jasper739b85f2015-06-29 10:42:59 +00005249 " aaaaa));");
Daniel Jasper0649d362013-08-23 15:14:03 +00005250 verifyFormat("*aaa = aaaaaaa( // break\n"
5251 " bbbbbb);");
Daniel Jasperf110e202013-08-21 08:39:01 +00005252}
5253
Daniel Jasper8863ada2013-08-26 08:10:17 +00005254TEST_F(FormatTest, UnderstandsOverloadedOperators) {
Daniel Jasper537a2962012-12-24 10:56:04 +00005255 verifyFormat("bool operator<();");
5256 verifyFormat("bool operator>();");
5257 verifyFormat("bool operator=();");
5258 verifyFormat("bool operator==();");
5259 verifyFormat("bool operator!=();");
5260 verifyFormat("int operator+();");
5261 verifyFormat("int operator++();");
Daniel Jasper804a2762016-01-09 15:56:40 +00005262 verifyFormat("bool operator,();");
Daniel Jasper537a2962012-12-24 10:56:04 +00005263 verifyFormat("bool operator();");
5264 verifyFormat("bool operator()();");
5265 verifyFormat("bool operator[]();");
5266 verifyFormat("operator bool();");
Daniel Jasper35d2dc72013-02-11 08:01:18 +00005267 verifyFormat("operator int();");
5268 verifyFormat("operator void *();");
Daniel Jasper537a2962012-12-24 10:56:04 +00005269 verifyFormat("operator SomeType<int>();");
Daniel Jasper35d2dc72013-02-11 08:01:18 +00005270 verifyFormat("operator SomeType<int, int>();");
Chandler Carruthf8b72662014-03-02 12:37:31 +00005271 verifyFormat("operator SomeType<SomeType<int>>();");
Daniel Jasper537a2962012-12-24 10:56:04 +00005272 verifyFormat("void *operator new(std::size_t size);");
5273 verifyFormat("void *operator new[](std::size_t size);");
5274 verifyFormat("void operator delete(void *ptr);");
5275 verifyFormat("void operator delete[](void *ptr);");
Daniel Jasper8f9624b2013-05-10 07:59:58 +00005276 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
5277 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);");
Daniel Jasper804a2762016-01-09 15:56:40 +00005278 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n"
Daniel Jasperdf51f2e62016-01-11 12:55:33 +00005279 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;");
Daniel Jasper35d2dc72013-02-11 08:01:18 +00005280
Daniel Jasper0af92eb2013-02-15 19:24:08 +00005281 verifyFormat(
5282 "ostream &operator<<(ostream &OutputStream,\n"
5283 " SomeReallyLongType WithSomeReallyLongValue);");
Daniel Jasper54ac8202013-04-05 17:21:59 +00005284 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
5285 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
5286 " return left.group < right.group;\n"
5287 "}");
Daniel Jasper6e8f4ed2013-04-11 08:48:20 +00005288 verifyFormat("SomeType &operator=(const SomeType &S);");
Daniel Jasper8835a322014-10-20 13:56:30 +00005289 verifyFormat("f.template operator()<int>();");
Daniel Jasper0af92eb2013-02-15 19:24:08 +00005290
Daniel Jasper35d2dc72013-02-11 08:01:18 +00005291 verifyGoogleFormat("operator void*();");
5292 verifyGoogleFormat("operator SomeType<SomeType<int>>();");
Daniel Jasperedc5f092013-10-29 12:24:23 +00005293 verifyGoogleFormat("operator ::A();");
Daniel Jasper42401c82013-09-02 09:20:39 +00005294
5295 verifyFormat("using A::operator+;");
Daniel Jasper5af04a42015-10-07 03:43:10 +00005296 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n"
5297 "int i;");
Daniel Jasperf7935112012-12-03 18:12:45 +00005298}
5299
Daniel Jasper1c220482015-02-25 10:30:06 +00005300TEST_F(FormatTest, UnderstandsFunctionRefQualification) {
Daniel Jasperaf642c62015-08-25 13:40:51 +00005301 verifyFormat("Deleted &operator=(const Deleted &) & = default;");
5302 verifyFormat("Deleted &operator=(const Deleted &) && = delete;");
5303 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;");
5304 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;");
5305 verifyFormat("Deleted &operator=(const Deleted &) &;");
5306 verifyFormat("Deleted &operator=(const Deleted &) &&;");
5307 verifyFormat("SomeType MemberFunction(const Deleted &) &;");
5308 verifyFormat("SomeType MemberFunction(const Deleted &) &&;");
5309 verifyFormat("SomeType MemberFunction(const Deleted &) && {}");
5310 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}");
5311 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}");
Jacob Bandes-Storch58933c52017-08-10 01:30:22 +00005312 verifyFormat("void Fn(T const &) const &;");
5313 verifyFormat("void Fn(T const volatile &&) const volatile &&;");
Daniel Jasper28b4d512016-11-01 06:23:19 +00005314 verifyFormat("template <typename T>\n"
5315 "void F(T) && = delete;",
5316 getGoogleStyle());
Daniel Jasper1c220482015-02-25 10:30:06 +00005317
Daniel Jasperaf642c62015-08-25 13:40:51 +00005318 FormatStyle AlignLeft = getLLVMStyle();
5319 AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
Daniel Jasper2b4d6ea2016-06-08 08:23:46 +00005320 verifyFormat("void A::b() && {}", AlignLeft);
Daniel Jasperaf642c62015-08-25 13:40:51 +00005321 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft);
5322 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;",
5323 AlignLeft);
5324 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft);
5325 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft);
Daniel Jasperc3ff0cd2016-04-18 11:31:21 +00005326 verifyFormat("auto Function(T t) & -> void {}", AlignLeft);
5327 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft);
5328 verifyFormat("auto Function(T) & -> void {}", AlignLeft);
5329 verifyFormat("auto Function(T) & -> void;", AlignLeft);
Jacob Bandes-Storch58933c52017-08-10 01:30:22 +00005330 verifyFormat("void Fn(T const&) const&;", AlignLeft);
5331 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft);
Daniel Jasper1c220482015-02-25 10:30:06 +00005332
5333 FormatStyle Spaces = getLLVMStyle();
5334 Spaces.SpacesInCStyleCastParentheses = true;
Daniel Jasperaf642c62015-08-25 13:40:51 +00005335 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces);
5336 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces);
5337 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces);
5338 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces);
Daniel Jasper1c220482015-02-25 10:30:06 +00005339
5340 Spaces.SpacesInCStyleCastParentheses = false;
5341 Spaces.SpacesInParentheses = true;
Daniel Jasperaf642c62015-08-25 13:40:51 +00005342 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces);
5343 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", Spaces);
5344 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces);
5345 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces);
Daniel Jasper1c220482015-02-25 10:30:06 +00005346}
5347
Daniel Jasperd6a947f2013-01-11 16:09:04 +00005348TEST_F(FormatTest, UnderstandsNewAndDelete) {
Daniel Jasperba0bda92013-02-23 08:07:18 +00005349 verifyFormat("void f() {\n"
5350 " A *a = new A;\n"
5351 " A *a = new (placement) A;\n"
5352 " delete a;\n"
5353 " delete (A *)a;\n"
5354 "}");
Daniel Jasper71646ec2014-07-30 12:14:10 +00005355 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
5356 " typename aaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper316ab382014-08-06 13:14:58 +00005357 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5358 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
5359 " typename aaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper80222262014-11-02 22:46:42 +00005360 verifyFormat("delete[] h->p;");
Daniel Jasperd6a947f2013-01-11 16:09:04 +00005361}
5362
Daniel Jasper22bcf8a2013-01-02 08:57:10 +00005363TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005364 verifyFormat("int *f(int *a) {}");
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005365 verifyFormat("int main(int argc, char **argv) {}");
Daniel Jasper5065bc42013-02-18 12:44:35 +00005366 verifyFormat("Test::Test(int b) : a(b * b) {}");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005367 verifyIndependentOfContext("f(a, *a);");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005368 verifyFormat("void g() { f(*a); }");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005369 verifyIndependentOfContext("int a = b * 10;");
5370 verifyIndependentOfContext("int a = 10 * b;");
5371 verifyIndependentOfContext("int a = b * c;");
5372 verifyIndependentOfContext("int a += b * c;");
5373 verifyIndependentOfContext("int a -= b * c;");
5374 verifyIndependentOfContext("int a *= b * c;");
5375 verifyIndependentOfContext("int a /= b * c;");
5376 verifyIndependentOfContext("int a = *b;");
5377 verifyIndependentOfContext("int a = *b * c;");
5378 verifyIndependentOfContext("int a = b * *c;");
Daniel Jasper93101662015-05-19 12:29:27 +00005379 verifyIndependentOfContext("int a = b * (10);");
5380 verifyIndependentOfContext("S << b * (10);");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005381 verifyIndependentOfContext("return 10 * b;");
5382 verifyIndependentOfContext("return *b * *c;");
5383 verifyIndependentOfContext("return a & ~b;");
5384 verifyIndependentOfContext("f(b ? *c : *d);");
5385 verifyIndependentOfContext("int a = b ? *c : *d;");
5386 verifyIndependentOfContext("*b = a;");
5387 verifyIndependentOfContext("a * ~b;");
5388 verifyIndependentOfContext("a * !b;");
5389 verifyIndependentOfContext("a * +b;");
5390 verifyIndependentOfContext("a * -b;");
5391 verifyIndependentOfContext("a * ++b;");
5392 verifyIndependentOfContext("a * --b;");
5393 verifyIndependentOfContext("a[4] * b;");
Daniel Jasper8e559272013-02-27 11:43:50 +00005394 verifyIndependentOfContext("a[a * a] = 1;");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005395 verifyIndependentOfContext("f() * b;");
5396 verifyIndependentOfContext("a * [self dostuff];");
Daniel Jasper6e42b1e2013-04-01 17:13:26 +00005397 verifyIndependentOfContext("int x = a * (a + b);");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005398 verifyIndependentOfContext("(a *)(a + b);");
Daniel Jasper942d9712014-04-28 09:19:28 +00005399 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005400 verifyIndependentOfContext("int *pa = (int *)&a;");
Nico Weber44449172013-02-12 16:17:07 +00005401 verifyIndependentOfContext("return sizeof(int **);");
5402 verifyIndependentOfContext("return sizeof(int ******);");
5403 verifyIndependentOfContext("return (int **&)a;");
Daniel Jasper4d03d3b2013-05-28 15:27:10 +00005404 verifyIndependentOfContext("f((*PointerToArray)[10]);");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005405 verifyFormat("void f(Type (*parameter)[10]) {}");
Daniel Jasper4bc013e2015-10-07 01:41:22 +00005406 verifyFormat("void f(Type (&parameter)[10]) {}");
Nico Weber44449172013-02-12 16:17:07 +00005407 verifyGoogleFormat("return sizeof(int**);");
5408 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);");
5409 verifyGoogleFormat("Type** A = static_cast<Type**>(P);");
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00005410 verifyFormat("auto a = [](int **&, int ***) {};");
Daniel Jasperd46e07e2013-10-20 18:15:30 +00005411 verifyFormat("auto PointerBinding = [](const char *S) {};");
Daniel Jasper71665cd2013-09-10 10:26:38 +00005412 verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
Daniel Jasper4ac7de72014-06-11 07:35:16 +00005413 verifyFormat("[](const decltype(*a) &value) {}");
Daniel Jasper033181b2015-08-13 13:43:51 +00005414 verifyFormat("decltype(a * b) F();");
Daniel Jasper99b5a462015-05-12 10:20:32 +00005415 verifyFormat("#define MACRO() [](A *a) { return 1; }");
Daniel Jasperd27df3d2016-02-01 11:21:07 +00005416 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}");
Daniel Jasper3682fcd2013-12-16 08:36:18 +00005417 verifyIndependentOfContext("typedef void (*f)(int *a);");
Daniel Jasper39485162014-05-22 09:00:33 +00005418 verifyIndependentOfContext("int i{a * b};");
Daniel Jasper7d028292014-06-02 11:54:20 +00005419 verifyIndependentOfContext("aaa && aaa->f();");
Daniel Jasper2ac3fdf2014-07-28 12:08:16 +00005420 verifyIndependentOfContext("int x = ~*p;");
Daniel Jasperd127e3b2014-11-14 17:26:49 +00005421 verifyFormat("Constructor() : a(a), area(width * height) {}");
Daniel Jaspere1e348b2014-11-17 18:42:22 +00005422 verifyFormat("Constructor() : a(a), area(a, width * height) {}");
Daniel Jaspere4ab49e2015-04-20 12:54:29 +00005423 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}");
Daniel Jasper6a3fd832014-11-17 13:55:04 +00005424 verifyFormat("void f() { f(a, c * d); }");
Daniel Jasper3a26a8d2015-05-13 12:54:30 +00005425 verifyFormat("void f() { f(new a(), c * d); }");
Daniel Jasperc941e7d2017-01-09 11:04:07 +00005426 verifyFormat("void f(const MyOverride &override);");
5427 verifyFormat("void f(const MyFinal &final);");
5428 verifyIndependentOfContext("bool a = f() && override.f();");
5429 verifyIndependentOfContext("bool a = f() && final.f();");
Daniel Jasper27234032012-12-07 09:52:15 +00005430
Daniel Jasper5b49f472013-01-23 12:10:53 +00005431 verifyIndependentOfContext("InvalidRegions[*R] = 0;");
Daniel Jasper3c2557d2013-01-04 20:46:38 +00005432
Daniel Jasper5b49f472013-01-23 12:10:53 +00005433 verifyIndependentOfContext("A<int *> a;");
5434 verifyIndependentOfContext("A<int **> a;");
5435 verifyIndependentOfContext("A<int *, int *> a;");
Daniel Jasper139d4a32014-04-08 13:07:41 +00005436 verifyIndependentOfContext("A<int *[]> a;");
Daniel Jasperc697ad22013-02-06 10:05:46 +00005437 verifyIndependentOfContext(
5438 "const char *const p = reinterpret_cast<const char *const>(q);");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005439 verifyIndependentOfContext("A<int **, int **> a;");
Daniel Jasper8035b0a2013-02-06 10:57:42 +00005440 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);");
Daniel Jasperae907642013-03-14 10:50:25 +00005441 verifyFormat("for (char **a = b; *a; ++a) {\n}");
Daniel Jasperc37de302013-05-03 14:41:24 +00005442 verifyFormat("for (; a && b;) {\n}");
Daniel Jasperea2d0422014-05-08 08:50:10 +00005443 verifyFormat("bool foo = true && [] { return false; }();");
Daniel Jaspera4396862012-12-10 18:59:13 +00005444
Daniel Jasper66dcb1c2013-01-08 20:03:18 +00005445 verifyFormat(
5446 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5447 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5448
Daniel Jasper1f5d6372016-06-13 14:45:12 +00005449 verifyGoogleFormat("int const* a = &b;");
Daniel Jasper6a968202015-01-07 12:19:53 +00005450 verifyGoogleFormat("**outparam = 1;");
Daniel Jasper75092162015-01-23 19:04:49 +00005451 verifyGoogleFormat("*outparam = a * b;");
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005452 verifyGoogleFormat("int main(int argc, char** argv) {}");
Daniel Jaspera4396862012-12-10 18:59:13 +00005453 verifyGoogleFormat("A<int*> a;");
5454 verifyGoogleFormat("A<int**> a;");
5455 verifyGoogleFormat("A<int*, int*> a;");
5456 verifyGoogleFormat("A<int**, int**> a;");
Daniel Jasper22bcf8a2013-01-02 08:57:10 +00005457 verifyGoogleFormat("f(b ? *c : *d);");
5458 verifyGoogleFormat("int a = b ? *c : *d;");
Daniel Jaspera1dc93a2013-01-16 16:04:06 +00005459 verifyGoogleFormat("Type* t = **x;");
5460 verifyGoogleFormat("Type* t = *++*x;");
5461 verifyGoogleFormat("*++*x;");
5462 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);");
5463 verifyGoogleFormat("Type* t = x++ * y;");
Daniel Jasperc697ad22013-02-06 10:05:46 +00005464 verifyGoogleFormat(
5465 "const char* const p = reinterpret_cast<const char* const>(q);");
Daniel Jasper8184d662014-07-28 12:24:21 +00005466 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);");
Daniel Jasper0bd9a192014-11-10 16:57:30 +00005467 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);");
5468 verifyGoogleFormat("template <typename T>\n"
5469 "void f(int i = 0, SomeType** temps = NULL);");
Manuel Klimek557811f2013-01-14 10:58:01 +00005470
Daniel Jasper1904e9b2014-08-14 10:53:19 +00005471 FormatStyle Left = getLLVMStyle();
5472 Left.PointerAlignment = FormatStyle::PAS_Left;
5473 verifyFormat("x = *a(x) = *a(y);", Left);
Daniel Jasper28b4d512016-11-01 06:23:19 +00005474 verifyFormat("for (;; *a = b) {\n}", Left);
Daniel Jasper95516cd2015-12-23 18:01:29 +00005475 verifyFormat("return *this += 1;", Left);
Manuel Klimek06b575c2017-07-17 15:27:53 +00005476 verifyFormat("throw *x;", Left);
Krasimir Georgiev9b5a89b2017-08-14 11:06:07 +00005477 verifyFormat("delete *x;", Left);
5478 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left);
5479 verifyFormat("[](const decltype(*a)* ptr) {}", Left);
5480 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left);
Daniel Jasper1904e9b2014-08-14 10:53:19 +00005481
Daniel Jasper5b49f472013-01-23 12:10:53 +00005482 verifyIndependentOfContext("a = *(x + y);");
5483 verifyIndependentOfContext("a = &(x + y);");
5484 verifyIndependentOfContext("*(x + y).call();");
5485 verifyIndependentOfContext("&(x + y)->call();");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005486 verifyFormat("void f() { &(*I).first; }");
Daniel Jasper71945272013-01-15 14:27:39 +00005487
Daniel Jasper5b49f472013-01-23 12:10:53 +00005488 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
Daniel Jasper71945272013-01-15 14:27:39 +00005489 verifyFormat(
Daniel Jasperf9fc2152014-04-09 13:18:49 +00005490 "int *MyValues = {\n"
5491 " *A, // Operator detection might be confused by the '{'\n"
5492 " *BB // Operator detection might be confused by previous comment\n"
Daniel Jasper71945272013-01-15 14:27:39 +00005493 "};");
Nico Weber80a82762013-01-17 17:17:19 +00005494
Daniel Jasper5b49f472013-01-23 12:10:53 +00005495 verifyIndependentOfContext("if (int *a = &b)");
5496 verifyIndependentOfContext("if (int &a = *b)");
5497 verifyIndependentOfContext("if (a & b[i])");
5498 verifyIndependentOfContext("if (a::b::c::d & b[i])");
5499 verifyIndependentOfContext("if (*b[i])");
5500 verifyIndependentOfContext("if (int *a = (&b))");
5501 verifyIndependentOfContext("while (int *a = &b)");
Daniel Jasperdf620b22013-09-21 17:31:51 +00005502 verifyIndependentOfContext("size = sizeof *a;");
Daniel Jasperdc4f7252015-03-11 12:59:49 +00005503 verifyIndependentOfContext("if (a && (b = c))");
Daniel Jasper420d7d32013-01-23 12:58:14 +00005504 verifyFormat("void f() {\n"
5505 " for (const int &v : Values) {\n"
5506 " }\n"
5507 "}");
Daniel Jasper5065bc42013-02-18 12:44:35 +00005508 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
5509 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
Daniel Jasper5ca9b712013-09-11 20:37:10 +00005510 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}");
Daniel Jasper0b820602013-01-22 11:46:26 +00005511
Daniel Jaspera98da3d2013-11-07 19:56:07 +00005512 verifyFormat("#define A (!a * b)");
Daniel Jasperb910bbb2013-05-13 07:14:40 +00005513 verifyFormat("#define MACRO \\\n"
5514 " int *i = a * b; \\\n"
5515 " void f(a *b);",
5516 getLLVMStyleWithColumns(19));
5517
Daniel Jasper97b89482013-03-13 07:49:51 +00005518 verifyIndependentOfContext("A = new SomeType *[Length];");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005519 verifyIndependentOfContext("A = new SomeType *[Length]();");
Daniel Jasper6f9c8d22013-07-05 13:30:40 +00005520 verifyIndependentOfContext("T **t = new T *;");
5521 verifyIndependentOfContext("T **t = new T *();");
Daniel Jasper532a0312015-04-23 10:23:53 +00005522 verifyGoogleFormat("A = new SomeType*[Length]();");
5523 verifyGoogleFormat("A = new SomeType*[Length];");
Daniel Jasper6f9c8d22013-07-05 13:30:40 +00005524 verifyGoogleFormat("T** t = new T*;");
5525 verifyGoogleFormat("T** t = new T*();");
Daniel Jasperb910bbb2013-05-13 07:14:40 +00005526
Daniel Jaspera65e8872014-03-25 10:52:45 +00005527 verifyFormat("STATIC_ASSERT((a & b) == 0);");
5528 verifyFormat("STATIC_ASSERT(0 == (a & b));");
Manuel Klimekf81e5c02014-03-27 11:17:36 +00005529 verifyFormat("template <bool a, bool b> "
Daniel Jasper4afc6b32014-06-02 10:57:55 +00005530 "typename t::if<x && y>::type f() {}");
5531 verifyFormat("template <int *y> f() {}");
Manuel Klimekf81e5c02014-03-27 11:17:36 +00005532 verifyFormat("vector<int *> v;");
5533 verifyFormat("vector<int *const> v;");
5534 verifyFormat("vector<int *const **const *> v;");
5535 verifyFormat("vector<int *volatile> v;");
5536 verifyFormat("vector<a * b> v;");
Manuel Klimek1f9d80a2014-03-27 19:00:52 +00005537 verifyFormat("foo<b && false>();");
5538 verifyFormat("foo<b & 1>();");
Daniel Jasper73e171f2014-08-29 12:54:38 +00005539 verifyFormat("decltype(*::std::declval<const T &>()) void F();");
Daniel Jasper13a7f462014-10-28 18:11:52 +00005540 verifyFormat(
Daniel Jasper21f7dea2017-02-01 09:23:39 +00005541 "template <class T, class = typename std::enable_if<\n"
5542 " std::is_integral<T>::value &&\n"
5543 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n"
5544 "void F();",
5545 getLLVMStyleWithColumns(70));
5546 verifyFormat(
Daniel Jasper22ed2622016-11-29 09:40:32 +00005547 "template <class T,\n"
5548 " class = typename std::enable_if<\n"
5549 " std::is_integral<T>::value &&\n"
Daniel Jasper21f7dea2017-02-01 09:23:39 +00005550 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n"
5551 " class U>\n"
Daniel Jasperf0c809a2014-10-28 18:28:22 +00005552 "void F();",
Daniel Jasper22ed2622016-11-29 09:40:32 +00005553 getLLVMStyleWithColumns(70));
Daniel Jasperf0c809a2014-10-28 18:28:22 +00005554 verifyFormat(
5555 "template <class T,\n"
5556 " class = typename ::std::enable_if<\n"
5557 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n"
5558 "void F();",
5559 getGoogleStyleWithColumns(68));
Manuel Klimek1f9d80a2014-03-27 19:00:52 +00005560
Daniel Jaspercc7bf7f2014-04-03 09:00:49 +00005561 verifyIndependentOfContext("MACRO(int *i);");
5562 verifyIndependentOfContext("MACRO(auto *a);");
5563 verifyIndependentOfContext("MACRO(const A *a);");
Daniel Jasper628dd852017-03-08 09:49:12 +00005564 verifyIndependentOfContext("MACRO(A *const a);");
Daniel Jasper91beebd2014-06-30 13:44:47 +00005565 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');");
Daniel Jasperd0d27aa2016-11-01 06:23:14 +00005566 verifyFormat("void f() { f(float{1}, a * a); }");
Daniel Jaspercc7bf7f2014-04-03 09:00:49 +00005567 // FIXME: Is there a way to make this work?
5568 // verifyIndependentOfContext("MACRO(A *a);");
5569
Daniel Jasper32ccb032014-06-23 07:36:18 +00005570 verifyFormat("DatumHandle const *operator->() const { return input_; }");
Daniel Jasper0ea4d792015-10-07 01:41:14 +00005571 verifyFormat("return options != nullptr && operator==(*options);");
Daniel Jasper32ccb032014-06-23 07:36:18 +00005572
Daniel Jasper866468a2014-04-14 13:15:29 +00005573 EXPECT_EQ("#define OP(x) \\\n"
5574 " ostream &operator<<(ostream &s, const A &a) { \\\n"
5575 " return s << a.DebugString(); \\\n"
5576 " }",
5577 format("#define OP(x) \\\n"
5578 " ostream &operator<<(ostream &s, const A &a) { \\\n"
5579 " return s << a.DebugString(); \\\n"
5580 " }",
5581 getLLVMStyleWithColumns(50)));
5582
Manuel Klimek1f9d80a2014-03-27 19:00:52 +00005583 // FIXME: We cannot handle this case yet; we might be able to figure out that
5584 // foo<x> d > v; doesn't make sense.
Daniel Jasper6ba16382014-07-28 13:19:58 +00005585 verifyFormat("foo<a<b && c> d> v;");
Daniel Jasper553d4872014-06-17 12:40:34 +00005586
5587 FormatStyle PointerMiddle = getLLVMStyle();
5588 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
5589 verifyFormat("delete *x;", PointerMiddle);
5590 verifyFormat("int * x;", PointerMiddle);
5591 verifyFormat("template <int * y> f() {}", PointerMiddle);
5592 verifyFormat("int * f(int * a) {}", PointerMiddle);
5593 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle);
5594 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle);
5595 verifyFormat("A<int *> a;", PointerMiddle);
5596 verifyFormat("A<int **> a;", PointerMiddle);
5597 verifyFormat("A<int *, int *> a;", PointerMiddle);
5598 verifyFormat("A<int * []> a;", PointerMiddle);
Daniel Jasper532a0312015-04-23 10:23:53 +00005599 verifyFormat("A = new SomeType *[Length]();", PointerMiddle);
5600 verifyFormat("A = new SomeType *[Length];", PointerMiddle);
Daniel Jasper553d4872014-06-17 12:40:34 +00005601 verifyFormat("T ** t = new T *;", PointerMiddle);
Daniel Jasper3992e2c2015-07-01 21:02:24 +00005602
5603 // Member function reference qualifiers aren't binary operators.
5604 verifyFormat("string // break\n"
Daniel Jasperaf642c62015-08-25 13:40:51 +00005605 "operator()() & {}");
Daniel Jasper3992e2c2015-07-01 21:02:24 +00005606 verifyFormat("string // break\n"
Daniel Jasperaf642c62015-08-25 13:40:51 +00005607 "operator()() && {}");
Daniel Jasper3992e2c2015-07-01 21:02:24 +00005608 verifyGoogleFormat("template <typename T>\n"
Daniel Jasperaf642c62015-08-25 13:40:51 +00005609 "auto x() & -> int {}");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005610}
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005611
Daniel Jasperee6d6502013-07-17 20:25:02 +00005612TEST_F(FormatTest, UnderstandsAttributes) {
5613 verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
Daniel Jasper559b63c2014-01-28 20:13:43 +00005614 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
5615 "aaaaaaaaaaaaaaaaaaaaaaa(int i);");
Daniel Jaspera5fa4d12015-07-06 11:30:34 +00005616 FormatStyle AfterType = getLLVMStyle();
Zachary Turner448592e2015-12-18 22:20:15 +00005617 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
Daniel Jaspera5fa4d12015-07-06 11:30:34 +00005618 verifyFormat("__attribute__((nodebug)) void\n"
5619 "foo() {}\n",
5620 AfterType);
Daniel Jasperee6d6502013-07-17 20:25:02 +00005621}
5622
Daniel Jasper10cd5812013-05-06 06:35:44 +00005623TEST_F(FormatTest, UnderstandsEllipsis) {
5624 verifyFormat("int printf(const char *fmt, ...);");
5625 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
Daniel Jasperbafa6b72013-07-01 09:47:25 +00005626 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}");
5627
5628 FormatStyle PointersLeft = getLLVMStyle();
Daniel Jasper553d4872014-06-17 12:40:34 +00005629 PointersLeft.PointerAlignment = FormatStyle::PAS_Left;
Daniel Jasperbafa6b72013-07-01 09:47:25 +00005630 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft);
Daniel Jasper10cd5812013-05-06 06:35:44 +00005631}
5632
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005633TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005634 EXPECT_EQ("int *a;\n"
5635 "int *a;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005636 "int *a;",
5637 format("int *a;\n"
5638 "int* a;\n"
5639 "int *a;",
5640 getGoogleStyle()));
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005641 EXPECT_EQ("int* a;\n"
5642 "int* a;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005643 "int* a;",
5644 format("int* a;\n"
5645 "int* a;\n"
5646 "int *a;",
5647 getGoogleStyle()));
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005648 EXPECT_EQ("int *a;\n"
5649 "int *a;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005650 "int *a;",
5651 format("int *a;\n"
5652 "int * a;\n"
5653 "int * a;",
5654 getGoogleStyle()));
Daniel Jasper352f0df2015-07-18 16:35:30 +00005655 EXPECT_EQ("auto x = [] {\n"
5656 " int *a;\n"
5657 " int *a;\n"
5658 " int *a;\n"
5659 "};",
5660 format("auto x=[]{int *a;\n"
5661 "int * a;\n"
5662 "int * a;};",
5663 getGoogleStyle()));
Daniel Jasperf7935112012-12-03 18:12:45 +00005664}
5665
Alexander Kornienkoa5151272013-03-12 16:28:18 +00005666TEST_F(FormatTest, UnderstandsRvalueReferences) {
5667 verifyFormat("int f(int &&a) {}");
5668 verifyFormat("int f(int a, char &&b) {}");
5669 verifyFormat("void f() { int &&a = b; }");
5670 verifyGoogleFormat("int f(int a, char&& b) {}");
5671 verifyGoogleFormat("void f() { int&& a = b; }");
5672
Daniel Jasper1eff9082013-05-27 16:36:33 +00005673 verifyIndependentOfContext("A<int &&> a;");
5674 verifyIndependentOfContext("A<int &&, int &&> a;");
5675 verifyGoogleFormat("A<int&&> a;");
5676 verifyGoogleFormat("A<int&&, int&&> a;");
Daniel Jasper8b1c6352013-08-01 17:58:23 +00005677
5678 // Not rvalue references:
5679 verifyFormat("template <bool B, bool C> class A {\n"
5680 " static_assert(B && C, \"Something is wrong\");\n"
5681 "};");
Daniel Jasper29a98cf2013-08-13 09:09:09 +00005682 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))");
5683 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))");
Daniel Jasper72ab43b2014-04-14 12:50:02 +00005684 verifyFormat("#define A(a, b) (a && b)");
Alexander Kornienkoa5151272013-03-12 16:28:18 +00005685}
5686
Manuel Klimekc1237a82013-01-23 14:08:21 +00005687TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
5688 verifyFormat("void f() {\n"
5689 " x[aaaaaaaaa -\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00005690 " b] = 23;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005691 "}",
5692 getLLVMStyleWithColumns(15));
Manuel Klimekc1237a82013-01-23 14:08:21 +00005693}
5694
Daniel Jasperef906a92013-01-13 08:01:36 +00005695TEST_F(FormatTest, FormatsCasts) {
5696 verifyFormat("Type *A = static_cast<Type *>(P);");
5697 verifyFormat("Type *A = (Type *)P;");
5698 verifyFormat("Type *A = (vector<Type *, int *>)P;");
5699 verifyFormat("int a = (int)(2.0f);");
Daniel Jasperda6f2252013-05-31 16:14:28 +00005700 verifyFormat("int a = (int)2.0f;");
5701 verifyFormat("x[(int32)y];");
5702 verifyFormat("x = (int32)y;");
5703 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
5704 verifyFormat("int a = (int)*b;");
5705 verifyFormat("int a = (int)2.0f;");
5706 verifyFormat("int a = (int)~0;");
5707 verifyFormat("int a = (int)++a;");
5708 verifyFormat("int a = (int)sizeof(int);");
5709 verifyFormat("int a = (int)+2;");
5710 verifyFormat("my_int a = (my_int)2.0f;");
5711 verifyFormat("my_int a = (my_int)sizeof(int);");
Daniel Jasper05866372013-06-06 08:20:20 +00005712 verifyFormat("return (my_int)aaa;");
Daniel Jasper49a94482013-07-15 15:04:42 +00005713 verifyFormat("#define x ((int)-1)");
Daniel Jaspera45eb4c2014-10-06 13:16:43 +00005714 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1");
Daniel Jasper49a94482013-07-15 15:04:42 +00005715 verifyFormat("#define p(q) ((int *)&q)");
Daniel Jasper30646202014-07-14 12:38:38 +00005716 verifyFormat("fn(a)(b) + 1;");
Daniel Jasperef906a92013-01-13 08:01:36 +00005717
Dinesh Dwivedi76f98f82014-05-05 13:14:35 +00005718 verifyFormat("void f() { my_int a = (my_int)*b; }");
5719 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }");
5720 verifyFormat("my_int a = (my_int)~0;");
5721 verifyFormat("my_int a = (my_int)++a;");
Daniel Jaspera45eb4c2014-10-06 13:16:43 +00005722 verifyFormat("my_int a = (my_int)-2;");
Dinesh Dwivedi76f98f82014-05-05 13:14:35 +00005723 verifyFormat("my_int a = (my_int)1;");
5724 verifyFormat("my_int a = (my_int *)1;");
5725 verifyFormat("my_int a = (const my_int)-1;");
5726 verifyFormat("my_int a = (const my_int *)-1;");
Daniel Jasper4b3ba212014-08-25 09:36:07 +00005727 verifyFormat("my_int a = (my_int)(my_int)-1;");
Daniel Jasperf5e5ee62015-05-19 11:18:39 +00005728 verifyFormat("my_int a = (ns::my_int)-2;");
Daniel Jasper554e49f2015-06-12 07:15:33 +00005729 verifyFormat("case (my_int)ONE:");
Daniel Jasper94b1bdf2016-04-05 11:46:06 +00005730 verifyFormat("auto x = (X)this;");
Dinesh Dwivedi76f98f82014-05-05 13:14:35 +00005731
5732 // FIXME: single value wrapped with paren will be treated as cast.
5733 verifyFormat("void f(int i = (kValue)*kMask) {}");
Daniel Jasperef906a92013-01-13 08:01:36 +00005734
Dinesh Dwivedi2e92e662014-05-06 11:46:49 +00005735 verifyFormat("{ (void)F; }");
5736
Daniel Jasper998cabc2013-07-18 14:46:07 +00005737 // Don't break after a cast's
5738 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5739 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
5740 " bbbbbbbbbbbbbbbbbbbbbb);");
5741
Daniel Jasperef906a92013-01-13 08:01:36 +00005742 // These are not casts.
5743 verifyFormat("void f(int *) {}");
Nico Weber4401b2a2013-02-13 04:32:57 +00005744 verifyFormat("f(foo)->b;");
5745 verifyFormat("f(foo).b;");
5746 verifyFormat("f(foo)(b);");
5747 verifyFormat("f(foo)[b];");
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00005748 verifyFormat("[](foo) { return 4; }(bar);");
Nico Weber4401b2a2013-02-13 04:32:57 +00005749 verifyFormat("(*funptr)(foo)[4];");
5750 verifyFormat("funptrs[4](foo)[4];");
Daniel Jasperef906a92013-01-13 08:01:36 +00005751 verifyFormat("void f(int *);");
5752 verifyFormat("void f(int *) = 0;");
5753 verifyFormat("void f(SmallVector<int>) {}");
5754 verifyFormat("void f(SmallVector<int>);");
5755 verifyFormat("void f(SmallVector<int>) = 0;");
Nico Weber06fcec12013-02-09 18:02:07 +00005756 verifyFormat("void f(int i = (kA * kB) & kMask) {}");
Nico Weber4401b2a2013-02-13 04:32:57 +00005757 verifyFormat("int a = sizeof(int) * b;");
Alexander Kornienko1e808872013-06-28 12:51:24 +00005758 verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
Daniel Jasper05866372013-06-06 08:20:20 +00005759 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
5760 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
Aaron Ballman61005bc2015-02-16 14:14:01 +00005761 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00005762
Daniel Jasperba0bda92013-02-23 08:07:18 +00005763 // These are not casts, but at some point were confused with casts.
5764 verifyFormat("virtual void foo(int *) override;");
5765 verifyFormat("virtual void foo(char &) const;");
5766 verifyFormat("virtual void foo(int *a, char *) const;");
Daniel Jasper8a68b952013-03-13 17:13:53 +00005767 verifyFormat("int a = sizeof(int *) + b;");
Alexander Kornienko1e808872013-06-28 12:51:24 +00005768 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
Daniel Jasper9bb30012015-11-23 15:55:50 +00005769 verifyFormat("bool b = f(g<int>) && c;");
Daniel Jasper8e8b4fb2015-11-23 19:11:45 +00005770 verifyFormat("typedef void (*f)(int i) func;");
Daniel Jasper1bc1b502013-07-05 07:58:34 +00005771
5772 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
5773 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
Daniel Jasperaea3bde2013-07-12 11:19:37 +00005774 // FIXME: The indentation here is not ideal.
Daniel Jasper0e90c3d2013-07-05 09:14:35 +00005775 verifyFormat(
Daniel Jasperaea3bde2013-07-12 11:19:37 +00005776 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5777 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
5778 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];");
Daniel Jasperef906a92013-01-13 08:01:36 +00005779}
5780
Daniel Jasperc1fa2812013-01-10 13:08:12 +00005781TEST_F(FormatTest, FormatsFunctionTypes) {
Daniel Jasperc1fa2812013-01-10 13:08:12 +00005782 verifyFormat("A<bool()> a;");
5783 verifyFormat("A<SomeType()> a;");
Daniel Jasper37194282013-05-28 08:33:00 +00005784 verifyFormat("A<void (*)(int, std::string)> a;");
Daniel Jasperb8914dd2013-03-20 09:53:18 +00005785 verifyFormat("A<void *(int)>;");
Daniel Jasper6e42b1e2013-04-01 17:13:26 +00005786 verifyFormat("void *(*a)(int *, SomeType *);");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005787 verifyFormat("int (*func)(void *);");
Daniel Jasper37194282013-05-28 08:33:00 +00005788 verifyFormat("void f() { int (*func)(void *); }");
Daniel Jasper59036852013-08-12 12:16:34 +00005789 verifyFormat("template <class CallbackClass>\n"
5790 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);");
Daniel Jasperb8914dd2013-03-20 09:53:18 +00005791
Daniel Jasper6e42b1e2013-04-01 17:13:26 +00005792 verifyGoogleFormat("A<void*(int*, SomeType*)>;");
5793 verifyGoogleFormat("void* (*a)(int);");
Daniel Jasper59036852013-08-12 12:16:34 +00005794 verifyGoogleFormat(
5795 "template <class CallbackClass>\n"
5796 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);");
Daniel Jasperabc34212013-05-14 08:34:47 +00005797
Daniel Jasper5dad58e2013-05-15 07:51:51 +00005798 // Other constructs can look somewhat like function types:
Daniel Jasperabc34212013-05-14 08:34:47 +00005799 verifyFormat("A<sizeof(*x)> a;");
Daniel Jasper5dad58e2013-05-15 07:51:51 +00005800 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
Daniel Jasper655d96a2013-07-16 11:37:21 +00005801 verifyFormat("some_var = function(*some_pointer_var)[0];");
5802 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
Daniel Jaspera85c3312015-12-28 07:44:25 +00005803 verifyFormat("int x = f(&h)();");
Daniel Jasper21561662016-06-13 07:49:35 +00005804 verifyFormat("returnsFunction(&param1, &param2)(param);");
Daniel Jaspercab46172017-04-24 14:28:49 +00005805 verifyFormat("std::function<\n"
5806 " LooooooooooongTemplatedType<\n"
5807 " SomeType>*(\n"
5808 " LooooooooooooooooongType type)>\n"
5809 " function;",
5810 getGoogleStyleWithColumns(40));
Daniel Jasperc1fa2812013-01-10 13:08:12 +00005811}
5812
Daniel Jasperbeaa3222015-02-26 11:30:50 +00005813TEST_F(FormatTest, FormatsPointersToArrayTypes) {
5814 verifyFormat("A (*foo_)[6];");
5815 verifyFormat("vector<int> (*foo_)[6];");
5816}
5817
Daniel Jasper4355e7f2014-07-09 07:50:33 +00005818TEST_F(FormatTest, BreaksLongVariableDeclarations) {
5819 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
5820 " LoooooooooooooooooooooooooooooooooooooooongVariable;");
5821 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
5822 " LoooooooooooooooooooooooooooooooooooooooongVariable;");
Daniel Jasperb754a742015-03-12 15:04:53 +00005823 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
5824 " *LoooooooooooooooooooooooooooooooooooooooongVariable;");
Daniel Jasper4355e7f2014-07-09 07:50:33 +00005825
5826 // Different ways of ()-initializiation.
5827 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
5828 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);");
5829 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
5830 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);");
5831 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
5832 " LoooooooooooooooooooooooooooooooooooooooongVariable({});");
Daniel Jasper0faa9132015-04-23 13:58:40 +00005833 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
5834 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);");
Daniel Jasper697a8ec2017-02-07 21:38:16 +00005835
5836 // Lambdas should not confuse the variable declaration heuristic.
5837 verifyFormat("LooooooooooooooooongType\n"
5838 " variable(nullptr, [](A *a) {});",
5839 getLLVMStyleWithColumns(40));
Daniel Jasper4355e7f2014-07-09 07:50:33 +00005840}
5841
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00005842TEST_F(FormatTest, BreaksLongDeclarations) {
Daniel Jasper8e357692013-05-06 08:27:33 +00005843 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00005844 " AnotherNameForTheLongType;");
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00005845 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00005846 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper8e357692013-05-06 08:27:33 +00005847 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00005848 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
Daniel Jasperb754a742015-03-12 15:04:53 +00005849 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n"
5850 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
Daniel Jasper8e357692013-05-06 08:27:33 +00005851 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
5852 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasper2ad0aba2014-10-28 17:06:04 +00005853 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n"
5854 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasperdba1c552013-07-02 09:47:29 +00005855 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
5856 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasperf10a28d2014-05-05 13:48:09 +00005857 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
5858 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasperc3ff0cd2016-04-18 11:31:21 +00005859 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
5860 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);");
5861 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
5862 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}");
Daniel Jasperc75e1ef2014-07-09 08:42:42 +00005863 FormatStyle Indented = getLLVMStyle();
5864 Indented.IndentWrappedFunctionNames = true;
5865 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
5866 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();",
5867 Indented);
5868 verifyFormat(
5869 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
5870 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
5871 Indented);
5872 verifyFormat(
5873 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
5874 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
5875 Indented);
5876 verifyFormat(
5877 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
5878 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
5879 Indented);
Daniel Jasper8e357692013-05-06 08:27:33 +00005880
5881 // FIXME: Without the comment, this breaks after "(".
Manuel Klimek836c2862013-06-21 17:25:42 +00005882 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n"
5883 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();",
5884 getGoogleStyle());
Daniel Jasper8e357692013-05-06 08:27:33 +00005885
Daniel Jasperd2639ef2013-01-28 15:16:31 +00005886 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00005887 " int LoooooooooooooooooooongParam2) {}");
Daniel Jasperd1926a32013-01-02 08:44:14 +00005888 verifyFormat(
Daniel Jasper6728fc12013-04-11 14:29:13 +00005889 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
5890 " SourceLocation L, IdentifierIn *II,\n"
5891 " Type *T) {}");
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00005892 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
Daniel Jasperb754a742015-03-12 15:04:53 +00005893 "ReallyReaaallyLongFunctionName(\n"
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00005894 " const std::string &SomeParameter,\n"
Daniel Jasperb754a742015-03-12 15:04:53 +00005895 " const SomeType<string, SomeOtherTemplateParameter>\n"
5896 " &ReallyReallyLongParameterName,\n"
5897 " const SomeType<string, SomeOtherTemplateParameter>\n"
5898 " &AnotherLongParameterName) {}");
Daniel Jasperc6fbc212013-05-15 09:35:08 +00005899 verifyFormat("template <typename A>\n"
5900 "SomeLoooooooooooooooooooooongType<\n"
5901 " typename some_namespace::SomeOtherType<A>::Type>\n"
5902 "Function() {}");
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00005903
Daniel Jasperd36ef5e2013-01-28 15:40:20 +00005904 verifyGoogleFormat(
Daniel Jasper53643062013-08-19 10:16:18 +00005905 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
5906 " aaaaaaaaaaaaaaaaaaaaaaa;");
5907 verifyGoogleFormat(
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00005908 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
5909 " SourceLocation L) {}");
Daniel Jasperb9caeac2013-02-13 20:33:44 +00005910 verifyGoogleFormat(
5911 "some_namespace::LongReturnType\n"
5912 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00005913 " int first_long_parameter, int second_parameter) {}");
Daniel Jasperb9caeac2013-02-13 20:33:44 +00005914
5915 verifyGoogleFormat("template <typename T>\n"
5916 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00005917 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
Daniel Jasper57d4a582013-02-28 10:06:05 +00005918 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5919 " int aaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper78b45332014-08-14 10:52:56 +00005920
5921 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
Daniel Jasperb754a742015-03-12 15:04:53 +00005922 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5923 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperde7ca752015-05-04 07:39:00 +00005924 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5925 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
5926 " aaaaaaaaaaaaaaaaaaaaaaaa);");
5927 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5928 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
5929 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n"
5930 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Andi-Bogdan Postelnicu67329892017-03-07 14:48:02 +00005931
Andi-Bogdan Postelnicu4743e2d2017-03-07 15:20:31 +00005932 verifyFormat("template <typename T> // Templates on own line.\n"
5933 "static int // Some comment.\n"
Andi-Bogdan Postelnicu67329892017-03-07 14:48:02 +00005934 "MyFunction(int a);",
5935 getLLVMStyle());
Daniel Jasperd1926a32013-01-02 08:44:14 +00005936}
5937
Daniel Jasperaea3bde2013-07-12 11:19:37 +00005938TEST_F(FormatTest, FormatsArrays) {
5939 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
5940 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
Daniel Jasper362a1bf2015-12-23 18:01:43 +00005941 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n"
5942 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;");
Daniel Jaspere1afb9b2015-12-30 12:23:00 +00005943 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n"
5944 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}");
Daniel Jasperaea3bde2013-07-12 11:19:37 +00005945 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5946 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
5947 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5948 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
5949 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5950 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
5951 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
5952 verifyFormat(
5953 "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
5954 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
5955 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
Daniel Jasperf9168de2016-03-01 04:19:55 +00005956 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n"
5957 " .aaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jaspere0ab9e72013-12-06 15:19:50 +00005958
5959 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n"
5960 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];");
Daniel Jasperecaba172014-06-10 13:27:57 +00005961 verifyFormat(
5962 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n"
5963 " .aaaaaaa[0]\n"
5964 " .aaaaaaaaaaaaaaaaaaaaaa();");
Manuel Klimek27f278182016-01-19 14:05:32 +00005965 verifyFormat("a[::b::c];");
Daniel Jasper675b4f82015-01-19 10:51:23 +00005966
5967 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10));
Daniel Jaspera3cd21642016-01-14 13:36:46 +00005968
5969 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0);
5970 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit);
Daniel Jasperaea3bde2013-07-12 11:19:37 +00005971}
5972
Daniel Jaspere9de2602012-12-06 09:56:08 +00005973TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
5974 verifyFormat("(a)->b();");
5975 verifyFormat("--a;");
5976}
5977
Daniel Jasper8b529712012-12-04 13:02:32 +00005978TEST_F(FormatTest, HandlesIncludeDirectives) {
Daniel Jasper2ab0d012013-01-14 15:52:06 +00005979 verifyFormat("#include <string>\n"
5980 "#include <a/b/c.h>\n"
5981 "#include \"a/b/string\"\n"
5982 "#include \"string.h\"\n"
5983 "#include \"string.h\"\n"
Manuel Klimek99c7baa2013-01-15 15:50:27 +00005984 "#include <a-a>\n"
Daniel Jasperaf5ba0e2013-02-23 07:46:38 +00005985 "#include < path with space >\n"
Daniel Jasperfa3f8fb2015-05-19 11:22:29 +00005986 "#include_next <test.h>"
Daniel Jasper4a4be012013-05-06 10:24:51 +00005987 "#include \"abc.h\" // this is included for ABC\n"
Daniel Jasper8bb99e82013-05-16 12:59:13 +00005988 "#include \"some long include\" // with a comment\n"
Daniel Jasperaf5ba0e2013-02-23 07:46:38 +00005989 "#include \"some very long include paaaaaaaaaaaaaaaaaaaaaaath\"",
5990 getLLVMStyleWithColumns(35));
Daniel Jasper98857842013-10-30 13:54:53 +00005991 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\""));
5992 EXPECT_EQ("#include <a>", format("#include<a>"));
Nico Weber8f83ee42012-12-21 18:21:56 +00005993
Daniel Jasper5ef433f2013-01-13 08:12:18 +00005994 verifyFormat("#import <string>");
5995 verifyFormat("#import <a/b/c.h>");
5996 verifyFormat("#import \"a/b/string\"");
5997 verifyFormat("#import \"string.h\"");
5998 verifyFormat("#import \"string.h\"");
Daniel Jaspered8f1c62013-08-28 08:24:04 +00005999 verifyFormat("#if __has_include(<strstream>)\n"
6000 "#include <strstream>\n"
6001 "#endif");
Daniel Jasper47ef6dd2014-01-17 16:21:39 +00006002
Daniel Jasper343643b2014-08-13 08:29:18 +00006003 verifyFormat("#define MY_IMPORT <a/b>");
6004
Nico Weber21088802017-02-10 19:36:52 +00006005 verifyFormat("#if __has_include(<a/b>)");
6006 verifyFormat("#if __has_include_next(<a/b>)");
6007 verifyFormat("#define F __has_include(<a/b>)");
6008 verifyFormat("#define F __has_include_next(<a/b>)");
6009
Daniel Jasper47ef6dd2014-01-17 16:21:39 +00006010 // Protocol buffer definition or missing "#".
6011 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";",
6012 getLLVMStyleWithColumns(30));
Daniel Jasper9509f182014-05-05 08:08:07 +00006013
6014 FormatStyle Style = getLLVMStyle();
6015 Style.AlwaysBreakBeforeMultilineStrings = true;
6016 Style.ColumnLimit = 0;
6017 verifyFormat("#import \"abc.h\"", Style);
Daniel Jasper86ee0b62014-12-04 08:57:27 +00006018
6019 // But 'import' might also be a regular C++ namespace.
6020 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6021 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper8b529712012-12-04 13:02:32 +00006022}
6023
Alexander Kornienko578fdd82012-12-06 18:03:27 +00006024//===----------------------------------------------------------------------===//
6025// Error recovery tests.
6026//===----------------------------------------------------------------------===//
6027
Daniel Jasper66e9dee2013-02-14 09:19:04 +00006028TEST_F(FormatTest, IncompleteParameterLists) {
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00006029 FormatStyle NoBinPacking = getLLVMStyle();
6030 NoBinPacking.BinPackParameters = false;
6031 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
6032 " double *min_x,\n"
6033 " double *max_x,\n"
6034 " double *min_y,\n"
6035 " double *max_y,\n"
6036 " double *min_z,\n"
6037 " double *max_z, ) {}",
6038 NoBinPacking);
Daniel Jasper66e9dee2013-02-14 09:19:04 +00006039}
6040
Daniel Jasper83a54d22013-01-10 09:26:47 +00006041TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
Alexander Kornienkoae6e53c2013-01-16 11:45:16 +00006042 verifyFormat("void f() { return; }\n42");
6043 verifyFormat("void f() {\n"
6044 " if (0)\n"
6045 " return;\n"
6046 "}\n"
6047 "42");
Alexander Kornienko1231e062013-01-16 11:43:46 +00006048 verifyFormat("void f() { return }\n42");
6049 verifyFormat("void f() {\n"
6050 " if (0)\n"
6051 " return\n"
6052 "}\n"
6053 "42");
6054}
6055
6056TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
6057 EXPECT_EQ("void f() { return }", format("void f ( ) { return }"));
6058 EXPECT_EQ("void f() {\n"
6059 " if (a)\n"
6060 " return\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006061 "}",
6062 format("void f ( ) { if ( a ) return }"));
Daniel Jasperabca58c2013-05-15 14:09:55 +00006063 EXPECT_EQ("namespace N {\n"
6064 "void f()\n"
6065 "}",
6066 format("namespace N { void f() }"));
Alexander Kornienko1231e062013-01-16 11:43:46 +00006067 EXPECT_EQ("namespace N {\n"
6068 "void f() {}\n"
6069 "void g()\n"
Krasimir Georgiev9163fe22017-03-02 09:54:44 +00006070 "} // namespace N",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006071 format("namespace N { void f( ) { } void g( ) }"));
Daniel Jasper83a54d22013-01-10 09:26:47 +00006072}
6073
Daniel Jasper2df93312013-01-09 10:16:05 +00006074TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
6075 verifyFormat("int aaaaaaaa =\n"
Alexander Kornienkoffd6d042013-03-27 11:52:18 +00006076 " // Overlylongcomment\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006077 " b;",
6078 getLLVMStyleWithColumns(20));
Daniel Jasper2df93312013-01-09 10:16:05 +00006079 verifyFormat("function(\n"
6080 " ShortArgument,\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006081 " LoooooooooooongArgument);\n",
6082 getLLVMStyleWithColumns(20));
Daniel Jasper2df93312013-01-09 10:16:05 +00006083}
6084
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00006085TEST_F(FormatTest, IncorrectAccessSpecifier) {
6086 verifyFormat("public:");
6087 verifyFormat("class A {\n"
6088 "public\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00006089 " void f() {}\n"
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00006090 "};");
6091 verifyFormat("public\n"
6092 "int qwerty;");
6093 verifyFormat("public\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00006094 "B {}");
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00006095 verifyFormat("public\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00006096 "{}");
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00006097 verifyFormat("public\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00006098 "B { int x; }");
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00006099}
Daniel Jasperf7935112012-12-03 18:12:45 +00006100
Daniel Jasper291f9362013-03-20 15:58:10 +00006101TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
6102 verifyFormat("{");
6103 verifyFormat("#})");
Daniel Jasperd97d5d52015-02-17 09:58:03 +00006104 verifyNoCrash("(/**/[:!] ?[).");
Daniel Jasper291f9362013-03-20 15:58:10 +00006105}
Alexander Kornienko0ea8e102012-12-04 15:40:36 +00006106
6107TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00006108 verifyFormat("do {\n}");
6109 verifyFormat("do {\n}\n"
Alexander Kornienko0ea8e102012-12-04 15:40:36 +00006110 "f();");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00006111 verifyFormat("do {\n}\n"
Alexander Kornienko0ea8e102012-12-04 15:40:36 +00006112 "wheeee(fun);");
6113 verifyFormat("do {\n"
6114 " f();\n"
Manuel Klimek28cacc72013-01-07 18:10:23 +00006115 "}");
Alexander Kornienko0ea8e102012-12-04 15:40:36 +00006116}
6117
Manuel Klimek9fa8d552013-01-11 19:23:05 +00006118TEST_F(FormatTest, IncorrectCodeMissingParens) {
Manuel Klimekadededf2013-01-11 18:28:36 +00006119 verifyFormat("if {\n foo;\n foo();\n}");
Manuel Klimek9fa8d552013-01-11 19:23:05 +00006120 verifyFormat("switch {\n foo;\n foo();\n}");
Manuel Klimekec5c3db2015-05-07 12:26:30 +00006121 verifyIncompleteFormat("for {\n foo;\n foo();\n}");
Manuel Klimek9fa8d552013-01-11 19:23:05 +00006122 verifyFormat("while {\n foo;\n foo();\n}");
6123 verifyFormat("do {\n foo;\n foo();\n} while;");
Manuel Klimekadededf2013-01-11 18:28:36 +00006124}
6125
Daniel Jasperc0880a92013-01-04 18:52:56 +00006126TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
Manuel Klimekec5c3db2015-05-07 12:26:30 +00006127 verifyIncompleteFormat("namespace {\n"
6128 "class Foo { Foo (\n"
6129 "};\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00006130 "} // namespace");
Daniel Jasperc0880a92013-01-04 18:52:56 +00006131}
6132
Alexander Kornienko870f9eb2012-12-04 17:27:50 +00006133TEST_F(FormatTest, IncorrectCodeErrorDetection) {
Daniel Jasperfbc057e2013-10-18 17:20:57 +00006134 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n"));
Manuel Klimeke7d10a12013-01-10 13:24:24 +00006135 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n"));
6136 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n"));
Daniel Jasperfbc057e2013-10-18 17:20:57 +00006137 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n"));
Alexander Kornienko870f9eb2012-12-04 17:27:50 +00006138
Alexander Kornienko870f9eb2012-12-04 17:27:50 +00006139 EXPECT_EQ("{\n"
Daniel Jasperfbc057e2013-10-18 17:20:57 +00006140 " {\n"
6141 " breakme(\n"
6142 " qwe);\n"
6143 " }\n",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006144 format("{\n"
6145 " {\n"
6146 " breakme(qwe);\n"
6147 "}\n",
6148 getLLVMStyleWithColumns(10)));
Alexander Kornienko870f9eb2012-12-04 17:27:50 +00006149}
6150
Manuel Klimek73a2fdf2013-01-10 14:36:46 +00006151TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006152 verifyFormat("int x = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006153 " avariable,\n"
6154 " b(alongervariable)};",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006155 getLLVMStyleWithColumns(25));
Manuel Klimek73a2fdf2013-01-10 14:36:46 +00006156}
6157
Manuel Klimek762dd182013-01-21 10:07:49 +00006158TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
Daniel Jasper4afc6b32014-06-02 10:57:55 +00006159 verifyFormat("return (a)(b){1, 2, 3};");
Manuel Klimek762dd182013-01-21 10:07:49 +00006160}
6161
Daniel Jasperae8e0d82014-04-17 11:32:02 +00006162TEST_F(FormatTest, LayoutCxx11BraceInitializers) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00006163 verifyFormat("vector<int> x{1, 2, 3, 4};");
Daniel Jaspera125d532014-03-21 12:38:57 +00006164 verifyFormat("vector<int> x{\n"
Francois Ferrandd2130f52017-06-30 20:00:02 +00006165 " 1,\n"
6166 " 2,\n"
6167 " 3,\n"
6168 " 4,\n"
Daniel Jaspera125d532014-03-21 12:38:57 +00006169 "};");
Chandler Carruthf8b72662014-03-02 12:37:31 +00006170 verifyFormat("vector<T> x{{}, {}, {}, {}};");
6171 verifyFormat("f({1, 2});");
6172 verifyFormat("auto v = Foo{-1};");
6173 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});");
6174 verifyFormat("Class::Class : member{1, 2, 3} {}");
6175 verifyFormat("new vector<int>{1, 2, 3};");
6176 verifyFormat("new int[3]{1, 2, 3};");
Daniel Jasper7a2d60e2014-05-07 07:59:03 +00006177 verifyFormat("new int{1};");
Chandler Carruthf8b72662014-03-02 12:37:31 +00006178 verifyFormat("return {arg1, arg2};");
6179 verifyFormat("return {arg1, SomeType{parameter}};");
6180 verifyFormat("int count = set<int>{f(), g(), h()}.size();");
6181 verifyFormat("new T{arg1, arg2};");
6182 verifyFormat("f(MyMap[{composite, key}]);");
6183 verifyFormat("class Class {\n"
6184 " T member = {arg1, arg2};\n"
6185 "};");
6186 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};");
Francois Ferrand5f07f442017-06-19 14:41:21 +00006187 verifyFormat("const struct A a = {.a = 1, .b = 2};");
6188 verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
Daniel Jasper91b032a2014-05-22 12:46:38 +00006189 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");");
6190 verifyFormat("int a = std::is_integral<int>{} + 0;");
Daniel Jaspere5777d22013-05-23 10:15:45 +00006191
Daniel Jasper438059e2014-05-22 12:11:13 +00006192 verifyFormat("int foo(int i) { return fo1{}(i); }");
6193 verifyFormat("int foo(int i) { return fo1{}(i); }");
Daniel Jasper4afc6b32014-06-02 10:57:55 +00006194 verifyFormat("auto i = decltype(x){};");
Daniel Jasper610381f2014-08-26 09:37:52 +00006195 verifyFormat("std::vector<int> v = {1, 0 /* comment */};");
Daniel Jasper168c8aa2014-08-27 11:53:26 +00006196 verifyFormat("Node n{1, Node{1000}, //\n"
6197 " 2};");
Daniel Jasperb812e322015-02-26 11:46:29 +00006198 verifyFormat("Aaaa aaaaaaa{\n"
6199 " {\n"
6200 " aaaa,\n"
6201 " },\n"
6202 "};");
Daniel Jaspercec9ffd2015-05-18 14:12:24 +00006203 verifyFormat("class C : public D {\n"
6204 " SomeClass SC{2};\n"
6205 "};");
Daniel Jasper3c883d12015-05-18 14:49:19 +00006206 verifyFormat("class C : public A {\n"
6207 " class D : public B {\n"
6208 " void f() { int i{2}; }\n"
6209 " };\n"
6210 "};");
Daniel Jasperb86e2722015-08-24 13:23:37 +00006211 verifyFormat("#define A {a, a},");
Daniel Jasper438059e2014-05-22 12:11:13 +00006212
Francois Ferrandd2130f52017-06-30 20:00:02 +00006213 // Binpacking only if there is no trailing comma
6214 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n"
6215 " cccccccccc, dddddddddd};",
6216 getLLVMStyleWithColumns(50));
6217 verifyFormat("const Aaaaaa aaaaa = {\n"
6218 " aaaaaaaaaaa,\n"
6219 " bbbbbbbbbbb,\n"
6220 " ccccccccccc,\n"
6221 " ddddddddddd,\n"
6222 "};", getLLVMStyleWithColumns(50));
6223
Daniel Jaspere4ada022016-12-13 10:05:03 +00006224 // Cases where distinguising braced lists and blocks is hard.
6225 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);");
6226 verifyFormat("void f() {\n"
6227 " return; // comment\n"
6228 "}\n"
6229 "SomeType t;");
6230 verifyFormat("void f() {\n"
6231 " if (a) {\n"
6232 " f();\n"
6233 " }\n"
6234 "}\n"
6235 "SomeType t;");
6236
Daniel Jasper08434342015-05-26 07:26:26 +00006237 // In combination with BinPackArguments = false.
Daniel Jasperae8e0d82014-04-17 11:32:02 +00006238 FormatStyle NoBinPacking = getLLVMStyle();
Daniel Jasper08434342015-05-26 07:26:26 +00006239 NoBinPacking.BinPackArguments = false;
Daniel Jasperae8e0d82014-04-17 11:32:02 +00006240 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n"
6241 " bbbbb,\n"
6242 " ccccc,\n"
6243 " ddddd,\n"
6244 " eeeee,\n"
6245 " ffffff,\n"
6246 " ggggg,\n"
6247 " hhhhhh,\n"
6248 " iiiiii,\n"
6249 " jjjjjj,\n"
6250 " kkkkkk};",
6251 NoBinPacking);
6252 verifyFormat("const Aaaaaa aaaaa = {\n"
6253 " aaaaa,\n"
6254 " bbbbb,\n"
6255 " ccccc,\n"
6256 " ddddd,\n"
6257 " eeeee,\n"
6258 " ffffff,\n"
6259 " ggggg,\n"
6260 " hhhhhh,\n"
6261 " iiiiii,\n"
6262 " jjjjjj,\n"
6263 " kkkkkk,\n"
6264 "};",
6265 NoBinPacking);
Daniel Jasper839922e2014-08-13 08:46:21 +00006266 verifyFormat(
6267 "const Aaaaaa aaaaa = {\n"
6268 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n"
6269 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n"
6270 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n"
6271 "};",
6272 NoBinPacking);
Daniel Jasperae8e0d82014-04-17 11:32:02 +00006273
Chandler Carruthf8b72662014-03-02 12:37:31 +00006274 // FIXME: The alignment of these trailing comments might be bad. Then again,
6275 // this might be utterly useless in real code.
6276 verifyFormat("Constructor::Constructor()\n"
Daniel Jasper64a328e2014-11-11 19:34:57 +00006277 " : some_value{ //\n"
6278 " aaaaaaa, //\n"
6279 " bbbbbbb} {}");
Daniel Jasper5a611392013-12-19 21:41:37 +00006280
Chandler Carruthf8b72662014-03-02 12:37:31 +00006281 // In braced lists, the first comment is always assumed to belong to the
6282 // first element. Thus, it can be moved to the next or previous line as
6283 // appropriate.
6284 EXPECT_EQ("function({// First element:\n"
6285 " 1,\n"
6286 " // Second element:\n"
6287 " 2});",
6288 format("function({\n"
6289 " // First element:\n"
6290 " 1,\n"
6291 " // Second element:\n"
6292 " 2});"));
6293 EXPECT_EQ("std::vector<int> MyNumbers{\n"
6294 " // First element:\n"
6295 " 1,\n"
6296 " // Second element:\n"
6297 " 2};",
6298 format("std::vector<int> MyNumbers{// First element:\n"
6299 " 1,\n"
6300 " // Second element:\n"
6301 " 2};",
6302 getLLVMStyleWithColumns(30)));
Francois Ferrandd2130f52017-06-30 20:00:02 +00006303 // A trailing comma should still lead to an enforced line break and no
6304 // binpacking.
Daniel Jasper64a328e2014-11-11 19:34:57 +00006305 EXPECT_EQ("vector<int> SomeVector = {\n"
6306 " // aaa\n"
Francois Ferrandd2130f52017-06-30 20:00:02 +00006307 " 1,\n"
6308 " 2,\n"
Daniel Jasper64a328e2014-11-11 19:34:57 +00006309 "};",
6310 format("vector<int> SomeVector = { // aaa\n"
6311 " 1, 2, };"));
Daniel Jasper5a611392013-12-19 21:41:37 +00006312
Chandler Carruthf8b72662014-03-02 12:37:31 +00006313 FormatStyle ExtraSpaces = getLLVMStyle();
6314 ExtraSpaces.Cpp11BracedListStyle = false;
6315 ExtraSpaces.ColumnLimit = 75;
6316 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces);
6317 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces);
6318 verifyFormat("f({ 1, 2 });", ExtraSpaces);
6319 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces);
6320 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces);
6321 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces);
6322 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces);
6323 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces);
6324 verifyFormat("return { arg1, arg2 };", ExtraSpaces);
6325 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces);
6326 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces);
6327 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces);
6328 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces);
6329 verifyFormat("class Class {\n"
6330 " T member = { arg1, arg2 };\n"
6331 "};",
6332 ExtraSpaces);
6333 verifyFormat(
6334 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6335 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
6336 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
6337 " bbbbbbbbbbbbbbbbbbbb, bbbbb };",
6338 ExtraSpaces);
6339 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces);
Daniel Jasper610381f2014-08-26 09:37:52 +00006340 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });",
Chandler Carruthf8b72662014-03-02 12:37:31 +00006341 ExtraSpaces);
6342 verifyFormat(
6343 "someFunction(OtherParam,\n"
6344 " BracedList{ // comment 1 (Forcing interesting break)\n"
6345 " param1, param2,\n"
6346 " // comment 2\n"
Daniel Jasper11a0ac62014-12-12 09:40:58 +00006347 " param3, param4 });",
Chandler Carruthf8b72662014-03-02 12:37:31 +00006348 ExtraSpaces);
6349 verifyFormat(
6350 "std::this_thread::sleep_for(\n"
6351 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);",
6352 ExtraSpaces);
Daniel Jasperff8d61362016-12-19 08:40:56 +00006353 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n"
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00006354 " aaaaaaa,\n"
6355 " aaaaaaaaaa,\n"
6356 " aaaaa,\n"
6357 " aaaaaaaaaaaaaaa,\n"
6358 " aaa,\n"
6359 " aaaaaaaaaa,\n"
6360 " a,\n"
6361 " aaaaaaaaaaaaaaaaaaaaa,\n"
6362 " aaaaaaaaaaaa,\n"
6363 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n"
6364 " aaaaaaa,\n"
6365 " a};");
Chandler Carruthf8b72662014-03-02 12:37:31 +00006366 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces);
Francois Ferrand5f07f442017-06-19 14:41:21 +00006367 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces);
6368 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces);
Manuel Klimekab419912013-05-23 09:41:43 +00006369}
6370
Daniel Jasper33b909c2013-10-25 14:29:37 +00006371TEST_F(FormatTest, FormatsBracedListsInColumnLayout) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00006372 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6373 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6374 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6375 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6376 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6377 " 1, 22, 333, 4444, 55555, 666666, 7777777};");
Daniel Jasper731dde92015-05-15 09:41:59 +00006378 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006379 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
Daniel Jasper731dde92015-05-15 09:41:59 +00006380 " 1, 22, 333, 4444, 55555, //\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006381 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6382 " 1, 22, 333, 4444, 55555, 666666, 7777777};");
Daniel Jasper8de9ed02013-08-22 15:00:41 +00006383 verifyFormat(
Chandler Carruthf8b72662014-03-02 12:37:31 +00006384 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6385 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6386 " 1, 22, 333, 4444, 55555, 666666, // comment\n"
6387 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
6388 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
6389 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
6390 " 7777777};");
Daniel Jasper8de9ed02013-08-22 15:00:41 +00006391 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006392 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
6393 " X86::R8, X86::R9, X86::R10, X86::R11, 0};");
Daniel Jasper731dde92015-05-15 09:41:59 +00006394 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
6395 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
6396 " // Separating comment.\n"
6397 " X86::R8, X86::R9, X86::R10, X86::R11, 0};");
6398 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
6399 " // Leading comment\n"
6400 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
6401 " X86::R8, X86::R9, X86::R10, X86::R11, 0};");
Chandler Carruthf8b72662014-03-02 12:37:31 +00006402 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
6403 " 1, 1, 1, 1};",
Daniel Jasper8de9ed02013-08-22 15:00:41 +00006404 getLLVMStyleWithColumns(39));
Chandler Carruthf8b72662014-03-02 12:37:31 +00006405 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
6406 " 1, 1, 1, 1};",
Daniel Jasper8de9ed02013-08-22 15:00:41 +00006407 getLLVMStyleWithColumns(38));
6408 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006409 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};",
6410 getLLVMStyleWithColumns(43));
Daniel Jaspere4c16c72015-05-08 13:51:14 +00006411 verifyFormat(
6412 "static unsigned SomeValues[10][3] = {\n"
6413 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n"
6414 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};");
6415 verifyFormat("static auto fields = new vector<string>{\n"
6416 " \"aaaaaaaaaaaaa\",\n"
6417 " \"aaaaaaaaaaaaa\",\n"
6418 " \"aaaaaaaaaaaa\",\n"
6419 " \"aaaaaaaaaaaaaa\",\n"
6420 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
6421 " \"aaaaaaaaaaaa\",\n"
6422 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
6423 "};");
Daniel Jasperd57843d2015-05-11 13:35:40 +00006424 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};");
6425 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n"
6426 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n"
6427 " 3, cccccccccccccccccccccc};",
6428 getLLVMStyleWithColumns(60));
Daniel Jasperf93551c2013-08-23 10:05:49 +00006429
6430 // Trailing commas.
Daniel Jaspera125d532014-03-21 12:38:57 +00006431 verifyFormat("vector<int> x = {\n"
6432 " 1, 1, 1, 1, 1, 1, 1, 1,\n"
6433 "};",
Daniel Jasperf93551c2013-08-23 10:05:49 +00006434 getLLVMStyleWithColumns(39));
Daniel Jasperb175d572014-04-09 09:53:23 +00006435 verifyFormat("vector<int> x = {\n"
6436 " 1, 1, 1, 1, 1, 1, 1, 1, //\n"
Daniel Jasperf93551c2013-08-23 10:05:49 +00006437 "};",
6438 getLLVMStyleWithColumns(39));
Daniel Jasper610381f2014-08-26 09:37:52 +00006439 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
6440 " 1, 1, 1, 1,\n"
6441 " /**/ /**/};",
Daniel Jasper8863ada2013-08-26 08:10:17 +00006442 getLLVMStyleWithColumns(39));
Daniel Jaspere4c16c72015-05-08 13:51:14 +00006443
Daniel Jasper60c27072015-05-13 08:16:00 +00006444 // Trailing comment in the first line.
6445 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n"
6446 " 1111111111, 2222222222, 33333333333, 4444444444, //\n"
6447 " 111111111, 222222222, 3333333333, 444444444, //\n"
6448 " 11111111, 22222222, 333333333, 44444444};");
Daniel Jasper00fb2a12015-07-15 16:26:47 +00006449 // Trailing comment in the last line.
6450 verifyFormat("int aaaaa[] = {\n"
6451 " 1, 2, 3, // comment\n"
6452 " 4, 5, 6 // comment\n"
6453 "};");
Daniel Jasper60c27072015-05-13 08:16:00 +00006454
Daniel Jaspere4c16c72015-05-08 13:51:14 +00006455 // With nested lists, we should either format one item per line or all nested
6456 // lists one on line.
6457 // FIXME: For some nested lists, we can do better.
Chandler Carruthf8b72662014-03-02 12:37:31 +00006458 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
6459 " {aaaaaaaaaaaaaaaaaaa},\n"
6460 " {aaaaaaaaaaaaaaaaaaaaa},\n"
6461 " {aaaaaaaaaaaaaaaaa}};",
Daniel Jaspercb3f0ed2013-08-27 08:43:47 +00006462 getLLVMStyleWithColumns(60));
Daniel Jasper63af7c42013-12-09 14:40:19 +00006463 verifyFormat(
6464 "SomeStruct my_struct_array = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006465 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n"
6466 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n"
6467 " {aaa, aaa},\n"
6468 " {aaa, aaa},\n"
6469 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n"
6470 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n"
6471 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};");
Daniel Jasper01603472014-01-09 13:42:56 +00006472
6473 // No column layout should be used here.
Francois Ferrandd2130f52017-06-30 20:00:02 +00006474 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006475 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};");
Daniel Jasper20e8c3b2015-01-19 10:51:42 +00006476
6477 verifyNoCrash("a<,");
Daniel Jasperabd1f572016-03-02 22:44:03 +00006478
Daniel Jaspereb65e912015-12-21 18:31:15 +00006479 // No braced initializer here.
6480 verifyFormat("void f() {\n"
6481 " struct Dummy {};\n"
6482 " f(v);\n"
6483 "}");
Daniel Jasper55582072016-01-04 07:30:44 +00006484
6485 // Long lists should be formatted in columns even if they are nested.
6486 verifyFormat(
6487 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6488 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6489 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6490 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6491 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6492 " 1, 22, 333, 4444, 55555, 666666, 7777777});");
Daniel Jaspere6169662016-12-19 07:26:11 +00006493
6494 // Allow "single-column" layout even if that violates the column limit. There
6495 // isn't going to be a better way.
6496 verifyFormat("std::vector<int> a = {\n"
6497 " aaaaaaaa,\n"
6498 " aaaaaaaa,\n"
6499 " aaaaaaaa,\n"
6500 " aaaaaaaa,\n"
6501 " aaaaaaaaaa,\n"
6502 " aaaaaaaa,\n"
6503 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};",
6504 getLLVMStyleWithColumns(30));
Daniel Jasper083d1702016-12-21 17:02:06 +00006505 verifyFormat("vector<int> aaaa = {\n"
6506 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6507 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6508 " aaaaaa.aaaaaaa,\n"
6509 " aaaaaa.aaaaaaa,\n"
6510 " aaaaaa.aaaaaaa,\n"
6511 " aaaaaa.aaaaaaa,\n"
6512 "};");
Daniel Jasperd1a9d8acd2017-01-12 19:35:26 +00006513
6514 // Don't create hanging lists.
Daniel Jasper21f7dea2017-02-01 09:23:39 +00006515 verifyFormat("someFunction(Param, {List1, List2,\n"
6516 " List3});",
6517 getLLVMStyleWithColumns(35));
6518 verifyFormat("someFunction(Param, Param,\n"
Daniel Jasperd1a9d8acd2017-01-12 19:35:26 +00006519 " {List1, List2,\n"
6520 " List3});",
6521 getLLVMStyleWithColumns(35));
Daniel Jaspere3710102017-01-12 20:06:28 +00006522 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n"
6523 " aaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper8de9ed02013-08-22 15:00:41 +00006524}
6525
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00006526TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00006527 FormatStyle DoNotMerge = getLLVMStyle();
Daniel Jasperd74cf402014-04-08 12:46:38 +00006528 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00006529
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00006530 verifyFormat("void f() { return 42; }");
6531 verifyFormat("void f() {\n"
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00006532 " return 42;\n"
6533 "}",
6534 DoNotMerge);
6535 verifyFormat("void f() {\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00006536 " // Comment\n"
6537 "}");
6538 verifyFormat("{\n"
6539 "#error {\n"
6540 " int a;\n"
6541 "}");
6542 verifyFormat("{\n"
6543 " int a;\n"
6544 "#error {\n"
6545 "}");
Daniel Jasperf9eb9b12013-05-16 10:17:39 +00006546 verifyFormat("void f() {} // comment");
6547 verifyFormat("void f() { int a; } // comment");
Daniel Jasper92716502013-05-16 16:54:34 +00006548 verifyFormat("void f() {\n"
6549 "} // comment",
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00006550 DoNotMerge);
6551 verifyFormat("void f() {\n"
6552 " int a;\n"
6553 "} // comment",
6554 DoNotMerge);
6555 verifyFormat("void f() {\n"
6556 "} // comment",
Daniel Jasper92716502013-05-16 16:54:34 +00006557 getLLVMStyleWithColumns(15));
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00006558
6559 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
6560 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22));
6561
6562 verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
6563 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
Alexander Kornienko06dd15a2013-12-04 13:58:27 +00006564 verifyFormat("class C {\n"
6565 " C()\n"
6566 " : iiiiiiii(nullptr),\n"
6567 " kkkkkkk(nullptr),\n"
6568 " mmmmmmm(nullptr),\n"
6569 " nnnnnnn(nullptr) {}\n"
6570 "};",
6571 getGoogleStyle());
Alexander Kornienko31e95542013-12-04 12:21:08 +00006572
6573 FormatStyle NoColumnLimit = getLLVMStyle();
6574 NoColumnLimit.ColumnLimit = 0;
6575 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));
6576 EXPECT_EQ("class C {\n"
6577 " A() : b(0) {}\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00006578 "};",
6579 format("class C{A():b(0){}};", NoColumnLimit));
Alexander Kornienko31e95542013-12-04 12:21:08 +00006580 EXPECT_EQ("A()\n"
6581 " : b(0) {\n"
6582 "}",
6583 format("A()\n:b(0)\n{\n}", NoColumnLimit));
6584
6585 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit;
Daniel Jasperd74cf402014-04-08 12:46:38 +00006586 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine =
6587 FormatStyle::SFS_None;
Alexander Kornienko31e95542013-12-04 12:21:08 +00006588 EXPECT_EQ("A()\n"
6589 " : b(0) {\n"
6590 "}",
6591 format("A():b(0){}", DoNotMergeNoColumnLimit));
6592 EXPECT_EQ("A()\n"
6593 " : b(0) {\n"
6594 "}",
6595 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit));
Daniel Jasper64989962014-02-07 13:45:27 +00006596
6597 verifyFormat("#define A \\\n"
6598 " void f() { \\\n"
6599 " int i; \\\n"
6600 " }",
6601 getLLVMStyleWithColumns(20));
6602 verifyFormat("#define A \\\n"
6603 " void f() { int i; }",
6604 getLLVMStyleWithColumns(21));
6605 verifyFormat("#define A \\\n"
6606 " void f() { \\\n"
6607 " int i; \\\n"
6608 " } \\\n"
6609 " int j;",
6610 getLLVMStyleWithColumns(22));
6611 verifyFormat("#define A \\\n"
6612 " void f() { int i; } \\\n"
6613 " int j;",
6614 getLLVMStyleWithColumns(23));
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00006615}
6616
Francois Ferrand2a81ca82017-06-13 07:02:43 +00006617TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) {
6618 FormatStyle MergeEmptyOnly = getLLVMStyle();
6619 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
6620 verifyFormat("class C {\n"
6621 " int f() {}\n"
6622 "};",
6623 MergeEmptyOnly);
6624 verifyFormat("class C {\n"
6625 " int f() {\n"
6626 " return 42;\n"
6627 " }\n"
6628 "};",
6629 MergeEmptyOnly);
6630 verifyFormat("int f() {}", MergeEmptyOnly);
6631 verifyFormat("int f() {\n"
6632 " return 42;\n"
6633 "}",
6634 MergeEmptyOnly);
6635
6636 // Also verify behavior when BraceWrapping.AfterFunction = true
6637 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
6638 MergeEmptyOnly.BraceWrapping.AfterFunction = true;
6639 verifyFormat("int f() {}", MergeEmptyOnly);
6640 verifyFormat("class C {\n"
6641 " int f() {}\n"
6642 "};",
6643 MergeEmptyOnly);
6644}
6645
Daniel Jasperd74cf402014-04-08 12:46:38 +00006646TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) {
6647 FormatStyle MergeInlineOnly = getLLVMStyle();
6648 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
6649 verifyFormat("class C {\n"
6650 " int f() { return 42; }\n"
6651 "};",
6652 MergeInlineOnly);
6653 verifyFormat("int f() {\n"
6654 " return 42;\n"
6655 "}",
6656 MergeInlineOnly);
Francois Ferrand2a81ca82017-06-13 07:02:43 +00006657
6658 // SFS_Inline implies SFS_Empty
6659 verifyFormat("class C {\n"
6660 " int f() {}\n"
6661 "};",
6662 MergeInlineOnly);
6663 verifyFormat("int f() {}", MergeInlineOnly);
6664
6665 // Also verify behavior when BraceWrapping.AfterFunction = true
6666 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
6667 MergeInlineOnly.BraceWrapping.AfterFunction = true;
6668 verifyFormat("class C {\n"
6669 " int f() { return 42; }\n"
6670 "};",
6671 MergeInlineOnly);
6672 verifyFormat("int f()\n"
6673 "{\n"
6674 " return 42;\n"
6675 "}",
6676 MergeInlineOnly);
6677
6678 // SFS_Inline implies SFS_Empty
6679 verifyFormat("int f() {}", MergeInlineOnly);
6680 verifyFormat("class C {\n"
6681 " int f() {}\n"
6682 "};",
6683 MergeInlineOnly);
6684}
6685
Francois Ferrandd3f0e3d2017-06-21 13:56:02 +00006686TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) {
6687 FormatStyle MergeInlineOnly = getLLVMStyle();
6688 MergeInlineOnly.AllowShortFunctionsOnASingleLine =
6689 FormatStyle::SFS_InlineOnly;
6690 verifyFormat("class C {\n"
6691 " int f() { return 42; }\n"
6692 "};",
6693 MergeInlineOnly);
6694 verifyFormat("int f() {\n"
6695 " return 42;\n"
6696 "}",
6697 MergeInlineOnly);
6698
6699 // SFS_InlineOnly does not imply SFS_Empty
6700 verifyFormat("class C {\n"
6701 " int f() {}\n"
6702 "};",
6703 MergeInlineOnly);
6704 verifyFormat("int f() {\n"
6705 "}",
6706 MergeInlineOnly);
6707
6708 // Also verify behavior when BraceWrapping.AfterFunction = true
6709 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
6710 MergeInlineOnly.BraceWrapping.AfterFunction = true;
6711 verifyFormat("class C {\n"
6712 " int f() { return 42; }\n"
6713 "};",
6714 MergeInlineOnly);
6715 verifyFormat("int f()\n"
6716 "{\n"
6717 " return 42;\n"
6718 "}",
6719 MergeInlineOnly);
6720
6721 // SFS_InlineOnly does not imply SFS_Empty
6722 verifyFormat("int f()\n"
6723 "{\n"
6724 "}",
6725 MergeInlineOnly);
6726 verifyFormat("class C {\n"
6727 " int f() {}\n"
6728 "};",
6729 MergeInlineOnly);
6730}
6731
Francois Ferrandad722562017-06-30 20:25:55 +00006732TEST_F(FormatTest, SplitEmptyFunction) {
Francois Ferrand2a81ca82017-06-13 07:02:43 +00006733 FormatStyle Style = getLLVMStyle();
6734 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
6735 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
6736 Style.BraceWrapping.AfterFunction = true;
Francois Ferrandad722562017-06-30 20:25:55 +00006737 Style.BraceWrapping.SplitEmptyFunction = false;
Francois Ferrand2a81ca82017-06-13 07:02:43 +00006738 Style.ColumnLimit = 40;
6739
6740 verifyFormat("int f()\n"
6741 "{}",
6742 Style);
6743 verifyFormat("int f()\n"
6744 "{\n"
6745 " return 42;\n"
6746 "}",
6747 Style);
6748 verifyFormat("int f()\n"
6749 "{\n"
6750 " // some comment\n"
6751 "}",
6752 Style);
6753
6754 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
6755 verifyFormat("int f() {}", Style);
6756 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
6757 "{}",
6758 Style);
6759 verifyFormat("int f()\n"
6760 "{\n"
6761 " return 0;\n"
6762 "}",
6763 Style);
6764
6765 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
6766 verifyFormat("class Foo {\n"
6767 " int f() {}\n"
6768 "};\n",
6769 Style);
6770 verifyFormat("class Foo {\n"
6771 " int f() { return 0; }\n"
6772 "};\n",
6773 Style);
6774 verifyFormat("class Foo {\n"
6775 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
6776 " {}\n"
6777 "};\n",
6778 Style);
6779 verifyFormat("class Foo {\n"
6780 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
6781 " {\n"
6782 " return 0;\n"
6783 " }\n"
6784 "};\n",
6785 Style);
6786
6787 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
6788 verifyFormat("int f() {}", Style);
6789 verifyFormat("int f() { return 0; }", Style);
6790 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
6791 "{}",
6792 Style);
6793 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
6794 "{\n"
6795 " return 0;\n"
6796 "}",
6797 Style);
Daniel Jasperd74cf402014-04-08 12:46:38 +00006798}
6799
Francois Ferrandad722562017-06-30 20:25:55 +00006800TEST_F(FormatTest, SplitEmptyClass) {
6801 FormatStyle Style = getLLVMStyle();
6802 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
6803 Style.BraceWrapping.AfterClass = true;
6804 Style.BraceWrapping.SplitEmptyRecord = false;
6805
6806 verifyFormat("class Foo\n"
6807 "{};",
6808 Style);
6809 verifyFormat("/* something */ class Foo\n"
6810 "{};",
6811 Style);
6812 verifyFormat("template <typename X> class Foo\n"
6813 "{};",
6814 Style);
6815 verifyFormat("class Foo\n"
6816 "{\n"
6817 " Foo();\n"
6818 "};",
6819 Style);
6820 verifyFormat("typedef class Foo\n"
6821 "{\n"
6822 "} Foo_t;",
6823 Style);
6824}
6825
6826TEST_F(FormatTest, SplitEmptyStruct) {
6827 FormatStyle Style = getLLVMStyle();
6828 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
6829 Style.BraceWrapping.AfterStruct = true;
6830 Style.BraceWrapping.SplitEmptyRecord = false;
6831
6832 verifyFormat("struct Foo\n"
6833 "{};",
6834 Style);
6835 verifyFormat("/* something */ struct Foo\n"
6836 "{};",
6837 Style);
6838 verifyFormat("template <typename X> struct Foo\n"
6839 "{};",
6840 Style);
6841 verifyFormat("struct Foo\n"
6842 "{\n"
6843 " Foo();\n"
6844 "};",
6845 Style);
6846 verifyFormat("typedef struct Foo\n"
6847 "{\n"
6848 "} Foo_t;",
6849 Style);
6850 //typedef struct Bar {} Bar_t;
6851}
6852
6853TEST_F(FormatTest, SplitEmptyUnion) {
6854 FormatStyle Style = getLLVMStyle();
6855 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
6856 Style.BraceWrapping.AfterUnion = true;
6857 Style.BraceWrapping.SplitEmptyRecord = false;
6858
6859 verifyFormat("union Foo\n"
6860 "{};",
6861 Style);
6862 verifyFormat("/* something */ union Foo\n"
6863 "{};",
6864 Style);
6865 verifyFormat("union Foo\n"
6866 "{\n"
6867 " A,\n"
6868 "};",
6869 Style);
6870 verifyFormat("typedef union Foo\n"
6871 "{\n"
6872 "} Foo_t;",
6873 Style);
6874}
6875
6876TEST_F(FormatTest, SplitEmptyNamespace) {
6877 FormatStyle Style = getLLVMStyle();
6878 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
6879 Style.BraceWrapping.AfterNamespace = true;
6880 Style.BraceWrapping.SplitEmptyNamespace = false;
6881
6882 verifyFormat("namespace Foo\n"
6883 "{};",
6884 Style);
6885 verifyFormat("/* something */ namespace Foo\n"
6886 "{};",
6887 Style);
6888 verifyFormat("inline namespace Foo\n"
6889 "{};",
6890 Style);
6891 verifyFormat("namespace Foo\n"
6892 "{\n"
6893 "void Bar();\n"
6894 "};",
6895 Style);
6896}
6897
6898TEST_F(FormatTest, NeverMergeShortRecords) {
6899 FormatStyle Style = getLLVMStyle();
6900
6901 verifyFormat("class Foo {\n"
6902 " Foo();\n"
6903 "};",
6904 Style);
6905 verifyFormat("typedef class Foo {\n"
6906 " Foo();\n"
6907 "} Foo_t;",
6908 Style);
6909 verifyFormat("struct Foo {\n"
6910 " Foo();\n"
6911 "};",
6912 Style);
6913 verifyFormat("typedef struct Foo {\n"
6914 " Foo();\n"
6915 "} Foo_t;",
6916 Style);
6917 verifyFormat("union Foo {\n"
6918 " A,\n"
6919 "};",
6920 Style);
6921 verifyFormat("typedef union Foo {\n"
6922 " A,\n"
6923 "} Foo_t;",
6924 Style);
6925 verifyFormat("namespace Foo {\n"
6926 "void Bar();\n"
6927 "};",
6928 Style);
6929
6930 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
6931 Style.BraceWrapping.AfterClass = true;
6932 Style.BraceWrapping.AfterStruct = true;
6933 Style.BraceWrapping.AfterUnion = true;
6934 Style.BraceWrapping.AfterNamespace = true;
6935 verifyFormat("class Foo\n"
6936 "{\n"
6937 " Foo();\n"
6938 "};",
6939 Style);
6940 verifyFormat("typedef class Foo\n"
6941 "{\n"
6942 " Foo();\n"
6943 "} Foo_t;",
6944 Style);
6945 verifyFormat("struct Foo\n"
6946 "{\n"
6947 " Foo();\n"
6948 "};",
6949 Style);
6950 verifyFormat("typedef struct Foo\n"
6951 "{\n"
6952 " Foo();\n"
6953 "} Foo_t;",
6954 Style);
6955 verifyFormat("union Foo\n"
6956 "{\n"
6957 " A,\n"
6958 "};",
6959 Style);
6960 verifyFormat("typedef union Foo\n"
6961 "{\n"
6962 " A,\n"
6963 "} Foo_t;",
6964 Style);
6965 verifyFormat("namespace Foo\n"
6966 "{\n"
6967 "void Bar();\n"
6968 "};",
6969 Style);
6970}
6971
Manuel Klimeke01bab52013-01-15 13:38:33 +00006972TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
6973 // Elaborate type variable declarations.
Chandler Carruthf8b72662014-03-02 12:37:31 +00006974 verifyFormat("struct foo a = {bar};\nint n;");
6975 verifyFormat("class foo a = {bar};\nint n;");
6976 verifyFormat("union foo a = {bar};\nint n;");
Manuel Klimeke01bab52013-01-15 13:38:33 +00006977
6978 // Elaborate types inside function definitions.
6979 verifyFormat("struct foo f() {}\nint n;");
6980 verifyFormat("class foo f() {}\nint n;");
6981 verifyFormat("union foo f() {}\nint n;");
6982
6983 // Templates.
6984 verifyFormat("template <class X> void f() {}\nint n;");
6985 verifyFormat("template <struct X> void f() {}\nint n;");
6986 verifyFormat("template <union X> void f() {}\nint n;");
6987
6988 // Actual definitions...
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00006989 verifyFormat("struct {\n} n;");
6990 verifyFormat(
6991 "template <template <class T, class Y>, class Z> class X {\n} n;");
Manuel Klimeke01bab52013-01-15 13:38:33 +00006992 verifyFormat("union Z {\n int n;\n} x;");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00006993 verifyFormat("class MACRO Z {\n} n;");
6994 verifyFormat("class MACRO(X) Z {\n} n;");
6995 verifyFormat("class __attribute__(X) Z {\n} n;");
6996 verifyFormat("class __declspec(X) Z {\n} n;");
Manuel Klimekd2650902013-02-06 15:57:54 +00006997 verifyFormat("class A##B##C {\n} n;");
Manuel Klimek91e48582013-10-07 09:15:41 +00006998 verifyFormat("class alignas(16) Z {\n} n;");
Daniel Jasper04785d02015-05-06 14:03:02 +00006999 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;");
7000 verifyFormat("class MACROA MACRO(X) Z {\n} n;");
Manuel Klimeke01bab52013-01-15 13:38:33 +00007001
Manuel Klimek3c6b7c72013-01-21 10:17:14 +00007002 // Redefinition from nested context:
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00007003 verifyFormat("class A::B::C {\n} n;");
Manuel Klimek3c6b7c72013-01-21 10:17:14 +00007004
Manuel Klimekcdee74d2013-01-21 13:58:54 +00007005 // Template definitions.
Daniel Jasper6f05e592013-05-15 13:46:48 +00007006 verifyFormat(
7007 "template <typename F>\n"
7008 "Matcher(const Matcher<F> &Other,\n"
7009 " typename enable_if_c<is_base_of<F, T>::value &&\n"
7010 " !is_same<F, T>::value>::type * = 0)\n"
7011 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
7012
Manuel Klimekcdee74d2013-01-21 13:58:54 +00007013 // FIXME: This is still incorrectly handled at the formatter side.
Daniel Jasper62c0ac02013-07-30 22:37:19 +00007014 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
Daniel Jasper6f2b88a2015-06-05 13:18:09 +00007015 verifyFormat("int i = SomeFunction(a<b, a> b);");
Manuel Klimekcdee74d2013-01-21 13:58:54 +00007016
7017 // FIXME:
7018 // This now gets parsed incorrectly as class definition.
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00007019 // verifyFormat("class A<int> f() {\n}\nint n;");
Manuel Klimekcdee74d2013-01-21 13:58:54 +00007020
Manuel Klimeke01bab52013-01-15 13:38:33 +00007021 // Elaborate types where incorrectly parsing the structural element would
7022 // break the indent.
7023 verifyFormat("if (true)\n"
7024 " class X x;\n"
7025 "else\n"
7026 " f();\n");
Daniel Jasper1a32a612013-03-20 15:12:38 +00007027
7028 // This is simply incomplete. Formatting is not important, but must not crash.
Daniel Jaspercdaffa42013-08-13 10:58:30 +00007029 verifyFormat("class A:");
Manuel Klimekd5e5f8f2013-01-11 18:13:04 +00007030}
7031
Manuel Klimek99c7baa2013-01-15 15:50:27 +00007032TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
Manuel Klimek71814b42013-10-11 21:25:45 +00007033 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n",
7034 format("#error Leave all white!!!!! space* alone!\n"));
7035 EXPECT_EQ(
7036 "#warning Leave all white!!!!! space* alone!\n",
7037 format("#warning Leave all white!!!!! space* alone!\n"));
Manuel Klimek99c7baa2013-01-15 15:50:27 +00007038 EXPECT_EQ("#error 1", format(" # error 1"));
7039 EXPECT_EQ("#warning 1", format(" # warning 1"));
7040}
7041
Daniel Jasper4431aa92013-04-23 13:54:04 +00007042TEST_F(FormatTest, FormatHashIfExpressions) {
Daniel Jasper7cfde412014-01-21 08:56:09 +00007043 verifyFormat("#if AAAA && BBBB");
Daniel Jasperd7884572015-08-14 12:44:06 +00007044 verifyFormat("#if (AAAA && BBBB)");
7045 verifyFormat("#elif (AAAA && BBBB)");
Daniel Jasper4431aa92013-04-23 13:54:04 +00007046 // FIXME: Come up with a better indentation for #elif.
7047 verifyFormat(
7048 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n"
7049 " defined(BBBBBBBB)\n"
7050 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n"
7051 " defined(BBBBBBBB)\n"
7052 "#endif",
7053 getLLVMStyleWithColumns(65));
7054}
7055
Manuel Klimekd3b92fa2013-01-18 14:04:34 +00007056TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
7057 FormatStyle AllowsMergedIf = getGoogleStyle();
7058 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true;
7059 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
7060 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
Manuel Klimekda087612013-01-18 14:46:43 +00007061 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf);
7062 EXPECT_EQ("if (true) return 42;",
7063 format("if (true)\nreturn 42;", AllowsMergedIf));
7064 FormatStyle ShortMergedIf = AllowsMergedIf;
7065 ShortMergedIf.ColumnLimit = 25;
Daniel Jasper6fe2f002013-04-25 08:56:26 +00007066 verifyFormat("#define A \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00007067 " if (true) return 42;",
7068 ShortMergedIf);
Daniel Jasper6fe2f002013-04-25 08:56:26 +00007069 verifyFormat("#define A \\\n"
7070 " f(); \\\n"
Manuel Klimekda087612013-01-18 14:46:43 +00007071 " if (true)\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00007072 "#define B",
7073 ShortMergedIf);
Daniel Jasper6fe2f002013-04-25 08:56:26 +00007074 verifyFormat("#define A \\\n"
7075 " f(); \\\n"
Manuel Klimekda087612013-01-18 14:46:43 +00007076 " if (true)\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00007077 "g();",
7078 ShortMergedIf);
Manuel Klimekd5e782b2013-01-21 14:16:56 +00007079 verifyFormat("{\n"
7080 "#ifdef A\n"
7081 " // Comment\n"
7082 " if (true) continue;\n"
7083 "#endif\n"
7084 " // Comment\n"
Manuel Klimek71814b42013-10-11 21:25:45 +00007085 " if (true) continue;\n"
7086 "}",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00007087 ShortMergedIf);
Daniel Jasper6a7d5a72017-06-19 07:40:49 +00007088 ShortMergedIf.ColumnLimit = 33;
7089 verifyFormat("#define A \\\n"
7090 " if constexpr (true) return 42;",
7091 ShortMergedIf);
Daniel Jasper64989962014-02-07 13:45:27 +00007092 ShortMergedIf.ColumnLimit = 29;
7093 verifyFormat("#define A \\\n"
7094 " if (aaaaaaaaaa) return 1; \\\n"
7095 " return 2;",
7096 ShortMergedIf);
7097 ShortMergedIf.ColumnLimit = 28;
7098 verifyFormat("#define A \\\n"
7099 " if (aaaaaaaaaa) \\\n"
7100 " return 1; \\\n"
7101 " return 2;",
7102 ShortMergedIf);
Daniel Jasper6a7d5a72017-06-19 07:40:49 +00007103 verifyFormat("#define A \\\n"
7104 " if constexpr (aaaaaaa) \\\n"
7105 " return 1; \\\n"
7106 " return 2;",
7107 ShortMergedIf);
Manuel Klimekd3b92fa2013-01-18 14:04:34 +00007108}
7109
Manuel Klimekd33516e2013-01-23 10:09:28 +00007110TEST_F(FormatTest, FormatStarDependingOnContext) {
Manuel Klimek0a3a3c92013-01-23 09:32:48 +00007111 verifyFormat("void f(int *a);");
7112 verifyFormat("void f() { f(fint * b); }");
Manuel Klimek39080572013-01-23 11:03:04 +00007113 verifyFormat("class A {\n void f(int *a);\n};");
7114 verifyFormat("class A {\n int *a;\n};");
7115 verifyFormat("namespace a {\n"
7116 "namespace b {\n"
7117 "class A {\n"
7118 " void f() {}\n"
7119 " int *a;\n"
7120 "};\n"
Krasimir Georgiev9163fe22017-03-02 09:54:44 +00007121 "} // namespace b\n"
7122 "} // namespace a");
Manuel Klimek0a3a3c92013-01-23 09:32:48 +00007123}
7124
Manuel Klimekd33516e2013-01-23 10:09:28 +00007125TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
7126 verifyFormat("while");
7127 verifyFormat("operator");
7128}
7129
Daniel Jasperfda47cd2016-10-31 13:23:00 +00007130TEST_F(FormatTest, SkipsDeeplyNestedLines) {
7131 // This code would be painfully slow to format if we didn't skip it.
7132 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
7133 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
7134 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
7135 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
7136 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
7137 "A(1, 1)\n"
7138 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x
7139 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7140 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7141 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7142 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7143 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7144 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7145 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7146 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7147 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n");
7148 // Deeply nested part is untouched, rest is formatted.
7149 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n",
7150 format(std::string("int i;\n") + Code + "int j;\n",
Krasimir Georgievbcda54b2017-04-21 14:35:20 +00007151 getLLVMStyle(), SC_ExpectIncomplete));
Daniel Jasperfda47cd2016-10-31 13:23:00 +00007152}
7153
Nico Weber7e6a7a12013-01-08 17:56:31 +00007154//===----------------------------------------------------------------------===//
7155// Objective-C tests.
7156//===----------------------------------------------------------------------===//
7157
Fariborz Jahanian68a542a2012-12-20 19:54:13 +00007158TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
7159 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
7160 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
7161 format("-(NSUInteger)indexOfObject:(id)anObject;"));
Daniel Jasper8d1832e2013-01-07 13:26:07 +00007162 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
Fariborz Jahanian68a542a2012-12-20 19:54:13 +00007163 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
7164 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
7165 format("-(NSInteger)Method3:(id)anObject;"));
7166 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
7167 format("-(NSInteger)Method4:(id)anObject;"));
7168 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
7169 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
7170 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
7171 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
Daniel Jaspera44991332015-04-29 13:06:49 +00007172 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "
7173 "forAllCells:(BOOL)flag;",
7174 format("- (void)sendAction:(SEL)aSelector to:(id)anObject "
7175 "forAllCells:(BOOL)flag;"));
Fariborz Jahanian9017ec32012-12-21 22:51:18 +00007176
7177 // Very long objectiveC method declaration.
Daniel Jasper55ca6082015-03-12 22:13:45 +00007178 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
7179 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;");
Daniel Jasper1ac3e052013-02-05 10:07:47 +00007180 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
7181 " inRange:(NSRange)range\n"
7182 " outRange:(NSRange)out_range\n"
7183 " outRange1:(NSRange)out_range1\n"
7184 " outRange2:(NSRange)out_range2\n"
7185 " outRange3:(NSRange)out_range3\n"
7186 " outRange4:(NSRange)out_range4\n"
7187 " outRange5:(NSRange)out_range5\n"
7188 " outRange6:(NSRange)out_range6\n"
7189 " outRange7:(NSRange)out_range7\n"
7190 " outRange8:(NSRange)out_range8\n"
7191 " outRange9:(NSRange)out_range9;");
Nico Weberd6f962f2013-01-10 20:18:33 +00007192
Daniel Jaspera2a4d9c2015-05-13 09:38:25 +00007193 // When the function name has to be wrapped.
7194 FormatStyle Style = getLLVMStyle();
7195 Style.IndentWrappedFunctionNames = false;
7196 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
7197 "veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
7198 " anotherName:(NSString)bbbbbbbbbbbbbb {\n"
7199 "}",
7200 Style);
7201 Style.IndentWrappedFunctionNames = true;
7202 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
7203 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
7204 " anotherName:(NSString)bbbbbbbbbbbbbb {\n"
7205 "}",
7206 Style);
7207
Nico Weberd6f962f2013-01-10 20:18:33 +00007208 verifyFormat("- (int)sum:(vector<int>)numbers;");
Nico Weber772fbfd2013-01-17 06:14:50 +00007209 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
Nico Weberd6f962f2013-01-10 20:18:33 +00007210 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
7211 // protocol lists (but not for template classes):
Daniel Jaspera44991332015-04-29 13:06:49 +00007212 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
Nico Weber9efe2912013-01-10 23:11:41 +00007213
Daniel Jasper37194282013-05-28 08:33:00 +00007214 verifyFormat("- (int (*)())foo:(int (*)())f;");
7215 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
Nico Weber9efe2912013-01-10 23:11:41 +00007216
7217 // If there's no return type (very rare in practice!), LLVM and Google style
7218 // agree.
Daniel Jasperdd9276e2013-03-22 16:55:40 +00007219 verifyFormat("- foo;");
Nico Weber9efe2912013-01-10 23:11:41 +00007220 verifyFormat("- foo:(int)f;");
7221 verifyGoogleFormat("- foo:(int)foo;");
Fariborz Jahanian68a542a2012-12-20 19:54:13 +00007222}
7223
Nico Weber0588b502013-02-07 00:19:29 +00007224
Alexander Kornienko64a42b82014-04-15 14:52:43 +00007225TEST_F(FormatTest, BreaksStringLiterals) {
Manuel Klimek1998ea22013-02-20 10:15:13 +00007226 EXPECT_EQ("\"some text \"\n"
7227 "\"other\";",
7228 format("\"some text other\";", getLLVMStyleWithColumns(12)));
Alexander Kornienko9e90b622013-04-17 17:34:05 +00007229 EXPECT_EQ("\"some text \"\n"
7230 "\"other\";",
7231 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
Manuel Klimek1998ea22013-02-20 10:15:13 +00007232 EXPECT_EQ(
7233 "#define A \\\n"
7234 " \"some \" \\\n"
7235 " \"text \" \\\n"
7236 " \"other\";",
7237 format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
7238 EXPECT_EQ(
7239 "#define A \\\n"
7240 " \"so \" \\\n"
7241 " \"text \" \\\n"
7242 " \"other\";",
7243 format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
7244
7245 EXPECT_EQ("\"some text\"",
7246 format("\"some text\"", getLLVMStyleWithColumns(1)));
7247 EXPECT_EQ("\"some text\"",
7248 format("\"some text\"", getLLVMStyleWithColumns(11)));
7249 EXPECT_EQ("\"some \"\n"
7250 "\"text\"",
7251 format("\"some text\"", getLLVMStyleWithColumns(10)));
7252 EXPECT_EQ("\"some \"\n"
7253 "\"text\"",
7254 format("\"some text\"", getLLVMStyleWithColumns(7)));
Manuel Klimekb176cff2013-03-01 13:14:08 +00007255 EXPECT_EQ("\"some\"\n"
Alexander Kornienkocb45bc12013-04-15 14:28:00 +00007256 "\" tex\"\n"
7257 "\"t\"",
Manuel Klimek1998ea22013-02-20 10:15:13 +00007258 format("\"some text\"", getLLVMStyleWithColumns(6)));
Manuel Klimekabf6e032013-03-04 20:03:38 +00007259 EXPECT_EQ("\"some\"\n"
7260 "\" tex\"\n"
7261 "\" and\"",
7262 format("\"some tex and\"", getLLVMStyleWithColumns(6)));
7263 EXPECT_EQ("\"some\"\n"
7264 "\"/tex\"\n"
7265 "\"/and\"",
7266 format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
Manuel Klimek1998ea22013-02-20 10:15:13 +00007267
7268 EXPECT_EQ("variable =\n"
7269 " \"long string \"\n"
7270 " \"literal\";",
7271 format("variable = \"long string literal\";",
7272 getLLVMStyleWithColumns(20)));
7273
7274 EXPECT_EQ("variable = f(\n"
7275 " \"long string \"\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00007276 " \"literal\",\n"
7277 " short,\n"
Manuel Klimek1998ea22013-02-20 10:15:13 +00007278 " loooooooooooooooooooong);",
7279 format("variable = f(\"long string literal\", short, "
7280 "loooooooooooooooooooong);",
7281 getLLVMStyleWithColumns(20)));
Alexander Kornienko4d26b6e2013-06-17 12:59:44 +00007282
Daniel Jaspera44991332015-04-29 13:06:49 +00007283 EXPECT_EQ(
7284 "f(g(\"long string \"\n"
7285 " \"literal\"),\n"
7286 " b);",
7287 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20)));
Alexander Kornienko4d26b6e2013-06-17 12:59:44 +00007288 EXPECT_EQ("f(g(\"long string \"\n"
7289 " \"literal\",\n"
7290 " a),\n"
7291 " b);",
7292 format("f(g(\"long string literal\", a), b);",
7293 getLLVMStyleWithColumns(20)));
Manuel Klimek1998ea22013-02-20 10:15:13 +00007294 EXPECT_EQ(
7295 "f(\"one two\".split(\n"
Daniel Jasperf79b0b12013-08-30 08:29:25 +00007296 " variable));",
Manuel Klimek1998ea22013-02-20 10:15:13 +00007297 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
7298 EXPECT_EQ("f(\"one two three four five six \"\n"
7299 " \"seven\".split(\n"
7300 " really_looooong_variable));",
7301 format("f(\"one two three four five six seven\"."
7302 "split(really_looooong_variable));",
7303 getLLVMStyleWithColumns(33)));
7304
7305 EXPECT_EQ("f(\"some \"\n"
7306 " \"text\",\n"
7307 " other);",
7308 format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
Daniel Jasper5497fce2013-02-26 12:52:34 +00007309
7310 // Only break as a last resort.
7311 verifyFormat(
7312 "aaaaaaaaaaaaaaaaaaaa(\n"
7313 " aaaaaaaaaaaaaaaaaaaa,\n"
7314 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
Manuel Klimekb176cff2013-03-01 13:14:08 +00007315
Daniel Jaspera44991332015-04-29 13:06:49 +00007316 EXPECT_EQ("\"splitmea\"\n"
7317 "\"trandomp\"\n"
7318 "\"oint\"",
7319 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
Manuel Klimeke317d1b2013-03-01 13:29:19 +00007320
Daniel Jaspera44991332015-04-29 13:06:49 +00007321 EXPECT_EQ("\"split/\"\n"
7322 "\"pathat/\"\n"
7323 "\"slashes\"",
7324 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
Daniel Jasper6fe2f002013-04-25 08:56:26 +00007325
Daniel Jaspera44991332015-04-29 13:06:49 +00007326 EXPECT_EQ("\"split/\"\n"
7327 "\"pathat/\"\n"
7328 "\"slashes\"",
7329 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
Alexander Kornienko72852072013-06-19 14:22:47 +00007330 EXPECT_EQ("\"split at \"\n"
7331 "\"spaces/at/\"\n"
7332 "\"slashes.at.any$\"\n"
7333 "\"non-alphanumeric%\"\n"
7334 "\"1111111111characte\"\n"
7335 "\"rs\"",
7336 format("\"split at "
7337 "spaces/at/"
7338 "slashes.at."
7339 "any$non-"
7340 "alphanumeric%"
7341 "1111111111characte"
7342 "rs\"",
7343 getLLVMStyleWithColumns(20)));
7344
Daniel Jasper5aad4e52013-07-12 11:37:05 +00007345 // Verify that splitting the strings understands
7346 // Style::AlwaysBreakBeforeMultilineStrings.
Daniel Jasper2aaedd32015-06-18 09:12:47 +00007347 EXPECT_EQ(
7348 "aaaaaaaaaaaa(\n"
7349 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
7350 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
7351 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
7352 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
7353 "aaaaaaaaaaaaaaaaaaaaaa\");",
7354 getGoogleStyle()));
Daniel Jasper2436fe92013-10-18 16:47:55 +00007355 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
7356 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",
7357 format("return \"aaaaaaaaaaaaaaaaaaaaaa "
7358 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
7359 "aaaaaaaaaaaaaaaaaaaaaa\";",
7360 getGoogleStyle()));
Daniel Jasper3dcd7ec2013-08-02 11:01:15 +00007361 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
7362 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
7363 format("llvm::outs() << "
7364 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
7365 "aaaaaaaaaaaaaaaaaaa\";"));
Daniel Jasperf438cb72013-08-23 11:57:34 +00007366 EXPECT_EQ("ffff(\n"
7367 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
7368 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
7369 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
7370 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
7371 getGoogleStyle()));
Daniel Jasper5aad4e52013-07-12 11:37:05 +00007372
Daniel Jaspere1a7b762016-02-01 11:21:02 +00007373 FormatStyle Style = getLLVMStyleWithColumns(12);
7374 Style.BreakStringLiterals = false;
7375 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style));
7376
Daniel Jasper6fe2f002013-04-25 08:56:26 +00007377 FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +00007378 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
Daniel Jaspera44991332015-04-29 13:06:49 +00007379 EXPECT_EQ("#define A \\\n"
7380 " \"some \" \\\n"
7381 " \"text \" \\\n"
7382 " \"other\";",
7383 format("#define A \"some text other\";", AlignLeft));
Manuel Klimek1998ea22013-02-20 10:15:13 +00007384}
7385
Manuel Klimek9e321992015-07-28 15:50:24 +00007386TEST_F(FormatTest, FullyRemoveEmptyLines) {
7387 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80);
7388 NoEmptyLines.MaxEmptyLinesToKeep = 0;
7389 EXPECT_EQ("int i = a(b());",
7390 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines));
7391}
7392
Alexander Kornienko64a42b82014-04-15 14:52:43 +00007393TEST_F(FormatTest, BreaksStringLiteralsWithTabs) {
7394 EXPECT_EQ(
7395 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
7396 "(\n"
7397 " \"x\t\");",
7398 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
7399 "aaaaaaa("
7400 "\"x\t\");"));
7401}
7402
Daniel Jasper174b0122014-01-09 14:18:12 +00007403TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {
Alexander Kornienko81e32942013-09-16 20:20:49 +00007404 EXPECT_EQ(
7405 "u8\"utf8 string \"\n"
7406 "u8\"literal\";",
7407 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
7408 EXPECT_EQ(
7409 "u\"utf16 string \"\n"
7410 "u\"literal\";",
7411 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
7412 EXPECT_EQ(
7413 "U\"utf32 string \"\n"
7414 "U\"literal\";",
7415 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
7416 EXPECT_EQ("L\"wide string \"\n"
7417 "L\"literal\";",
7418 format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
Daniel Jasper174b0122014-01-09 14:18:12 +00007419 EXPECT_EQ("@\"NSString \"\n"
7420 "@\"literal\";",
Daniel Jasperd07c2ee2014-01-14 09:53:07 +00007421 format("@\"NSString literal\";", getGoogleStyleWithColumns(19)));
Alexander Kornienkod4fa2e62017-04-11 09:55:00 +00007422 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26));
Daniel Jaspere4b48c62015-01-21 19:50:35 +00007423
7424 // This input makes clang-format try to split the incomplete unicode escape
7425 // sequence, which used to lead to a crasher.
7426 verifyNoCrash(
7427 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
7428 getLLVMStyleWithColumns(60));
Alexander Kornienko81e32942013-09-16 20:20:49 +00007429}
7430
Alexander Kornienko732b6bd2014-12-14 20:47:11 +00007431TEST_F(FormatTest, DoesNotBreakRawStringLiterals) {
7432 FormatStyle Style = getGoogleStyleWithColumns(15);
7433 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style));
7434 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style));
7435 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style));
7436 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style));
7437 EXPECT_EQ("u8R\"x(raw literal)x\";",
7438 format("u8R\"x(raw literal)x\";", Style));
Alexander Kornienko81e32942013-09-16 20:20:49 +00007439}
7440
7441TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
7442 FormatStyle Style = getLLVMStyleWithColumns(20);
7443 EXPECT_EQ(
7444 "_T(\"aaaaaaaaaaaaaa\")\n"
7445 "_T(\"aaaaaaaaaaaaaa\")\n"
7446 "_T(\"aaaaaaaaaaaa\")",
7447 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
Krasimir Georgievbc05eba2017-03-08 12:54:50 +00007448 EXPECT_EQ("f(x,\n"
7449 " _T(\"aaaaaaaaaaaa\")\n"
7450 " _T(\"aaa\"),\n"
Alexander Kornienko81e32942013-09-16 20:20:49 +00007451 " z);",
7452 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
7453
7454 // FIXME: Handle embedded spaces in one iteration.
7455 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
7456 // "_T(\"aaaaaaaaaaaaa\")\n"
7457 // "_T(\"aaaaaaaaaaaaa\")\n"
7458 // "_T(\"a\")",
7459 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
7460 // getLLVMStyleWithColumns(20)));
7461 EXPECT_EQ(
7462 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
7463 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
Daniel Jaspere99c72f2015-03-26 14:47:35 +00007464 EXPECT_EQ("f(\n"
7465 "#if !TEST\n"
7466 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
7467 "#endif\n"
Martin Probst2c1cdae2017-05-15 11:15:29 +00007468 ");",
Daniel Jaspere99c72f2015-03-26 14:47:35 +00007469 format("f(\n"
7470 "#if !TEST\n"
7471 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
7472 "#endif\n"
7473 ");"));
7474 EXPECT_EQ("f(\n"
7475 "\n"
7476 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));",
7477 format("f(\n"
7478 "\n"
7479 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));"));
Alexander Kornienko81e32942013-09-16 20:20:49 +00007480}
7481
Krasimir Georgievbc05eba2017-03-08 12:54:50 +00007482TEST_F(FormatTest, BreaksStringLiteralOperands) {
7483 // In a function call with two operands, the second can be broken with no line
7484 // break before it.
7485 EXPECT_EQ("func(a, \"long long \"\n"
7486 " \"long long\");",
7487 format("func(a, \"long long long long\");",
7488 getLLVMStyleWithColumns(24)));
7489 // In a function call with three operands, the second must be broken with a
7490 // line break before it.
7491 EXPECT_EQ("func(a,\n"
7492 " \"long long long \"\n"
7493 " \"long\",\n"
7494 " c);",
7495 format("func(a, \"long long long long\", c);",
7496 getLLVMStyleWithColumns(24)));
7497 // In a function call with three operands, the third must be broken with a
7498 // line break before it.
7499 EXPECT_EQ("func(a, b,\n"
7500 " \"long long long \"\n"
7501 " \"long\");",
7502 format("func(a, b, \"long long long long\");",
7503 getLLVMStyleWithColumns(24)));
7504 // In a function call with three operands, both the second and the third must
7505 // be broken with a line break before them.
7506 EXPECT_EQ("func(a,\n"
7507 " \"long long long \"\n"
7508 " \"long\",\n"
7509 " \"long long long \"\n"
7510 " \"long\");",
7511 format("func(a, \"long long long long\", \"long long long long\");",
7512 getLLVMStyleWithColumns(24)));
7513 // In a chain of << with two operands, the second can be broken with no line
7514 // break before it.
7515 EXPECT_EQ("a << \"line line \"\n"
7516 " \"line\";",
7517 format("a << \"line line line\";",
7518 getLLVMStyleWithColumns(20)));
7519 // In a chain of << with three operands, the second can be broken with no line
7520 // break before it.
7521 EXPECT_EQ("abcde << \"line \"\n"
7522 " \"line line\"\n"
7523 " << c;",
7524 format("abcde << \"line line line\" << c;",
7525 getLLVMStyleWithColumns(20)));
7526 // In a chain of << with three operands, the third must be broken with a line
7527 // break before it.
7528 EXPECT_EQ("a << b\n"
7529 " << \"line line \"\n"
7530 " \"line\";",
7531 format("a << b << \"line line line\";",
7532 getLLVMStyleWithColumns(20)));
7533 // In a chain of << with three operands, the second can be broken with no line
7534 // break before it and the third must be broken with a line break before it.
7535 EXPECT_EQ("abcd << \"line line \"\n"
7536 " \"line\"\n"
7537 " << \"line line \"\n"
7538 " \"line\";",
7539 format("abcd << \"line line line\" << \"line line line\";",
7540 getLLVMStyleWithColumns(20)));
7541 // In a chain of binary operators with two operands, the second can be broken
7542 // with no line break before it.
7543 EXPECT_EQ("abcd + \"line line \"\n"
7544 " \"line line\";",
7545 format("abcd + \"line line line line\";",
7546 getLLVMStyleWithColumns(20)));
7547 // In a chain of binary operators with three operands, the second must be
7548 // broken with a line break before it.
7549 EXPECT_EQ("abcd +\n"
7550 " \"line line \"\n"
7551 " \"line line\" +\n"
7552 " e;",
7553 format("abcd + \"line line line line\" + e;",
7554 getLLVMStyleWithColumns(20)));
7555 // In a function call with two operands, with AlignAfterOpenBracket enabled,
7556 // the first must be broken with a line break before it.
7557 FormatStyle Style = getLLVMStyleWithColumns(25);
7558 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7559 EXPECT_EQ("someFunction(\n"
7560 " \"long long long \"\n"
7561 " \"long\",\n"
7562 " a);",
7563 format("someFunction(\"long long long long\", a);", Style));
7564}
7565
Alexander Kornienko657c67b2013-07-16 21:06:13 +00007566TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
Alexander Kornienkod7b837e2013-08-29 17:32:57 +00007567 EXPECT_EQ(
7568 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
7569 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
7570 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
7571 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
7572 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
7573 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
7574}
7575
7576TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
7577 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
Daniel Jasperc39b56f2013-12-16 07:23:08 +00007578 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle()));
Alexander Kornienkod7b837e2013-08-29 17:32:57 +00007579 EXPECT_EQ("fffffffffff(g(R\"x(\n"
7580 "multiline raw string literal xxxxxxxxxxxxxx\n"
7581 ")x\",\n"
7582 " a),\n"
7583 " b);",
7584 format("fffffffffff(g(R\"x(\n"
7585 "multiline raw string literal xxxxxxxxxxxxxx\n"
7586 ")x\", a), b);",
7587 getGoogleStyleWithColumns(20)));
7588 EXPECT_EQ("fffffffffff(\n"
7589 " g(R\"x(qqq\n"
7590 "multiline raw string literal xxxxxxxxxxxxxx\n"
7591 ")x\",\n"
7592 " a),\n"
7593 " b);",
7594 format("fffffffffff(g(R\"x(qqq\n"
7595 "multiline raw string literal xxxxxxxxxxxxxx\n"
7596 ")x\", a), b);",
7597 getGoogleStyleWithColumns(20)));
7598
7599 EXPECT_EQ("fffffffffff(R\"x(\n"
7600 "multiline raw string literal xxxxxxxxxxxxxx\n"
7601 ")x\");",
7602 format("fffffffffff(R\"x(\n"
7603 "multiline raw string literal xxxxxxxxxxxxxx\n"
7604 ")x\");",
7605 getGoogleStyleWithColumns(20)));
7606 EXPECT_EQ("fffffffffff(R\"x(\n"
7607 "multiline raw string literal xxxxxxxxxxxxxx\n"
Daniel Jasper5d2587d2014-03-27 16:14:13 +00007608 ")x\" + bbbbbb);",
Alexander Kornienkod7b837e2013-08-29 17:32:57 +00007609 format("fffffffffff(R\"x(\n"
7610 "multiline raw string literal xxxxxxxxxxxxxx\n"
Daniel Jasper5d2587d2014-03-27 16:14:13 +00007611 ")x\" + bbbbbb);",
Alexander Kornienkod7b837e2013-08-29 17:32:57 +00007612 getGoogleStyleWithColumns(20)));
Daniel Jasperc39b56f2013-12-16 07:23:08 +00007613 EXPECT_EQ("fffffffffff(\n"
7614 " R\"x(\n"
7615 "multiline raw string literal xxxxxxxxxxxxxx\n"
7616 ")x\" +\n"
7617 " bbbbbb);",
7618 format("fffffffffff(\n"
7619 " R\"x(\n"
7620 "multiline raw string literal xxxxxxxxxxxxxx\n"
7621 ")x\" + bbbbbb);",
7622 getGoogleStyleWithColumns(20)));
Alexander Kornienko657c67b2013-07-16 21:06:13 +00007623}
7624
Alexander Kornienkobe633902013-06-14 11:46:10 +00007625TEST_F(FormatTest, SkipsUnknownStringLiterals) {
Daniel Jasper8369aa52013-07-16 20:28:33 +00007626 verifyFormat("string a = \"unterminated;");
7627 EXPECT_EQ("function(\"unterminated,\n"
7628 " OtherParameter);",
7629 format("function( \"unterminated,\n"
7630 " OtherParameter);"));
Alexander Kornienko1e808872013-06-28 12:51:24 +00007631}
7632
7633TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00007634 FormatStyle Style = getLLVMStyle();
7635 Style.Standard = FormatStyle::LS_Cpp03;
Alexander Kornienko1e808872013-06-28 12:51:24 +00007636 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
Chandler Carruthf8b72662014-03-02 12:37:31 +00007637 format("#define x(_a) printf(\"foo\"_a);", Style));
Alexander Kornienkobe633902013-06-14 11:46:10 +00007638}
7639
Daniel Jaspera44991332015-04-29 13:06:49 +00007640TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }
Daniel Jasper20fd3c62014-04-15 08:49:21 +00007641
Manuel Klimek5ecb5fd2013-05-14 09:04:24 +00007642TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
7643 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
7644 " \"ddeeefff\");",
7645 format("someFunction(\"aaabbbcccdddeeefff\");",
7646 getLLVMStyleWithColumns(25)));
7647 EXPECT_EQ("someFunction1234567890(\n"
7648 " \"aaabbbcccdddeeefff\");",
7649 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
7650 getLLVMStyleWithColumns(26)));
7651 EXPECT_EQ("someFunction1234567890(\n"
7652 " \"aaabbbcccdddeeeff\"\n"
7653 " \"f\");",
7654 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
7655 getLLVMStyleWithColumns(25)));
7656 EXPECT_EQ("someFunction1234567890(\n"
7657 " \"aaabbbcccdddeeeff\"\n"
7658 " \"f\");",
7659 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
7660 getLLVMStyleWithColumns(24)));
Daniel Jasper2739af32013-08-28 10:03:58 +00007661 EXPECT_EQ("someFunction(\"aaabbbcc \"\n"
7662 " \"ddde \"\n"
7663 " \"efff\");",
7664 format("someFunction(\"aaabbbcc ddde efff\");",
Manuel Klimek5ecb5fd2013-05-14 09:04:24 +00007665 getLLVMStyleWithColumns(25)));
7666 EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
7667 " \"ddeeefff\");",
7668 format("someFunction(\"aaabbbccc ddeeefff\");",
7669 getLLVMStyleWithColumns(25)));
7670 EXPECT_EQ("someFunction1234567890(\n"
7671 " \"aaabb \"\n"
7672 " \"cccdddeeefff\");",
7673 format("someFunction1234567890(\"aaabb cccdddeeefff\");",
7674 getLLVMStyleWithColumns(25)));
7675 EXPECT_EQ("#define A \\\n"
7676 " string s = \\\n"
7677 " \"123456789\" \\\n"
7678 " \"0\"; \\\n"
7679 " int i;",
7680 format("#define A string s = \"1234567890\"; int i;",
7681 getLLVMStyleWithColumns(20)));
Daniel Jasper2739af32013-08-28 10:03:58 +00007682 // FIXME: Put additional penalties on breaking at non-whitespace locations.
7683 EXPECT_EQ("someFunction(\"aaabbbcc \"\n"
7684 " \"dddeeeff\"\n"
7685 " \"f\");",
7686 format("someFunction(\"aaabbbcc dddeeefff\");",
7687 getLLVMStyleWithColumns(25)));
Manuel Klimek5ecb5fd2013-05-14 09:04:24 +00007688}
7689
Manuel Klimek5085d9b2013-03-08 18:59:48 +00007690TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
Daniel Jaspera44991332015-04-29 13:06:49 +00007691 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3)));
7692 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2)));
Manuel Klimek5085d9b2013-03-08 18:59:48 +00007693 EXPECT_EQ("\"test\"\n"
7694 "\"\\n\"",
7695 format("\"test\\n\"", getLLVMStyleWithColumns(7)));
7696 EXPECT_EQ("\"tes\\\\\"\n"
7697 "\"n\"",
7698 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
7699 EXPECT_EQ("\"\\\\\\\\\"\n"
7700 "\"\\n\"",
7701 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
Daniel Jaspera44991332015-04-29 13:06:49 +00007702 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
Manuel Klimek5085d9b2013-03-08 18:59:48 +00007703 EXPECT_EQ("\"\\uff01\"\n"
7704 "\"test\"",
7705 format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
7706 EXPECT_EQ("\"\\Uff01ff02\"",
7707 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
7708 EXPECT_EQ("\"\\x000000000001\"\n"
7709 "\"next\"",
7710 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
7711 EXPECT_EQ("\"\\x000000000001next\"",
7712 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
7713 EXPECT_EQ("\"\\x000000000001\"",
7714 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
7715 EXPECT_EQ("\"test\"\n"
7716 "\"\\000000\"\n"
7717 "\"000001\"",
7718 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
7719 EXPECT_EQ("\"test\\000\"\n"
Alexander Kornienkocb45bc12013-04-15 14:28:00 +00007720 "\"00000000\"\n"
7721 "\"1\"",
Manuel Klimek5085d9b2013-03-08 18:59:48 +00007722 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
Manuel Klimek5085d9b2013-03-08 18:59:48 +00007723}
7724
Manuel Klimeka3ff45e2013-04-10 09:52:05 +00007725TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
7726 verifyFormat("void f() {\n"
7727 " return g() {}\n"
7728 " void h() {}");
Daniel Jasper4afc6b32014-06-02 10:57:55 +00007729 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
Daniel Jasper1ec31062013-05-28 18:50:02 +00007730 "g();\n"
Manuel Klimeka3ff45e2013-04-10 09:52:05 +00007731 "}");
7732}
7733
Manuel Klimek421147e2014-01-24 09:25:23 +00007734TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) {
7735 verifyFormat(
Daniel Jasper39485162014-05-22 09:00:33 +00007736 "void f() { return C{param1, param2}.SomeCall(param1, param2); }");
Manuel Klimek421147e2014-01-24 09:25:23 +00007737}
7738
Manuel Klimek13b97d82013-05-13 08:42:42 +00007739TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
7740 verifyFormat("class X {\n"
7741 " void f() {\n"
7742 " }\n"
7743 "};",
7744 getLLVMStyleWithColumns(12));
7745}
7746
7747TEST_F(FormatTest, ConfigurableIndentWidth) {
7748 FormatStyle EightIndent = getLLVMStyleWithColumns(18);
7749 EightIndent.IndentWidth = 8;
Chandler Carruthf8b72662014-03-02 12:37:31 +00007750 EightIndent.ContinuationIndentWidth = 8;
Manuel Klimek13b97d82013-05-13 08:42:42 +00007751 verifyFormat("void f() {\n"
7752 " someFunction();\n"
7753 " if (true) {\n"
7754 " f();\n"
7755 " }\n"
7756 "}",
7757 EightIndent);
7758 verifyFormat("class X {\n"
7759 " void f() {\n"
7760 " }\n"
7761 "};",
7762 EightIndent);
7763 verifyFormat("int x[] = {\n"
7764 " call(),\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00007765 " call()};",
Manuel Klimek13b97d82013-05-13 08:42:42 +00007766 EightIndent);
7767}
7768
Alexander Kornienko34a87e82013-06-22 01:35:36 +00007769TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
Daniel Jaspere068ac72014-10-27 17:13:59 +00007770 verifyFormat("double\n"
Manuel Klimek836c2862013-06-21 17:25:42 +00007771 "f();",
7772 getLLVMStyleWithColumns(8));
7773}
7774
Manuel Klimekb9eae4c2013-05-13 09:22:11 +00007775TEST_F(FormatTest, ConfigurableUseOfTab) {
7776 FormatStyle Tab = getLLVMStyleWithColumns(42);
7777 Tab.IndentWidth = 8;
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00007778 Tab.UseTab = FormatStyle::UT_Always;
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +00007779 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left;
Alexander Kornienkodb4c21f2013-09-27 09:45:40 +00007780
7781 EXPECT_EQ("if (aaaaaaaa && // q\n"
7782 " bb)\t\t// w\n"
7783 "\t;",
7784 format("if (aaaaaaaa &&// q\n"
7785 "bb)// w\n"
7786 ";",
7787 Tab));
7788 EXPECT_EQ("if (aaa && bbb) // w\n"
7789 "\t;",
7790 format("if(aaa&&bbb)// w\n"
7791 ";",
7792 Tab));
7793
Manuel Klimekb9eae4c2013-05-13 09:22:11 +00007794 verifyFormat("class X {\n"
7795 "\tvoid f() {\n"
7796 "\t\tsomeFunction(parameter1,\n"
7797 "\t\t\t parameter2);\n"
7798 "\t}\n"
7799 "};",
7800 Tab);
7801 verifyFormat("#define A \\\n"
7802 "\tvoid f() { \\\n"
7803 "\t\tsomeFunction( \\\n"
7804 "\t\t parameter1, \\\n"
7805 "\t\t parameter2); \\\n"
7806 "\t}",
7807 Tab);
Manuel Klimek34d15152013-05-28 10:01:59 +00007808
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +00007809 Tab.TabWidth = 4;
7810 Tab.IndentWidth = 8;
7811 verifyFormat("class TabWidth4Indent8 {\n"
7812 "\t\tvoid f() {\n"
7813 "\t\t\t\tsomeFunction(parameter1,\n"
7814 "\t\t\t\t\t\t\t parameter2);\n"
7815 "\t\t}\n"
7816 "};",
7817 Tab);
7818
7819 Tab.TabWidth = 4;
7820 Tab.IndentWidth = 4;
7821 verifyFormat("class TabWidth4Indent4 {\n"
7822 "\tvoid f() {\n"
7823 "\t\tsomeFunction(parameter1,\n"
7824 "\t\t\t\t\t parameter2);\n"
7825 "\t}\n"
7826 "};",
7827 Tab);
7828
7829 Tab.TabWidth = 8;
7830 Tab.IndentWidth = 4;
7831 verifyFormat("class TabWidth8Indent4 {\n"
7832 " void f() {\n"
7833 "\tsomeFunction(parameter1,\n"
7834 "\t\t parameter2);\n"
7835 " }\n"
7836 "};",
7837 Tab);
7838
Alexander Kornienko39856b72013-09-10 09:38:25 +00007839 Tab.TabWidth = 8;
7840 Tab.IndentWidth = 8;
7841 EXPECT_EQ("/*\n"
7842 "\t a\t\tcomment\n"
7843 "\t in multiple lines\n"
7844 " */",
7845 format(" /*\t \t \n"
7846 " \t \t a\t\tcomment\t \t\n"
7847 " \t \t in multiple lines\t\n"
7848 " \t */",
7849 Tab));
Alexander Kornienkodb4c21f2013-09-27 09:45:40 +00007850
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00007851 Tab.UseTab = FormatStyle::UT_ForIndentation;
Chandler Carruthf8b72662014-03-02 12:37:31 +00007852 verifyFormat("{\n"
7853 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
7854 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
7855 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
7856 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
7857 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
7858 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
Alexander Kornienkoe2e03872013-10-14 00:46:35 +00007859 "};",
7860 Tab);
Daniel Jasper411af722016-01-05 16:10:39 +00007861 verifyFormat("enum AA {\n"
Daniel Jasper96972812014-01-05 12:38:10 +00007862 "\ta1, // Force multiple lines\n"
Alexander Kornienkoe2e03872013-10-14 00:46:35 +00007863 "\ta2,\n"
7864 "\ta3\n"
7865 "};",
7866 Tab);
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00007867 EXPECT_EQ("if (aaaaaaaa && // q\n"
7868 " bb) // w\n"
7869 "\t;",
7870 format("if (aaaaaaaa &&// q\n"
7871 "bb)// w\n"
7872 ";",
7873 Tab));
7874 verifyFormat("class X {\n"
7875 "\tvoid f() {\n"
7876 "\t\tsomeFunction(parameter1,\n"
7877 "\t\t parameter2);\n"
7878 "\t}\n"
7879 "};",
7880 Tab);
7881 verifyFormat("{\n"
Daniel Jasper100ffc62015-08-21 11:44:57 +00007882 "\tQ(\n"
7883 "\t {\n"
7884 "\t\t int a;\n"
7885 "\t\t someFunction(aaaaaaaa,\n"
7886 "\t\t bbbbbbb);\n"
7887 "\t },\n"
7888 "\t p);\n"
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00007889 "}",
7890 Tab);
7891 EXPECT_EQ("{\n"
7892 "\t/* aaaa\n"
7893 "\t bbbb */\n"
7894 "}",
7895 format("{\n"
7896 "/* aaaa\n"
7897 " bbbb */\n"
7898 "}",
7899 Tab));
7900 EXPECT_EQ("{\n"
7901 "\t/*\n"
7902 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7903 "\t bbbbbbbbbbbbb\n"
7904 "\t*/\n"
7905 "}",
7906 format("{\n"
7907 "/*\n"
7908 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
7909 "*/\n"
7910 "}",
7911 Tab));
7912 EXPECT_EQ("{\n"
7913 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7914 "\t// bbbbbbbbbbbbb\n"
7915 "}",
7916 format("{\n"
7917 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
7918 "}",
7919 Tab));
7920 EXPECT_EQ("{\n"
7921 "\t/*\n"
7922 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7923 "\t bbbbbbbbbbbbb\n"
7924 "\t*/\n"
7925 "}",
7926 format("{\n"
7927 "\t/*\n"
7928 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
7929 "\t*/\n"
7930 "}",
7931 Tab));
7932 EXPECT_EQ("{\n"
7933 "\t/*\n"
7934 "\n"
7935 "\t*/\n"
7936 "}",
7937 format("{\n"
7938 "\t/*\n"
7939 "\n"
7940 "\t*/\n"
Alexander Kornienko45dc1b22013-09-27 16:40:11 +00007941 "}",
7942 Tab));
7943 EXPECT_EQ("{\n"
7944 "\t/*\n"
7945 " asdf\n"
7946 "\t*/\n"
7947 "}",
7948 format("{\n"
7949 "\t/*\n"
7950 " asdf\n"
7951 "\t*/\n"
7952 "}",
7953 Tab));
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00007954
7955 Tab.UseTab = FormatStyle::UT_Never;
Alexander Kornienko39856b72013-09-10 09:38:25 +00007956 EXPECT_EQ("/*\n"
7957 " a\t\tcomment\n"
7958 " in multiple lines\n"
7959 " */",
7960 format(" /*\t \t \n"
7961 " \t \t a\t\tcomment\t \t\n"
7962 " \t \t in multiple lines\t\n"
7963 " \t */",
7964 Tab));
7965 EXPECT_EQ("/* some\n"
7966 " comment */",
Daniel Jaspera44991332015-04-29 13:06:49 +00007967 format(" \t \t /* some\n"
7968 " \t \t comment */",
7969 Tab));
Alexander Kornienko39856b72013-09-10 09:38:25 +00007970 EXPECT_EQ("int a; /* some\n"
7971 " comment */",
Daniel Jaspera44991332015-04-29 13:06:49 +00007972 format(" \t \t int a; /* some\n"
7973 " \t \t comment */",
7974 Tab));
Manuel Klimek34d15152013-05-28 10:01:59 +00007975
Alexander Kornienko39856b72013-09-10 09:38:25 +00007976 EXPECT_EQ("int a; /* some\n"
7977 "comment */",
Daniel Jaspera44991332015-04-29 13:06:49 +00007978 format(" \t \t int\ta; /* some\n"
7979 " \t \t comment */",
7980 Tab));
Alexander Kornienko39856b72013-09-10 09:38:25 +00007981 EXPECT_EQ("f(\"\t\t\"); /* some\n"
7982 " comment */",
Daniel Jaspera44991332015-04-29 13:06:49 +00007983 format(" \t \t f(\"\t\t\"); /* some\n"
7984 " \t \t comment */",
7985 Tab));
Manuel Klimek34d15152013-05-28 10:01:59 +00007986 EXPECT_EQ("{\n"
7987 " /*\n"
7988 " * Comment\n"
7989 " */\n"
7990 " int i;\n"
7991 "}",
7992 format("{\n"
7993 "\t/*\n"
7994 "\t * Comment\n"
7995 "\t */\n"
7996 "\t int i;\n"
7997 "}"));
Marianne Mailhot-Sarrasin51fe2792016-04-14 14:52:26 +00007998
7999 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
8000 Tab.TabWidth = 8;
8001 Tab.IndentWidth = 8;
8002 EXPECT_EQ("if (aaaaaaaa && // q\n"
8003 " bb) // w\n"
8004 "\t;",
8005 format("if (aaaaaaaa &&// q\n"
8006 "bb)// w\n"
8007 ";",
8008 Tab));
8009 EXPECT_EQ("if (aaa && bbb) // w\n"
8010 "\t;",
8011 format("if(aaa&&bbb)// w\n"
8012 ";",
8013 Tab));
8014 verifyFormat("class X {\n"
8015 "\tvoid f() {\n"
8016 "\t\tsomeFunction(parameter1,\n"
8017 "\t\t\t parameter2);\n"
8018 "\t}\n"
8019 "};",
8020 Tab);
8021 verifyFormat("#define A \\\n"
8022 "\tvoid f() { \\\n"
8023 "\t\tsomeFunction( \\\n"
8024 "\t\t parameter1, \\\n"
8025 "\t\t parameter2); \\\n"
8026 "\t}",
8027 Tab);
8028 Tab.TabWidth = 4;
8029 Tab.IndentWidth = 8;
8030 verifyFormat("class TabWidth4Indent8 {\n"
8031 "\t\tvoid f() {\n"
8032 "\t\t\t\tsomeFunction(parameter1,\n"
8033 "\t\t\t\t\t\t\t parameter2);\n"
8034 "\t\t}\n"
8035 "};",
8036 Tab);
8037 Tab.TabWidth = 4;
8038 Tab.IndentWidth = 4;
8039 verifyFormat("class TabWidth4Indent4 {\n"
8040 "\tvoid f() {\n"
8041 "\t\tsomeFunction(parameter1,\n"
8042 "\t\t\t\t\t parameter2);\n"
8043 "\t}\n"
8044 "};",
8045 Tab);
8046 Tab.TabWidth = 8;
8047 Tab.IndentWidth = 4;
8048 verifyFormat("class TabWidth8Indent4 {\n"
8049 " void f() {\n"
8050 "\tsomeFunction(parameter1,\n"
8051 "\t\t parameter2);\n"
8052 " }\n"
8053 "};",
8054 Tab);
8055 Tab.TabWidth = 8;
8056 Tab.IndentWidth = 8;
8057 EXPECT_EQ("/*\n"
8058 "\t a\t\tcomment\n"
8059 "\t in multiple lines\n"
8060 " */",
8061 format(" /*\t \t \n"
8062 " \t \t a\t\tcomment\t \t\n"
8063 " \t \t in multiple lines\t\n"
8064 " \t */",
8065 Tab));
8066 verifyFormat("{\n"
8067 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8068 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8069 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8070 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8071 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8072 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8073 "};",
8074 Tab);
8075 verifyFormat("enum AA {\n"
8076 "\ta1, // Force multiple lines\n"
8077 "\ta2,\n"
8078 "\ta3\n"
8079 "};",
8080 Tab);
8081 EXPECT_EQ("if (aaaaaaaa && // q\n"
8082 " bb) // w\n"
8083 "\t;",
8084 format("if (aaaaaaaa &&// q\n"
8085 "bb)// w\n"
8086 ";",
8087 Tab));
8088 verifyFormat("class X {\n"
8089 "\tvoid f() {\n"
8090 "\t\tsomeFunction(parameter1,\n"
8091 "\t\t\t parameter2);\n"
8092 "\t}\n"
8093 "};",
8094 Tab);
8095 verifyFormat("{\n"
8096 "\tQ(\n"
8097 "\t {\n"
8098 "\t\t int a;\n"
8099 "\t\t someFunction(aaaaaaaa,\n"
8100 "\t\t\t\t bbbbbbb);\n"
8101 "\t },\n"
8102 "\t p);\n"
8103 "}",
8104 Tab);
8105 EXPECT_EQ("{\n"
8106 "\t/* aaaa\n"
8107 "\t bbbb */\n"
8108 "}",
8109 format("{\n"
8110 "/* aaaa\n"
8111 " bbbb */\n"
8112 "}",
8113 Tab));
8114 EXPECT_EQ("{\n"
8115 "\t/*\n"
8116 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8117 "\t bbbbbbbbbbbbb\n"
8118 "\t*/\n"
8119 "}",
8120 format("{\n"
8121 "/*\n"
8122 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
8123 "*/\n"
8124 "}",
8125 Tab));
8126 EXPECT_EQ("{\n"
8127 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8128 "\t// bbbbbbbbbbbbb\n"
8129 "}",
8130 format("{\n"
8131 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
8132 "}",
8133 Tab));
8134 EXPECT_EQ("{\n"
8135 "\t/*\n"
8136 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8137 "\t bbbbbbbbbbbbb\n"
8138 "\t*/\n"
8139 "}",
8140 format("{\n"
8141 "\t/*\n"
8142 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
8143 "\t*/\n"
8144 "}",
8145 Tab));
8146 EXPECT_EQ("{\n"
8147 "\t/*\n"
8148 "\n"
8149 "\t*/\n"
8150 "}",
8151 format("{\n"
8152 "\t/*\n"
8153 "\n"
8154 "\t*/\n"
8155 "}",
8156 Tab));
8157 EXPECT_EQ("{\n"
8158 "\t/*\n"
8159 " asdf\n"
8160 "\t*/\n"
8161 "}",
8162 format("{\n"
8163 "\t/*\n"
8164 " asdf\n"
8165 "\t*/\n"
8166 "}",
8167 Tab));
8168 EXPECT_EQ("/*\n"
8169 "\t a\t\tcomment\n"
8170 "\t in multiple lines\n"
8171 " */",
8172 format(" /*\t \t \n"
8173 " \t \t a\t\tcomment\t \t\n"
8174 " \t \t in multiple lines\t\n"
8175 " \t */",
8176 Tab));
8177 EXPECT_EQ("/* some\n"
8178 " comment */",
8179 format(" \t \t /* some\n"
8180 " \t \t comment */",
8181 Tab));
8182 EXPECT_EQ("int a; /* some\n"
8183 " comment */",
8184 format(" \t \t int a; /* some\n"
8185 " \t \t comment */",
8186 Tab));
8187 EXPECT_EQ("int a; /* some\n"
8188 "comment */",
8189 format(" \t \t int\ta; /* some\n"
8190 " \t \t comment */",
8191 Tab));
8192 EXPECT_EQ("f(\"\t\t\"); /* some\n"
8193 " comment */",
8194 format(" \t \t f(\"\t\t\"); /* some\n"
8195 " \t \t comment */",
8196 Tab));
8197 EXPECT_EQ("{\n"
8198 " /*\n"
8199 " * Comment\n"
8200 " */\n"
8201 " int i;\n"
8202 "}",
8203 format("{\n"
8204 "\t/*\n"
8205 "\t * Comment\n"
8206 "\t */\n"
8207 "\t int i;\n"
8208 "}"));
8209 Tab.AlignConsecutiveAssignments = true;
8210 Tab.AlignConsecutiveDeclarations = true;
8211 Tab.TabWidth = 4;
8212 Tab.IndentWidth = 4;
8213 verifyFormat("class Assign {\n"
8214 "\tvoid f() {\n"
8215 "\t\tint x = 123;\n"
8216 "\t\tint random = 4;\n"
8217 "\t\tstd::string alphabet =\n"
8218 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
8219 "\t}\n"
8220 "};",
8221 Tab);
Manuel Klimekb9eae4c2013-05-13 09:22:11 +00008222}
8223
Alexander Kornienko917f9e02013-09-10 12:29:48 +00008224TEST_F(FormatTest, CalculatesOriginalColumn) {
8225 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8226 "q\"; /* some\n"
8227 " comment */",
8228 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8229 "q\"; /* some\n"
8230 " comment */",
8231 getLLVMStyle()));
8232 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
8233 "/* some\n"
8234 " comment */",
8235 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
8236 " /* some\n"
8237 " comment */",
8238 getLLVMStyle()));
8239 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8240 "qqq\n"
8241 "/* some\n"
8242 " comment */",
8243 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8244 "qqq\n"
8245 " /* some\n"
8246 " comment */",
8247 getLLVMStyle()));
8248 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8249 "wwww; /* some\n"
8250 " comment */",
8251 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8252 "wwww; /* some\n"
8253 " comment */",
8254 getLLVMStyle()));
8255}
8256
Alexander Kornienkofdca83d2013-12-10 10:18:34 +00008257TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
Daniel Jasperb55acad2013-08-20 12:36:34 +00008258 FormatStyle NoSpace = getLLVMStyle();
Alexander Kornienkofdca83d2013-12-10 10:18:34 +00008259 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never;
Daniel Jasperb55acad2013-08-20 12:36:34 +00008260
8261 verifyFormat("while(true)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008262 " continue;",
8263 NoSpace);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008264 verifyFormat("for(;;)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008265 " continue;",
8266 NoSpace);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008267 verifyFormat("if(true)\n"
8268 " f();\n"
8269 "else if(true)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008270 " f();",
8271 NoSpace);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008272 verifyFormat("do {\n"
8273 " do_something();\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008274 "} while(something());",
8275 NoSpace);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008276 verifyFormat("switch(x) {\n"
8277 "default:\n"
8278 " break;\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008279 "}",
8280 NoSpace);
Chad Rosier0a84f172014-08-05 17:58:54 +00008281 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace);
Daniel Jasper78b194992014-08-06 14:15:41 +00008282 verifyFormat("size_t x = sizeof(x);", NoSpace);
8283 verifyFormat("auto f(int x) -> decltype(x);", NoSpace);
8284 verifyFormat("int f(T x) noexcept(x.create());", NoSpace);
8285 verifyFormat("alignas(128) char a[128];", NoSpace);
8286 verifyFormat("size_t x = alignof(MyType);", NoSpace);
8287 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace);
8288 verifyFormat("int f() throw(Deprecated);", NoSpace);
Anders Waldenborgb09075a2015-05-19 16:54:26 +00008289 verifyFormat("typedef void (*cb)(int);", NoSpace);
Daniel Jaspera804d1e2015-08-11 20:32:24 +00008290 verifyFormat("T A::operator()();", NoSpace);
8291 verifyFormat("X A::operator++(T);", NoSpace);
Alexander Kornienkofdca83d2013-12-10 10:18:34 +00008292
8293 FormatStyle Space = getLLVMStyle();
8294 Space.SpaceBeforeParens = FormatStyle::SBPO_Always;
8295
8296 verifyFormat("int f ();", Space);
8297 verifyFormat("void f (int a, T b) {\n"
8298 " while (true)\n"
8299 " continue;\n"
8300 "}",
8301 Space);
8302 verifyFormat("if (true)\n"
8303 " f ();\n"
8304 "else if (true)\n"
8305 " f ();",
8306 Space);
8307 verifyFormat("do {\n"
8308 " do_something ();\n"
8309 "} while (something ());",
8310 Space);
8311 verifyFormat("switch (x) {\n"
8312 "default:\n"
8313 " break;\n"
8314 "}",
8315 Space);
8316 verifyFormat("A::A () : a (1) {}", Space);
8317 verifyFormat("void f () __attribute__ ((asdf));", Space);
8318 verifyFormat("*(&a + 1);\n"
8319 "&((&a)[1]);\n"
8320 "a[(b + c) * d];\n"
8321 "(((a + 1) * 2) + 3) * 4;",
8322 Space);
8323 verifyFormat("#define A(x) x", Space);
8324 verifyFormat("#define A (x) x", Space);
8325 verifyFormat("#if defined(x)\n"
8326 "#endif",
8327 Space);
Chad Rosier0a84f172014-08-05 17:58:54 +00008328 verifyFormat("auto i = std::make_unique<int> (5);", Space);
Daniel Jasper78b194992014-08-06 14:15:41 +00008329 verifyFormat("size_t x = sizeof (x);", Space);
8330 verifyFormat("auto f (int x) -> decltype (x);", Space);
8331 verifyFormat("int f (T x) noexcept (x.create ());", Space);
8332 verifyFormat("alignas (128) char a[128];", Space);
8333 verifyFormat("size_t x = alignof (MyType);", Space);
8334 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space);
8335 verifyFormat("int f () throw (Deprecated);", Space);
Anders Waldenborgb09075a2015-05-19 16:54:26 +00008336 verifyFormat("typedef void (*cb) (int);", Space);
Daniel Jaspera804d1e2015-08-11 20:32:24 +00008337 verifyFormat("T A::operator() ();", Space);
8338 verifyFormat("X A::operator++ (T);", Space);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008339}
8340
8341TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
8342 FormatStyle Spaces = getLLVMStyle();
8343
8344 Spaces.SpacesInParentheses = true;
8345 verifyFormat("call( x, y, z );", Spaces);
Daniel Jasper92e09822015-03-18 12:59:19 +00008346 verifyFormat("call();", Spaces);
8347 verifyFormat("std::function<void( int, int )> callback;", Spaces);
Daniel Jasper74331d42015-10-26 12:08:47 +00008348 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }",
8349 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008350 verifyFormat("while ( (bool)1 )\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008351 " continue;",
8352 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008353 verifyFormat("for ( ;; )\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008354 " continue;",
8355 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008356 verifyFormat("if ( true )\n"
8357 " f();\n"
8358 "else if ( true )\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008359 " f();",
8360 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008361 verifyFormat("do {\n"
8362 " do_something( (int)i );\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008363 "} while ( something() );",
8364 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008365 verifyFormat("switch ( x ) {\n"
8366 "default:\n"
8367 " break;\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008368 "}",
8369 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008370
8371 Spaces.SpacesInParentheses = false;
8372 Spaces.SpacesInCStyleCastParentheses = true;
8373 verifyFormat("Type *A = ( Type * )P;", Spaces);
8374 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
8375 verifyFormat("x = ( int32 )y;", Spaces);
8376 verifyFormat("int a = ( int )(2.0f);", Spaces);
8377 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
8378 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
8379 verifyFormat("#define x (( int )-1)", Spaces);
8380
Daniel Jasper92e09822015-03-18 12:59:19 +00008381 // Run the first set of tests again with:
Richard Trieucc3949d2016-02-18 22:34:54 +00008382 Spaces.SpacesInParentheses = false;
8383 Spaces.SpaceInEmptyParentheses = true;
Daniel Jasperb55acad2013-08-20 12:36:34 +00008384 Spaces.SpacesInCStyleCastParentheses = true;
8385 verifyFormat("call(x, y, z);", Spaces);
Daniel Jasper92e09822015-03-18 12:59:19 +00008386 verifyFormat("call( );", Spaces);
8387 verifyFormat("std::function<void(int, int)> callback;", Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008388 verifyFormat("while (( bool )1)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008389 " continue;",
8390 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008391 verifyFormat("for (;;)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008392 " continue;",
8393 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008394 verifyFormat("if (true)\n"
8395 " f( );\n"
8396 "else if (true)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008397 " f( );",
8398 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008399 verifyFormat("do {\n"
8400 " do_something(( int )i);\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008401 "} while (something( ));",
8402 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008403 verifyFormat("switch (x) {\n"
8404 "default:\n"
8405 " break;\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008406 "}",
8407 Spaces);
Daniel Jasperdb986eb2014-09-03 07:37:29 +00008408
Daniel Jasper92e09822015-03-18 12:59:19 +00008409 // Run the first set of tests again with:
Daniel Jasperdb986eb2014-09-03 07:37:29 +00008410 Spaces.SpaceAfterCStyleCast = true;
8411 verifyFormat("call(x, y, z);", Spaces);
Daniel Jasper92e09822015-03-18 12:59:19 +00008412 verifyFormat("call( );", Spaces);
8413 verifyFormat("std::function<void(int, int)> callback;", Spaces);
Daniel Jasperdb986eb2014-09-03 07:37:29 +00008414 verifyFormat("while (( bool ) 1)\n"
8415 " continue;",
8416 Spaces);
8417 verifyFormat("for (;;)\n"
8418 " continue;",
8419 Spaces);
8420 verifyFormat("if (true)\n"
8421 " f( );\n"
8422 "else if (true)\n"
8423 " f( );",
8424 Spaces);
8425 verifyFormat("do {\n"
8426 " do_something(( int ) i);\n"
8427 "} while (something( ));",
8428 Spaces);
8429 verifyFormat("switch (x) {\n"
8430 "default:\n"
8431 " break;\n"
8432 "}",
8433 Spaces);
Daniel Jasper92e09822015-03-18 12:59:19 +00008434
8435 // Run subset of tests again with:
Daniel Jasperdb986eb2014-09-03 07:37:29 +00008436 Spaces.SpacesInCStyleCastParentheses = false;
8437 Spaces.SpaceAfterCStyleCast = true;
8438 verifyFormat("while ((bool) 1)\n"
8439 " continue;",
8440 Spaces);
8441 verifyFormat("do {\n"
8442 " do_something((int) i);\n"
8443 "} while (something( ));",
8444 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008445}
8446
Daniel Jasperad981f82014-08-26 11:41:14 +00008447TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) {
8448 verifyFormat("int a[5];");
8449 verifyFormat("a[3] += 42;");
8450
8451 FormatStyle Spaces = getLLVMStyle();
8452 Spaces.SpacesInSquareBrackets = true;
8453 // Lambdas unchanged.
8454 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces);
8455 verifyFormat("return [i, args...] {};", Spaces);
8456
8457 // Not lambdas.
8458 verifyFormat("int a[ 5 ];", Spaces);
8459 verifyFormat("a[ 3 ] += 42;", Spaces);
8460 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces);
8461 verifyFormat("double &operator[](int i) { return 0; }\n"
8462 "int i;",
8463 Spaces);
8464 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces);
8465 verifyFormat("int i = a[ a ][ a ]->f();", Spaces);
8466 verifyFormat("int i = (*b)[ a ]->f();", Spaces);
8467}
8468
Daniel Jasperd94bff32013-09-25 15:15:02 +00008469TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
8470 verifyFormat("int a = 5;");
8471 verifyFormat("a += 42;");
8472 verifyFormat("a or_eq 8;");
8473
8474 FormatStyle Spaces = getLLVMStyle();
8475 Spaces.SpaceBeforeAssignmentOperators = false;
8476 verifyFormat("int a= 5;", Spaces);
8477 verifyFormat("a+= 42;", Spaces);
8478 verifyFormat("a or_eq 8;", Spaces);
8479}
8480
Daniel Jaspera44991332015-04-29 13:06:49 +00008481TEST_F(FormatTest, AlignConsecutiveAssignments) {
8482 FormatStyle Alignment = getLLVMStyle();
8483 Alignment.AlignConsecutiveAssignments = false;
8484 verifyFormat("int a = 5;\n"
8485 "int oneTwoThree = 123;",
8486 Alignment);
8487 verifyFormat("int a = 5;\n"
8488 "int oneTwoThree = 123;",
8489 Alignment);
8490
8491 Alignment.AlignConsecutiveAssignments = true;
8492 verifyFormat("int a = 5;\n"
8493 "int oneTwoThree = 123;",
8494 Alignment);
8495 verifyFormat("int a = method();\n"
8496 "int oneTwoThree = 133;",
8497 Alignment);
8498 verifyFormat("a &= 5;\n"
8499 "bcd *= 5;\n"
8500 "ghtyf += 5;\n"
8501 "dvfvdb -= 5;\n"
8502 "a /= 5;\n"
8503 "vdsvsv %= 5;\n"
8504 "sfdbddfbdfbb ^= 5;\n"
8505 "dvsdsv |= 5;\n"
8506 "int dsvvdvsdvvv = 123;",
8507 Alignment);
8508 verifyFormat("int i = 1, j = 10;\n"
8509 "something = 2000;",
8510 Alignment);
8511 verifyFormat("something = 2000;\n"
8512 "int i = 1, j = 10;\n",
8513 Alignment);
8514 verifyFormat("something = 2000;\n"
8515 "another = 911;\n"
8516 "int i = 1, j = 10;\n"
8517 "oneMore = 1;\n"
8518 "i = 2;",
8519 Alignment);
8520 verifyFormat("int a = 5;\n"
8521 "int one = 1;\n"
8522 "method();\n"
8523 "int oneTwoThree = 123;\n"
8524 "int oneTwo = 12;",
8525 Alignment);
Daniel Jasperbbfd20d2015-09-22 09:32:00 +00008526 verifyFormat("int oneTwoThree = 123;\n"
8527 "int oneTwo = 12;\n"
8528 "method();\n",
8529 Alignment);
Daniel Jaspera44991332015-04-29 13:06:49 +00008530 verifyFormat("int oneTwoThree = 123; // comment\n"
8531 "int oneTwo = 12; // comment",
8532 Alignment);
8533 EXPECT_EQ("int a = 5;\n"
8534 "\n"
8535 "int oneTwoThree = 123;",
8536 format("int a = 5;\n"
8537 "\n"
8538 "int oneTwoThree= 123;",
8539 Alignment));
8540 EXPECT_EQ("int a = 5;\n"
8541 "int one = 1;\n"
8542 "\n"
8543 "int oneTwoThree = 123;",
8544 format("int a = 5;\n"
8545 "int one = 1;\n"
8546 "\n"
8547 "int oneTwoThree = 123;",
8548 Alignment));
8549 EXPECT_EQ("int a = 5;\n"
8550 "int one = 1;\n"
8551 "\n"
8552 "int oneTwoThree = 123;\n"
8553 "int oneTwo = 12;",
8554 format("int a = 5;\n"
8555 "int one = 1;\n"
8556 "\n"
8557 "int oneTwoThree = 123;\n"
8558 "int oneTwo = 12;",
8559 Alignment));
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +00008560 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
8561 verifyFormat("#define A \\\n"
8562 " int aaaa = 12; \\\n"
8563 " int b = 23; \\\n"
8564 " int ccc = 234; \\\n"
8565 " int dddddddddd = 2345;",
8566 Alignment);
8567 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
Daniel Jaspera44991332015-04-29 13:06:49 +00008568 verifyFormat("#define A \\\n"
8569 " int aaaa = 12; \\\n"
8570 " int b = 23; \\\n"
8571 " int ccc = 234; \\\n"
8572 " int dddddddddd = 2345;",
8573 Alignment);
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +00008574 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
Daniel Jaspera44991332015-04-29 13:06:49 +00008575 verifyFormat("#define A "
8576 " \\\n"
8577 " int aaaa = 12; "
8578 " \\\n"
8579 " int b = 23; "
8580 " \\\n"
8581 " int ccc = 234; "
8582 " \\\n"
8583 " int dddddddddd = 2345;",
8584 Alignment);
8585 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
8586 "k = 4, int l = 5,\n"
8587 " int m = 6) {\n"
8588 " int j = 10;\n"
8589 " otherThing = 1;\n"
8590 "}",
8591 Alignment);
8592 verifyFormat("void SomeFunction(int parameter = 0) {\n"
8593 " int i = 1;\n"
8594 " int j = 2;\n"
8595 " int big = 10000;\n"
8596 "}",
8597 Alignment);
8598 verifyFormat("class C {\n"
8599 "public:\n"
Daniel Jasperec90e512015-12-01 12:00:43 +00008600 " int i = 1;\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008601 " virtual void f() = 0;\n"
8602 "};",
8603 Alignment);
8604 verifyFormat("int i = 1;\n"
8605 "if (SomeType t = getSomething()) {\n"
8606 "}\n"
8607 "int j = 2;\n"
8608 "int big = 10000;",
8609 Alignment);
8610 verifyFormat("int j = 7;\n"
8611 "for (int k = 0; k < N; ++k) {\n"
8612 "}\n"
8613 "int j = 2;\n"
8614 "int big = 10000;\n"
8615 "}",
8616 Alignment);
8617 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
8618 verifyFormat("int i = 1;\n"
8619 "LooooooooooongType loooooooooooooooooooooongVariable\n"
8620 " = someLooooooooooooooooongFunction();\n"
8621 "int j = 2;",
8622 Alignment);
8623 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
8624 verifyFormat("int i = 1;\n"
8625 "LooooooooooongType loooooooooooooooooooooongVariable =\n"
8626 " someLooooooooooooooooongFunction();\n"
8627 "int j = 2;",
8628 Alignment);
Daniel Jasper39828252015-10-07 15:03:26 +00008629
8630 verifyFormat("auto lambda = []() {\n"
8631 " auto i = 0;\n"
8632 " return 0;\n"
8633 "};\n"
8634 "int i = 0;\n"
8635 "auto v = type{\n"
8636 " i = 1, //\n"
8637 " (i = 2), //\n"
8638 " i = 3 //\n"
8639 "};",
8640 Alignment);
8641
Daniel Jaspera44991332015-04-29 13:06:49 +00008642 verifyFormat(
8643 "int i = 1;\n"
8644 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
8645 " loooooooooooooooooooooongParameterB);\n"
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00008646 "int j = 2;",
Daniel Jaspera44991332015-04-29 13:06:49 +00008647 Alignment);
Daniel Jasperec90e512015-12-01 12:00:43 +00008648
8649 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
8650 " typename B = very_long_type_name_1,\n"
8651 " typename T_2 = very_long_type_name_2>\n"
8652 "auto foo() {}\n",
8653 Alignment);
8654 verifyFormat("int a, b = 1;\n"
8655 "int c = 2;\n"
8656 "int dd = 3;\n",
8657 Alignment);
8658 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n"
8659 "float b[1][] = {{3.f}};\n",
8660 Alignment);
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00008661 verifyFormat("for (int i = 0; i < 1; i++)\n"
8662 " int x = 1;\n",
8663 Alignment);
8664 verifyFormat("for (i = 0; i < 1; i++)\n"
8665 " x = 1;\n"
8666 "y = 1;\n",
8667 Alignment);
Daniel Jaspera44991332015-04-29 13:06:49 +00008668}
8669
Daniel Jaspere12597c2015-10-01 10:06:54 +00008670TEST_F(FormatTest, AlignConsecutiveDeclarations) {
8671 FormatStyle Alignment = getLLVMStyle();
8672 Alignment.AlignConsecutiveDeclarations = false;
8673 verifyFormat("float const a = 5;\n"
8674 "int oneTwoThree = 123;",
8675 Alignment);
8676 verifyFormat("int a = 5;\n"
8677 "float const oneTwoThree = 123;",
8678 Alignment);
8679
8680 Alignment.AlignConsecutiveDeclarations = true;
8681 verifyFormat("float const a = 5;\n"
8682 "int oneTwoThree = 123;",
8683 Alignment);
8684 verifyFormat("int a = method();\n"
8685 "float const oneTwoThree = 133;",
8686 Alignment);
8687 verifyFormat("int i = 1, j = 10;\n"
8688 "something = 2000;",
8689 Alignment);
8690 verifyFormat("something = 2000;\n"
8691 "int i = 1, j = 10;\n",
8692 Alignment);
8693 verifyFormat("float something = 2000;\n"
8694 "double another = 911;\n"
8695 "int i = 1, j = 10;\n"
8696 "const int *oneMore = 1;\n"
8697 "unsigned i = 2;",
8698 Alignment);
8699 verifyFormat("float a = 5;\n"
8700 "int one = 1;\n"
8701 "method();\n"
8702 "const double oneTwoThree = 123;\n"
8703 "const unsigned int oneTwo = 12;",
8704 Alignment);
8705 verifyFormat("int oneTwoThree{0}; // comment\n"
8706 "unsigned oneTwo; // comment",
8707 Alignment);
8708 EXPECT_EQ("float const a = 5;\n"
8709 "\n"
8710 "int oneTwoThree = 123;",
8711 format("float const a = 5;\n"
8712 "\n"
8713 "int oneTwoThree= 123;",
8714 Alignment));
8715 EXPECT_EQ("float a = 5;\n"
8716 "int one = 1;\n"
8717 "\n"
8718 "unsigned oneTwoThree = 123;",
8719 format("float a = 5;\n"
8720 "int one = 1;\n"
8721 "\n"
8722 "unsigned oneTwoThree = 123;",
8723 Alignment));
8724 EXPECT_EQ("float a = 5;\n"
8725 "int one = 1;\n"
8726 "\n"
8727 "unsigned oneTwoThree = 123;\n"
8728 "int oneTwo = 12;",
8729 format("float a = 5;\n"
8730 "int one = 1;\n"
8731 "\n"
8732 "unsigned oneTwoThree = 123;\n"
8733 "int oneTwo = 12;",
8734 Alignment));
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00008735 // Function prototype alignment
8736 verifyFormat("int a();\n"
8737 "double b();",
8738 Alignment);
8739 verifyFormat("int a(int x);\n"
8740 "double b();",
8741 Alignment);
8742 unsigned OldColumnLimit = Alignment.ColumnLimit;
8743 // We need to set ColumnLimit to zero, in order to stress nested alignments,
8744 // otherwise the function parameters will be re-flowed onto a single line.
8745 Alignment.ColumnLimit = 0;
8746 EXPECT_EQ("int a(int x,\n"
8747 " float y);\n"
8748 "double b(int x,\n"
8749 " double y);",
8750 format("int a(int x,\n"
8751 " float y);\n"
8752 "double b(int x,\n"
8753 " double y);",
8754 Alignment));
8755 // This ensures that function parameters of function declarations are
8756 // correctly indented when their owning functions are indented.
8757 // The failure case here is for 'double y' to not be indented enough.
8758 EXPECT_EQ("double a(int x);\n"
8759 "int b(int y,\n"
8760 " double z);",
8761 format("double a(int x);\n"
8762 "int b(int y,\n"
8763 " double z);",
8764 Alignment));
8765 // Set ColumnLimit low so that we induce wrapping immediately after
8766 // the function name and opening paren.
8767 Alignment.ColumnLimit = 13;
8768 verifyFormat("int function(\n"
8769 " int x,\n"
8770 " bool y);",
8771 Alignment);
8772 Alignment.ColumnLimit = OldColumnLimit;
8773 // Ensure function pointers don't screw up recursive alignment
8774 verifyFormat("int a(int x, void (*fp)(int y));\n"
8775 "double b();",
8776 Alignment);
Daniel Jaspere12597c2015-10-01 10:06:54 +00008777 Alignment.AlignConsecutiveAssignments = true;
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00008778 // Ensure recursive alignment is broken by function braces, so that the
8779 // "a = 1" does not align with subsequent assignments inside the function
8780 // body.
8781 verifyFormat("int func(int a = 1) {\n"
8782 " int b = 2;\n"
8783 " int cc = 3;\n"
8784 "}",
8785 Alignment);
Daniel Jaspere12597c2015-10-01 10:06:54 +00008786 verifyFormat("float something = 2000;\n"
8787 "double another = 911;\n"
8788 "int i = 1, j = 10;\n"
8789 "const int *oneMore = 1;\n"
8790 "unsigned i = 2;",
8791 Alignment);
8792 verifyFormat("int oneTwoThree = {0}; // comment\n"
8793 "unsigned oneTwo = 0; // comment",
8794 Alignment);
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00008795 // Make sure that scope is correctly tracked, in the absence of braces
8796 verifyFormat("for (int i = 0; i < n; i++)\n"
8797 " j = i;\n"
8798 "double x = 1;\n",
8799 Alignment);
8800 verifyFormat("if (int i = 0)\n"
8801 " j = i;\n"
8802 "double x = 1;\n",
8803 Alignment);
8804 // Ensure operator[] and operator() are comprehended
8805 verifyFormat("struct test {\n"
8806 " long long int foo();\n"
8807 " int operator[](int a);\n"
8808 " double bar();\n"
8809 "};\n",
8810 Alignment);
8811 verifyFormat("struct test {\n"
8812 " long long int foo();\n"
8813 " int operator()(int a);\n"
8814 " double bar();\n"
8815 "};\n",
8816 Alignment);
Daniel Jaspere12597c2015-10-01 10:06:54 +00008817 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
8818 " int const i = 1;\n"
8819 " int * j = 2;\n"
8820 " int big = 10000;\n"
8821 "\n"
8822 " unsigned oneTwoThree = 123;\n"
8823 " int oneTwo = 12;\n"
8824 " method();\n"
8825 " float k = 2;\n"
8826 " int ll = 10000;\n"
8827 "}",
8828 format("void SomeFunction(int parameter= 0) {\n"
8829 " int const i= 1;\n"
8830 " int *j=2;\n"
8831 " int big = 10000;\n"
8832 "\n"
8833 "unsigned oneTwoThree =123;\n"
8834 "int oneTwo = 12;\n"
8835 " method();\n"
8836 "float k= 2;\n"
8837 "int ll=10000;\n"
8838 "}",
8839 Alignment));
8840 Alignment.AlignConsecutiveAssignments = false;
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +00008841 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
8842 verifyFormat("#define A \\\n"
8843 " int aaaa = 12; \\\n"
8844 " float b = 23; \\\n"
8845 " const int ccc = 234; \\\n"
8846 " unsigned dddddddddd = 2345;",
8847 Alignment);
8848 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
Daniel Jaspere12597c2015-10-01 10:06:54 +00008849 verifyFormat("#define A \\\n"
8850 " int aaaa = 12; \\\n"
8851 " float b = 23; \\\n"
8852 " const int ccc = 234; \\\n"
8853 " unsigned dddddddddd = 2345;",
8854 Alignment);
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +00008855 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
Daniel Jaspere12597c2015-10-01 10:06:54 +00008856 Alignment.ColumnLimit = 30;
8857 verifyFormat("#define A \\\n"
8858 " int aaaa = 12; \\\n"
8859 " float b = 23; \\\n"
8860 " const int ccc = 234; \\\n"
8861 " int dddddddddd = 2345;",
8862 Alignment);
8863 Alignment.ColumnLimit = 80;
8864 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
8865 "k = 4, int l = 5,\n"
8866 " int m = 6) {\n"
8867 " const int j = 10;\n"
8868 " otherThing = 1;\n"
8869 "}",
8870 Alignment);
8871 verifyFormat("void SomeFunction(int parameter = 0) {\n"
8872 " int const i = 1;\n"
8873 " int * j = 2;\n"
8874 " int big = 10000;\n"
8875 "}",
8876 Alignment);
8877 verifyFormat("class C {\n"
8878 "public:\n"
8879 " int i = 1;\n"
8880 " virtual void f() = 0;\n"
8881 "};",
8882 Alignment);
8883 verifyFormat("float i = 1;\n"
8884 "if (SomeType t = getSomething()) {\n"
8885 "}\n"
8886 "const unsigned j = 2;\n"
8887 "int big = 10000;",
8888 Alignment);
8889 verifyFormat("float j = 7;\n"
8890 "for (int k = 0; k < N; ++k) {\n"
8891 "}\n"
8892 "unsigned j = 2;\n"
8893 "int big = 10000;\n"
8894 "}",
8895 Alignment);
8896 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
8897 verifyFormat("float i = 1;\n"
8898 "LooooooooooongType loooooooooooooooooooooongVariable\n"
8899 " = someLooooooooooooooooongFunction();\n"
8900 "int j = 2;",
8901 Alignment);
8902 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
8903 verifyFormat("int i = 1;\n"
8904 "LooooooooooongType loooooooooooooooooooooongVariable =\n"
8905 " someLooooooooooooooooongFunction();\n"
8906 "int j = 2;",
8907 Alignment);
Daniel Jasper39828252015-10-07 15:03:26 +00008908
8909 Alignment.AlignConsecutiveAssignments = true;
8910 verifyFormat("auto lambda = []() {\n"
8911 " auto ii = 0;\n"
8912 " float j = 0;\n"
8913 " return 0;\n"
8914 "};\n"
8915 "int i = 0;\n"
8916 "float i2 = 0;\n"
8917 "auto v = type{\n"
8918 " i = 1, //\n"
8919 " (i = 2), //\n"
8920 " i = 3 //\n"
8921 "};",
8922 Alignment);
8923 Alignment.AlignConsecutiveAssignments = false;
8924
Daniel Jaspere12597c2015-10-01 10:06:54 +00008925 verifyFormat(
8926 "int i = 1;\n"
8927 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
8928 " loooooooooooooooooooooongParameterB);\n"
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00008929 "int j = 2;",
Daniel Jaspere12597c2015-10-01 10:06:54 +00008930 Alignment);
8931
8932 // Test interactions with ColumnLimit and AlignConsecutiveAssignments:
8933 // We expect declarations and assignments to align, as long as it doesn't
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00008934 // exceed the column limit, starting a new alignment sequence whenever it
Daniel Jaspere12597c2015-10-01 10:06:54 +00008935 // happens.
8936 Alignment.AlignConsecutiveAssignments = true;
8937 Alignment.ColumnLimit = 30;
8938 verifyFormat("float ii = 1;\n"
8939 "unsigned j = 2;\n"
8940 "int someVerylongVariable = 1;\n"
8941 "AnotherLongType ll = 123456;\n"
8942 "VeryVeryLongType k = 2;\n"
8943 "int myvar = 1;",
8944 Alignment);
8945 Alignment.ColumnLimit = 80;
Daniel Jasperec90e512015-12-01 12:00:43 +00008946 Alignment.AlignConsecutiveAssignments = false;
8947
8948 verifyFormat(
8949 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n"
8950 " typename LongType, typename B>\n"
8951 "auto foo() {}\n",
8952 Alignment);
8953 verifyFormat("float a, b = 1;\n"
8954 "int c = 2;\n"
8955 "int dd = 3;\n",
8956 Alignment);
8957 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n"
8958 "float b[1][] = {{3.f}};\n",
8959 Alignment);
8960 Alignment.AlignConsecutiveAssignments = true;
8961 verifyFormat("float a, b = 1;\n"
8962 "int c = 2;\n"
8963 "int dd = 3;\n",
8964 Alignment);
8965 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n"
8966 "float b[1][] = {{3.f}};\n",
8967 Alignment);
8968 Alignment.AlignConsecutiveAssignments = false;
8969
8970 Alignment.ColumnLimit = 30;
8971 Alignment.BinPackParameters = false;
8972 verifyFormat("void foo(float a,\n"
8973 " float b,\n"
8974 " int c,\n"
8975 " uint32_t *d) {\n"
8976 " int * e = 0;\n"
8977 " float f = 0;\n"
8978 " double g = 0;\n"
8979 "}\n"
8980 "void bar(ino_t a,\n"
8981 " int b,\n"
8982 " uint32_t *c,\n"
8983 " bool d) {}\n",
8984 Alignment);
8985 Alignment.BinPackParameters = true;
8986 Alignment.ColumnLimit = 80;
Daniel Jasper4917af62017-08-25 19:14:53 +00008987
8988 // Bug 33507
8989 Alignment.PointerAlignment = FormatStyle::PAS_Middle;
8990 verifyFormat(
8991 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n"
8992 " static const Version verVs2017;\n"
8993 " return true;\n"
8994 "});\n",
8995 Alignment);
8996 Alignment.PointerAlignment = FormatStyle::PAS_Right;
Daniel Jaspere12597c2015-10-01 10:06:54 +00008997}
8998
Manuel Klimeka8eb9142013-05-13 12:51:40 +00008999TEST_F(FormatTest, LinuxBraceBreaking) {
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009000 FormatStyle LinuxBraceStyle = getLLVMStyle();
9001 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009002 verifyFormat("namespace a\n"
9003 "{\n"
9004 "class A\n"
9005 "{\n"
9006 " void f()\n"
9007 " {\n"
9008 " if (true) {\n"
9009 " a();\n"
9010 " b();\n"
Daniel Jasper96cbb502015-12-14 08:33:07 +00009011 " } else {\n"
9012 " a();\n"
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009013 " }\n"
9014 " }\n"
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00009015 " void g() { return; }\n"
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009016 "};\n"
9017 "struct B {\n"
9018 " int x;\n"
9019 "};\n"
9020 "}\n",
9021 LinuxBraceStyle);
9022 verifyFormat("enum X {\n"
9023 " Y = 0,\n"
9024 "}\n",
9025 LinuxBraceStyle);
9026 verifyFormat("struct S {\n"
9027 " int Type;\n"
9028 " union {\n"
9029 " int x;\n"
9030 " double y;\n"
9031 " } Value;\n"
9032 " class C\n"
9033 " {\n"
9034 " MyFavoriteType Value;\n"
9035 " } Class;\n"
9036 "}\n",
9037 LinuxBraceStyle);
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009038}
9039
Birunthan Mohanathas305fa9c2015-07-12 03:13:54 +00009040TEST_F(FormatTest, MozillaBraceBreaking) {
9041 FormatStyle MozillaBraceStyle = getLLVMStyle();
9042 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00009043 MozillaBraceStyle.FixNamespaceComments = false;
Birunthan Mohanathas305fa9c2015-07-12 03:13:54 +00009044 verifyFormat("namespace a {\n"
9045 "class A\n"
9046 "{\n"
9047 " void f()\n"
9048 " {\n"
9049 " if (true) {\n"
9050 " a();\n"
9051 " b();\n"
9052 " }\n"
9053 " }\n"
9054 " void g() { return; }\n"
9055 "};\n"
9056 "enum E\n"
9057 "{\n"
9058 " A,\n"
9059 " // foo\n"
9060 " B,\n"
9061 " C\n"
9062 "};\n"
9063 "struct B\n"
9064 "{\n"
9065 " int x;\n"
9066 "};\n"
9067 "}\n",
9068 MozillaBraceStyle);
9069 verifyFormat("struct S\n"
9070 "{\n"
9071 " int Type;\n"
9072 " union\n"
9073 " {\n"
9074 " int x;\n"
9075 " double y;\n"
9076 " } Value;\n"
9077 " class C\n"
9078 " {\n"
9079 " MyFavoriteType Value;\n"
9080 " } Class;\n"
9081 "}\n",
9082 MozillaBraceStyle);
9083}
9084
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009085TEST_F(FormatTest, StroustrupBraceBreaking) {
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009086 FormatStyle StroustrupBraceStyle = getLLVMStyle();
9087 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009088 verifyFormat("namespace a {\n"
9089 "class A {\n"
9090 " void f()\n"
9091 " {\n"
9092 " if (true) {\n"
9093 " a();\n"
9094 " b();\n"
9095 " }\n"
9096 " }\n"
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00009097 " void g() { return; }\n"
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009098 "};\n"
9099 "struct B {\n"
9100 " int x;\n"
9101 "};\n"
Krasimir Georgiev9163fe22017-03-02 09:54:44 +00009102 "} // namespace a\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009103 StroustrupBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009104
Daniel Jasperd9670872014-08-05 12:06:20 +00009105 verifyFormat("void foo()\n"
9106 "{\n"
9107 " if (a) {\n"
9108 " a();\n"
9109 " }\n"
9110 " else {\n"
9111 " b();\n"
9112 " }\n"
9113 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009114 StroustrupBraceStyle);
Daniel Jasperd9670872014-08-05 12:06:20 +00009115
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009116 verifyFormat("#ifdef _DEBUG\n"
9117 "int foo(int i = 0)\n"
9118 "#else\n"
9119 "int foo(int i = 5)\n"
9120 "#endif\n"
9121 "{\n"
9122 " return i;\n"
9123 "}",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009124 StroustrupBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009125
9126 verifyFormat("void foo() {}\n"
9127 "void bar()\n"
9128 "#ifdef _DEBUG\n"
9129 "{\n"
9130 " foo();\n"
9131 "}\n"
9132 "#else\n"
9133 "{\n"
9134 "}\n"
9135 "#endif",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009136 StroustrupBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009137
9138 verifyFormat("void foobar() { int i = 5; }\n"
9139 "#ifdef _DEBUG\n"
9140 "void bar() {}\n"
9141 "#else\n"
9142 "void bar() { foobar(); }\n"
9143 "#endif",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009144 StroustrupBraceStyle);
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009145}
9146
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00009147TEST_F(FormatTest, AllmanBraceBreaking) {
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009148 FormatStyle AllmanBraceStyle = getLLVMStyle();
9149 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00009150 verifyFormat("namespace a\n"
9151 "{\n"
9152 "class A\n"
9153 "{\n"
9154 " void f()\n"
9155 " {\n"
9156 " if (true)\n"
9157 " {\n"
9158 " a();\n"
9159 " b();\n"
9160 " }\n"
9161 " }\n"
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00009162 " void g() { return; }\n"
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009163 "};\n"
9164 "struct B\n"
9165 "{\n"
9166 " int x;\n"
9167 "};\n"
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00009168 "}",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009169 AllmanBraceStyle);
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00009170
9171 verifyFormat("void f()\n"
9172 "{\n"
9173 " if (true)\n"
9174 " {\n"
9175 " a();\n"
9176 " }\n"
9177 " else if (false)\n"
9178 " {\n"
9179 " b();\n"
9180 " }\n"
9181 " else\n"
9182 " {\n"
9183 " c();\n"
9184 " }\n"
9185 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009186 AllmanBraceStyle);
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00009187
9188 verifyFormat("void f()\n"
9189 "{\n"
9190 " for (int i = 0; i < 10; ++i)\n"
9191 " {\n"
9192 " a();\n"
9193 " }\n"
9194 " while (false)\n"
9195 " {\n"
9196 " b();\n"
9197 " }\n"
9198 " do\n"
9199 " {\n"
9200 " c();\n"
9201 " } while (false)\n"
9202 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009203 AllmanBraceStyle);
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00009204
9205 verifyFormat("void f(int a)\n"
9206 "{\n"
9207 " switch (a)\n"
9208 " {\n"
9209 " case 0:\n"
9210 " break;\n"
9211 " case 1:\n"
9212 " {\n"
9213 " break;\n"
9214 " }\n"
9215 " case 2:\n"
9216 " {\n"
9217 " }\n"
9218 " break;\n"
9219 " default:\n"
9220 " break;\n"
9221 " }\n"
9222 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009223 AllmanBraceStyle);
Manuel Klimeka027f302013-08-07 19:20:45 +00009224
9225 verifyFormat("enum X\n"
9226 "{\n"
9227 " Y = 0,\n"
9228 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009229 AllmanBraceStyle);
Daniel Jaspere18ff372014-06-02 10:17:32 +00009230 verifyFormat("enum X\n"
9231 "{\n"
9232 " Y = 0\n"
9233 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009234 AllmanBraceStyle);
Manuel Klimeka027f302013-08-07 19:20:45 +00009235
Dinesh Dwivediea3aca82014-05-02 17:01:46 +00009236 verifyFormat("@interface BSApplicationController ()\n"
9237 "{\n"
9238 "@private\n"
9239 " id _extraIvar;\n"
9240 "}\n"
9241 "@end\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009242 AllmanBraceStyle);
Dinesh Dwivediea3aca82014-05-02 17:01:46 +00009243
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009244 verifyFormat("#ifdef _DEBUG\n"
9245 "int foo(int i = 0)\n"
9246 "#else\n"
9247 "int foo(int i = 5)\n"
9248 "#endif\n"
9249 "{\n"
9250 " return i;\n"
9251 "}",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009252 AllmanBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009253
9254 verifyFormat("void foo() {}\n"
9255 "void bar()\n"
9256 "#ifdef _DEBUG\n"
9257 "{\n"
9258 " foo();\n"
9259 "}\n"
9260 "#else\n"
9261 "{\n"
9262 "}\n"
9263 "#endif",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009264 AllmanBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009265
9266 verifyFormat("void foobar() { int i = 5; }\n"
9267 "#ifdef _DEBUG\n"
9268 "void bar() {}\n"
9269 "#else\n"
9270 "void bar() { foobar(); }\n"
9271 "#endif",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009272 AllmanBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009273
Daniel Jasperba1b6bb2014-05-26 07:24:34 +00009274 // This shouldn't affect ObjC blocks..
Daniel Jasper565ed5e2014-05-22 13:53:55 +00009275 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +00009276 " // ...\n"
9277 " int i;\n"
Daniel Jasperba1b6bb2014-05-26 07:24:34 +00009278 "}];",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009279 AllmanBraceStyle);
Daniel Jasper565ed5e2014-05-22 13:53:55 +00009280 verifyFormat("void (^block)(void) = ^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +00009281 " // ...\n"
9282 " int i;\n"
Daniel Jasperba1b6bb2014-05-26 07:24:34 +00009283 "};",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009284 AllmanBraceStyle);
Daniel Jasperba1b6bb2014-05-26 07:24:34 +00009285 // .. or dict literals.
9286 verifyFormat("void f()\n"
9287 "{\n"
Alexander Kornienkod4fa2e62017-04-11 09:55:00 +00009288 " // ...\n"
9289 " [object someMethod:@{@\"a\" : @\"b\"}];\n"
9290 "}",
9291 AllmanBraceStyle);
9292 verifyFormat("void f()\n"
9293 "{\n"
9294 " // ...\n"
9295 " [object someMethod:@{a : @\"b\"}];\n"
Daniel Jasperba1b6bb2014-05-26 07:24:34 +00009296 "}",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009297 AllmanBraceStyle);
Daniel Jasper55aed672014-12-07 16:44:49 +00009298 verifyFormat("int f()\n"
9299 "{ // comment\n"
9300 " return 42;\n"
9301 "}",
9302 AllmanBraceStyle);
Daniel Jasper565ed5e2014-05-22 13:53:55 +00009303
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009304 AllmanBraceStyle.ColumnLimit = 19;
9305 verifyFormat("void f() { int i; }", AllmanBraceStyle);
9306 AllmanBraceStyle.ColumnLimit = 18;
Daniel Jasper234379f2013-12-24 13:31:25 +00009307 verifyFormat("void f()\n"
9308 "{\n"
9309 " int i;\n"
9310 "}",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009311 AllmanBraceStyle);
9312 AllmanBraceStyle.ColumnLimit = 80;
Daniel Jasper234379f2013-12-24 13:31:25 +00009313
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009314 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle;
Manuel Klimeka027f302013-08-07 19:20:45 +00009315 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = true;
9316 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
9317 verifyFormat("void f(bool b)\n"
9318 "{\n"
9319 " if (b)\n"
9320 " {\n"
9321 " return;\n"
9322 " }\n"
9323 "}\n",
9324 BreakBeforeBraceShortIfs);
9325 verifyFormat("void f(bool b)\n"
9326 "{\n"
Daniel Jasper6a7d5a72017-06-19 07:40:49 +00009327 " if constexpr (b)\n"
9328 " {\n"
9329 " return;\n"
9330 " }\n"
9331 "}\n",
9332 BreakBeforeBraceShortIfs);
9333 verifyFormat("void f(bool b)\n"
9334 "{\n"
Manuel Klimeka027f302013-08-07 19:20:45 +00009335 " if (b) return;\n"
9336 "}\n",
9337 BreakBeforeBraceShortIfs);
9338 verifyFormat("void f(bool b)\n"
9339 "{\n"
Daniel Jasper6a7d5a72017-06-19 07:40:49 +00009340 " if constexpr (b) return;\n"
9341 "}\n",
9342 BreakBeforeBraceShortIfs);
9343 verifyFormat("void f(bool b)\n"
9344 "{\n"
Manuel Klimeka027f302013-08-07 19:20:45 +00009345 " while (b)\n"
9346 " {\n"
9347 " return;\n"
9348 " }\n"
9349 "}\n",
9350 BreakBeforeBraceShortIfs);
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00009351}
9352
Alexander Kornienko3a33f022013-12-12 09:49:52 +00009353TEST_F(FormatTest, GNUBraceBreaking) {
9354 FormatStyle GNUBraceStyle = getLLVMStyle();
9355 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU;
9356 verifyFormat("namespace a\n"
9357 "{\n"
9358 "class A\n"
9359 "{\n"
9360 " void f()\n"
9361 " {\n"
9362 " int a;\n"
9363 " {\n"
9364 " int b;\n"
9365 " }\n"
9366 " if (true)\n"
9367 " {\n"
9368 " a();\n"
9369 " b();\n"
9370 " }\n"
9371 " }\n"
9372 " void g() { return; }\n"
9373 "}\n"
9374 "}",
9375 GNUBraceStyle);
9376
9377 verifyFormat("void f()\n"
9378 "{\n"
9379 " if (true)\n"
9380 " {\n"
9381 " a();\n"
9382 " }\n"
9383 " else if (false)\n"
9384 " {\n"
9385 " b();\n"
9386 " }\n"
9387 " else\n"
9388 " {\n"
9389 " c();\n"
9390 " }\n"
9391 "}\n",
9392 GNUBraceStyle);
9393
9394 verifyFormat("void f()\n"
9395 "{\n"
9396 " for (int i = 0; i < 10; ++i)\n"
9397 " {\n"
9398 " a();\n"
9399 " }\n"
9400 " while (false)\n"
9401 " {\n"
9402 " b();\n"
9403 " }\n"
9404 " do\n"
9405 " {\n"
9406 " c();\n"
9407 " }\n"
9408 " while (false);\n"
9409 "}\n",
9410 GNUBraceStyle);
9411
9412 verifyFormat("void f(int a)\n"
9413 "{\n"
9414 " switch (a)\n"
9415 " {\n"
9416 " case 0:\n"
9417 " break;\n"
9418 " case 1:\n"
9419 " {\n"
9420 " break;\n"
9421 " }\n"
9422 " case 2:\n"
9423 " {\n"
9424 " }\n"
9425 " break;\n"
9426 " default:\n"
9427 " break;\n"
9428 " }\n"
9429 "}\n",
9430 GNUBraceStyle);
9431
9432 verifyFormat("enum X\n"
9433 "{\n"
9434 " Y = 0,\n"
9435 "}\n",
9436 GNUBraceStyle);
Dinesh Dwivediea3aca82014-05-02 17:01:46 +00009437
9438 verifyFormat("@interface BSApplicationController ()\n"
9439 "{\n"
9440 "@private\n"
9441 " id _extraIvar;\n"
9442 "}\n"
9443 "@end\n",
9444 GNUBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009445
9446 verifyFormat("#ifdef _DEBUG\n"
9447 "int foo(int i = 0)\n"
9448 "#else\n"
9449 "int foo(int i = 5)\n"
9450 "#endif\n"
9451 "{\n"
9452 " return i;\n"
9453 "}",
9454 GNUBraceStyle);
9455
9456 verifyFormat("void foo() {}\n"
9457 "void bar()\n"
9458 "#ifdef _DEBUG\n"
9459 "{\n"
9460 " foo();\n"
9461 "}\n"
9462 "#else\n"
9463 "{\n"
9464 "}\n"
9465 "#endif",
9466 GNUBraceStyle);
9467
9468 verifyFormat("void foobar() { int i = 5; }\n"
9469 "#ifdef _DEBUG\n"
9470 "void bar() {}\n"
9471 "#else\n"
9472 "void bar() { foobar(); }\n"
9473 "#endif",
9474 GNUBraceStyle);
Alexander Kornienko3a33f022013-12-12 09:49:52 +00009475}
Roman Kashitsyn291f64f2015-08-10 13:43:19 +00009476
9477TEST_F(FormatTest, WebKitBraceBreaking) {
9478 FormatStyle WebKitBraceStyle = getLLVMStyle();
9479 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit;
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00009480 WebKitBraceStyle.FixNamespaceComments = false;
Roman Kashitsyn291f64f2015-08-10 13:43:19 +00009481 verifyFormat("namespace a {\n"
9482 "class A {\n"
9483 " void f()\n"
9484 " {\n"
9485 " if (true) {\n"
9486 " a();\n"
9487 " b();\n"
9488 " }\n"
9489 " }\n"
9490 " void g() { return; }\n"
9491 "};\n"
9492 "enum E {\n"
9493 " A,\n"
9494 " // foo\n"
9495 " B,\n"
9496 " C\n"
9497 "};\n"
9498 "struct B {\n"
9499 " int x;\n"
9500 "};\n"
9501 "}\n",
9502 WebKitBraceStyle);
9503 verifyFormat("struct S {\n"
9504 " int Type;\n"
9505 " union {\n"
9506 " int x;\n"
9507 " double y;\n"
9508 " } Value;\n"
9509 " class C {\n"
9510 " MyFavoriteType Value;\n"
9511 " } Class;\n"
9512 "};\n",
9513 WebKitBraceStyle);
9514}
9515
Manuel Klimekd5735502013-08-12 03:51:17 +00009516TEST_F(FormatTest, CatchExceptionReferenceBinding) {
9517 verifyFormat("void f() {\n"
9518 " try {\n"
Daniel Jasper04a71a42014-05-08 11:58:24 +00009519 " } catch (const Exception &e) {\n"
Manuel Klimekd5735502013-08-12 03:51:17 +00009520 " }\n"
9521 "}\n",
9522 getLLVMStyle());
9523}
9524
Daniel Jasper9613c812013-08-07 16:29:23 +00009525TEST_F(FormatTest, UnderstandsPragmas) {
9526 verifyFormat("#pragma omp reduction(| : var)");
9527 verifyFormat("#pragma omp reduction(+ : var)");
Daniel Jasperdc32c1b2014-01-09 13:56:49 +00009528
9529 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
9530 "(including parentheses).",
9531 format("#pragma mark Any non-hyphenated or hyphenated string "
9532 "(including parentheses)."));
Daniel Jasper9613c812013-08-07 16:29:23 +00009533}
9534
Daniel Jasperee4a8a12015-04-22 09:45:42 +00009535TEST_F(FormatTest, UnderstandPragmaOption) {
9536 verifyFormat("#pragma option -C -A");
9537
9538 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A"));
9539}
9540
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009541#define EXPECT_ALL_STYLES_EQUAL(Styles) \
9542 for (size_t i = 1; i < Styles.size(); ++i) \
Daniel Jaspera44991332015-04-29 13:06:49 +00009543 EXPECT_EQ(Styles[0], Styles[i]) << "Style #" << i << " of " << Styles.size() \
9544 << " differs from Style #0"
Alexander Kornienkod6538332013-05-07 15:32:14 +00009545
9546TEST_F(FormatTest, GetsPredefinedStyleByName) {
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009547 SmallVector<FormatStyle, 3> Styles;
9548 Styles.resize(3);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009549
Alexander Kornienko006b5c82013-05-19 00:53:30 +00009550 Styles[0] = getLLVMStyle();
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009551 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
9552 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
9553 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009554
Alexander Kornienko006b5c82013-05-19 00:53:30 +00009555 Styles[0] = getGoogleStyle();
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009556 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
9557 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
9558 EXPECT_ALL_STYLES_EQUAL(Styles);
9559
Nico Weber514ecc82014-02-02 20:50:45 +00009560 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009561 EXPECT_TRUE(
9562 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
9563 EXPECT_TRUE(
9564 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
9565 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009566
Nico Weber514ecc82014-02-02 20:50:45 +00009567 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009568 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
9569 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
9570 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienko006b5c82013-05-19 00:53:30 +00009571
9572 Styles[0] = getMozillaStyle();
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009573 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
9574 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
9575 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienko006b5c82013-05-19 00:53:30 +00009576
Daniel Jasperffefb3d2013-07-24 13:10:59 +00009577 Styles[0] = getWebKitStyle();
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009578 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
9579 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
9580 EXPECT_ALL_STYLES_EQUAL(Styles);
Daniel Jasperffefb3d2013-07-24 13:10:59 +00009581
Alexander Kornienkofe7a57f2013-12-10 15:42:15 +00009582 Styles[0] = getGNUStyle();
9583 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
9584 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
9585 EXPECT_ALL_STYLES_EQUAL(Styles);
9586
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009587 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
9588}
9589
9590TEST_F(FormatTest, GetsCorrectBasedOnStyle) {
9591 SmallVector<FormatStyle, 8> Styles;
9592 Styles.resize(2);
9593
9594 Styles[0] = getGoogleStyle();
9595 Styles[1] = getLLVMStyle();
9596 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
9597 EXPECT_ALL_STYLES_EQUAL(Styles);
9598
9599 Styles.resize(5);
Nico Weber514ecc82014-02-02 20:50:45 +00009600 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009601 Styles[1] = getLLVMStyle();
9602 Styles[1].Language = FormatStyle::LK_JavaScript;
9603 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
9604
9605 Styles[2] = getLLVMStyle();
9606 Styles[2].Language = FormatStyle::LK_JavaScript;
9607 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
9608 "BasedOnStyle: Google",
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00009609 &Styles[2])
9610 .value());
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009611
9612 Styles[3] = getLLVMStyle();
9613 Styles[3].Language = FormatStyle::LK_JavaScript;
9614 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
9615 "Language: JavaScript",
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00009616 &Styles[3])
9617 .value());
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009618
9619 Styles[4] = getLLVMStyle();
9620 Styles[4].Language = FormatStyle::LK_JavaScript;
9621 EXPECT_EQ(0, parseConfiguration("---\n"
9622 "BasedOnStyle: LLVM\n"
9623 "IndentWidth: 123\n"
9624 "---\n"
9625 "BasedOnStyle: Google\n"
9626 "Language: JavaScript",
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00009627 &Styles[4])
9628 .value());
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009629 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009630}
9631
Daniel Jasper91881d92014-09-29 08:07:46 +00009632#define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \
Alexander Kornienkod6538332013-05-07 15:32:14 +00009633 Style.FIELD = false; \
Daniel Jasper91881d92014-09-29 08:07:46 +00009634 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \
Alexander Kornienko006b5c82013-05-19 00:53:30 +00009635 EXPECT_TRUE(Style.FIELD); \
Daniel Jasper91881d92014-09-29 08:07:46 +00009636 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \
Patrik Hagglund76aca642013-05-14 07:53:53 +00009637 EXPECT_FALSE(Style.FIELD);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009638
Daniel Jasper91881d92014-09-29 08:07:46 +00009639#define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
9640
Daniel Jasperc1bc38e2015-09-29 14:57:55 +00009641#define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \
9642 Style.STRUCT.FIELD = false; \
9643 EXPECT_EQ(0, \
9644 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \
9645 .value()); \
9646 EXPECT_TRUE(Style.STRUCT.FIELD); \
9647 EXPECT_EQ(0, \
9648 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \
9649 .value()); \
9650 EXPECT_FALSE(Style.STRUCT.FIELD);
9651
9652#define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \
9653 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD)
9654
Daniel Jasper00853002014-09-16 16:22:30 +00009655#define CHECK_PARSE(TEXT, FIELD, VALUE) \
9656 EXPECT_NE(VALUE, Style.FIELD); \
9657 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \
9658 EXPECT_EQ(VALUE, Style.FIELD)
9659
Alexander Kornienkoc6221a52014-08-14 13:07:35 +00009660TEST_F(FormatTest, ParsesConfigurationBools) {
Alexander Kornienkocabdd732013-11-29 15:19:43 +00009661 FormatStyle Style = {};
9662 Style.Language = FormatStyle::LK_Cpp;
Daniel Jasper3219e432014-12-02 13:24:51 +00009663 CHECK_PARSE_BOOL(AlignOperands);
Daniel Jasper552f4a72013-07-31 23:55:15 +00009664 CHECK_PARSE_BOOL(AlignTrailingComments);
Daniel Jaspera44991332015-04-29 13:06:49 +00009665 CHECK_PARSE_BOOL(AlignConsecutiveAssignments);
Daniel Jaspere12597c2015-10-01 10:06:54 +00009666 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009667 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
Daniel Jasper17605d32014-05-14 09:33:35 +00009668 CHECK_PARSE_BOOL(AllowShortBlocksOnASingleLine);
Daniel Jasperb87899b2014-09-10 13:11:45 +00009669 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009670 CHECK_PARSE_BOOL(AllowShortIfStatementsOnASingleLine);
Daniel Jasper997af662013-05-16 12:16:23 +00009671 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
Daniel Jasper61e6bbf2013-05-29 12:07:31 +00009672 CHECK_PARSE_BOOL(AlwaysBreakTemplateDeclarations);
Daniel Jasper18210d72014-10-09 09:52:05 +00009673 CHECK_PARSE_BOOL(BinPackArguments);
Daniel Jasper6501f7e2015-10-27 12:38:37 +00009674 CHECK_PARSE_BOOL(BinPackParameters);
Daniel Jaspere1a7b762016-02-01 11:21:02 +00009675 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
Daniel Jasper165b29e2013-11-08 00:57:11 +00009676 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
Daniel Jaspere1a7b762016-02-01 11:21:02 +00009677 CHECK_PARSE_BOOL(BreakStringLiterals);
Andi-Bogdan Postelnicu0ef8ee12017-03-10 15:10:37 +00009678 CHECK_PARSE_BOOL(BreakBeforeInheritanceComma)
Francois Ferrande56a8292017-06-14 12:29:47 +00009679 CHECK_PARSE_BOOL(CompactNamespaces);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009680 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
Daniel Jasper553d4872014-06-17 12:40:34 +00009681 CHECK_PARSE_BOOL(DerivePointerAlignment);
Daniel Jasper91881d92014-09-29 08:07:46 +00009682 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
Daniel Jasperda446772015-11-16 12:38:56 +00009683 CHECK_PARSE_BOOL(DisableFormat);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009684 CHECK_PARSE_BOOL(IndentCaseLabels);
Daniel Jasperc75e1ef2014-07-09 08:42:42 +00009685 CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
Daniel Jaspera26fc5c2014-03-21 13:43:14 +00009686 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
Daniel Jaspere9beea22014-01-28 15:20:33 +00009687 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009688 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
Daniel Jasper6ab54682013-07-16 18:22:10 +00009689 CHECK_PARSE_BOOL(Cpp11BracedListStyle);
Daniel Jaspera0a50392015-12-01 13:28:53 +00009690 CHECK_PARSE_BOOL(ReflowComments);
Daniel Jasperda446772015-11-16 12:38:56 +00009691 CHECK_PARSE_BOOL(SortIncludes);
Krasimir Georgievac16a202017-06-23 11:46:03 +00009692 CHECK_PARSE_BOOL(SortUsingDeclarations);
Daniel Jasperb55acad2013-08-20 12:36:34 +00009693 CHECK_PARSE_BOOL(SpacesInParentheses);
Daniel Jasperad981f82014-08-26 11:41:14 +00009694 CHECK_PARSE_BOOL(SpacesInSquareBrackets);
Daniel Jasperdd978ae2013-10-29 14:52:02 +00009695 CHECK_PARSE_BOOL(SpacesInAngles);
Daniel Jasperb55acad2013-08-20 12:36:34 +00009696 CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
Daniel Jasperb2e10a52014-01-15 15:09:08 +00009697 CHECK_PARSE_BOOL(SpacesInContainerLiterals);
Daniel Jasperb55acad2013-08-20 12:36:34 +00009698 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
Daniel Jasperdb986eb2014-09-03 07:37:29 +00009699 CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
Sylvestre Ledru83bbd572016-08-09 14:24:40 +00009700 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
Daniel Jasperd94bff32013-09-25 15:15:02 +00009701 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
Daniel Jasperc1bc38e2015-09-29 14:57:55 +00009702
9703 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass);
9704 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterControlStatement);
9705 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum);
9706 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction);
9707 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace);
9708 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration);
9709 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct);
9710 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion);
9711 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch);
9712 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse);
9713 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces);
Francois Ferrandad722562017-06-30 20:25:55 +00009714 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction);
9715 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord);
9716 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace);
Alexander Kornienkoc6221a52014-08-14 13:07:35 +00009717}
Alexander Kornienkod6538332013-05-07 15:32:14 +00009718
Alexander Kornienkoc6221a52014-08-14 13:07:35 +00009719#undef CHECK_PARSE_BOOL
9720
Alexander Kornienkoc6221a52014-08-14 13:07:35 +00009721TEST_F(FormatTest, ParsesConfiguration) {
9722 FormatStyle Style = {};
9723 Style.Language = FormatStyle::LK_Cpp;
Alexander Kornienkod6538332013-05-07 15:32:14 +00009724 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
Daniel Jaspercdaffa42013-08-13 10:58:30 +00009725 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
9726 ConstructorInitializerIndentWidth, 1234u);
Daniel Jasper50d634b2014-10-28 16:53:38 +00009727 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009728 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
9729 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
Francois Ferrand9976efa2017-05-22 08:28:17 +00009730 CHECK_PARSE("PenaltyBreakAssignment: 1234",
9731 PenaltyBreakAssignment, 1234u);
Daniel Jasper33b909c2013-10-25 14:29:37 +00009732 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
9733 PenaltyBreakBeforeFirstCallParameter, 1234u);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009734 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
9735 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
9736 PenaltyReturnTypeOnItsOwnLine, 1234u);
9737 CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
9738 SpacesBeforeTrailingComments, 1234u);
Manuel Klimek13b97d82013-05-13 08:42:42 +00009739 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
Daniel Jasper6633ab82013-10-18 10:38:14 +00009740 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
Daniel Jasper9c8ff352016-03-21 14:11:27 +00009741 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
Alexander Kornienkod6538332013-05-07 15:32:14 +00009742
Daniel Jasper553d4872014-06-17 12:40:34 +00009743 Style.PointerAlignment = FormatStyle::PAS_Middle;
Daniel Jasperac043c92014-09-15 11:11:00 +00009744 CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
9745 FormatStyle::PAS_Left);
9746 CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
9747 FormatStyle::PAS_Right);
9748 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
9749 FormatStyle::PAS_Middle);
Daniel Jasper00853002014-09-16 16:22:30 +00009750 // For backward compatibility:
9751 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
9752 FormatStyle::PAS_Left);
9753 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
9754 FormatStyle::PAS_Right);
9755 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
9756 FormatStyle::PAS_Middle);
Daniel Jasper553d4872014-06-17 12:40:34 +00009757
Alexander Kornienkod6538332013-05-07 15:32:14 +00009758 Style.Standard = FormatStyle::LS_Auto;
Alexander Kornienkob40cfe42013-09-04 14:09:13 +00009759 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
9760 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Cpp11);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009761 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
9762 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
9763 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
9764
Daniel Jasperac043c92014-09-15 11:11:00 +00009765 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
Daniel Jasperac043c92014-09-15 11:11:00 +00009766 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
9767 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
Daniel Jasperac043c92014-09-15 11:11:00 +00009768 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
9769 FormatStyle::BOS_None);
9770 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
9771 FormatStyle::BOS_All);
Daniel Jasper00853002014-09-16 16:22:30 +00009772 // For backward compatibility:
9773 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
9774 FormatStyle::BOS_None);
9775 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
9776 FormatStyle::BOS_All);
Daniel Jasperac043c92014-09-15 11:11:00 +00009777
Francois Ferranda6b6d512017-05-24 11:36:58 +00009778 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
9779 CHECK_PARSE("BreakConstructorInitializers: BeforeComma",
9780 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
9781 CHECK_PARSE("BreakConstructorInitializers: AfterColon",
9782 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon);
9783 CHECK_PARSE("BreakConstructorInitializers: BeforeColon",
9784 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon);
9785 // For backward compatibility:
9786 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true",
9787 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
9788
Daniel Jasper6501f7e2015-10-27 12:38:37 +00009789 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
9790 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
9791 FormatStyle::BAS_Align);
9792 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket,
9793 FormatStyle::BAS_DontAlign);
9794 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket,
9795 FormatStyle::BAS_AlwaysBreak);
9796 // For backward compatibility:
9797 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
9798 FormatStyle::BAS_DontAlign);
9799 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
9800 FormatStyle::BAS_Align);
9801
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +00009802 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left;
9803 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines,
9804 FormatStyle::ENAS_DontAlign);
9805 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines,
9806 FormatStyle::ENAS_Left);
9807 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines,
9808 FormatStyle::ENAS_Right);
9809 // For backward compatibility:
9810 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines,
9811 FormatStyle::ENAS_Left);
9812 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines,
9813 FormatStyle::ENAS_Right);
9814
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00009815 Style.UseTab = FormatStyle::UT_ForIndentation;
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00009816 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
9817 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
9818 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
Marianne Mailhot-Sarrasin51fe2792016-04-14 14:52:26 +00009819 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
9820 FormatStyle::UT_ForContinuationAndIndentation);
Daniel Jasper00853002014-09-16 16:22:30 +00009821 // For backward compatibility:
9822 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
9823 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00009824
Daniel Jasperd74cf402014-04-08 12:46:38 +00009825 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
Daniel Jasperd74cf402014-04-08 12:46:38 +00009826 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
9827 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
9828 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
9829 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
Daniel Jasper9e709352014-11-26 10:43:58 +00009830 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
9831 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
Daniel Jasperd74cf402014-04-08 12:46:38 +00009832 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
9833 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
Daniel Jasper00853002014-09-16 16:22:30 +00009834 // For backward compatibility:
9835 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
9836 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
9837 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
9838 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
Daniel Jasperd74cf402014-04-08 12:46:38 +00009839
Alexander Kornienkofdca83d2013-12-10 10:18:34 +00009840 Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
9841 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
9842 FormatStyle::SBPO_Never);
9843 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
9844 FormatStyle::SBPO_Always);
9845 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
9846 FormatStyle::SBPO_ControlStatements);
9847 // For backward compatibility:
9848 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
9849 FormatStyle::SBPO_Never);
9850 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
9851 FormatStyle::SBPO_ControlStatements);
9852
Alexander Kornienkod6538332013-05-07 15:32:14 +00009853 Style.ColumnLimit = 123;
9854 FormatStyle BaseStyle = getLLVMStyle();
9855 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
9856 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
9857
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009858 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
9859 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
9860 FormatStyle::BS_Attach);
9861 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
9862 FormatStyle::BS_Linux);
Birunthan Mohanathas305fa9c2015-07-12 03:13:54 +00009863 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces,
9864 FormatStyle::BS_Mozilla);
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009865 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
9866 FormatStyle::BS_Stroustrup);
Alexander Kornienko3a33f022013-12-12 09:49:52 +00009867 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
9868 FormatStyle::BS_Allman);
9869 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
Daniel Jasperc1bc38e2015-09-29 14:57:55 +00009870 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces,
9871 FormatStyle::BS_WebKit);
9872 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces,
9873 FormatStyle::BS_Custom);
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009874
Zachary Turner448592e2015-12-18 22:20:15 +00009875 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
9876 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
9877 FormatStyle::RTBS_None);
9878 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
9879 FormatStyle::RTBS_All);
9880 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",
Zachary Turner6bc7f972015-12-18 22:58:42 +00009881 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel);
Zachary Turner448592e2015-12-18 22:20:15 +00009882 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions",
9883 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions);
9884 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions",
9885 AlwaysBreakAfterReturnType,
9886 FormatStyle::RTBS_TopLevelDefinitions);
9887
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00009888 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
9889 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None",
9890 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None);
9891 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All",
9892 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All);
9893 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel",
9894 AlwaysBreakAfterDefinitionReturnType,
9895 FormatStyle::DRTBS_TopLevel);
9896
Daniel Jasper65ee3472013-07-31 23:16:02 +00009897 Style.NamespaceIndentation = FormatStyle::NI_All;
9898 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
9899 FormatStyle::NI_None);
9900 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
9901 FormatStyle::NI_Inner);
9902 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
9903 FormatStyle::NI_All);
Daniel Jaspere1e43192014-04-01 12:55:11 +00009904
Daniel Jasper8ce1b8d2015-10-06 11:54:18 +00009905 // FIXME: This is required because parsing a configuration simply overwrites
9906 // the first N elements of the list instead of resetting it.
Daniel Jaspere1e43192014-04-01 12:55:11 +00009907 Style.ForEachMacros.clear();
Aaron Ballman2b9036d2014-04-01 16:30:35 +00009908 std::vector<std::string> BoostForeach;
9909 BoostForeach.push_back("BOOST_FOREACH");
Daniel Jaspere1e43192014-04-01 12:55:11 +00009910 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
Aaron Ballman2b9036d2014-04-01 16:30:35 +00009911 std::vector<std::string> BoostAndQForeach;
9912 BoostAndQForeach.push_back("BOOST_FOREACH");
9913 BoostAndQForeach.push_back("Q_FOREACH");
Daniel Jaspere1e43192014-04-01 12:55:11 +00009914 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
9915 BoostAndQForeach);
Daniel Jasper8ce1b8d2015-10-06 11:54:18 +00009916
9917 Style.IncludeCategories.clear();
9918 std::vector<FormatStyle::IncludeCategory> ExpectedCategories = {{"abc/.*", 2},
9919 {".*", 1}};
9920 CHECK_PARSE("IncludeCategories:\n"
9921 " - Regex: abc/.*\n"
9922 " Priority: 2\n"
9923 " - Regex: .*\n"
9924 " Priority: 1",
9925 IncludeCategories, ExpectedCategories);
Daniel Jasper9c8ff352016-03-21 14:11:27 +00009926 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeIsMainRegex, "abc$");
Alexander Kornienkocabdd732013-11-29 15:19:43 +00009927}
9928
9929TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
9930 FormatStyle Style = {};
9931 Style.Language = FormatStyle::LK_Cpp;
9932 CHECK_PARSE("Language: Cpp\n"
9933 "IndentWidth: 12",
9934 IndentWidth, 12u);
Rafael Espindola1f243172014-06-12 11:35:17 +00009935 EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
9936 "IndentWidth: 34",
9937 &Style),
9938 ParseError::Unsuitable);
Alexander Kornienkocabdd732013-11-29 15:19:43 +00009939 EXPECT_EQ(12u, Style.IndentWidth);
9940 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
9941 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
9942
9943 Style.Language = FormatStyle::LK_JavaScript;
9944 CHECK_PARSE("Language: JavaScript\n"
9945 "IndentWidth: 12",
9946 IndentWidth, 12u);
9947 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
Rafael Espindola1f243172014-06-12 11:35:17 +00009948 EXPECT_EQ(parseConfiguration("Language: Cpp\n"
9949 "IndentWidth: 34",
9950 &Style),
9951 ParseError::Unsuitable);
Alexander Kornienkocabdd732013-11-29 15:19:43 +00009952 EXPECT_EQ(23u, Style.IndentWidth);
9953 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
9954 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
9955
9956 CHECK_PARSE("BasedOnStyle: LLVM\n"
9957 "IndentWidth: 67",
9958 IndentWidth, 67u);
9959
9960 CHECK_PARSE("---\n"
9961 "Language: JavaScript\n"
9962 "IndentWidth: 12\n"
9963 "---\n"
9964 "Language: Cpp\n"
9965 "IndentWidth: 34\n"
9966 "...\n",
9967 IndentWidth, 12u);
9968
9969 Style.Language = FormatStyle::LK_Cpp;
9970 CHECK_PARSE("---\n"
9971 "Language: JavaScript\n"
9972 "IndentWidth: 12\n"
9973 "---\n"
9974 "Language: Cpp\n"
9975 "IndentWidth: 34\n"
9976 "...\n",
9977 IndentWidth, 34u);
9978 CHECK_PARSE("---\n"
9979 "IndentWidth: 78\n"
9980 "---\n"
9981 "Language: JavaScript\n"
9982 "IndentWidth: 56\n"
9983 "...\n",
9984 IndentWidth, 78u);
9985
9986 Style.ColumnLimit = 123;
9987 Style.IndentWidth = 234;
9988 Style.BreakBeforeBraces = FormatStyle::BS_Linux;
9989 Style.TabWidth = 345;
Rafael Espindola3ae06202014-05-31 03:20:52 +00009990 EXPECT_FALSE(parseConfiguration("---\n"
9991 "IndentWidth: 456\n"
9992 "BreakBeforeBraces: Allman\n"
9993 "---\n"
9994 "Language: JavaScript\n"
9995 "IndentWidth: 111\n"
9996 "TabWidth: 111\n"
9997 "---\n"
9998 "Language: Cpp\n"
9999 "BreakBeforeBraces: Stroustrup\n"
10000 "TabWidth: 789\n"
10001 "...\n",
10002 &Style));
Alexander Kornienkocabdd732013-11-29 15:19:43 +000010003 EXPECT_EQ(123u, Style.ColumnLimit);
10004 EXPECT_EQ(456u, Style.IndentWidth);
10005 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
10006 EXPECT_EQ(789u, Style.TabWidth);
10007
Rafael Espindola1f243172014-06-12 11:35:17 +000010008 EXPECT_EQ(parseConfiguration("---\n"
10009 "Language: JavaScript\n"
10010 "IndentWidth: 56\n"
10011 "---\n"
10012 "IndentWidth: 78\n"
10013 "...\n",
10014 &Style),
10015 ParseError::Error);
10016 EXPECT_EQ(parseConfiguration("---\n"
10017 "Language: JavaScript\n"
10018 "IndentWidth: 56\n"
10019 "---\n"
10020 "Language: JavaScript\n"
10021 "IndentWidth: 78\n"
10022 "...\n",
10023 &Style),
10024 ParseError::Error);
Alexander Kornienkocabdd732013-11-29 15:19:43 +000010025
10026 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
10027}
Daniel Jasper65ee3472013-07-31 23:16:02 +000010028
Alexander Kornienkod6bd7472013-12-30 16:11:28 +000010029#undef CHECK_PARSE
Alexander Kornienkod6bd7472013-12-30 16:11:28 +000010030
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010031TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
10032 FormatStyle Style = {};
10033 Style.Language = FormatStyle::LK_JavaScript;
10034 Style.BreakBeforeTernaryOperators = true;
Alexander Kornienkod6bd7472013-12-30 16:11:28 +000010035 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
Daniel Jaspere551bb72014-11-05 17:22:31 +000010036 EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
Alexander Kornienkod6bd7472013-12-30 16:11:28 +000010037
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010038 Style.BreakBeforeTernaryOperators = true;
Alexander Kornienkod6bd7472013-12-30 16:11:28 +000010039 EXPECT_EQ(0, parseConfiguration("---\n"
Daniel Jaspera44991332015-04-29 13:06:49 +000010040 "BasedOnStyle: Google\n"
10041 "---\n"
10042 "Language: JavaScript\n"
10043 "IndentWidth: 76\n"
10044 "...\n",
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +000010045 &Style)
10046 .value());
Daniel Jaspere551bb72014-11-05 17:22:31 +000010047 EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010048 EXPECT_EQ(76u, Style.IndentWidth);
10049 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
10050}
10051
Alexander Kornienkod6538332013-05-07 15:32:14 +000010052TEST_F(FormatTest, ConfigurationRoundTripTest) {
10053 FormatStyle Style = getLLVMStyle();
10054 std::string YAML = configurationAsText(Style);
10055 FormatStyle ParsedStyle = {};
Alexander Kornienkocabdd732013-11-29 15:19:43 +000010056 ParsedStyle.Language = FormatStyle::LK_Cpp;
Alexander Kornienkod6538332013-05-07 15:32:14 +000010057 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
10058 EXPECT_EQ(Style, ParsedStyle);
10059}
10060
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010061TEST_F(FormatTest, WorksFor8bitEncodings) {
10062 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
10063 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
10064 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
10065 "\"\xef\xee\xf0\xf3...\"",
10066 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
10067 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
10068 "\xef\xee\xf0\xf3...\"",
10069 getLLVMStyleWithColumns(12)));
10070}
10071
Alexander Kornienko393e3082013-11-13 14:04:17 +000010072TEST_F(FormatTest, HandlesUTF8BOM) {
10073 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
10074 EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
10075 format("\xef\xbb\xbf#include <iostream>"));
10076 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
10077 format("\xef\xbb\xbf\n#include <iostream>"));
10078}
10079
NAKAMURA Takumi5238eba2013-06-06 01:14:58 +000010080// FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
10081#if !defined(_MSC_VER)
10082
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010083TEST_F(FormatTest, CountsUTF8CharactersProperly) {
10084 verifyFormat("\"Однажды в студёную зимнюю пору...\"",
10085 getLLVMStyleWithColumns(35));
10086 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010087 getLLVMStyleWithColumns(31));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010088 verifyFormat("// Однажды в студёную зимнюю пору...",
10089 getLLVMStyleWithColumns(36));
Daniel Jaspera44991332015-04-29 13:06:49 +000010090 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010091 verifyFormat("/* Однажды в студёную зимнюю пору... */",
10092 getLLVMStyleWithColumns(39));
10093 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010094 getLLVMStyleWithColumns(35));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010095}
10096
10097TEST_F(FormatTest, SplitsUTF8Strings) {
Alexander Kornienko71d95d62013-11-26 10:38:53 +000010098 // Non-printable characters' width is currently considered to be the length in
10099 // bytes in UTF8. The characters can be displayed in very different manner
10100 // (zero-width, single width with a substitution glyph, expanded to their code
10101 // (e.g. "<8d>"), so there's no single correct way to handle them.
10102 EXPECT_EQ("\"aaaaÄ\"\n"
Alexander Kornienkofd1d7002013-11-26 13:31:46 +000010103 "\"\xc2\x8d\";",
10104 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
Alexander Kornienko71d95d62013-11-26 10:38:53 +000010105 EXPECT_EQ("\"aaaaaaaÄ\"\n"
Alexander Kornienkofd1d7002013-11-26 13:31:46 +000010106 "\"\xc2\x8d\";",
10107 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
Daniel Jaspera44991332015-04-29 13:06:49 +000010108 EXPECT_EQ("\"Однажды, в \"\n"
10109 "\"студёную \"\n"
10110 "\"зимнюю \"\n"
10111 "\"пору,\"",
10112 format("\"Однажды, в студёную зимнюю пору,\"",
10113 getLLVMStyleWithColumns(13)));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010114 EXPECT_EQ(
Daniel Jaspera44991332015-04-29 13:06:49 +000010115 "\"一 二 三 \"\n"
10116 "\"四 五六 \"\n"
10117 "\"七 八 九 \"\n"
10118 "\"十\"",
10119 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010120 EXPECT_EQ("\"一\t二 \"\n"
10121 "\"\t三 \"\n"
10122 "\"四 五\t六 \"\n"
10123 "\"\t七 \"\n"
10124 "\"八九十\tqq\"",
10125 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
10126 getLLVMStyleWithColumns(11)));
Daniel Jaspere35c2202015-07-20 23:28:07 +000010127
10128 // UTF8 character in an escape sequence.
10129 EXPECT_EQ("\"aaaaaa\"\n"
10130 "\"\\\xC2\x8D\"",
10131 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10)));
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010132}
10133
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010134TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
10135 EXPECT_EQ("const char *sssss =\n"
10136 " \"一二三四五六七八\\\n"
10137 " 九 十\";",
10138 format("const char *sssss = \"一二三四五六七八\\\n"
10139 " 九 十\";",
10140 getLLVMStyleWithColumns(30)));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010141}
10142
10143TEST_F(FormatTest, SplitsUTF8LineComments) {
Alexander Kornienkofd1d7002013-11-26 13:31:46 +000010144 EXPECT_EQ("// aaaaÄ\xc2\x8d",
10145 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010146 EXPECT_EQ("// Я из лесу\n"
10147 "// вышел; был\n"
10148 "// сильный\n"
10149 "// мороз.",
10150 format("// Я из лесу вышел; был сильный мороз.",
10151 getLLVMStyleWithColumns(13)));
10152 EXPECT_EQ("// 一二三\n"
10153 "// 四五六七\n"
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010154 "// 八 九\n"
10155 "// 十",
10156 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9)));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010157}
10158
10159TEST_F(FormatTest, SplitsUTF8BlockComments) {
10160 EXPECT_EQ("/* Гляжу,\n"
10161 " * поднимается\n"
10162 " * медленно в\n"
10163 " * гору\n"
10164 " * Лошадка,\n"
10165 " * везущая\n"
10166 " * хворосту\n"
10167 " * воз. */",
10168 format("/* Гляжу, поднимается медленно в гору\n"
10169 " * Лошадка, везущая хворосту воз. */",
10170 getLLVMStyleWithColumns(13)));
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010171 EXPECT_EQ(
10172 "/* 一二三\n"
10173 " * 四五六七\n"
10174 " * 八 九\n"
10175 " * 十 */",
10176 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9)));
Alexander Kornienkoff73c202013-06-05 15:08:20 +000010177 EXPECT_EQ("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯\n"
10178 " * 𝕓𝕪𝕥𝕖\n"
10179 " * 𝖀𝕿𝕱-𝟠 */",
10180 format("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯 𝕓𝕪𝕥𝕖 𝖀𝕿𝕱-𝟠 */", getLLVMStyleWithColumns(12)));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010181}
10182
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010183#endif // _MSC_VER
10184
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010185TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
10186 FormatStyle Style = getLLVMStyle();
10187
10188 Style.ConstructorInitializerIndentWidth = 4;
10189 verifyFormat(
10190 "SomeClass::Constructor()\n"
10191 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
10192 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
10193 Style);
10194
10195 Style.ConstructorInitializerIndentWidth = 2;
10196 verifyFormat(
10197 "SomeClass::Constructor()\n"
10198 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
10199 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
10200 Style);
10201
10202 Style.ConstructorInitializerIndentWidth = 0;
10203 verifyFormat(
10204 "SomeClass::Constructor()\n"
10205 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
10206 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
10207 Style);
Daniel Jasperb618a982016-02-02 10:28:11 +000010208 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
10209 verifyFormat(
10210 "SomeLongTemplateVariableName<\n"
10211 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>",
10212 Style);
10213 verifyFormat(
10214 "bool smaller = 1 < bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
10215 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
10216 Style);
Daniel Jasper00853002014-09-16 16:22:30 +000010217}
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010218
Daniel Jasper00853002014-09-16 16:22:30 +000010219TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
10220 FormatStyle Style = getLLVMStyle();
Francois Ferranda6b6d512017-05-24 11:36:58 +000010221 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010222 Style.ConstructorInitializerIndentWidth = 4;
10223 verifyFormat("SomeClass::Constructor()\n"
10224 " : a(a)\n"
10225 " , b(b)\n"
10226 " , c(c) {}",
10227 Style);
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010228 verifyFormat("SomeClass::Constructor()\n"
10229 " : a(a) {}",
10230 Style);
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010231
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010232 Style.ColumnLimit = 0;
10233 verifyFormat("SomeClass::Constructor()\n"
10234 " : a(a) {}",
10235 Style);
Daniel Jasper56ef6ac2016-03-01 21:41:58 +000010236 verifyFormat("SomeClass::Constructor() noexcept\n"
10237 " : a(a) {}",
10238 Style);
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010239 verifyFormat("SomeClass::Constructor()\n"
10240 " : a(a)\n"
10241 " , b(b)\n"
10242 " , c(c) {}",
10243 Style);
10244 verifyFormat("SomeClass::Constructor()\n"
10245 " : a(a) {\n"
10246 " foo();\n"
10247 " bar();\n"
10248 "}",
10249 Style);
10250
Daniel Jasperd74cf402014-04-08 12:46:38 +000010251 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010252 verifyFormat("SomeClass::Constructor()\n"
10253 " : a(a)\n"
10254 " , b(b)\n"
10255 " , c(c) {\n}",
10256 Style);
10257 verifyFormat("SomeClass::Constructor()\n"
10258 " : a(a) {\n}",
10259 Style);
10260
10261 Style.ColumnLimit = 80;
Daniel Jasperd74cf402014-04-08 12:46:38 +000010262 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010263 Style.ConstructorInitializerIndentWidth = 2;
10264 verifyFormat("SomeClass::Constructor()\n"
10265 " : a(a)\n"
10266 " , b(b)\n"
10267 " , c(c) {}",
10268 Style);
10269
10270 Style.ConstructorInitializerIndentWidth = 0;
10271 verifyFormat("SomeClass::Constructor()\n"
10272 ": a(a)\n"
10273 ", b(b)\n"
10274 ", c(c) {}",
10275 Style);
Daniel Jasperec01cd62013-10-08 05:11:18 +000010276
10277 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
10278 Style.ConstructorInitializerIndentWidth = 4;
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010279 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
10280 verifyFormat(
10281 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
10282 Style);
Daniel Jasperec01cd62013-10-08 05:11:18 +000010283 verifyFormat(
10284 "SomeClass::Constructor()\n"
10285 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
10286 Style);
10287 Style.ConstructorInitializerIndentWidth = 4;
10288 Style.ColumnLimit = 60;
10289 verifyFormat("SomeClass::Constructor()\n"
10290 " : aaaaaaaa(aaaaaaaa)\n"
10291 " , aaaaaaaa(aaaaaaaa)\n"
10292 " , aaaaaaaa(aaaaaaaa) {}",
10293 Style);
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010294}
10295
Daniel Jasper38efc132014-10-21 07:51:54 +000010296TEST_F(FormatTest, Destructors) {
10297 verifyFormat("void F(int &i) { i.~int(); }");
10298 verifyFormat("void F(int &i) { i->~int(); }");
10299}
10300
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010301TEST_F(FormatTest, FormatsWithWebKitStyle) {
10302 FormatStyle Style = getWebKitStyle();
10303
10304 // Don't indent in outer namespaces.
10305 verifyFormat("namespace outer {\n"
10306 "int i;\n"
10307 "namespace inner {\n"
Daniel Jasper65ee3472013-07-31 23:16:02 +000010308 " int i;\n"
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010309 "} // namespace inner\n"
10310 "} // namespace outer\n"
10311 "namespace other_outer {\n"
10312 "int i;\n"
10313 "}",
10314 Style);
10315
10316 // Don't indent case labels.
10317 verifyFormat("switch (variable) {\n"
10318 "case 1:\n"
10319 "case 2:\n"
10320 " doSomething();\n"
10321 " break;\n"
10322 "default:\n"
10323 " ++variable;\n"
10324 "}",
10325 Style);
10326
10327 // Wrap before binary operators.
Daniel Jaspera44991332015-04-29 13:06:49 +000010328 EXPECT_EQ("void f()\n"
10329 "{\n"
10330 " if (aaaaaaaaaaaaaaaa\n"
10331 " && bbbbbbbbbbbbbbbbbbbbbbbb\n"
10332 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
10333 " return;\n"
10334 "}",
10335 format("void f() {\n"
10336 "if (aaaaaaaaaaaaaaaa\n"
10337 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
10338 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
10339 "return;\n"
10340 "}",
10341 Style));
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010342
Daniel Jasper35995672014-04-29 14:05:20 +000010343 // Allow functions on a single line.
10344 verifyFormat("void f() { return; }", Style);
10345
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010346 // Constructor initializers are formatted one per line with the "," on the
10347 // new line.
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010348 verifyFormat("Constructor()\n"
10349 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
10350 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
Daniel Jasper3aa9a6a2014-11-18 23:55:27 +000010351 " aaaaaaaaaaaaaa)\n"
Daniel Jasper234379f2013-12-24 13:31:25 +000010352 " , aaaaaaaaaaaaaaaaaaaaaaa()\n"
10353 "{\n"
10354 "}",
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010355 Style);
10356 verifyFormat("SomeClass::Constructor()\n"
10357 " : a(a)\n"
Daniel Jasper234379f2013-12-24 13:31:25 +000010358 "{\n"
10359 "}",
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010360 Style);
Daniel Jasper234379f2013-12-24 13:31:25 +000010361 EXPECT_EQ("SomeClass::Constructor()\n"
10362 " : a(a)\n"
10363 "{\n"
10364 "}",
10365 format("SomeClass::Constructor():a(a){}", Style));
10366 verifyFormat("SomeClass::Constructor()\n"
10367 " : a(a)\n"
10368 " , b(b)\n"
10369 " , c(c)\n"
10370 "{\n"
Daniel Jaspera44991332015-04-29 13:06:49 +000010371 "}",
10372 Style);
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010373 verifyFormat("SomeClass::Constructor()\n"
10374 " : a(a)\n"
10375 "{\n"
10376 " foo();\n"
10377 " bar();\n"
10378 "}",
10379 Style);
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010380
Daniel Jasper65ee3472013-07-31 23:16:02 +000010381 // Access specifiers should be aligned left.
10382 verifyFormat("class C {\n"
10383 "public:\n"
10384 " int i;\n"
10385 "};",
10386 Style);
10387
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010388 // Do not align comments.
Daniel Jasper552f4a72013-07-31 23:55:15 +000010389 verifyFormat("int a; // Do not\n"
10390 "double b; // align comments.",
10391 Style);
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010392
Daniel Jasper3219e432014-12-02 13:24:51 +000010393 // Do not align operands.
10394 EXPECT_EQ("ASSERT(aaaa\n"
10395 " || bbbb);",
10396 format("ASSERT ( aaaa\n||bbbb);", Style));
10397
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010398 // Accept input's line breaks.
10399 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
10400 " || bbbbbbbbbbbbbbb) {\n"
10401 " i++;\n"
10402 "}",
10403 format("if (aaaaaaaaaaaaaaa\n"
10404 "|| bbbbbbbbbbbbbbb) { i++; }",
10405 Style));
10406 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
10407 " i++;\n"
10408 "}",
10409 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
Daniel Jasper98fb6e12013-11-08 17:33:27 +000010410
10411 // Don't automatically break all macro definitions (llvm.org/PR17842).
10412 verifyFormat("#define aNumber 10", Style);
10413 // However, generally keep the line breaks that the user authored.
10414 EXPECT_EQ("#define aNumber \\\n"
10415 " 10",
10416 format("#define aNumber \\\n"
10417 " 10",
10418 Style));
Daniel Jasperaf4fee22014-04-14 12:05:05 +000010419
10420 // Keep empty and one-element array literals on a single line.
Daniel Jasper7f0c5172014-05-19 08:06:34 +000010421 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
10422 " copyItems:YES];",
10423 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
10424 "copyItems:YES];",
10425 Style));
10426 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
10427 " copyItems:YES];",
10428 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
10429 " copyItems:YES];",
10430 Style));
Daniel Jasper335ff262014-05-28 09:11:53 +000010431 // FIXME: This does not seem right, there should be more indentation before
10432 // the array literal's entries. Nested blocks have the same problem.
Daniel Jasperdb8804b2014-04-14 12:11:07 +000010433 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
Daniel Jasper335ff262014-05-28 09:11:53 +000010434 " @\"a\",\n"
10435 " @\"a\"\n"
10436 "]\n"
Daniel Jasperdb8804b2014-04-14 12:11:07 +000010437 " copyItems:YES];",
10438 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
10439 " @\"a\",\n"
10440 " @\"a\"\n"
10441 " ]\n"
10442 " copyItems:YES];",
10443 Style));
Daniel Jasper7f0c5172014-05-19 08:06:34 +000010444 EXPECT_EQ(
Daniel Jasperdb8804b2014-04-14 12:11:07 +000010445 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
10446 " copyItems:YES];",
Daniel Jasper7f0c5172014-05-19 08:06:34 +000010447 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
10448 " copyItems:YES];",
10449 Style));
10450
10451 verifyFormat("[self.a b:c c:d];", Style);
10452 EXPECT_EQ("[self.a b:c\n"
10453 " c:d];",
10454 format("[self.a b:c\n"
10455 "c:d];",
10456 Style));
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010457}
10458
Manuel Klimekffdeb592013-09-03 15:10:01 +000010459TEST_F(FormatTest, FormatsLambdas) {
Daniel Jasper5f3ea472014-05-22 08:36:53 +000010460 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
10461 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
10462 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
10463 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
10464 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
Chandler Carruthf8b72662014-03-02 12:37:31 +000010465 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
Daniel Jasper3ade3be2016-11-01 06:23:05 +000010466 verifyFormat("int x = f(*+[] {});");
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +000010467 verifyFormat("void f() {\n"
10468 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
10469 "}\n");
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +000010470 verifyFormat("void f() {\n"
10471 " other(x.begin(), //\n"
10472 " x.end(), //\n"
Daniel Jasper9a8d48b2013-09-05 10:04:31 +000010473 " [&](int, int) { return 1; });\n"
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +000010474 "}\n");
Daniel Jasper21397a32014-04-09 12:21:48 +000010475 verifyFormat("SomeFunction([]() { // A cool function...\n"
10476 " return 43;\n"
10477 "});");
Daniel Jasper56346192014-10-27 16:31:46 +000010478 EXPECT_EQ("SomeFunction([]() {\n"
10479 "#define A a\n"
10480 " return 43;\n"
10481 "});",
10482 format("SomeFunction([](){\n"
10483 "#define A a\n"
10484 "return 43;\n"
10485 "});"));
Daniel Jasper0e6c51c2014-05-05 12:36:29 +000010486 verifyFormat("void f() {\n"
10487 " SomeFunction([](decltype(x), A *a) {});\n"
10488 "}");
Daniel Jaspera2fb50f2014-06-24 09:15:49 +000010489 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
10490 " [](const aaaaaaaaaa &a) { return a; });");
Daniel Jaspera5621202014-08-08 12:00:13 +000010491 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
10492 " SomeOtherFunctioooooooooooooooooooooooooon();\n"
10493 "});");
Daniel Jasperd6a1cab2015-01-12 10:23:24 +000010494 verifyFormat("Constructor()\n"
10495 " : Field([] { // comment\n"
10496 " int i;\n"
10497 " }) {}");
Daniel Jasper0ad28142015-05-13 08:47:16 +000010498 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
10499 " return some_parameter.size();\n"
10500 "};");
Daniel Jasper9c8a7742016-01-04 07:29:40 +000010501 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n"
10502 " [](const string &s) { return s; };");
Daniel Jasperc4144ea2015-05-13 16:09:21 +000010503 verifyFormat("int i = aaaaaa ? 1 //\n"
10504 " : [] {\n"
10505 " return 2; //\n"
10506 " }();");
10507 verifyFormat("llvm::errs() << \"number of twos is \"\n"
10508 " << std::count_if(v.begin(), v.end(), [](int x) {\n"
10509 " return x == 2; // force break\n"
10510 " });");
Daniel Jasperd9b319e2017-02-20 12:43:48 +000010511 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
10512 " [=](int iiiiiiiiiiii) {\n"
10513 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n"
10514 " aaaaaaaaaaaaaaaaaaaaaaa;\n"
10515 " });",
Daniel Jasperb9edcfb2015-07-07 13:50:50 +000010516 getLLVMStyleWithColumns(60));
Daniel Jasperea40cee2015-07-14 11:26:14 +000010517 verifyFormat("SomeFunction({[&] {\n"
10518 " // comment\n"
10519 " },\n"
10520 " [&] {\n"
10521 " // comment\n"
10522 " }});");
10523 verifyFormat("SomeFunction({[&] {\n"
10524 " // comment\n"
10525 "}});");
Daniel Jasper100ffc62015-08-21 11:44:57 +000010526 verifyFormat("virtual aaaaaaaaaaaaaaaa(std::function<bool()> bbbbbbbbbbbb =\n"
10527 " [&]() { return true; },\n"
10528 " aaaaa aaaaaaaaa);");
Daniel Jasperbf02b2c12013-09-05 11:49:39 +000010529
Daniel Jaspercb51cf42014-01-16 09:11:55 +000010530 // Lambdas with return types.
Daniel Jasper81a20782014-03-10 10:02:02 +000010531 verifyFormat("int c = []() -> int { return 2; }();\n");
Daniel Jasper60ba32d2015-06-12 09:59:16 +000010532 verifyFormat("int c = []() -> int * { return 2; }();\n");
Daniel Jasper81a20782014-03-10 10:02:02 +000010533 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
10534 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
Daniel Jasperbcb55ee2014-11-21 14:08:38 +000010535 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};");
Daniel Jasper3431b752014-12-08 13:22:37 +000010536 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};");
Daniel Jasperbcb55ee2014-11-21 14:08:38 +000010537 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};");
10538 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};");
Daniel Jasper5eaa0092015-08-13 13:37:08 +000010539 verifyFormat("[a, a]() -> a<1> {};");
Daniel Jasper8f59ae52014-03-11 11:03:26 +000010540 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
10541 " int j) -> int {\n"
Daniel Jaspera2fb50f2014-06-24 09:15:49 +000010542 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n"
Daniel Jasper8f59ae52014-03-11 11:03:26 +000010543 "};");
Daniel Jaspere6623162015-03-02 10:35:13 +000010544 verifyFormat(
10545 "aaaaaaaaaaaaaaaaaaaaaa(\n"
10546 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n"
10547 " return aaaaaaaaaaaaaaaaa;\n"
10548 " });",
10549 getLLVMStyleWithColumns(70));
Daniel Jasper87448c52016-06-13 07:48:45 +000010550 verifyFormat("[]() //\n"
10551 " -> int {\n"
10552 " return 1; //\n"
10553 "};");
Daniel Jaspercb51cf42014-01-16 09:11:55 +000010554
Daniel Jasper3ae6f5a2014-04-09 12:08:39 +000010555 // Multiple lambdas in the same parentheses change indentation rules.
Daniel Jasper4b444492014-11-21 13:38:53 +000010556 verifyFormat("SomeFunction(\n"
10557 " []() {\n"
10558 " int i = 42;\n"
10559 " return i;\n"
10560 " },\n"
10561 " []() {\n"
10562 " int j = 43;\n"
10563 " return j;\n"
10564 " });");
Daniel Jasper3ae6f5a2014-04-09 12:08:39 +000010565
Daniel Jasperda18fd82014-06-10 06:39:03 +000010566 // More complex introducers.
10567 verifyFormat("return [i, args...] {};");
10568
Daniel Jasperbf02b2c12013-09-05 11:49:39 +000010569 // Not lambdas.
Chandler Carruthf8b72662014-03-02 12:37:31 +000010570 verifyFormat("constexpr char hello[]{\"hello\"};");
Daniel Jasperb4b99982013-09-06 21:25:51 +000010571 verifyFormat("double &operator[](int i) { return 0; }\n"
10572 "int i;");
Daniel Jasper6b70ec02014-01-22 17:01:47 +000010573 verifyFormat("std::unique_ptr<int[]> foo() {}");
Daniel Jasperd3c7ab92014-03-11 09:59:36 +000010574 verifyFormat("int i = a[a][a]->f();");
Daniel Jaspera58dd5d2014-03-11 10:03:33 +000010575 verifyFormat("int i = (*b)[a]->f();");
Daniel Jasper84a12e12014-03-10 15:06:25 +000010576
10577 // Other corner cases.
10578 verifyFormat("void f() {\n"
10579 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n"
Martin Probst2c1cdae2017-05-15 11:15:29 +000010580 " );\n"
Daniel Jasper84a12e12014-03-10 15:06:25 +000010581 "}");
Daniel Jasperc580af92014-03-11 09:29:46 +000010582
10583 // Lambdas created through weird macros.
10584 verifyFormat("void f() {\n"
10585 " MACRO((const AA &a) { return 1; });\n"
Daniel Jasper54353da2016-01-07 14:36:11 +000010586 " MACRO((AA &a) { return 1; });\n"
Daniel Jasperc580af92014-03-11 09:29:46 +000010587 "}");
Daniel Jasper11a0ac62014-12-12 09:40:58 +000010588
10589 verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
10590 " doo_dah();\n"
10591 " doo_dah();\n"
10592 " })) {\n"
10593 "}");
Daniel Jasper6a7d5a72017-06-19 07:40:49 +000010594 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n"
10595 " doo_dah();\n"
10596 " doo_dah();\n"
10597 " })) {\n"
10598 "}");
Daniel Jasper29d39d52015-02-08 09:34:49 +000010599 verifyFormat("auto lambda = []() {\n"
10600 " int a = 2\n"
10601 "#if A\n"
10602 " + 2\n"
10603 "#endif\n"
10604 " ;\n"
10605 "};");
Daniel Jasperd9b319e2017-02-20 12:43:48 +000010606
10607 // Lambdas with complex multiline introducers.
10608 verifyFormat(
10609 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
10610 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n"
10611 " -> ::std::unordered_set<\n"
10612 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n"
10613 " //\n"
10614 " });");
Manuel Klimekffdeb592013-09-03 15:10:01 +000010615}
10616
Manuel Klimek516e0542013-09-04 13:25:30 +000010617TEST_F(FormatTest, FormatsBlocks) {
Daniel Jasper76284682014-10-22 09:12:44 +000010618 FormatStyle ShortBlocks = getLLVMStyle();
10619 ShortBlocks.AllowShortBlocksOnASingleLine = true;
10620 verifyFormat("int (^Block)(int, int);", ShortBlocks);
10621 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
10622 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
10623 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
10624 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
10625 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
Daniel Jasper31745732014-01-19 07:46:32 +000010626
Daniel Jasper76284682014-10-22 09:12:44 +000010627 verifyFormat("foo(^{ bar(); });", ShortBlocks);
10628 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
10629 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
Daniel Jasper31745732014-01-19 07:46:32 +000010630
Daniel Jasper76284682014-10-22 09:12:44 +000010631 verifyFormat("[operation setCompletionBlock:^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010632 " [self onOperationDone];\n"
Daniel Jasper76284682014-10-22 09:12:44 +000010633 "}];");
10634 verifyFormat("int i = {[operation setCompletionBlock:^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010635 " [self onOperationDone];\n"
Daniel Jasper76284682014-10-22 09:12:44 +000010636 "}]};");
10637 verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010638 " f();\n"
Daniel Jasper76284682014-10-22 09:12:44 +000010639 "}];");
10640 verifyFormat("int a = [operation block:^int(int *i) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010641 " return 1;\n"
Daniel Jasper76284682014-10-22 09:12:44 +000010642 "}];");
Daniel Jaspera225bce2014-01-16 19:14:34 +000010643 verifyFormat("[myObject doSomethingWith:arg1\n"
Daniel Jasper76284682014-10-22 09:12:44 +000010644 " aaa:^int(int *a) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010645 " return 1;\n"
Daniel Jasper76284682014-10-22 09:12:44 +000010646 " }\n"
Daniel Jasper5f3ea472014-05-22 08:36:53 +000010647 " bbb:f(a * bbbbbbbb)];");
Daniel Jasperb88b25f2013-12-23 07:29:06 +000010648
10649 verifyFormat("[operation setCompletionBlock:^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010650 " [self.delegate newDataAvailable];\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000010651 "}];",
10652 getLLVMStyleWithColumns(60));
10653 verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010654 " NSString *path = [self sessionFilePath];\n"
10655 " if (path) {\n"
10656 " // ...\n"
10657 " }\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000010658 "});");
10659 verifyFormat("[[SessionService sharedService]\n"
10660 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010661 " if (window) {\n"
10662 " [self windowDidLoad:window];\n"
10663 " } else {\n"
10664 " [self errorLoadingWindow];\n"
10665 " }\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000010666 " }];");
10667 verifyFormat("void (^largeBlock)(void) = ^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010668 " // ...\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000010669 "};\n",
10670 getLLVMStyleWithColumns(40));
10671 verifyFormat("[[SessionService sharedService]\n"
10672 " loadWindowWithCompletionBlock: //\n"
10673 " ^(SessionWindow *window) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010674 " if (window) {\n"
10675 " [self windowDidLoad:window];\n"
10676 " } else {\n"
10677 " [self errorLoadingWindow];\n"
10678 " }\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000010679 " }];",
10680 getLLVMStyleWithColumns(60));
10681 verifyFormat("[myObject doSomethingWith:arg1\n"
10682 " firstBlock:^(Foo *a) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010683 " // ...\n"
10684 " int i;\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000010685 " }\n"
10686 " secondBlock:^(Bar *b) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010687 " // ...\n"
10688 " int i;\n"
Daniel Jasperc13ee342014-03-27 09:43:54 +000010689 " }\n"
10690 " thirdBlock:^Foo(Bar *b) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010691 " // ...\n"
10692 " int i;\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000010693 " }];");
Daniel Jasperb77105d2014-04-08 14:04:31 +000010694 verifyFormat("[myObject doSomethingWith:arg1\n"
10695 " firstBlock:-1\n"
10696 " secondBlock:^(Bar *b) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010697 " // ...\n"
10698 " int i;\n"
Daniel Jasperb77105d2014-04-08 14:04:31 +000010699 " }];");
Daniel Jasperac7e34e2014-03-13 10:11:17 +000010700
10701 verifyFormat("f(^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010702 " @autoreleasepool {\n"
10703 " if (a) {\n"
10704 " g();\n"
Daniel Jasperac7e34e2014-03-13 10:11:17 +000010705 " }\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000010706 " }\n"
Daniel Jasperac7e34e2014-03-13 10:11:17 +000010707 "});");
Daniel Jasperbb86d842014-11-23 19:15:35 +000010708 verifyFormat("Block b = ^int *(A *a, B *b) {}");
Daniel Jaspere31388a2016-09-26 22:19:08 +000010709 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
10710 "};");
Daniel Jasper50d634b2014-10-28 16:53:38 +000010711
10712 FormatStyle FourIndent = getLLVMStyle();
10713 FourIndent.ObjCBlockIndentWidth = 4;
10714 verifyFormat("[operation setCompletionBlock:^{\n"
10715 " [self onOperationDone];\n"
10716 "}];",
10717 FourIndent);
Manuel Klimek516e0542013-09-04 13:25:30 +000010718}
10719
Daniel Jasper289afc02015-04-23 09:23:17 +000010720TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) {
10721 FormatStyle ZeroColumn = getLLVMStyle();
10722 ZeroColumn.ColumnLimit = 0;
10723
10724 verifyFormat("[[SessionService sharedService] "
10725 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
10726 " if (window) {\n"
10727 " [self windowDidLoad:window];\n"
10728 " } else {\n"
10729 " [self errorLoadingWindow];\n"
10730 " }\n"
10731 "}];",
10732 ZeroColumn);
10733 EXPECT_EQ("[[SessionService sharedService]\n"
10734 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
10735 " if (window) {\n"
10736 " [self windowDidLoad:window];\n"
10737 " } else {\n"
10738 " [self errorLoadingWindow];\n"
10739 " }\n"
10740 " }];",
10741 format("[[SessionService sharedService]\n"
10742 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
10743 " if (window) {\n"
10744 " [self windowDidLoad:window];\n"
10745 " } else {\n"
10746 " [self errorLoadingWindow];\n"
10747 " }\n"
10748 "}];",
10749 ZeroColumn));
10750 verifyFormat("[myObject doSomethingWith:arg1\n"
10751 " firstBlock:^(Foo *a) {\n"
10752 " // ...\n"
10753 " int i;\n"
10754 " }\n"
10755 " secondBlock:^(Bar *b) {\n"
10756 " // ...\n"
10757 " int i;\n"
10758 " }\n"
10759 " thirdBlock:^Foo(Bar *b) {\n"
10760 " // ...\n"
10761 " int i;\n"
10762 " }];",
10763 ZeroColumn);
10764 verifyFormat("f(^{\n"
10765 " @autoreleasepool {\n"
10766 " if (a) {\n"
10767 " g();\n"
10768 " }\n"
10769 " }\n"
10770 "});",
10771 ZeroColumn);
10772 verifyFormat("void (^largeBlock)(void) = ^{\n"
10773 " // ...\n"
10774 "};",
10775 ZeroColumn);
10776
10777 ZeroColumn.AllowShortBlocksOnASingleLine = true;
10778 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +000010779 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn));
Daniel Jasper289afc02015-04-23 09:23:17 +000010780 ZeroColumn.AllowShortBlocksOnASingleLine = false;
10781 EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
10782 " int i;\n"
10783 "};",
10784 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn));
10785}
10786
Alexander Kornienko9e649af2013-09-11 12:25:57 +000010787TEST_F(FormatTest, SupportsCRLF) {
10788 EXPECT_EQ("int a;\r\n"
10789 "int b;\r\n"
10790 "int c;\r\n",
10791 format("int a;\r\n"
10792 " int b;\r\n"
10793 " int c;\r\n",
10794 getLLVMStyle()));
10795 EXPECT_EQ("int a;\r\n"
10796 "int b;\r\n"
10797 "int c;\r\n",
10798 format("int a;\r\n"
10799 " int b;\n"
10800 " int c;\r\n",
10801 getLLVMStyle()));
10802 EXPECT_EQ("int a;\n"
10803 "int b;\n"
10804 "int c;\n",
10805 format("int a;\r\n"
10806 " int b;\n"
10807 " int c;\n",
10808 getLLVMStyle()));
10809 EXPECT_EQ("\"aaaaaaa \"\r\n"
10810 "\"bbbbbbb\";\r\n",
10811 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
10812 EXPECT_EQ("#define A \\\r\n"
10813 " b; \\\r\n"
10814 " c; \\\r\n"
10815 " d;\r\n",
10816 format("#define A \\\r\n"
10817 " b; \\\r\n"
10818 " c; d; \r\n",
10819 getGoogleStyle()));
Daniel Jasper580da272013-10-30 07:36:40 +000010820
10821 EXPECT_EQ("/*\r\n"
10822 "multi line block comments\r\n"
10823 "should not introduce\r\n"
10824 "an extra carriage return\r\n"
10825 "*/\r\n",
10826 format("/*\r\n"
10827 "multi line block comments\r\n"
10828 "should not introduce\r\n"
10829 "an extra carriage return\r\n"
10830 "*/\r\n"));
Alexander Kornienko9e649af2013-09-11 12:25:57 +000010831}
10832
Manuel Klimekb212f3b2013-10-12 22:46:56 +000010833TEST_F(FormatTest, MunchSemicolonAfterBlocks) {
10834 verifyFormat("MY_CLASS(C) {\n"
10835 " int i;\n"
10836 " int j;\n"
10837 "};");
10838}
10839
Daniel Jasper6633ab82013-10-18 10:38:14 +000010840TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {
10841 FormatStyle TwoIndent = getLLVMStyleWithColumns(15);
10842 TwoIndent.ContinuationIndentWidth = 2;
10843
10844 EXPECT_EQ("int i =\n"
10845 " longFunction(\n"
10846 " arg);",
10847 format("int i = longFunction(arg);", TwoIndent));
10848
10849 FormatStyle SixIndent = getLLVMStyleWithColumns(20);
10850 SixIndent.ContinuationIndentWidth = 6;
10851
10852 EXPECT_EQ("int i =\n"
10853 " longFunction(\n"
10854 " arg);",
10855 format("int i = longFunction(arg);", SixIndent));
10856}
10857
Daniel Jasperdd978ae2013-10-29 14:52:02 +000010858TEST_F(FormatTest, SpacesInAngles) {
10859 FormatStyle Spaces = getLLVMStyle();
10860 Spaces.SpacesInAngles = true;
10861
10862 verifyFormat("static_cast< int >(arg);", Spaces);
10863 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
10864 verifyFormat("f< int, float >();", Spaces);
10865 verifyFormat("template <> g() {}", Spaces);
10866 verifyFormat("template < std::vector< int > > f() {}", Spaces);
Daniel Jasper74331d42015-10-26 12:08:47 +000010867 verifyFormat("std::function< void(int, int) > fct;", Spaces);
10868 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }",
10869 Spaces);
Daniel Jasperdd978ae2013-10-29 14:52:02 +000010870
10871 Spaces.Standard = FormatStyle::LS_Cpp03;
10872 Spaces.SpacesInAngles = true;
10873 verifyFormat("A< A< int > >();", Spaces);
10874
10875 Spaces.SpacesInAngles = false;
10876 verifyFormat("A<A<int> >();", Spaces);
10877
10878 Spaces.Standard = FormatStyle::LS_Cpp11;
10879 Spaces.SpacesInAngles = true;
10880 verifyFormat("A< A< int > >();", Spaces);
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000010881
Daniel Jasperdd978ae2013-10-29 14:52:02 +000010882 Spaces.SpacesInAngles = false;
10883 verifyFormat("A<A<int>>();", Spaces);
10884}
10885
Sylvestre Ledru83bbd572016-08-09 14:24:40 +000010886TEST_F(FormatTest, SpaceAfterTemplateKeyword) {
10887 FormatStyle Style = getLLVMStyle();
10888 Style.SpaceAfterTemplateKeyword = false;
10889 verifyFormat("template<int> void foo();", Style);
10890}
10891
Jacques Pienaarfc275112015-02-18 23:48:37 +000010892TEST_F(FormatTest, TripleAngleBrackets) {
10893 verifyFormat("f<<<1, 1>>>();");
10894 verifyFormat("f<<<1, 1, 1, s>>>();");
10895 verifyFormat("f<<<a, b, c, d>>>();");
Daniel Jaspera44991332015-04-29 13:06:49 +000010896 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
Jacques Pienaarfc275112015-02-18 23:48:37 +000010897 verifyFormat("f<param><<<1, 1>>>();");
10898 verifyFormat("f<1><<<1, 1>>>();");
Daniel Jaspera44991332015-04-29 13:06:49 +000010899 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
Jacques Pienaarfc275112015-02-18 23:48:37 +000010900 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10901 "aaaaaaaaaaa<<<\n 1, 1>>>();");
Daniel Jaspera4322082016-11-05 17:43:16 +000010902 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
10903 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();");
Jacques Pienaarfc275112015-02-18 23:48:37 +000010904}
10905
10906TEST_F(FormatTest, MergeLessLessAtEnd) {
Jacques Pienaar68a7dbf2015-02-20 21:09:01 +000010907 verifyFormat("<<");
Jacques Pienaar411b2512015-02-24 23:23:24 +000010908 EXPECT_EQ("< < <", format("\\\n<<<"));
Jacques Pienaarfc275112015-02-18 23:48:37 +000010909 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10910 "aaallvm::outs() <<");
10911 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10912 "aaaallvm::outs()\n <<");
10913}
10914
Manuel Klimek819788d2014-03-18 11:22:45 +000010915TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {
10916 std::string code = "#if A\n"
10917 "#if B\n"
10918 "a.\n"
10919 "#endif\n"
10920 " a = 1;\n"
10921 "#else\n"
10922 "#endif\n"
10923 "#if C\n"
10924 "#else\n"
10925 "#endif\n";
10926 EXPECT_EQ(code, format(code));
10927}
10928
Manuel Klimek68b03042014-04-14 09:14:11 +000010929TEST_F(FormatTest, HandleConflictMarkers) {
10930 // Git/SVN conflict markers.
10931 EXPECT_EQ("int a;\n"
10932 "void f() {\n"
10933 " callme(some(parameter1,\n"
10934 "<<<<<<< text by the vcs\n"
10935 " parameter2),\n"
10936 "||||||| text by the vcs\n"
10937 " parameter2),\n"
10938 " parameter3,\n"
10939 "======= text by the vcs\n"
10940 " parameter2, parameter3),\n"
10941 ">>>>>>> text by the vcs\n"
10942 " otherparameter);\n",
10943 format("int a;\n"
10944 "void f() {\n"
10945 " callme(some(parameter1,\n"
10946 "<<<<<<< text by the vcs\n"
10947 " parameter2),\n"
10948 "||||||| text by the vcs\n"
10949 " parameter2),\n"
10950 " parameter3,\n"
10951 "======= text by the vcs\n"
10952 " parameter2,\n"
10953 " parameter3),\n"
10954 ">>>>>>> text by the vcs\n"
10955 " otherparameter);\n"));
10956
10957 // Perforce markers.
10958 EXPECT_EQ("void f() {\n"
10959 " function(\n"
10960 ">>>> text by the vcs\n"
10961 " parameter,\n"
10962 "==== text by the vcs\n"
10963 " parameter,\n"
10964 "==== text by the vcs\n"
10965 " parameter,\n"
10966 "<<<< text by the vcs\n"
10967 " parameter);\n",
10968 format("void f() {\n"
10969 " function(\n"
10970 ">>>> text by the vcs\n"
10971 " parameter,\n"
10972 "==== text by the vcs\n"
10973 " parameter,\n"
10974 "==== text by the vcs\n"
10975 " parameter,\n"
10976 "<<<< text by the vcs\n"
10977 " parameter);\n"));
10978
10979 EXPECT_EQ("<<<<<<<\n"
10980 "|||||||\n"
10981 "=======\n"
10982 ">>>>>>>",
10983 format("<<<<<<<\n"
10984 "|||||||\n"
10985 "=======\n"
10986 ">>>>>>>"));
10987
10988 EXPECT_EQ("<<<<<<<\n"
10989 "|||||||\n"
10990 "int i;\n"
10991 "=======\n"
10992 ">>>>>>>",
10993 format("<<<<<<<\n"
10994 "|||||||\n"
10995 "int i;\n"
10996 "=======\n"
10997 ">>>>>>>"));
10998
10999 // FIXME: Handle parsing of macros around conflict markers correctly:
11000 EXPECT_EQ("#define Macro \\\n"
11001 "<<<<<<<\n"
11002 "Something \\\n"
11003 "|||||||\n"
11004 "Else \\\n"
11005 "=======\n"
11006 "Other \\\n"
11007 ">>>>>>>\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +000011008 " End int i;\n",
Manuel Klimek68b03042014-04-14 09:14:11 +000011009 format("#define Macro \\\n"
11010 "<<<<<<<\n"
11011 " Something \\\n"
11012 "|||||||\n"
11013 " Else \\\n"
11014 "=======\n"
11015 " Other \\\n"
11016 ">>>>>>>\n"
11017 " End\n"
11018 "int i;\n"));
11019}
11020
Daniel Jasper471894432014-08-06 13:40:26 +000011021TEST_F(FormatTest, DisableRegions) {
11022 EXPECT_EQ("int i;\n"
11023 "// clang-format off\n"
11024 " int j;\n"
11025 "// clang-format on\n"
11026 "int k;",
11027 format(" int i;\n"
11028 " // clang-format off\n"
11029 " int j;\n"
11030 " // clang-format on\n"
11031 " int k;"));
Roman Kashitsyn650ecb52014-09-11 14:47:20 +000011032 EXPECT_EQ("int i;\n"
11033 "/* clang-format off */\n"
11034 " int j;\n"
11035 "/* clang-format on */\n"
11036 "int k;",
11037 format(" int i;\n"
11038 " /* clang-format off */\n"
11039 " int j;\n"
11040 " /* clang-format on */\n"
11041 " int k;"));
Krasimir Georgiev91834222017-01-25 13:58:58 +000011042
11043 // Don't reflow comments within disabled regions.
11044 EXPECT_EQ(
11045 "// clang-format off\n"
11046 "// long long long long long long line\n"
11047 "/* clang-format on */\n"
11048 "/* long long long\n"
11049 " * long long long\n"
11050 " * line */\n"
11051 "int i;\n"
11052 "/* clang-format off */\n"
11053 "/* long long long long long long line */\n",
11054 format("// clang-format off\n"
11055 "// long long long long long long line\n"
11056 "/* clang-format on */\n"
11057 "/* long long long long long long line */\n"
11058 "int i;\n"
11059 "/* clang-format off */\n"
11060 "/* long long long long long long line */\n",
11061 getLLVMStyleWithColumns(20)));
Daniel Jasper471894432014-08-06 13:40:26 +000011062}
11063
Manuel Klimekf0c95b32015-06-11 10:14:13 +000011064TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
11065 format("? ) =");
11066 verifyNoCrash("#define a\\\n /**/}");
11067}
Manuel Klimek5f594f82014-08-13 14:00:41 +000011068
Daniel Jasper498f5582015-12-25 08:53:31 +000011069TEST_F(FormatTest, FormatsTableGenCode) {
11070 FormatStyle Style = getLLVMStyle();
11071 Style.Language = FormatStyle::LK_TableGen;
11072 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);
11073}
11074
Nico Weberb2673a12016-11-10 21:49:25 +000011075TEST_F(FormatTest, ArrayOfTemplates) {
11076 EXPECT_EQ("auto a = new unique_ptr<int>[10];",
11077 format("auto a = new unique_ptr<int > [ 10];"));
11078
11079 FormatStyle Spaces = getLLVMStyle();
11080 Spaces.SpacesInSquareBrackets = true;
11081 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];",
11082 format("auto a = new unique_ptr<int > [10];", Spaces));
11083}
11084
11085TEST_F(FormatTest, ArrayAsTemplateType) {
11086 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;",
11087 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;"));
11088
11089 FormatStyle Spaces = getLLVMStyle();
11090 Spaces.SpacesInSquareBrackets = true;
11091 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",
11092 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces));
11093}
11094
Martin Probstc9c51c42017-03-16 10:21:35 +000011095TEST_F(FormatTest, NoSpaceAfterSuper) {
11096 verifyFormat("__super::FooBar();");
11097}
11098
Eric Liu547d8792016-03-24 13:22:42 +000011099TEST(FormatStyle, GetStyleOfFile) {
11100 vfs::InMemoryFileSystem FS;
11101 // Test 1: format file in the same directory.
11102 ASSERT_TRUE(
11103 FS.addFile("/a/.clang-format", 0,
11104 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
11105 ASSERT_TRUE(
11106 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
Daniel Jasper03a04fe2016-12-12 12:42:29 +000011107 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS);
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +000011108 ASSERT_TRUE((bool)Style1);
11109 ASSERT_EQ(*Style1, getLLVMStyle());
Eric Liu547d8792016-03-24 13:22:42 +000011110
Antonio Maiorano7eb75072017-01-20 01:22:42 +000011111 // Test 2.1: fallback to default.
Eric Liu547d8792016-03-24 13:22:42 +000011112 ASSERT_TRUE(
11113 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
Daniel Jasper03a04fe2016-12-12 12:42:29 +000011114 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS);
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +000011115 ASSERT_TRUE((bool)Style2);
11116 ASSERT_EQ(*Style2, getMozillaStyle());
Eric Liu547d8792016-03-24 13:22:42 +000011117
Antonio Maiorano7eb75072017-01-20 01:22:42 +000011118 // Test 2.2: no format on 'none' fallback style.
11119 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
11120 ASSERT_TRUE((bool)Style2);
11121 ASSERT_EQ(*Style2, getNoStyle());
11122
11123 // Test 2.3: format if config is found with no based style while fallback is
11124 // 'none'.
11125 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
11126 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2")));
11127 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
11128 ASSERT_TRUE((bool)Style2);
11129 ASSERT_EQ(*Style2, getLLVMStyle());
11130
11131 // Test 2.4: format if yaml with no based style, while fallback is 'none'.
11132 Style2 = getStyle("{}", "a.h", "none", "", &FS);
11133 ASSERT_TRUE((bool)Style2);
11134 ASSERT_EQ(*Style2, getLLVMStyle());
11135
Eric Liu547d8792016-03-24 13:22:42 +000011136 // Test 3: format file in parent directory.
11137 ASSERT_TRUE(
11138 FS.addFile("/c/.clang-format", 0,
11139 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
11140 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
11141 llvm::MemoryBuffer::getMemBuffer("int i;")));
Daniel Jasper03a04fe2016-12-12 12:42:29 +000011142 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS);
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +000011143 ASSERT_TRUE((bool)Style3);
11144 ASSERT_EQ(*Style3, getGoogleStyle());
11145
11146 // Test 4: error on invalid fallback style
11147 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS);
11148 ASSERT_FALSE((bool)Style4);
11149 llvm::consumeError(Style4.takeError());
11150
11151 // Test 5: error on invalid yaml on command line
11152 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS);
11153 ASSERT_FALSE((bool)Style5);
11154 llvm::consumeError(Style5.takeError());
11155
11156 // Test 6: error on invalid style
11157 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS);
11158 ASSERT_FALSE((bool)Style6);
11159 llvm::consumeError(Style6.takeError());
11160
11161 // Test 7: found config file, error on parsing it
11162 ASSERT_TRUE(
11163 FS.addFile("/d/.clang-format", 0,
11164 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n"
11165 "InvalidKey: InvalidValue")));
11166 ASSERT_TRUE(
11167 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
11168 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS);
11169 ASSERT_FALSE((bool)Style7);
11170 llvm::consumeError(Style7.takeError());
Eric Liu547d8792016-03-24 13:22:42 +000011171}
11172
Manuel Klimekb12e5a52016-03-01 12:37:30 +000011173TEST_F(ReplacementTest, FormatCodeAfterReplacements) {
11174 // Column limit is 20.
11175 std::string Code = "Type *a =\n"
11176 " new Type();\n"
11177 "g(iiiii, 0, jjjjj,\n"
11178 " 0, kkkkk, 0, mm);\n"
11179 "int bad = format ;";
11180 std::string Expected = "auto a = new Type();\n"
11181 "g(iiiii, nullptr,\n"
11182 " jjjjj, nullptr,\n"
11183 " kkkkk, nullptr,\n"
11184 " mm);\n"
11185 "int bad = format ;";
11186 FileID ID = Context.createInMemoryFile("format.cpp", Code);
Eric Liu40ef2fb2016-08-01 10:16:37 +000011187 tooling::Replacements Replaces = toReplacements(
11188 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6,
11189 "auto "),
11190 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1,
11191 "nullptr"),
11192 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1,
11193 "nullptr"),
11194 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1,
11195 "nullptr")});
Manuel Klimekb12e5a52016-03-01 12:37:30 +000011196
11197 format::FormatStyle Style = format::getLLVMStyle();
11198 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility.
Eric Liu4f8d9942016-07-11 13:53:12 +000011199 auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
11200 EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
11201 << llvm::toString(FormattedReplaces.takeError()) << "\n";
11202 auto Result = applyAllReplacements(Code, *FormattedReplaces);
11203 EXPECT_TRUE(static_cast<bool>(Result));
11204 EXPECT_EQ(Expected, *Result);
Manuel Klimekb12e5a52016-03-01 12:37:30 +000011205}
11206
Eric Liubaf58c22016-05-18 13:43:48 +000011207TEST_F(ReplacementTest, SortIncludesAfterReplacement) {
11208 std::string Code = "#include \"a.h\"\n"
11209 "#include \"c.h\"\n"
11210 "\n"
11211 "int main() {\n"
11212 " return 0;\n"
11213 "}";
11214 std::string Expected = "#include \"a.h\"\n"
11215 "#include \"b.h\"\n"
11216 "#include \"c.h\"\n"
11217 "\n"
11218 "int main() {\n"
11219 " return 0;\n"
11220 "}";
11221 FileID ID = Context.createInMemoryFile("fix.cpp", Code);
Eric Liu40ef2fb2016-08-01 10:16:37 +000011222 tooling::Replacements Replaces = toReplacements(
11223 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0,
11224 "#include \"b.h\"\n")});
Eric Liubaf58c22016-05-18 13:43:48 +000011225
11226 format::FormatStyle Style = format::getLLVMStyle();
11227 Style.SortIncludes = true;
Eric Liu4f8d9942016-07-11 13:53:12 +000011228 auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
11229 EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
11230 << llvm::toString(FormattedReplaces.takeError()) << "\n";
11231 auto Result = applyAllReplacements(Code, *FormattedReplaces);
11232 EXPECT_TRUE(static_cast<bool>(Result));
11233 EXPECT_EQ(Expected, *Result);
Eric Liubaf58c22016-05-18 13:43:48 +000011234}
11235
Krasimir Georgievac16a202017-06-23 11:46:03 +000011236TEST_F(FormatTest, FormatSortsUsingDeclarations) {
11237 EXPECT_EQ("using std::cin;\n"
11238 "using std::cout;",
11239 format("using std::cout;\n"
11240 "using std::cin;", getGoogleStyle()));
11241}
11242
Nico Weberdc065182017-04-05 18:10:42 +000011243TEST_F(FormatTest, UTF8CharacterLiteralCpp03) {
11244 format::FormatStyle Style = format::getLLVMStyle();
11245 Style.Standard = FormatStyle::LS_Cpp03;
11246 // cpp03 recognize this string as identifier u8 and literal character 'a'
11247 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style));
11248}
11249
11250TEST_F(FormatTest, UTF8CharacterLiteralCpp11) {
11251 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers
11252 // all modes, including C++11, C++14 and C++17
11253 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';"));
11254}
11255
Daniel Jasperd246a5a2015-06-15 15:25:11 +000011256} // end namespace
11257} // end namespace format
Daniel Jasper8d1832e2013-01-07 13:26:07 +000011258} // end namespace clang