blob: 2cae9dd0c547b8d71b875281f23839220143a514 [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
Martin Probsta004b3f2017-11-17 18:06:33 +000073 void verifyFormat(llvm::StringRef Expected, llvm::StringRef Code,
Manuel Klimekb69e3c62013-01-02 18:33:23 +000074 const FormatStyle &Style = getLLVMStyle()) {
Martin Probsta004b3f2017-11-17 18:06:33 +000075 EXPECT_EQ(Expected.str(), format(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;
Martin Probsta004b3f2017-11-17 18:06:33 +000081 EXPECT_EQ(Expected.str(), format(test::messUp(Code), ObjCStyle));
Nico Weberd96ae862017-02-24 19:10:12 +000082 }
Daniel Jasperf7935112012-12-03 18:12:45 +000083 }
84
Martin Probsta004b3f2017-11-17 18:06:33 +000085 void verifyFormat(llvm::StringRef Code,
86 const FormatStyle &Style = getLLVMStyle()) {
87 verifyFormat(Code, test::messUp(Code), Style);
88 }
89
Manuel Klimekec5c3db2015-05-07 12:26:30 +000090 void verifyIncompleteFormat(llvm::StringRef Code,
91 const FormatStyle &Style = getLLVMStyle()) {
92 EXPECT_EQ(Code.str(),
Krasimir Georgievbcda54b2017-04-21 14:35:20 +000093 format(test::messUp(Code), Style, SC_ExpectIncomplete));
Manuel Klimekec5c3db2015-05-07 12:26:30 +000094 }
95
Daniel Jasperf7935112012-12-03 18:12:45 +000096 void verifyGoogleFormat(llvm::StringRef Code) {
Manuel Klimekb69e3c62013-01-02 18:33:23 +000097 verifyFormat(Code, getGoogleStyle());
Daniel Jasperf7935112012-12-03 18:12:45 +000098 }
Daniel Jasper5b49f472013-01-23 12:10:53 +000099
100 void verifyIndependentOfContext(llvm::StringRef text) {
101 verifyFormat(text);
102 verifyFormat(llvm::Twine("void f() { " + text + " }").str());
103 }
Daniel Jasper7b038a22013-01-30 09:46:12 +0000104
Daniel Jasper675b4f82015-01-19 10:51:23 +0000105 /// \brief Verify that clang-format does not crash on the given input.
106 void verifyNoCrash(llvm::StringRef Code,
107 const FormatStyle &Style = getLLVMStyle()) {
Krasimir Georgievbcda54b2017-04-21 14:35:20 +0000108 format(Code, Style, SC_DoNotCheck);
Daniel Jasper675b4f82015-01-19 10:51:23 +0000109 }
110
Daniel Jasper7b038a22013-01-30 09:46:12 +0000111 int ReplacementCount;
Daniel Jasperf7935112012-12-03 18:12:45 +0000112};
113
Manuel Klimek52b15152013-01-09 15:25:02 +0000114TEST_F(FormatTest, MessUp) {
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +0000115 EXPECT_EQ("1 2 3", test::messUp("1 2 3"));
116 EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n"));
117 EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc"));
118 EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc"));
119 EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne"));
Manuel Klimek52b15152013-01-09 15:25:02 +0000120}
121
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000122//===----------------------------------------------------------------------===//
123// Basic function tests.
124//===----------------------------------------------------------------------===//
125
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +0000126TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) {
Daniel Jasperf7935112012-12-03 18:12:45 +0000127 EXPECT_EQ(";", format(";"));
128}
129
130TEST_F(FormatTest, FormatsGlobalStatementsAt0) {
131 EXPECT_EQ("int i;", format(" int i;"));
Alexander Kornienko9e649af2013-09-11 12:25:57 +0000132 EXPECT_EQ("\nint i;", format(" \n\t \v \f int i;"));
Daniel Jasperf7935112012-12-03 18:12:45 +0000133 EXPECT_EQ("int i;\nint j;", format(" int i; int j;"));
134 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;"));
135}
136
137TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) {
138 EXPECT_EQ("int i;", format("int\ni;"));
139}
140
141TEST_F(FormatTest, FormatsNestedBlockStatements) {
Manuel Klimeke7d10a12013-01-10 13:24:24 +0000142 EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}"));
Daniel Jasperf7935112012-12-03 18:12:45 +0000143}
144
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000145TEST_F(FormatTest, FormatsNestedCall) {
146 verifyFormat("Method(f1, f2(f3));");
147 verifyFormat("Method(f1(f2, f3()));");
Daniel Jasper48cb3b92013-01-13 08:19:51 +0000148 verifyFormat("Method(f1(f2, (f3())));");
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000149}
150
Daniel Jasper14556742013-02-07 21:08:36 +0000151TEST_F(FormatTest, NestedNameSpecifiers) {
Chandler Carruthf8b72662014-03-02 12:37:31 +0000152 verifyFormat("vector<::Type> v;");
Daniel Jasper14556742013-02-07 21:08:36 +0000153 verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())");
Daniel Jasper11be8ac2013-08-28 07:07:07 +0000154 verifyFormat("static constexpr bool Bar = decltype(bar())::value;");
Daniel Jasperf322eb52014-10-23 20:22:22 +0000155 verifyFormat("bool a = 2 < ::SomeFunction();");
Daniel Jasper23c2b5a2017-02-17 10:44:07 +0000156 verifyFormat("ALWAYS_INLINE ::std::string getName();");
157 verifyFormat("some::string getName();");
Daniel Jasper736c14f2013-01-16 07:19:28 +0000158}
159
Daniel Jasper7b038a22013-01-30 09:46:12 +0000160TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) {
161 EXPECT_EQ("if (a) {\n"
162 " f();\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000163 "}",
164 format("if(a){f();}"));
Daniel Jasper7b038a22013-01-30 09:46:12 +0000165 EXPECT_EQ(4, ReplacementCount);
166 EXPECT_EQ("if (a) {\n"
167 " f();\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000168 "}",
169 format("if (a) {\n"
170 " f();\n"
171 "}"));
Daniel Jasper7b038a22013-01-30 09:46:12 +0000172 EXPECT_EQ(0, ReplacementCount);
Daniel Jasperd6e61882015-06-17 12:23:15 +0000173 EXPECT_EQ("/*\r\n"
174 "\r\n"
175 "*/\r\n",
176 format("/*\r\n"
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +0000177 "\r\n"
178 "*/\r\n"));
Daniel Jasperd6e61882015-06-17 12:23:15 +0000179 EXPECT_EQ(0, ReplacementCount);
Daniel Jasper7b038a22013-01-30 09:46:12 +0000180}
181
Daniel Jasper1027c6e2013-06-03 16:16:41 +0000182TEST_F(FormatTest, RemovesEmptyLines) {
183 EXPECT_EQ("class C {\n"
184 " int i;\n"
185 "};",
186 format("class C {\n"
187 " int i;\n"
188 "\n"
189 "};"));
190
Nico Weber34272652014-11-13 16:25:37 +0000191 // Don't remove empty lines at the start of namespaces or extern "C" blocks.
Daniel Jasper01b35482014-03-21 13:03:33 +0000192 EXPECT_EQ("namespace N {\n"
193 "\n"
194 "int i;\n"
Krasimir Georgiev9163fe22017-03-02 09:54:44 +0000195 "}",
Daniel Jasper01b35482014-03-21 13:03:33 +0000196 format("namespace N {\n"
197 "\n"
198 "int i;\n"
Daniel Jaspera26fc5c2014-03-21 13:43:14 +0000199 "}",
200 getGoogleStyle()));
Nico Weber34272652014-11-13 16:25:37 +0000201 EXPECT_EQ("extern /**/ \"C\" /**/ {\n"
202 "\n"
203 "int i;\n"
204 "}",
205 format("extern /**/ \"C\" /**/ {\n"
206 "\n"
207 "int i;\n"
208 "}",
209 getGoogleStyle()));
210
211 // ...but do keep inlining and removing empty lines for non-block extern "C"
212 // functions.
213 verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle());
214 EXPECT_EQ("extern \"C\" int f() {\n"
215 " int i = 42;\n"
216 " return i;\n"
217 "}",
218 format("extern \"C\" int f() {\n"
219 "\n"
220 " int i = 42;\n"
221 " return i;\n"
222 "}",
223 getGoogleStyle()));
Daniel Jasper01b35482014-03-21 13:03:33 +0000224
Daniel Jasper11164bd2014-03-21 12:58:53 +0000225 // Remove empty lines at the beginning and end of blocks.
226 EXPECT_EQ("void f() {\n"
Daniel Jaspera26fc5c2014-03-21 13:43:14 +0000227 "\n"
228 " if (a) {\n"
229 "\n"
230 " f();\n"
231 " }\n"
232 "}",
233 format("void f() {\n"
234 "\n"
235 " if (a) {\n"
236 "\n"
237 " f();\n"
238 "\n"
239 " }\n"
240 "\n"
241 "}",
242 getLLVMStyle()));
243 EXPECT_EQ("void f() {\n"
Daniel Jasper11164bd2014-03-21 12:58:53 +0000244 " if (a) {\n"
245 " f();\n"
246 " }\n"
247 "}",
248 format("void f() {\n"
249 "\n"
250 " if (a) {\n"
251 "\n"
252 " f();\n"
253 "\n"
254 " }\n"
255 "\n"
Daniel Jaspera26fc5c2014-03-21 13:43:14 +0000256 "}",
257 getGoogleStyle()));
Daniel Jasper11164bd2014-03-21 12:58:53 +0000258
Daniel Jasper1027c6e2013-06-03 16:16:41 +0000259 // Don't remove empty lines in more complex control statements.
260 EXPECT_EQ("void f() {\n"
261 " if (a) {\n"
262 " f();\n"
263 "\n"
264 " } else if (b) {\n"
265 " f();\n"
266 " }\n"
267 "}",
268 format("void f() {\n"
269 " if (a) {\n"
270 " f();\n"
271 "\n"
272 " } else if (b) {\n"
273 " f();\n"
274 "\n"
275 " }\n"
276 "\n"
277 "}"));
278
279 // FIXME: This is slightly inconsistent.
Krasimir Georgiev32eaa862017-03-01 15:35:39 +0000280 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
281 LLVMWithNoNamespaceFix.FixNamespaceComments = false;
Daniel Jasper1027c6e2013-06-03 16:16:41 +0000282 EXPECT_EQ("namespace {\n"
283 "int i;\n"
284 "}",
285 format("namespace {\n"
286 "int i;\n"
287 "\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +0000288 "}", LLVMWithNoNamespaceFix));
289 EXPECT_EQ("namespace {\n"
290 "int i;\n"
Krasimir Georgiev9163fe22017-03-02 09:54:44 +0000291 "}",
Krasimir Georgiev32eaa862017-03-01 15:35:39 +0000292 format("namespace {\n"
293 "int i;\n"
294 "\n"
Daniel Jasper1027c6e2013-06-03 16:16:41 +0000295 "}"));
296 EXPECT_EQ("namespace {\n"
297 "int i;\n"
298 "\n"
299 "} // namespace",
300 format("namespace {\n"
301 "int i;\n"
302 "\n"
303 "} // namespace"));
Cameron Desrochers1991e5d2016-11-15 15:07:07 +0000304
305 FormatStyle Style = getLLVMStyle();
306 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
307 Style.MaxEmptyLinesToKeep = 2;
308 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
309 Style.BraceWrapping.AfterClass = true;
310 Style.BraceWrapping.AfterFunction = true;
311 Style.KeepEmptyLinesAtTheStartOfBlocks = false;
312
313 EXPECT_EQ("class Foo\n"
314 "{\n"
315 " Foo() {}\n"
316 "\n"
317 " void funk() {}\n"
318 "};",
319 format("class Foo\n"
320 "{\n"
321 " Foo()\n"
322 " {\n"
323 " }\n"
324 "\n"
325 " void funk() {}\n"
326 "};",
327 Style));
Daniel Jasper1027c6e2013-06-03 16:16:41 +0000328}
329
Nikola Smiljanice08a91e2014-05-08 00:05:13 +0000330TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) {
Daniel Jaspera44991332015-04-29 13:06:49 +0000331 verifyFormat("x = (a) and (b);");
332 verifyFormat("x = (a) or (b);");
333 verifyFormat("x = (a) bitand (b);");
334 verifyFormat("x = (a) bitor (b);");
335 verifyFormat("x = (a) not_eq (b);");
336 verifyFormat("x = (a) and_eq (b);");
337 verifyFormat("x = (a) or_eq (b);");
338 verifyFormat("x = (a) xor (b);");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +0000339}
340
Olivier Goffart90f981b2017-07-14 09:23:40 +0000341TEST_F(FormatTest, RecognizesUnaryOperatorKeywords) {
342 verifyFormat("x = compl(a);");
343 verifyFormat("x = not(a);");
344 verifyFormat("x = bitand(a);");
345 // Unary operator must not be merged with the next identifier
346 verifyFormat("x = compl a;");
347 verifyFormat("x = not a;");
348 verifyFormat("x = bitand a;");
349}
350
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000351//===----------------------------------------------------------------------===//
352// Tests for control statements.
353//===----------------------------------------------------------------------===//
354
Daniel Jaspercdd06622013-05-14 10:31:09 +0000355TEST_F(FormatTest, FormatIfWithoutCompoundStatement) {
Daniel Jasper1b750ed2013-01-14 16:24:39 +0000356 verifyFormat("if (true)\n f();\ng();");
357 verifyFormat("if (a)\n if (b)\n if (c)\n g();\nh();");
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000358 verifyFormat("if (a)\n if (b) {\n f();\n }\ng();");
Daniel Jasper6a7d5a72017-06-19 07:40:49 +0000359 verifyFormat("if constexpr (true)\n"
360 " f();\ng();");
361 verifyFormat("if constexpr (a)\n"
362 " if constexpr (b)\n"
363 " if constexpr (c)\n"
364 " g();\n"
365 "h();");
366 verifyFormat("if constexpr (a)\n"
367 " if constexpr (b) {\n"
368 " f();\n"
369 " }\n"
370 "g();");
Daniel Jasperced17f82013-01-16 15:44:34 +0000371
Daniel Jasper3a685df2013-05-16 12:12:21 +0000372 FormatStyle AllowsMergedIf = getLLVMStyle();
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +0000373 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left;
Daniel Jasperced17f82013-01-16 15:44:34 +0000374 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true;
375 verifyFormat("if (a)\n"
376 " // comment\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000377 " f();",
378 AllowsMergedIf);
Daniel Jasper40609472016-04-06 15:02:46 +0000379 verifyFormat("{\n"
380 " if (a)\n"
381 " label:\n"
382 " f();\n"
383 "}",
384 AllowsMergedIf);
Daniel Jasper2cce7b72016-04-06 16:41:39 +0000385 verifyFormat("#define A \\\n"
386 " if (a) \\\n"
387 " label: \\\n"
388 " f()",
389 AllowsMergedIf);
Daniel Jasper3a685df2013-05-16 12:12:21 +0000390 verifyFormat("if (a)\n"
391 " ;",
392 AllowsMergedIf);
393 verifyFormat("if (a)\n"
394 " if (b) return;",
395 AllowsMergedIf);
Daniel Jasperced17f82013-01-16 15:44:34 +0000396
Daniel Jasper3a685df2013-05-16 12:12:21 +0000397 verifyFormat("if (a) // Can't merge this\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000398 " f();\n",
399 AllowsMergedIf);
Daniel Jasperced17f82013-01-16 15:44:34 +0000400 verifyFormat("if (a) /* still don't merge */\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000401 " f();",
402 AllowsMergedIf);
Daniel Jasper3a685df2013-05-16 12:12:21 +0000403 verifyFormat("if (a) { // Never merge this\n"
Daniel Jasperced17f82013-01-16 15:44:34 +0000404 " f();\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000405 "}",
406 AllowsMergedIf);
Daniel Jaspereb65e912015-12-21 18:31:15 +0000407 verifyFormat("if (a) { /* Never merge this */\n"
Daniel Jasperced17f82013-01-16 15:44:34 +0000408 " f();\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000409 "}",
410 AllowsMergedIf);
Daniel Jasperced17f82013-01-16 15:44:34 +0000411
412 AllowsMergedIf.ColumnLimit = 14;
413 verifyFormat("if (a) return;", AllowsMergedIf);
Daniel Jasper3e9218e2013-01-14 16:02:06 +0000414 verifyFormat("if (aaaaaaaaa)\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000415 " return;",
416 AllowsMergedIf);
Daniel Jasperced17f82013-01-16 15:44:34 +0000417
418 AllowsMergedIf.ColumnLimit = 13;
419 verifyFormat("if (a)\n return;", AllowsMergedIf);
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000420}
421
Daniel Jasper3a685df2013-05-16 12:12:21 +0000422TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) {
423 FormatStyle AllowsMergedLoops = getLLVMStyle();
424 AllowsMergedLoops.AllowShortLoopsOnASingleLine = true;
425 verifyFormat("while (true) continue;", AllowsMergedLoops);
426 verifyFormat("for (;;) continue;", AllowsMergedLoops);
427 verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops);
428 verifyFormat("while (true)\n"
429 " ;",
430 AllowsMergedLoops);
431 verifyFormat("for (;;)\n"
432 " ;",
433 AllowsMergedLoops);
434 verifyFormat("for (;;)\n"
435 " for (;;) continue;",
436 AllowsMergedLoops);
437 verifyFormat("for (;;) // Can't merge this\n"
438 " continue;",
439 AllowsMergedLoops);
440 verifyFormat("for (;;) /* still don't merge */\n"
441 " continue;",
442 AllowsMergedLoops);
443}
444
Daniel Jasper17605d32014-05-14 09:33:35 +0000445TEST_F(FormatTest, FormatShortBracedStatements) {
446 FormatStyle AllowSimpleBracedStatements = getLLVMStyle();
Krasimir Georgiev3b0b50b2017-09-11 10:12:16 +0000447 AllowSimpleBracedStatements.ColumnLimit = 40;
Daniel Jasper17605d32014-05-14 09:33:35 +0000448 AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine = true;
449
450 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = true;
451 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
452
Krasimir Georgiev3b0b50b2017-09-11 10:12:16 +0000453 AllowSimpleBracedStatements.BreakBeforeBraces = FormatStyle::BS_Custom;
454 AllowSimpleBracedStatements.BraceWrapping.AfterFunction = true;
455 AllowSimpleBracedStatements.BraceWrapping.SplitEmptyRecord = false;
456
Daniel Jasper17605d32014-05-14 09:33:35 +0000457 verifyFormat("if (true) {}", AllowSimpleBracedStatements);
Daniel Jasper6a7d5a72017-06-19 07:40:49 +0000458 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements);
Daniel Jasper17605d32014-05-14 09:33:35 +0000459 verifyFormat("while (true) {}", AllowSimpleBracedStatements);
460 verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
461 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
Daniel Jasper6a7d5a72017-06-19 07:40:49 +0000462 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements);
Daniel Jasper17605d32014-05-14 09:33:35 +0000463 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
464 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
Krasimir Georgiev3b0b50b2017-09-11 10:12:16 +0000465 verifyFormat("if (true) {\n"
466 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
467 "}",
468 AllowSimpleBracedStatements);
Daniel Jasper17605d32014-05-14 09:33:35 +0000469 verifyFormat("if (true) { //\n"
470 " f();\n"
471 "}",
472 AllowSimpleBracedStatements);
473 verifyFormat("if (true) {\n"
474 " f();\n"
475 " f();\n"
476 "}",
477 AllowSimpleBracedStatements);
Daniel Jaspere9f53572015-04-30 09:24:17 +0000478 verifyFormat("if (true) {\n"
479 " f();\n"
480 "} else {\n"
481 " f();\n"
482 "}",
483 AllowSimpleBracedStatements);
Daniel Jasper17605d32014-05-14 09:33:35 +0000484
Daniel Jasperf92659e2017-06-19 07:45:41 +0000485 verifyFormat("struct A2 {\n"
486 " int X;\n"
487 "};",
488 AllowSimpleBracedStatements);
489 verifyFormat("typedef struct A2 {\n"
490 " int X;\n"
491 "} A2_t;",
492 AllowSimpleBracedStatements);
Daniel Jasperbd630732014-05-22 13:25:26 +0000493 verifyFormat("template <int> struct A2 {\n"
494 " struct B {};\n"
495 "};",
496 AllowSimpleBracedStatements);
497
Daniel Jasper17605d32014-05-14 09:33:35 +0000498 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = false;
Krasimir Georgiev3b0b50b2017-09-11 10:12:16 +0000499 verifyFormat("if (true) {}", AllowSimpleBracedStatements);
Daniel Jasper17605d32014-05-14 09:33:35 +0000500 verifyFormat("if (true) {\n"
501 " f();\n"
502 "}",
503 AllowSimpleBracedStatements);
Daniel Jaspere9f53572015-04-30 09:24:17 +0000504 verifyFormat("if (true) {\n"
505 " f();\n"
506 "} else {\n"
507 " f();\n"
508 "}",
509 AllowSimpleBracedStatements);
Daniel Jasper17605d32014-05-14 09:33:35 +0000510
511 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
Krasimir Georgiev3b0b50b2017-09-11 10:12:16 +0000512 verifyFormat("while (true) {}", AllowSimpleBracedStatements);
Daniel Jasper17605d32014-05-14 09:33:35 +0000513 verifyFormat("while (true) {\n"
514 " f();\n"
515 "}",
516 AllowSimpleBracedStatements);
Krasimir Georgiev3b0b50b2017-09-11 10:12:16 +0000517 verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
Daniel Jasper17605d32014-05-14 09:33:35 +0000518 verifyFormat("for (;;) {\n"
519 " f();\n"
520 "}",
521 AllowSimpleBracedStatements);
Krasimir Georgiev3b0b50b2017-09-11 10:12:16 +0000522
523 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = true;
524 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
525 AllowSimpleBracedStatements.BraceWrapping.AfterControlStatement = true;
526
527 verifyFormat("if (true) {}", AllowSimpleBracedStatements);
528 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements);
529 verifyFormat("while (true) {}", AllowSimpleBracedStatements);
530 verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
531 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
532 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements);
533 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
534 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
535 verifyFormat("if (true)\n"
536 "{\n"
537 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
538 "}",
539 AllowSimpleBracedStatements);
540 verifyFormat("if (true)\n"
541 "{ //\n"
542 " f();\n"
543 "}",
544 AllowSimpleBracedStatements);
545 verifyFormat("if (true)\n"
546 "{\n"
547 " f();\n"
548 " f();\n"
549 "}",
550 AllowSimpleBracedStatements);
551 verifyFormat("if (true)\n"
552 "{\n"
553 " f();\n"
554 "} else\n"
555 "{\n"
556 " f();\n"
557 "}",
558 AllowSimpleBracedStatements);
559
560 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = false;
561 verifyFormat("if (true) {}", AllowSimpleBracedStatements);
562 verifyFormat("if (true)\n"
563 "{\n"
564 " f();\n"
565 "}",
566 AllowSimpleBracedStatements);
567 verifyFormat("if (true)\n"
568 "{\n"
569 " f();\n"
570 "} else\n"
571 "{\n"
572 " f();\n"
573 "}",
574 AllowSimpleBracedStatements);
575
576 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
577 verifyFormat("while (true) {}", AllowSimpleBracedStatements);
578 verifyFormat("while (true)\n"
579 "{\n"
580 " f();\n"
581 "}",
582 AllowSimpleBracedStatements);
583 verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
584 verifyFormat("for (;;)\n"
585 "{\n"
586 " f();\n"
587 "}",
588 AllowSimpleBracedStatements);
Daniel Jasper17605d32014-05-14 09:33:35 +0000589}
590
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000591TEST_F(FormatTest, ParseIfElse) {
592 verifyFormat("if (true)\n"
593 " if (true)\n"
594 " if (true)\n"
595 " f();\n"
596 " else\n"
597 " g();\n"
598 " else\n"
599 " h();\n"
600 "else\n"
601 " i();");
602 verifyFormat("if (true)\n"
603 " if (true)\n"
604 " if (true) {\n"
Daniel Jasper1b750ed2013-01-14 16:24:39 +0000605 " if (true)\n"
606 " f();\n"
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000607 " } else {\n"
608 " g();\n"
609 " }\n"
610 " else\n"
611 " h();\n"
612 "else {\n"
613 " i();\n"
614 "}");
Daniel Jasper6a7d5a72017-06-19 07:40:49 +0000615 verifyFormat("if (true)\n"
616 " if constexpr (true)\n"
617 " if (true) {\n"
618 " if constexpr (true)\n"
619 " f();\n"
620 " } else {\n"
621 " g();\n"
622 " }\n"
623 " else\n"
624 " h();\n"
625 "else {\n"
626 " i();\n"
627 "}");
Daniel Jasper88f92222013-09-17 08:28:05 +0000628 verifyFormat("void f() {\n"
629 " if (a) {\n"
630 " } else {\n"
631 " }\n"
632 "}");
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000633}
634
635TEST_F(FormatTest, ElseIf) {
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000636 verifyFormat("if (a) {\n} else if (b) {\n}");
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000637 verifyFormat("if (a)\n"
638 " f();\n"
639 "else if (b)\n"
640 " g();\n"
641 "else\n"
642 " h();");
Daniel Jasper6a7d5a72017-06-19 07:40:49 +0000643 verifyFormat("if constexpr (a)\n"
644 " f();\n"
645 "else if constexpr (b)\n"
646 " g();\n"
647 "else\n"
648 " h();");
Daniel Jasper16fc7542013-10-30 14:04:10 +0000649 verifyFormat("if (a) {\n"
650 " f();\n"
651 "}\n"
652 "// or else ..\n"
653 "else {\n"
654 " g()\n"
655 "}");
Daniel Jasper8acf8222014-05-07 09:23:05 +0000656
657 verifyFormat("if (a) {\n"
658 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
659 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
660 "}");
Daniel Jaspera42de762015-02-26 09:49:08 +0000661 verifyFormat("if (a) {\n"
662 "} else if (\n"
663 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
664 "}",
665 getLLVMStyleWithColumns(62));
Daniel Jasper6a7d5a72017-06-19 07:40:49 +0000666 verifyFormat("if (a) {\n"
667 "} else if constexpr (\n"
668 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
669 "}",
670 getLLVMStyleWithColumns(62));
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000671}
672
Daniel Jasperf7935112012-12-03 18:12:45 +0000673TEST_F(FormatTest, FormatsForLoop) {
674 verifyFormat(
675 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n"
Alexander Kornienko37d6c942012-12-05 15:06:06 +0000676 " ++VeryVeryLongLoopVariable)\n"
677 " ;");
678 verifyFormat("for (;;)\n"
679 " f();");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000680 verifyFormat("for (;;) {\n}");
Alexander Kornienko37d6c942012-12-05 15:06:06 +0000681 verifyFormat("for (;;) {\n"
682 " f();\n"
683 "}");
Daniel Jasper72463d32013-05-03 14:50:50 +0000684 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}");
Daniel Jasperfbde69e2012-12-21 14:37:20 +0000685
686 verifyFormat(
687 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
688 " E = UnwrappedLines.end();\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000689 " I != E; ++I) {\n}");
Daniel Jasperfbde69e2012-12-21 14:37:20 +0000690
691 verifyFormat(
692 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000693 " ++IIIII) {\n}");
Daniel Jaspera628c982013-04-03 13:36:17 +0000694 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n"
695 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000696 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}");
Daniel Jasper37905f72013-02-21 15:00:29 +0000697 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n"
698 " I = FD->getDeclsInPrototypeScope().begin(),\n"
699 " E = FD->getDeclsInPrototypeScope().end();\n"
700 " I != E; ++I) {\n}");
Daniel Jasperd6e09e82015-05-19 11:51:39 +0000701 verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n"
702 " I = Container.begin(),\n"
703 " E = Container.end();\n"
704 " I != E; ++I) {\n}",
705 getLLVMStyleWithColumns(76));
Daniel Jasper48c62f92013-01-28 17:30:17 +0000706
Daniel Jasper48c62f92013-01-28 17:30:17 +0000707 verifyFormat(
708 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
709 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n"
Daniel Jasper98f8ae32015-03-06 10:57:12 +0000710 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
711 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
Daniel Jasper48c62f92013-01-28 17:30:17 +0000712 " ++aaaaaaaaaaa) {\n}");
Daniel Jasper98f8ae32015-03-06 10:57:12 +0000713 verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
714 " bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n"
715 " ++i) {\n}");
Daniel Jasper2cf17bf2013-02-27 09:47:53 +0000716 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n"
717 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
718 "}");
Daniel Jaspera628c982013-04-03 13:36:17 +0000719 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n"
720 " aaaaaaaaaa);\n"
721 " iter; ++iter) {\n"
722 "}");
Daniel Jasper3bacc4d2015-07-07 16:09:39 +0000723 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
724 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
725 " aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n"
726 " ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {");
Daniel Jasperf7f13c02013-02-04 07:30:30 +0000727
Daniel Jasper2cf17bf2013-02-27 09:47:53 +0000728 FormatStyle NoBinPacking = getLLVMStyle();
729 NoBinPacking.BinPackParameters = false;
730 verifyFormat("for (int aaaaaaaaaaa = 1;\n"
731 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n"
732 " aaaaaaaaaaaaaaaa,\n"
733 " aaaaaaaaaaaaaaaa,\n"
734 " aaaaaaaaaaaaaaaa);\n"
735 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
736 "}",
737 NoBinPacking);
738 verifyFormat(
Daniel Jaspercd8599e2013-02-23 21:01:55 +0000739 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
740 " E = UnwrappedLines.end();\n"
741 " I != E;\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +0000742 " ++I) {\n}",
743 NoBinPacking);
Daniel Jasper7b85a192017-09-03 08:56:24 +0000744
745 FormatStyle AlignLeft = getLLVMStyle();
746 AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
747 verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft);
Daniel Jasperf7935112012-12-03 18:12:45 +0000748}
749
Daniel Jasper0b41cbb2013-01-28 13:21:16 +0000750TEST_F(FormatTest, RangeBasedForLoops) {
751 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
752 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
753 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n"
754 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}");
Daniel Jasper16b35622013-02-26 13:18:08 +0000755 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n"
756 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasper9cc3e972014-02-07 10:09:46 +0000757 verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n"
758 " aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}");
Daniel Jasper0b41cbb2013-01-28 13:21:16 +0000759}
760
Daniel Jaspere1e43192014-04-01 12:55:11 +0000761TEST_F(FormatTest, ForEachLoops) {
762 verifyFormat("void f() {\n"
763 " foreach (Item *item, itemlist) {}\n"
764 " Q_FOREACH (Item *item, itemlist) {}\n"
765 " BOOST_FOREACH (Item *item, itemlist) {}\n"
766 " UNKNOWN_FORACH(Item * item, itemlist) {}\n"
767 "}");
Daniel Jasper229628b2015-06-11 08:38:19 +0000768
769 // As function-like macros.
770 verifyFormat("#define foreach(x, y)\n"
771 "#define Q_FOREACH(x, y)\n"
772 "#define BOOST_FOREACH(x, y)\n"
773 "#define UNKNOWN_FOREACH(x, y)\n");
774
775 // Not as function-like macros.
776 verifyFormat("#define foreach (x, y)\n"
777 "#define Q_FOREACH (x, y)\n"
778 "#define BOOST_FOREACH (x, y)\n"
779 "#define UNKNOWN_FOREACH (x, y)\n");
Daniel Jaspere1e43192014-04-01 12:55:11 +0000780}
781
Daniel Jasperf7935112012-12-03 18:12:45 +0000782TEST_F(FormatTest, FormatsWhileLoop) {
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000783 verifyFormat("while (true) {\n}");
Alexander Kornienko37d6c942012-12-05 15:06:06 +0000784 verifyFormat("while (true)\n"
785 " f();");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000786 verifyFormat("while () {\n}");
Alexander Kornienko37d6c942012-12-05 15:06:06 +0000787 verifyFormat("while () {\n"
788 " f();\n"
789 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +0000790}
791
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000792TEST_F(FormatTest, FormatsDoWhile) {
793 verifyFormat("do {\n"
794 " do_something();\n"
795 "} while (something());");
796 verifyFormat("do\n"
797 " do_something();\n"
798 "while (something());");
Daniel Jasperf7935112012-12-03 18:12:45 +0000799}
800
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000801TEST_F(FormatTest, FormatsSwitchStatement) {
Daniel Jasperf7935112012-12-03 18:12:45 +0000802 verifyFormat("switch (x) {\n"
803 "case 1:\n"
804 " f();\n"
805 " break;\n"
806 "case kFoo:\n"
807 "case ns::kBar:\n"
808 "case kBaz:\n"
809 " break;\n"
810 "default:\n"
811 " g();\n"
812 " break;\n"
813 "}");
814 verifyFormat("switch (x) {\n"
815 "case 1: {\n"
816 " f();\n"
817 " break;\n"
818 "}\n"
Daniel Jasper922349c2014-04-04 06:46:23 +0000819 "case 2: {\n"
820 " break;\n"
821 "}\n"
Daniel Jasperf7935112012-12-03 18:12:45 +0000822 "}");
Nico Webera5510af2013-01-18 05:50:57 +0000823 verifyFormat("switch (x) {\n"
824 "case 1: {\n"
825 " f();\n"
826 " {\n"
827 " g();\n"
828 " h();\n"
829 " }\n"
830 " break;\n"
831 "}\n"
832 "}");
833 verifyFormat("switch (x) {\n"
834 "case 1: {\n"
835 " f();\n"
836 " if (foo) {\n"
837 " g();\n"
838 " h();\n"
839 " }\n"
840 " break;\n"
841 "}\n"
842 "}");
843 verifyFormat("switch (x) {\n"
844 "case 1: {\n"
845 " f();\n"
846 " g();\n"
847 "} break;\n"
848 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +0000849 verifyFormat("switch (test)\n"
850 " ;");
Daniel Jasper18104652013-03-12 12:26:55 +0000851 verifyFormat("switch (x) {\n"
852 "default: {\n"
853 " // Do nothing.\n"
Manuel Klimek1a18c402013-04-12 14:13:36 +0000854 "}\n"
Daniel Jasper18104652013-03-12 12:26:55 +0000855 "}");
Daniel Jasper0f8ed9e2013-03-13 15:53:12 +0000856 verifyFormat("switch (x) {\n"
Daniel Jasperb67cc422013-04-09 17:46:55 +0000857 "// comment\n"
Daniel Jasper0f8ed9e2013-03-13 15:53:12 +0000858 "// if 1, do f()\n"
859 "case 1:\n"
860 " f();\n"
861 "}");
Daniel Jasper2bd32ca2013-03-19 18:33:58 +0000862 verifyFormat("switch (x) {\n"
863 "case 1:\n"
864 " // Do amazing stuff\n"
865 " {\n"
866 " f();\n"
867 " g();\n"
868 " }\n"
869 " break;\n"
870 "}");
Daniel Jaspera1275122013-03-20 10:23:53 +0000871 verifyFormat("#define A \\\n"
872 " switch (x) { \\\n"
873 " case a: \\\n"
874 " foo = b; \\\n"
Daniel Jaspera44991332015-04-29 13:06:49 +0000875 " }",
876 getLLVMStyleWithColumns(20));
Daniel Jasper72407622013-09-02 08:26:29 +0000877 verifyFormat("#define OPERATION_CASE(name) \\\n"
878 " case OP_name: \\\n"
879 " return operations::Operation##name\n",
880 getLLVMStyleWithColumns(40));
Daniel Jasper1fe0d5c2015-05-06 15:19:47 +0000881 verifyFormat("switch (x) {\n"
882 "case 1:;\n"
883 "default:;\n"
884 " int i;\n"
885 "}");
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000886
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000887 verifyGoogleFormat("switch (x) {\n"
888 " case 1:\n"
889 " f();\n"
890 " break;\n"
891 " case kFoo:\n"
892 " case ns::kBar:\n"
893 " case kBaz:\n"
894 " break;\n"
895 " default:\n"
896 " g();\n"
897 " break;\n"
898 "}");
899 verifyGoogleFormat("switch (x) {\n"
900 " case 1: {\n"
901 " f();\n"
902 " break;\n"
903 " }\n"
904 "}");
905 verifyGoogleFormat("switch (test)\n"
Daniel Jasper516d7972013-07-25 11:31:57 +0000906 " ;");
907
908 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n"
909 " case OP_name: \\\n"
910 " return operations::Operation##name\n");
911 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n"
912 " // Get the correction operation class.\n"
913 " switch (OpCode) {\n"
914 " CASE(Add);\n"
915 " CASE(Subtract);\n"
916 " default:\n"
917 " return operations::Unknown;\n"
918 " }\n"
919 "#undef OPERATION_CASE\n"
920 "}");
Daniel Jasper1c5d9df2013-09-06 07:54:20 +0000921 verifyFormat("DEBUG({\n"
922 " switch (x) {\n"
923 " case A:\n"
924 " f();\n"
925 " break;\n"
Krasimir Georgieve0926342017-07-12 15:21:43 +0000926 " // fallthrough\n"
Daniel Jasper1c5d9df2013-09-06 07:54:20 +0000927 " case B:\n"
928 " g();\n"
929 " break;\n"
930 " }\n"
931 "});");
Krasimir Georgieve0926342017-07-12 15:21:43 +0000932 EXPECT_EQ("DEBUG({\n"
933 " switch (x) {\n"
934 " case A:\n"
935 " f();\n"
936 " break;\n"
937 " // On B:\n"
938 " case B:\n"
939 " g();\n"
940 " break;\n"
941 " }\n"
942 "});",
943 format("DEBUG({\n"
944 " switch (x) {\n"
945 " case A:\n"
946 " f();\n"
947 " break;\n"
948 " // On B:\n"
949 " case B:\n"
950 " g();\n"
951 " break;\n"
952 " }\n"
953 "});",
954 getLLVMStyle()));
Daniel Jasper031e2402014-04-28 07:48:36 +0000955 verifyFormat("switch (a) {\n"
956 "case (b):\n"
957 " return;\n"
958 "}");
Daniel Jasperd39312ec2014-05-28 10:09:11 +0000959
960 verifyFormat("switch (a) {\n"
961 "case some_namespace::\n"
962 " some_constant:\n"
963 " return;\n"
964 "}",
965 getLLVMStyleWithColumns(34));
Daniel Jasperf7935112012-12-03 18:12:45 +0000966}
967
Daniel Jasper2d0cd492013-10-20 16:56:16 +0000968TEST_F(FormatTest, CaseRanges) {
969 verifyFormat("switch (x) {\n"
970 "case 'A' ... 'Z':\n"
971 "case 1 ... 5:\n"
Daniel Jaspere2fab132016-05-19 06:19:17 +0000972 "case a ... b:\n"
Daniel Jasper2d0cd492013-10-20 16:56:16 +0000973 " break;\n"
974 "}");
975}
976
Daniel Jasperb87899b2014-09-10 13:11:45 +0000977TEST_F(FormatTest, ShortCaseLabels) {
978 FormatStyle Style = getLLVMStyle();
979 Style.AllowShortCaseLabelsOnASingleLine = true;
980 verifyFormat("switch (a) {\n"
981 "case 1: x = 1; break;\n"
982 "case 2: return;\n"
983 "case 3:\n"
984 "case 4:\n"
985 "case 5: return;\n"
Daniel Jasperd081e882014-11-21 12:36:25 +0000986 "case 6: // comment\n"
987 " return;\n"
988 "case 7:\n"
989 " // comment\n"
990 " return;\n"
Daniel Jasper368369b2015-09-21 09:50:01 +0000991 "case 8:\n"
992 " x = 8; // comment\n"
993 " break;\n"
Daniel Jasperb87899b2014-09-10 13:11:45 +0000994 "default: y = 1; break;\n"
995 "}",
996 Style);
997 verifyFormat("switch (a) {\n"
Francois Ferranda64ba702017-07-28 07:56:18 +0000998 "case 0: return; // comment\n"
999 "case 1: break; // comment\n"
1000 "case 2: return;\n"
1001 "// comment\n"
1002 "case 3: return;\n"
1003 "// comment 1\n"
1004 "// comment 2\n"
1005 "// comment 3\n"
1006 "case 4: break; /* comment */\n"
1007 "case 5:\n"
1008 " // comment\n"
1009 " break;\n"
1010 "case 6: /* comment */ x = 1; break;\n"
1011 "case 7: x = /* comment */ 1; break;\n"
1012 "case 8:\n"
1013 " x = 1; /* comment */\n"
1014 " break;\n"
1015 "case 9:\n"
1016 " break; // comment line 1\n"
1017 " // comment line 2\n"
1018 "}",
1019 Style);
1020 EXPECT_EQ("switch (a) {\n"
1021 "case 1:\n"
1022 " x = 8;\n"
1023 " // fall through\n"
1024 "case 2: x = 8;\n"
1025 "// comment\n"
1026 "case 3:\n"
1027 " return; /* comment line 1\n"
1028 " * comment line 2 */\n"
1029 "case 4: i = 8;\n"
1030 "// something else\n"
1031 "#if FOO\n"
1032 "case 5: break;\n"
1033 "#endif\n"
1034 "}",
1035 format("switch (a) {\n"
1036 "case 1: x = 8;\n"
1037 " // fall through\n"
1038 "case 2:\n"
1039 " x = 8;\n"
1040 "// comment\n"
1041 "case 3:\n"
1042 " return; /* comment line 1\n"
1043 " * comment line 2 */\n"
1044 "case 4:\n"
1045 " i = 8;\n"
1046 "// something else\n"
1047 "#if FOO\n"
1048 "case 5: break;\n"
1049 "#endif\n"
1050 "}",
1051 Style));
1052 EXPECT_EQ("switch (a) {\n" "case 0:\n"
1053 " return; // long long long long long long long long long long long long comment\n"
1054 " // line\n" "}",
1055 format("switch (a) {\n"
1056 "case 0: return; // long long long long long long long long long long long long comment line\n"
1057 "}",
1058 Style));
1059 EXPECT_EQ("switch (a) {\n"
1060 "case 0:\n"
1061 " return; /* long long long long long long long long long long long long comment\n"
1062 " line */\n"
1063 "}",
1064 format("switch (a) {\n"
1065 "case 0: return; /* long long long long long long long long long long long long comment line */\n"
1066 "}",
1067 Style));
1068 verifyFormat("switch (a) {\n"
Daniel Jasper79f226e2014-11-23 21:45:03 +00001069 "#if FOO\n"
1070 "case 0: return 0;\n"
1071 "#endif\n"
1072 "}",
1073 Style);
1074 verifyFormat("switch (a) {\n"
Daniel Jasperb87899b2014-09-10 13:11:45 +00001075 "case 1: {\n"
1076 "}\n"
1077 "case 2: {\n"
1078 " return;\n"
1079 "}\n"
1080 "case 3: {\n"
1081 " x = 1;\n"
1082 " return;\n"
1083 "}\n"
1084 "case 4:\n"
1085 " if (x)\n"
1086 " return;\n"
1087 "}",
1088 Style);
1089 Style.ColumnLimit = 21;
1090 verifyFormat("switch (a) {\n"
1091 "case 1: x = 1; break;\n"
1092 "case 2: return;\n"
1093 "case 3:\n"
1094 "case 4:\n"
1095 "case 5: return;\n"
1096 "default:\n"
1097 " y = 1;\n"
1098 " break;\n"
1099 "}",
1100 Style);
1101}
1102
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001103TEST_F(FormatTest, FormatsLabels) {
Daniel Jasperf7935112012-12-03 18:12:45 +00001104 verifyFormat("void f() {\n"
1105 " some_code();\n"
1106 "test_label:\n"
1107 " some_other_code();\n"
1108 " {\n"
1109 " some_more_code();\n"
1110 " another_label:\n"
1111 " some_more_code();\n"
1112 " }\n"
1113 "}");
Daniel Jasper676e5162015-04-07 14:36:33 +00001114 verifyFormat("{\n"
1115 " some_code();\n"
Daniel Jasperf7935112012-12-03 18:12:45 +00001116 "test_label:\n"
Daniel Jasper676e5162015-04-07 14:36:33 +00001117 " some_other_code();\n"
1118 "}");
Daniel Jasper1fe0d5c2015-05-06 15:19:47 +00001119 verifyFormat("{\n"
1120 " some_code();\n"
1121 "test_label:;\n"
1122 " int i = 0;\n"
1123 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +00001124}
1125
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001126//===----------------------------------------------------------------------===//
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001127// Tests for classes, namespaces, etc.
1128//===----------------------------------------------------------------------===//
1129
1130TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) {
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001131 verifyFormat("class A {};");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001132}
1133
1134TEST_F(FormatTest, UnderstandsAccessSpecifiers) {
1135 verifyFormat("class A {\n"
1136 "public:\n"
Daniel Jasperc04baae2013-04-10 09:49:49 +00001137 "public: // comment\n"
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001138 "protected:\n"
1139 "private:\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00001140 " void f() {}\n"
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001141 "};");
1142 verifyGoogleFormat("class A {\n"
1143 " public:\n"
1144 " protected:\n"
1145 " private:\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00001146 " void f() {}\n"
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001147 "};");
Daniel Jasper84c47a12013-11-23 17:53:41 +00001148 verifyFormat("class A {\n"
1149 "public slots:\n"
Daniel Jaspera00de632015-12-01 12:05:04 +00001150 " void f1() {}\n"
Daniel Jasper1556b592013-11-29 08:51:56 +00001151 "public Q_SLOTS:\n"
Daniel Jaspera00de632015-12-01 12:05:04 +00001152 " void f2() {}\n"
1153 "protected slots:\n"
1154 " void f3() {}\n"
1155 "protected Q_SLOTS:\n"
1156 " void f4() {}\n"
1157 "private slots:\n"
1158 " void f5() {}\n"
1159 "private Q_SLOTS:\n"
1160 " void f6() {}\n"
Daniel Jasper53395402015-04-07 15:04:40 +00001161 "signals:\n"
Daniel Jaspera00de632015-12-01 12:05:04 +00001162 " void g1();\n"
1163 "Q_SIGNALS:\n"
1164 " void g2();\n"
Daniel Jasper84c47a12013-11-23 17:53:41 +00001165 "};");
Daniel Jasperde0d1f32015-04-24 07:50:34 +00001166
1167 // Don't interpret 'signals' the wrong way.
1168 verifyFormat("signals.set();");
1169 verifyFormat("for (Signals signals : f()) {\n}");
Daniel Jasper03618142015-05-06 19:21:23 +00001170 verifyFormat("{\n"
1171 " signals.set(); // This needs indentation.\n"
1172 "}");
Daniel Jasper31343832016-07-27 10:13:24 +00001173 verifyFormat("void f() {\n"
1174 "label:\n"
1175 " signals.baz();\n"
1176 "}");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001177}
1178
Alexander Kornienkofd433362013-03-27 17:08:02 +00001179TEST_F(FormatTest, SeparatesLogicalBlocks) {
1180 EXPECT_EQ("class A {\n"
1181 "public:\n"
1182 " void f();\n"
1183 "\n"
1184 "private:\n"
1185 " void g() {}\n"
1186 " // test\n"
1187 "protected:\n"
1188 " int h;\n"
1189 "};",
1190 format("class A {\n"
1191 "public:\n"
1192 "void f();\n"
1193 "private:\n"
1194 "void g() {}\n"
1195 "// test\n"
1196 "protected:\n"
1197 "int h;\n"
1198 "};"));
Daniel Jasper320997e2013-10-06 11:40:08 +00001199 EXPECT_EQ("class A {\n"
1200 "protected:\n"
1201 "public:\n"
1202 " void f();\n"
1203 "};",
1204 format("class A {\n"
1205 "protected:\n"
1206 "\n"
1207 "public:\n"
1208 "\n"
1209 " void f();\n"
1210 "};"));
Daniel Jasperac5c97e32015-03-09 08:13:55 +00001211
1212 // Even ensure proper spacing inside macros.
1213 EXPECT_EQ("#define B \\\n"
1214 " class A { \\\n"
1215 " protected: \\\n"
1216 " public: \\\n"
1217 " void f(); \\\n"
1218 " };",
1219 format("#define B \\\n"
1220 " class A { \\\n"
1221 " protected: \\\n"
1222 " \\\n"
1223 " public: \\\n"
1224 " \\\n"
1225 " void f(); \\\n"
1226 " };",
1227 getGoogleStyle()));
1228 // But don't remove empty lines after macros ending in access specifiers.
1229 EXPECT_EQ("#define A private:\n"
1230 "\n"
1231 "int i;",
1232 format("#define A private:\n"
1233 "\n"
1234 "int i;"));
Alexander Kornienkofd433362013-03-27 17:08:02 +00001235}
1236
Daniel Jasper83193602013-04-05 17:22:09 +00001237TEST_F(FormatTest, FormatsClasses) {
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001238 verifyFormat("class A : public B {};");
1239 verifyFormat("class A : public ::B {};");
Daniel Jaspereead02b2013-02-14 08:42:54 +00001240
1241 verifyFormat(
1242 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001243 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
Daniel Jaspera61aefb2013-05-06 06:45:09 +00001244 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
1245 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001246 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
Daniel Jaspereead02b2013-02-14 08:42:54 +00001247 verifyFormat(
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001248 "class A : public B, public C, public D, public E, public F {};");
Daniel Jaspereead02b2013-02-14 08:42:54 +00001249 verifyFormat("class AAAAAAAAAAAA : public B,\n"
1250 " public C,\n"
1251 " public D,\n"
1252 " public E,\n"
1253 " public F,\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001254 " public G {};");
Daniel Jasper83193602013-04-05 17:22:09 +00001255
1256 verifyFormat("class\n"
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00001257 " ReallyReallyLongClassName {\n"
1258 " int i;\n"
1259 "};",
Daniel Jasper83193602013-04-05 17:22:09 +00001260 getLLVMStyleWithColumns(32));
Daniel Jasperf9a5e402013-10-08 16:24:07 +00001261 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n"
1262 " aaaaaaaaaaaaaaaa> {};");
1263 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n"
1264 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n"
1265 " aaaaaaaaaaaaaaaaaaaaaa> {};");
Daniel Jasper3a122c02014-02-14 18:22:40 +00001266 verifyFormat("template <class R, class C>\n"
1267 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n"
1268 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};");
Manuel Klimek45bf56c2014-07-31 07:19:30 +00001269 verifyFormat("class ::A::B {};");
Daniel Jasperf7935112012-12-03 18:12:45 +00001270}
1271
Andi-Bogdan Postelnicu0ef8ee12017-03-10 15:10:37 +00001272TEST_F(FormatTest, BreakBeforeInheritanceComma) {
1273 FormatStyle StyleWithInheritanceBreak = getLLVMStyle();
1274 StyleWithInheritanceBreak.BreakBeforeInheritanceComma = true;
1275
1276 verifyFormat("class MyClass : public X {};", StyleWithInheritanceBreak);
1277 verifyFormat("class MyClass\n"
1278 " : public X\n"
1279 " , public Y {};",
1280 StyleWithInheritanceBreak);
1281}
1282
Manuel Klimek28cacc72013-01-07 18:10:23 +00001283TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) {
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00001284 verifyFormat("class A {\n} a, b;");
1285 verifyFormat("struct A {\n} a, b;");
1286 verifyFormat("union A {\n} a;");
Manuel Klimek28cacc72013-01-07 18:10:23 +00001287}
1288
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001289TEST_F(FormatTest, FormatsEnum) {
Alexander Kornienkob7076a22012-12-04 14:46:19 +00001290 verifyFormat("enum {\n"
1291 " Zero,\n"
1292 " One = 1,\n"
1293 " Two = One + 1,\n"
1294 " Three = (One + Two),\n"
1295 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1296 " Five = (One, Two, Three, Four, 5)\n"
1297 "};");
Daniel Jasper015ed022013-09-13 09:20:45 +00001298 verifyGoogleFormat("enum {\n"
1299 " Zero,\n"
1300 " One = 1,\n"
1301 " Two = One + 1,\n"
1302 " Three = (One + Two),\n"
1303 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1304 " Five = (One, Two, Three, Four, 5)\n"
1305 "};");
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001306 verifyFormat("enum Enum {};");
1307 verifyFormat("enum {};");
Daniel Jasper015ed022013-09-13 09:20:45 +00001308 verifyFormat("enum X E {} d;");
1309 verifyFormat("enum __attribute__((...)) E {} d;");
1310 verifyFormat("enum __declspec__((...)) E {} d;");
Daniel Jasper015ed022013-09-13 09:20:45 +00001311 verifyFormat("enum {\n"
1312 " Bar = Foo<int, int>::value\n"
Daniel Jasper96972812014-01-05 12:38:10 +00001313 "};",
1314 getLLVMStyleWithColumns(30));
1315
1316 verifyFormat("enum ShortEnum { A, B, C };");
Daniel Jasper1a148b42014-01-05 13:23:23 +00001317 verifyGoogleFormat("enum ShortEnum { A, B, C };");
Daniel Jaspera69ca9b2014-06-04 12:40:57 +00001318
1319 EXPECT_EQ("enum KeepEmptyLines {\n"
1320 " ONE,\n"
1321 "\n"
1322 " TWO,\n"
1323 "\n"
1324 " THREE\n"
1325 "}",
1326 format("enum KeepEmptyLines {\n"
1327 " ONE,\n"
1328 "\n"
1329 " TWO,\n"
1330 "\n"
1331 "\n"
1332 " THREE\n"
1333 "}"));
Daniel Jasper90818052014-06-10 10:42:26 +00001334 verifyFormat("enum E { // comment\n"
1335 " ONE,\n"
1336 " TWO\n"
Daniel Jasper502fac32014-11-05 10:55:36 +00001337 "};\n"
1338 "int i;");
Daniel Jasper47721ac2015-06-18 15:45:17 +00001339 // Not enums.
1340 verifyFormat("enum X f() {\n"
1341 " a();\n"
1342 " return 42;\n"
1343 "}");
Daniel Jasperb5a0b852015-06-19 08:17:32 +00001344 verifyFormat("enum X Type::f() {\n"
1345 " a();\n"
1346 " return 42;\n"
1347 "}");
Daniel Jasper47721ac2015-06-18 15:45:17 +00001348 verifyFormat("enum ::X f() {\n"
1349 " a();\n"
1350 " return 42;\n"
1351 "}");
1352 verifyFormat("enum ns::X f() {\n"
1353 " a();\n"
1354 " return 42;\n"
1355 "}");
Alexander Kornienkob7076a22012-12-04 14:46:19 +00001356}
1357
Daniel Jasperb7150872013-08-30 10:10:19 +00001358TEST_F(FormatTest, FormatsEnumsWithErrors) {
1359 verifyFormat("enum Type {\n"
Daniel Jasper96972812014-01-05 12:38:10 +00001360 " One = 0; // These semicolons should be commas.\n"
Daniel Jasperb7150872013-08-30 10:10:19 +00001361 " Two = 1;\n"
1362 "};");
1363 verifyFormat("namespace n {\n"
1364 "enum Type {\n"
1365 " One,\n"
Daniel Jasper96972812014-01-05 12:38:10 +00001366 " Two, // missing };\n"
Daniel Jasperb7150872013-08-30 10:10:19 +00001367 " int i;\n"
1368 "}\n"
1369 "void g() {}");
1370}
1371
Daniel Jasper2b41a822013-08-20 12:42:50 +00001372TEST_F(FormatTest, FormatsEnumStruct) {
1373 verifyFormat("enum struct {\n"
1374 " Zero,\n"
1375 " One = 1,\n"
1376 " Two = One + 1,\n"
1377 " Three = (One + Two),\n"
1378 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1379 " Five = (One, Two, Three, Four, 5)\n"
1380 "};");
1381 verifyFormat("enum struct Enum {};");
1382 verifyFormat("enum struct {};");
Daniel Jasper015ed022013-09-13 09:20:45 +00001383 verifyFormat("enum struct X E {} d;");
1384 verifyFormat("enum struct __attribute__((...)) E {} d;");
1385 verifyFormat("enum struct __declspec__((...)) E {} d;");
Daniel Jasper2b41a822013-08-20 12:42:50 +00001386 verifyFormat("enum struct X f() {\n a();\n return 42;\n}");
1387}
1388
1389TEST_F(FormatTest, FormatsEnumClass) {
1390 verifyFormat("enum class {\n"
1391 " Zero,\n"
1392 " One = 1,\n"
1393 " Two = One + 1,\n"
1394 " Three = (One + Two),\n"
1395 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1396 " Five = (One, Two, Three, Four, 5)\n"
1397 "};");
1398 verifyFormat("enum class Enum {};");
1399 verifyFormat("enum class {};");
Daniel Jasper015ed022013-09-13 09:20:45 +00001400 verifyFormat("enum class X E {} d;");
1401 verifyFormat("enum class __attribute__((...)) E {} d;");
1402 verifyFormat("enum class __declspec__((...)) E {} d;");
Daniel Jasper2b41a822013-08-20 12:42:50 +00001403 verifyFormat("enum class X f() {\n a();\n return 42;\n}");
1404}
1405
Manuel Klimek9a53c7f2013-09-05 15:34:55 +00001406TEST_F(FormatTest, FormatsEnumTypes) {
1407 verifyFormat("enum X : int {\n"
Daniel Jasper96972812014-01-05 12:38:10 +00001408 " A, // Force multiple lines.\n"
Manuel Klimek9a53c7f2013-09-05 15:34:55 +00001409 " B\n"
1410 "};");
Daniel Jasper96972812014-01-05 12:38:10 +00001411 verifyFormat("enum X : int { A, B };");
1412 verifyFormat("enum X : std::uint32_t { A, B };");
Manuel Klimek9a53c7f2013-09-05 15:34:55 +00001413}
1414
Krasimir Georgiev81341d72017-08-29 13:32:30 +00001415TEST_F(FormatTest, FormatsTypedefEnum) {
1416 FormatStyle Style = getLLVMStyle();
1417 Style.ColumnLimit = 40;
1418 verifyFormat("typedef enum {} EmptyEnum;");
1419 verifyFormat("typedef enum { A, B, C } ShortEnum;");
1420 verifyFormat("typedef enum {\n"
Marek Kurdejcaf6fd52017-09-27 07:51:51 +00001421 " ZERO = 0,\n"
Krasimir Georgiev81341d72017-08-29 13:32:30 +00001422 " ONE = 1,\n"
1423 " TWO = 2,\n"
1424 " THREE = 3\n"
1425 "} LongEnum;",
1426 Style);
1427 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
1428 Style.BraceWrapping.AfterEnum = true;
1429 verifyFormat("typedef enum {} EmptyEnum;");
1430 verifyFormat("typedef enum { A, B, C } ShortEnum;");
1431 verifyFormat("typedef enum\n"
1432 "{\n"
Marek Kurdejcaf6fd52017-09-27 07:51:51 +00001433 " ZERO = 0,\n"
Krasimir Georgiev81341d72017-08-29 13:32:30 +00001434 " ONE = 1,\n"
1435 " TWO = 2,\n"
1436 " THREE = 3\n"
1437 "} LongEnum;",
1438 Style);
1439}
1440
Daniel Jaspera88f80a2014-01-30 14:38:37 +00001441TEST_F(FormatTest, FormatsNSEnums) {
1442 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }");
1443 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n"
1444 " // Information about someDecentlyLongValue.\n"
1445 " someDecentlyLongValue,\n"
1446 " // Information about anotherDecentlyLongValue.\n"
1447 " anotherDecentlyLongValue,\n"
1448 " // Information about aThirdDecentlyLongValue.\n"
1449 " aThirdDecentlyLongValue\n"
1450 "};");
Daniel Jasper31f6c542014-12-05 10:42:21 +00001451 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n"
1452 " a = 1,\n"
1453 " b = 2,\n"
1454 " c = 3,\n"
1455 "};");
1456 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n"
1457 " a = 1,\n"
1458 " b = 2,\n"
1459 " c = 3,\n"
1460 "};");
1461 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n"
1462 " a = 1,\n"
1463 " b = 2,\n"
1464 " c = 3,\n"
1465 "};");
Daniel Jaspera88f80a2014-01-30 14:38:37 +00001466}
1467
Nico Weber7769a902013-01-14 05:49:49 +00001468TEST_F(FormatTest, FormatsBitfields) {
1469 verifyFormat("struct Bitfields {\n"
1470 " unsigned sClass : 8;\n"
1471 " unsigned ValueKind : 2;\n"
1472 "};");
Alexander Kornienko60d1b042013-10-10 13:36:20 +00001473 verifyFormat("struct A {\n"
1474 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n"
1475 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n"
1476 "};");
Daniel Jasper676e5162015-04-07 14:36:33 +00001477 verifyFormat("struct MyStruct {\n"
1478 " uchar data;\n"
1479 " uchar : 8;\n"
1480 " uchar : 8;\n"
1481 " uchar other;\n"
1482 "};");
Nico Weber7769a902013-01-14 05:49:49 +00001483}
1484
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001485TEST_F(FormatTest, FormatsNamespaces) {
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001486 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
1487 LLVMWithNoNamespaceFix.FixNamespaceComments = false;
1488
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001489 verifyFormat("namespace some_namespace {\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001490 "class A {};\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00001491 "void f() { f(); }\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001492 "}",
1493 LLVMWithNoNamespaceFix);
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001494 verifyFormat("namespace {\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001495 "class A {};\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00001496 "void f() { f(); }\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001497 "}",
1498 LLVMWithNoNamespaceFix);
Dmitri Gribenko58d64e22012-12-30 21:27:25 +00001499 verifyFormat("inline namespace X {\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001500 "class A {};\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00001501 "void f() { f(); }\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001502 "}",
1503 LLVMWithNoNamespaceFix);
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001504 verifyFormat("using namespace some_namespace;\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001505 "class A {};\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001506 "void f() { f(); }",
1507 LLVMWithNoNamespaceFix);
Manuel Klimek046b9302013-02-06 16:08:09 +00001508
1509 // This code is more common than we thought; if we
1510 // layout this correctly the semicolon will go into
Alp Tokerf6a24ce2013-12-05 16:25:25 +00001511 // its own line, which is undesirable.
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001512 verifyFormat("namespace {};",
1513 LLVMWithNoNamespaceFix);
Manuel Klimek046b9302013-02-06 16:08:09 +00001514 verifyFormat("namespace {\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001515 "class A {};\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001516 "};",
1517 LLVMWithNoNamespaceFix);
Daniel Jasper251b3c92013-07-01 11:22:57 +00001518
1519 verifyFormat("namespace {\n"
1520 "int SomeVariable = 0; // comment\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001521 "} // namespace",
1522 LLVMWithNoNamespaceFix);
Daniel Jasper251b3c92013-07-01 11:22:57 +00001523 EXPECT_EQ("#ifndef HEADER_GUARD\n"
1524 "#define HEADER_GUARD\n"
1525 "namespace my_namespace {\n"
1526 "int i;\n"
1527 "} // my_namespace\n"
1528 "#endif // HEADER_GUARD",
1529 format("#ifndef HEADER_GUARD\n"
1530 " #define HEADER_GUARD\n"
1531 " namespace my_namespace {\n"
1532 "int i;\n"
1533 "} // my_namespace\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001534 "#endif // HEADER_GUARD",
1535 LLVMWithNoNamespaceFix));
Daniel Jasper65ee3472013-07-31 23:16:02 +00001536
Saleem Abdulrasool328085f2015-10-30 05:07:56 +00001537 EXPECT_EQ("namespace A::B {\n"
1538 "class C {};\n"
1539 "}",
1540 format("namespace A::B {\n"
1541 "class C {};\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001542 "}",
1543 LLVMWithNoNamespaceFix));
Saleem Abdulrasool328085f2015-10-30 05:07:56 +00001544
Daniel Jasper65ee3472013-07-31 23:16:02 +00001545 FormatStyle Style = getLLVMStyle();
1546 Style.NamespaceIndentation = FormatStyle::NI_All;
1547 EXPECT_EQ("namespace out {\n"
1548 " int i;\n"
1549 " namespace in {\n"
1550 " int i;\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001551 " } // namespace in\n"
1552 "} // namespace out",
Daniel Jasper65ee3472013-07-31 23:16:02 +00001553 format("namespace out {\n"
1554 "int i;\n"
1555 "namespace in {\n"
1556 "int i;\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001557 "} // namespace in\n"
1558 "} // namespace out",
Daniel Jasper65ee3472013-07-31 23:16:02 +00001559 Style));
1560
1561 Style.NamespaceIndentation = FormatStyle::NI_Inner;
1562 EXPECT_EQ("namespace out {\n"
1563 "int i;\n"
1564 "namespace in {\n"
1565 " int i;\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001566 "} // namespace in\n"
1567 "} // namespace out",
Daniel Jasper65ee3472013-07-31 23:16:02 +00001568 format("namespace out {\n"
1569 "int i;\n"
1570 "namespace in {\n"
1571 "int i;\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001572 "} // namespace in\n"
1573 "} // namespace out",
Daniel Jasper65ee3472013-07-31 23:16:02 +00001574 Style));
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001575}
1576
Francois Ferrande56a8292017-06-14 12:29:47 +00001577TEST_F(FormatTest, FormatsCompactNamespaces) {
1578 FormatStyle Style = getLLVMStyle();
1579 Style.CompactNamespaces = true;
1580
1581 verifyFormat("namespace A { namespace B {\n"
1582 "}} // namespace A::B",
1583 Style);
1584
1585 EXPECT_EQ("namespace out { namespace in {\n"
1586 "}} // namespace out::in",
1587 format("namespace out {\n"
1588 "namespace in {\n"
1589 "} // namespace in\n"
1590 "} // namespace out",
1591 Style));
1592
1593 // Only namespaces which have both consecutive opening and end get compacted
1594 EXPECT_EQ("namespace out {\n"
1595 "namespace in1 {\n"
1596 "} // namespace in1\n"
1597 "namespace in2 {\n"
1598 "} // namespace in2\n"
1599 "} // namespace out",
1600 format("namespace out {\n"
1601 "namespace in1 {\n"
1602 "} // namespace in1\n"
1603 "namespace in2 {\n"
1604 "} // namespace in2\n"
1605 "} // namespace out",
1606 Style));
1607
1608 EXPECT_EQ("namespace out {\n"
1609 "int i;\n"
1610 "namespace in {\n"
1611 "int j;\n"
1612 "} // namespace in\n"
1613 "int k;\n"
1614 "} // namespace out",
1615 format("namespace out { int i;\n"
1616 "namespace in { int j; } // namespace in\n"
1617 "int k; } // namespace out",
1618 Style));
1619
1620 EXPECT_EQ("namespace A { namespace B { namespace C {\n"
1621 "}}} // namespace A::B::C\n",
1622 format("namespace A { namespace B {\n"
1623 "namespace C {\n"
1624 "}} // namespace B::C\n"
1625 "} // namespace A\n",
1626 Style));
1627
1628 Style.ColumnLimit = 40;
1629 EXPECT_EQ("namespace aaaaaaaaaa {\n"
1630 "namespace bbbbbbbbbb {\n"
1631 "}} // namespace aaaaaaaaaa::bbbbbbbbbb",
1632 format("namespace aaaaaaaaaa {\n"
1633 "namespace bbbbbbbbbb {\n"
1634 "} // namespace bbbbbbbbbb\n"
1635 "} // namespace aaaaaaaaaa",
1636 Style));
1637
1638 EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n"
1639 "namespace cccccc {\n"
1640 "}}} // namespace aaaaaa::bbbbbb::cccccc",
1641 format("namespace aaaaaa {\n"
1642 "namespace bbbbbb {\n"
1643 "namespace cccccc {\n"
1644 "} // namespace cccccc\n"
1645 "} // namespace bbbbbb\n"
1646 "} // namespace aaaaaa",
1647 Style));
1648 Style.ColumnLimit = 80;
1649
1650 // Extra semicolon after 'inner' closing brace prevents merging
1651 EXPECT_EQ("namespace out { namespace in {\n"
1652 "}; } // namespace out::in",
1653 format("namespace out {\n"
1654 "namespace in {\n"
1655 "}; // namespace in\n"
1656 "} // namespace out",
1657 Style));
1658
1659 // Extra semicolon after 'outer' closing brace is conserved
1660 EXPECT_EQ("namespace out { namespace in {\n"
1661 "}}; // namespace out::in",
1662 format("namespace out {\n"
1663 "namespace in {\n"
1664 "} // namespace in\n"
1665 "}; // namespace out",
1666 Style));
1667
1668 Style.NamespaceIndentation = FormatStyle::NI_All;
1669 EXPECT_EQ("namespace out { namespace in {\n"
1670 " int i;\n"
1671 "}} // namespace out::in",
1672 format("namespace out {\n"
1673 "namespace in {\n"
1674 "int i;\n"
1675 "} // namespace in\n"
1676 "} // namespace out",
1677 Style));
1678 EXPECT_EQ("namespace out { namespace mid {\n"
1679 " namespace in {\n"
1680 " int j;\n"
1681 " } // namespace in\n"
1682 " int k;\n"
1683 "}} // namespace out::mid",
1684 format("namespace out { namespace mid {\n"
1685 "namespace in { int j; } // namespace in\n"
1686 "int k; }} // namespace out::mid",
1687 Style));
1688
1689 Style.NamespaceIndentation = FormatStyle::NI_Inner;
1690 EXPECT_EQ("namespace out { namespace in {\n"
1691 " int i;\n"
1692 "}} // namespace out::in",
1693 format("namespace out {\n"
1694 "namespace in {\n"
1695 "int i;\n"
1696 "} // namespace in\n"
1697 "} // namespace out",
1698 Style));
1699 EXPECT_EQ("namespace out { namespace mid { namespace in {\n"
1700 " int i;\n"
1701 "}}} // namespace out::mid::in",
1702 format("namespace out {\n"
1703 "namespace mid {\n"
1704 "namespace in {\n"
1705 "int i;\n"
1706 "} // namespace in\n"
1707 "} // namespace mid\n"
1708 "} // namespace out",
1709 Style));
1710}
1711
Krasimir Georgievd6ce9372017-09-15 11:23:50 +00001712TEST_F(FormatTest, FormatsExternC) {
1713 verifyFormat("extern \"C\" {\nint a;");
1714 verifyFormat("extern \"C\" {}");
1715 verifyFormat("extern \"C\" {\n"
1716 "int foo();\n"
1717 "}");
1718 verifyFormat("extern \"C\" int foo() {}");
1719 verifyFormat("extern \"C\" int foo();");
1720 verifyFormat("extern \"C\" int foo() {\n"
1721 " int i = 42;\n"
1722 " return i;\n"
1723 "}");
1724
1725 FormatStyle Style = getLLVMStyle();
1726 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
1727 Style.BraceWrapping.AfterFunction = true;
1728 verifyFormat("extern \"C\" int foo() {}", Style);
1729 verifyFormat("extern \"C\" int foo();", Style);
1730 verifyFormat("extern \"C\" int foo()\n"
1731 "{\n"
1732 " int i = 42;\n"
1733 " return i;\n"
1734 "}",
1735 Style);
1736
1737 Style.BraceWrapping.AfterExternBlock = true;
1738 Style.BraceWrapping.SplitEmptyRecord = false;
1739 verifyFormat("extern \"C\"\n"
1740 "{}",
1741 Style);
1742 verifyFormat("extern \"C\"\n"
1743 "{\n"
1744 " int foo();\n"
1745 "}",
1746 Style);
1747}
Manuel Klimekae610d12013-01-21 14:32:05 +00001748
Daniel Jasper40aacf42013-03-14 13:45:21 +00001749TEST_F(FormatTest, FormatsInlineASM) {
1750 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));");
Daniel Jasperb23e20b2014-09-16 16:36:57 +00001751 verifyFormat("asm(\"nop\" ::: \"memory\");");
Daniel Jasper40aacf42013-03-14 13:45:21 +00001752 verifyFormat(
1753 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
1754 " \"cpuid\\n\\t\"\n"
1755 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
Daniel Jasper5dad58e2013-05-15 07:51:51 +00001756 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n"
Daniel Jasper40aacf42013-03-14 13:45:21 +00001757 " : \"a\"(value));");
Daniel Jasper8f463652014-08-26 23:15:12 +00001758 EXPECT_EQ(
1759 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n"
Daniel Jasper2337f282015-01-12 10:14:56 +00001760 " __asm {\n"
Daniel Jasper8f463652014-08-26 23:15:12 +00001761 " mov edx,[that] // vtable in edx\n"
1762 " mov eax,methodIndex\n"
1763 " call [edx][eax*4] // stdcall\n"
Daniel Jasper2337f282015-01-12 10:14:56 +00001764 " }\n"
Daniel Jasper8f463652014-08-26 23:15:12 +00001765 "}",
1766 format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n"
1767 " __asm {\n"
1768 " mov edx,[that] // vtable in edx\n"
1769 " mov eax,methodIndex\n"
1770 " call [edx][eax*4] // stdcall\n"
1771 " }\n"
1772 "}"));
Daniel Jasperc6366072015-05-10 08:42:04 +00001773 EXPECT_EQ("_asm {\n"
1774 " xor eax, eax;\n"
1775 " cpuid;\n"
1776 "}",
1777 format("_asm {\n"
1778 " xor eax, eax;\n"
1779 " cpuid;\n"
1780 "}"));
Daniel Jasper2337f282015-01-12 10:14:56 +00001781 verifyFormat("void function() {\n"
1782 " // comment\n"
1783 " asm(\"\");\n"
1784 "}");
Daniel Jasper790d4f92015-05-11 11:59:46 +00001785 EXPECT_EQ("__asm {\n"
1786 "}\n"
1787 "int i;",
1788 format("__asm {\n"
1789 "}\n"
1790 "int i;"));
Daniel Jasper40aacf42013-03-14 13:45:21 +00001791}
1792
Nico Weberd5650bd2013-01-07 16:36:17 +00001793TEST_F(FormatTest, FormatTryCatch) {
1794 verifyFormat("try {\n"
1795 " throw a * b;\n"
Daniel Jasper04a71a42014-05-08 11:58:24 +00001796 "} catch (int a) {\n"
Nico Weberd5650bd2013-01-07 16:36:17 +00001797 " // Do nothing.\n"
Daniel Jasper04a71a42014-05-08 11:58:24 +00001798 "} catch (...) {\n"
Nico Weberd5650bd2013-01-07 16:36:17 +00001799 " exit(42);\n"
1800 "}");
1801
1802 // Function-level try statements.
Daniel Jasper04a71a42014-05-08 11:58:24 +00001803 verifyFormat("int f() try { return 4; } catch (...) {\n"
Nico Weberd5650bd2013-01-07 16:36:17 +00001804 " return 5;\n"
1805 "}");
1806 verifyFormat("class A {\n"
1807 " int a;\n"
Daniel Jasper04a71a42014-05-08 11:58:24 +00001808 " A() try : a(0) {\n"
1809 " } catch (...) {\n"
Nico Weberd5650bd2013-01-07 16:36:17 +00001810 " throw;\n"
1811 " }\n"
1812 "};\n");
Daniel Jasper2bd7a642015-01-19 10:50:51 +00001813
1814 // Incomplete try-catch blocks.
Manuel Klimekec5c3db2015-05-07 12:26:30 +00001815 verifyIncompleteFormat("try {} catch (");
Nico Weberd5650bd2013-01-07 16:36:17 +00001816}
1817
Nico Weberfac23712015-02-04 15:26:27 +00001818TEST_F(FormatTest, FormatSEHTryCatch) {
1819 verifyFormat("__try {\n"
1820 " int a = b * c;\n"
1821 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n"
1822 " // Do nothing.\n"
1823 "}");
1824
1825 verifyFormat("__try {\n"
1826 " int a = b * c;\n"
1827 "} __finally {\n"
1828 " // Do nothing.\n"
1829 "}");
1830
1831 verifyFormat("DEBUG({\n"
1832 " __try {\n"
1833 " } __finally {\n"
1834 " }\n"
1835 "});\n");
1836}
1837
Daniel Jasper04a71a42014-05-08 11:58:24 +00001838TEST_F(FormatTest, IncompleteTryCatchBlocks) {
1839 verifyFormat("try {\n"
1840 " f();\n"
1841 "} catch {\n"
1842 " g();\n"
1843 "}");
1844 verifyFormat("try {\n"
1845 " f();\n"
1846 "} catch (A a) MACRO(x) {\n"
1847 " g();\n"
1848 "} catch (B b) MACRO(x) {\n"
1849 " g();\n"
1850 "}");
1851}
1852
1853TEST_F(FormatTest, FormatTryCatchBraceStyles) {
1854 FormatStyle Style = getLLVMStyle();
Daniel Jasper55bbe662015-10-07 04:06:10 +00001855 for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla,
1856 FormatStyle::BS_WebKit}) {
Roman Kashitsyn291f64f2015-08-10 13:43:19 +00001857 Style.BreakBeforeBraces = BraceStyle;
1858 verifyFormat("try {\n"
1859 " // something\n"
1860 "} catch (...) {\n"
1861 " // something\n"
1862 "}",
1863 Style);
1864 }
Daniel Jasper04a71a42014-05-08 11:58:24 +00001865 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
1866 verifyFormat("try {\n"
1867 " // something\n"
1868 "}\n"
1869 "catch (...) {\n"
1870 " // something\n"
1871 "}",
1872 Style);
Nico Weberfac23712015-02-04 15:26:27 +00001873 verifyFormat("__try {\n"
1874 " // something\n"
1875 "}\n"
1876 "__finally {\n"
1877 " // something\n"
1878 "}",
1879 Style);
Nico Weber33381f52015-02-07 01:57:32 +00001880 verifyFormat("@try {\n"
1881 " // something\n"
1882 "}\n"
1883 "@finally {\n"
1884 " // something\n"
1885 "}",
1886 Style);
Daniel Jasper04a71a42014-05-08 11:58:24 +00001887 Style.BreakBeforeBraces = FormatStyle::BS_Allman;
1888 verifyFormat("try\n"
1889 "{\n"
1890 " // something\n"
1891 "}\n"
1892 "catch (...)\n"
1893 "{\n"
1894 " // something\n"
1895 "}",
1896 Style);
1897 Style.BreakBeforeBraces = FormatStyle::BS_GNU;
1898 verifyFormat("try\n"
1899 " {\n"
1900 " // something\n"
1901 " }\n"
1902 "catch (...)\n"
1903 " {\n"
1904 " // something\n"
1905 " }",
1906 Style);
Daniel Jasper55bbe662015-10-07 04:06:10 +00001907 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
1908 Style.BraceWrapping.BeforeCatch = true;
1909 verifyFormat("try {\n"
1910 " // something\n"
1911 "}\n"
1912 "catch (...) {\n"
1913 " // something\n"
1914 "}",
1915 Style);
Daniel Jasper04a71a42014-05-08 11:58:24 +00001916}
1917
Daniel Jaspere25509f2012-12-17 11:29:41 +00001918TEST_F(FormatTest, StaticInitializers) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00001919 verifyFormat("static SomeClass SC = {1, 'a'};");
Daniel Jaspere25509f2012-12-17 11:29:41 +00001920
Daniel Jaspera44991332015-04-29 13:06:49 +00001921 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n"
1922 " 100000000, "
1923 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};");
Manuel Klimek0ddd57a2013-01-10 15:58:26 +00001924
Daniel Jasper473c62c2013-05-17 09:35:01 +00001925 // Here, everything other than the "}" would fit on a line.
1926 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00001927 " 10000000000000000000000000};");
Daniel Jaspera69ca9b2014-06-04 12:40:57 +00001928 EXPECT_EQ("S s = {a,\n"
1929 "\n"
1930 " b};",
1931 format("S s = {\n"
1932 " a,\n"
1933 "\n"
1934 " b\n"
1935 "};"));
Daniel Jasper473c62c2013-05-17 09:35:01 +00001936
1937 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first
1938 // line. However, the formatting looks a bit off and this probably doesn't
1939 // happen often in practice.
1940 verifyFormat("static int Variable[1] = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00001941 " {1000000000000000000000000000000000000}};",
Daniel Jasper473c62c2013-05-17 09:35:01 +00001942 getLLVMStyleWithColumns(40));
Daniel Jaspere25509f2012-12-17 11:29:41 +00001943}
1944
Daniel Jasperbca4bbe2013-05-28 11:30:49 +00001945TEST_F(FormatTest, DesignatedInitializers) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00001946 verifyFormat("const struct A a = {.a = 1, .b = 2};");
1947 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n"
1948 " .bbbbbbbbbb = 2,\n"
1949 " .cccccccccc = 3,\n"
1950 " .dddddddddd = 4,\n"
1951 " .eeeeeeeeee = 5};");
Daniel Jasperbca4bbe2013-05-28 11:30:49 +00001952 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00001953 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n"
1954 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n"
1955 " .ccccccccccccccccccccccccccc = 3,\n"
1956 " .ddddddddddddddddddddddddddd = 4,\n"
1957 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};");
Daniel Jasperbca4bbe2013-05-28 11:30:49 +00001958
1959 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};");
Francois Ferrand5f07f442017-06-19 14:41:21 +00001960
1961 verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
1962 verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n"
1963 " [2] = bbbbbbbbbb,\n"
1964 " [3] = cccccccccc,\n"
1965 " [4] = dddddddddd,\n"
1966 " [5] = eeeeeeeeee};");
1967 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
1968 " [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
1969 " [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
1970 " [3] = cccccccccccccccccccccccccccccccccccccc,\n"
1971 " [4] = dddddddddddddddddddddddddddddddddddddd,\n"
1972 " [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};");
Daniel Jasperbca4bbe2013-05-28 11:30:49 +00001973}
1974
Manuel Klimeka54d1a92013-01-14 16:41:43 +00001975TEST_F(FormatTest, NestedStaticInitializers) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00001976 verifyFormat("static A x = {{{}}};\n");
1977 verifyFormat("static A x = {{{init1, init2, init3, init4},\n"
1978 " {init1, init2, init3, init4}}};",
1979 getLLVMStyleWithColumns(50));
Daniel Jasper9278eb92013-01-16 14:59:02 +00001980
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001981 verifyFormat("somes Status::global_reps[3] = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00001982 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
1983 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
1984 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};",
1985 getLLVMStyleWithColumns(60));
Daniel Jaspere5777d22013-05-23 10:15:45 +00001986 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n"
Daniel Jasper6ab54682013-07-16 18:22:10 +00001987 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
1988 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
1989 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};");
Daniel Jaspera44991332015-04-29 13:06:49 +00001990 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n"
1991 " {rect.fRight - rect.fLeft, rect.fBottom - "
1992 "rect.fTop}};");
Manuel Klimeka54d1a92013-01-14 16:41:43 +00001993
Daniel Jasper8a8ce242013-01-31 14:59:26 +00001994 verifyFormat(
Chandler Carruthf8b72662014-03-02 12:37:31 +00001995 "SomeArrayOfSomeType a = {\n"
1996 " {{1, 2, 3},\n"
1997 " {1, 2, 3},\n"
1998 " {111111111111111111111111111111, 222222222222222222222222222222,\n"
1999 " 333333333333333333333333333333},\n"
2000 " {1, 2, 3},\n"
2001 " {1, 2, 3}}};");
Daniel Jasper1ca05cc2013-02-03 18:07:15 +00002002 verifyFormat(
Daniel Jasper6ab54682013-07-16 18:22:10 +00002003 "SomeArrayOfSomeType a = {\n"
Daniel Jasper01603472014-01-09 13:42:56 +00002004 " {{1, 2, 3}},\n"
2005 " {{1, 2, 3}},\n"
Daniel Jasper6ab54682013-07-16 18:22:10 +00002006 " {{111111111111111111111111111111, 222222222222222222222222222222,\n"
2007 " 333333333333333333333333333333}},\n"
Daniel Jasper01603472014-01-09 13:42:56 +00002008 " {{1, 2, 3}},\n"
2009 " {{1, 2, 3}}};");
Daniel Jasper8a8ce242013-01-31 14:59:26 +00002010
Daniel Jaspera44991332015-04-29 13:06:49 +00002011 verifyFormat("struct {\n"
2012 " unsigned bit;\n"
2013 " const char *const name;\n"
2014 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n"
2015 " {kOsWin, \"Windows\"},\n"
2016 " {kOsLinux, \"Linux\"},\n"
2017 " {kOsCrOS, \"Chrome OS\"}};");
2018 verifyFormat("struct {\n"
2019 " unsigned bit;\n"
2020 " const char *const name;\n"
2021 "} kBitsToOs[] = {\n"
2022 " {kOsMac, \"Mac\"},\n"
2023 " {kOsWin, \"Windows\"},\n"
2024 " {kOsLinux, \"Linux\"},\n"
2025 " {kOsCrOS, \"Chrome OS\"},\n"
2026 "};");
Manuel Klimeka54d1a92013-01-14 16:41:43 +00002027}
2028
Manuel Klimeka71e5d82013-01-02 16:30:12 +00002029TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) {
2030 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("
2031 " \\\n"
2032 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)");
2033}
2034
Daniel Jasperda16db32013-01-07 10:48:50 +00002035TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) {
Alexander Kornienko384b40b2013-10-11 21:43:05 +00002036 verifyFormat("virtual void write(ELFWriter *writerrr,\n"
2037 " OwningPtr<FileOutputBuffer> &buffer) = 0;");
Daniel Jaspercaf84fe2015-04-23 12:59:09 +00002038
2039 // Do break defaulted and deleted functions.
2040 verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
2041 " default;",
2042 getLLVMStyleWithColumns(40));
2043 verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
2044 " delete;",
2045 getLLVMStyleWithColumns(40));
Alexander Kornienko384b40b2013-10-11 21:43:05 +00002046}
2047
2048TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) {
2049 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3",
2050 getLLVMStyleWithColumns(40));
2051 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
2052 getLLVMStyleWithColumns(40));
2053 EXPECT_EQ("#define Q \\\n"
2054 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n"
2055 " \"aaaaaaaa.cpp\"",
2056 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
2057 getLLVMStyleWithColumns(40)));
2058}
2059
2060TEST_F(FormatTest, UnderstandsLinePPDirective) {
2061 EXPECT_EQ("# 123 \"A string literal\"",
2062 format(" # 123 \"A string literal\""));
Daniel Jasperda16db32013-01-07 10:48:50 +00002063}
2064
Manuel Klimek591b5802013-01-31 15:58:48 +00002065TEST_F(FormatTest, LayoutUnknownPPDirective) {
Manuel Klimek591b5802013-01-31 15:58:48 +00002066 EXPECT_EQ("#;", format("#;"));
Manuel Klimek78725712013-01-07 10:03:37 +00002067 verifyFormat("#\n;\n;\n;");
Manuel Klimeka71e5d82013-01-02 16:30:12 +00002068}
2069
2070TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) {
2071 EXPECT_EQ("#line 42 \"test\"\n",
2072 format("# \\\n line \\\n 42 \\\n \"test\"\n"));
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002073 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n",
2074 getLLVMStyleWithColumns(12)));
Manuel Klimeka71e5d82013-01-02 16:30:12 +00002075}
2076
2077TEST_F(FormatTest, EndOfFileEndsPPDirective) {
2078 EXPECT_EQ("#line 42 \"test\"",
2079 format("# \\\n line \\\n 42 \\\n \"test\""));
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002080 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B"));
Manuel Klimeka71e5d82013-01-02 16:30:12 +00002081}
2082
Daniel Jasper877615c2013-10-11 19:45:02 +00002083TEST_F(FormatTest, DoesntRemoveUnknownTokens) {
2084 verifyFormat("#define A \\x20");
2085 verifyFormat("#define A \\ x20");
2086 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20"));
2087 verifyFormat("#define A ''");
2088 verifyFormat("#define A ''qqq");
2089 verifyFormat("#define A `qqq");
2090 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");
Daniel Jasperda353cd2014-03-12 08:24:47 +00002091 EXPECT_EQ("const char *c = STRINGIFY(\n"
2092 "\\na : b);",
2093 format("const char * c = STRINGIFY(\n"
2094 "\\na : b);"));
Daniel Jasper30029c62015-02-05 11:05:31 +00002095
2096 verifyFormat("a\r\\");
2097 verifyFormat("a\v\\");
2098 verifyFormat("a\f\\");
Daniel Jasper877615c2013-10-11 19:45:02 +00002099}
2100
Manuel Klimekb69e3c62013-01-02 18:33:23 +00002101TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {
Daniel Jasperc22f5b42013-02-28 11:05:57 +00002102 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
2103 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12));
Manuel Klimekb69e3c62013-01-02 18:33:23 +00002104 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12));
Daniel Jasperc22f5b42013-02-28 11:05:57 +00002105 // FIXME: We never break before the macro name.
Daniel Jaspera49393f2013-08-28 09:07:32 +00002106 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12));
Daniel Jasper39825ea2013-01-14 15:40:57 +00002107
2108 verifyFormat("#define A A\n#define A A");
2109 verifyFormat("#define A(X) A\n#define A A");
2110
Daniel Jasperc22f5b42013-02-28 11:05:57 +00002111 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
2112 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22));
Manuel Klimekb69e3c62013-01-02 18:33:23 +00002113}
2114
2115TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {
Alexander Kornienkoefd98382013-03-28 18:40:55 +00002116 EXPECT_EQ("// somecomment\n"
Manuel Klimek1abf7892013-01-04 23:34:14 +00002117 "#include \"a.h\"\n"
Daniel Jasperc22f5b42013-02-28 11:05:57 +00002118 "#define A( \\\n"
2119 " A, B)\n"
Manuel Klimek1abf7892013-01-04 23:34:14 +00002120 "#include \"b.h\"\n"
Alexander Kornienkoffd6d042013-03-27 11:52:18 +00002121 "// somecomment\n",
Alexander Kornienkoefd98382013-03-28 18:40:55 +00002122 format(" // somecomment\n"
Manuel Klimek1abf7892013-01-04 23:34:14 +00002123 " #include \"a.h\"\n"
2124 "#define A(A,\\\n"
2125 " B)\n"
2126 " #include \"b.h\"\n"
Alexander Kornienkoffd6d042013-03-27 11:52:18 +00002127 " // somecomment\n",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002128 getLLVMStyleWithColumns(13)));
Manuel Klimekb69e3c62013-01-02 18:33:23 +00002129}
2130
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002131TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
Manuel Klimek1abf7892013-01-04 23:34:14 +00002132
2133TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
2134 EXPECT_EQ("#define A \\\n"
2135 " c; \\\n"
2136 " e;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002137 "f;",
2138 format("#define A c; e;\n"
2139 "f;",
2140 getLLVMStyleWithColumns(14)));
Manuel Klimek1abf7892013-01-04 23:34:14 +00002141}
2142
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002143TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
Manuel Klimek1abf7892013-01-04 23:34:14 +00002144
Manuel Klimek1abf7892013-01-04 23:34:14 +00002145TEST_F(FormatTest, MacroDefinitionInsideStatement) {
Manuel Klimek52b15152013-01-09 15:25:02 +00002146 EXPECT_EQ("int x,\n"
2147 "#define A\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002148 " y;",
2149 format("int x,\n#define A\ny;"));
Manuel Klimek1abf7892013-01-04 23:34:14 +00002150}
2151
Manuel Klimek09e07972013-01-05 21:34:55 +00002152TEST_F(FormatTest, HashInMacroDefinition) {
Alexander Kornienkod8d47fa2013-09-10 13:41:43 +00002153 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle()));
Manuel Klimek09e07972013-01-05 21:34:55 +00002154 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11));
Daniel Jaspera49393f2013-08-28 09:07:32 +00002155 verifyFormat("#define A \\\n"
2156 " { \\\n"
2157 " f(#c); \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002158 " }",
2159 getLLVMStyleWithColumns(11));
Daniel Jasper4f397152013-01-08 16:17:54 +00002160
2161 verifyFormat("#define A(X) \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002162 " void function##X()",
2163 getLLVMStyleWithColumns(22));
Daniel Jasper4f397152013-01-08 16:17:54 +00002164
2165 verifyFormat("#define A(a, b, c) \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002166 " void a##b##c()",
2167 getLLVMStyleWithColumns(22));
Daniel Jasper4f397152013-01-08 16:17:54 +00002168
Daniel Jasper39825ea2013-01-14 15:40:57 +00002169 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
Manuel Klimek09e07972013-01-05 21:34:55 +00002170}
2171
Manuel Klimekd053c5b2013-01-23 14:37:36 +00002172TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) {
Alexander Kornienkofdca83d2013-12-10 10:18:34 +00002173 EXPECT_EQ("#define A (x)", format("#define A (x)"));
2174 EXPECT_EQ("#define A(x)", format("#define A(x)"));
Manuel Klimekd053c5b2013-01-23 14:37:36 +00002175}
2176
Manuel Klimek0c137952013-02-11 12:33:24 +00002177TEST_F(FormatTest, EmptyLinesInMacroDefinitions) {
2178 EXPECT_EQ("#define A b;", format("#define A \\\n"
2179 " \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002180 " b;",
2181 getLLVMStyleWithColumns(25)));
Manuel Klimek0c137952013-02-11 12:33:24 +00002182 EXPECT_EQ("#define A \\\n"
2183 " \\\n"
2184 " a; \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002185 " b;",
2186 format("#define A \\\n"
2187 " \\\n"
2188 " a; \\\n"
2189 " b;",
2190 getLLVMStyleWithColumns(11)));
Manuel Klimek0c137952013-02-11 12:33:24 +00002191 EXPECT_EQ("#define A \\\n"
2192 " a; \\\n"
2193 " \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002194 " b;",
2195 format("#define A \\\n"
2196 " a; \\\n"
2197 " \\\n"
2198 " b;",
2199 getLLVMStyleWithColumns(11)));
Manuel Klimek0c137952013-02-11 12:33:24 +00002200}
2201
Daniel Jasper00475962013-02-19 17:14:38 +00002202TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
Manuel Klimekec5c3db2015-05-07 12:26:30 +00002203 verifyIncompleteFormat("#define A :");
Daniel Jasper00475962013-02-19 17:14:38 +00002204 verifyFormat("#define SOMECASES \\\n"
Daniel Jaspera1275122013-03-20 10:23:53 +00002205 " case 1: \\\n"
Daniel Jasper00475962013-02-19 17:14:38 +00002206 " case 2\n",
2207 getLLVMStyleWithColumns(20));
Daniel Jasper451544a2016-05-19 06:30:48 +00002208 verifyFormat("#define MACRO(a) \\\n"
2209 " if (a) \\\n"
2210 " f(); \\\n"
2211 " else \\\n"
2212 " g()",
2213 getLLVMStyleWithColumns(18));
Daniel Jasper00475962013-02-19 17:14:38 +00002214 verifyFormat("#define A template <typename T>");
Manuel Klimekec5c3db2015-05-07 12:26:30 +00002215 verifyIncompleteFormat("#define STR(x) #x\n"
2216 "f(STR(this_is_a_string_literal{));");
Daniel Jasper96df37a2013-08-28 09:17:37 +00002217 verifyFormat("#pragma omp threadprivate( \\\n"
2218 " y)), // expected-warning",
2219 getLLVMStyleWithColumns(28));
Daniel Jasperb1567c12015-01-19 10:50:08 +00002220 verifyFormat("#d, = };");
Daniel Jasper9d22bcc2015-01-19 10:51:05 +00002221 verifyFormat("#if \"a");
Manuel Klimekec5c3db2015-05-07 12:26:30 +00002222 verifyIncompleteFormat("({\n"
Manuel Klimek3d3ea842015-05-12 09:23:57 +00002223 "#define b \\\n"
2224 " } \\\n"
Manuel Klimekec5c3db2015-05-07 12:26:30 +00002225 " a\n"
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00002226 "a",
2227 getLLVMStyleWithColumns(15));
Daniel Jasper9ecb0e92015-03-13 13:32:11 +00002228 verifyFormat("#define A \\\n"
2229 " { \\\n"
2230 " {\n"
2231 "#define B \\\n"
2232 " } \\\n"
2233 " }",
2234 getLLVMStyleWithColumns(15));
Daniel Jasperfd725c02015-01-21 17:35:29 +00002235 verifyNoCrash("#if a\na(\n#else\n#endif\n{a");
Daniel Jasperd1debfc2015-01-21 18:04:02 +00002236 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}");
Daniel Jasper04b979d2015-01-21 18:35:47 +00002237 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};");
Daniel Jasperd1c13732015-01-23 19:37:25 +00002238 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}");
Daniel Jasper00475962013-02-19 17:14:38 +00002239}
2240
Daniel Jasper40e19212013-05-29 13:16:10 +00002241TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) {
2242 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
2243 EXPECT_EQ("class A : public QObject {\n"
2244 " Q_OBJECT\n"
2245 "\n"
2246 " A() {}\n"
2247 "};",
2248 format("class A : public QObject {\n"
2249 " Q_OBJECT\n"
2250 "\n"
2251 " A() {\n}\n"
2252 "} ;"));
Daniel Jaspere60cba12015-05-13 11:35:53 +00002253 EXPECT_EQ("MACRO\n"
2254 "/*static*/ int i;",
2255 format("MACRO\n"
2256 " /*static*/ int i;"));
Daniel Jasper41a0f782013-05-29 14:09:17 +00002257 EXPECT_EQ("SOME_MACRO\n"
2258 "namespace {\n"
2259 "void f();\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00002260 "} // namespace",
Daniel Jasper41a0f782013-05-29 14:09:17 +00002261 format("SOME_MACRO\n"
2262 " namespace {\n"
2263 "void f( );\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00002264 "} // namespace"));
Daniel Jasper40e19212013-05-29 13:16:10 +00002265 // Only if the identifier contains at least 5 characters.
Daniel Jaspera44991332015-04-29 13:06:49 +00002266 EXPECT_EQ("HTTP f();", format("HTTP\nf();"));
2267 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();"));
Daniel Jasper40e19212013-05-29 13:16:10 +00002268 // Only if everything is upper case.
2269 EXPECT_EQ("class A : public QObject {\n"
2270 " Q_Object A() {}\n"
2271 "};",
2272 format("class A : public QObject {\n"
2273 " Q_Object\n"
Daniel Jasper40e19212013-05-29 13:16:10 +00002274 " A() {\n}\n"
2275 "} ;"));
Daniel Jasper680b09b2014-11-05 10:48:04 +00002276
2277 // Only if the next line can actually start an unwrapped line.
2278 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;",
2279 format("SOME_WEIRD_LOG_MACRO\n"
2280 "<< SomeThing;"));
Nico Weber23846262014-12-09 23:22:35 +00002281
2282 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), "
Daniel Jaspera44991332015-04-29 13:06:49 +00002283 "(n, buffers))\n",
2284 getChromiumStyle(FormatStyle::LK_Cpp));
Daniel Jasper40e19212013-05-29 13:16:10 +00002285}
2286
Alexander Kornienkode644272013-04-08 22:16:06 +00002287TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) {
2288 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
2289 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
2290 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00002291 "class X {};\n"
Alexander Kornienkode644272013-04-08 22:16:06 +00002292 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
2293 "int *createScopDetectionPass() { return 0; }",
2294 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
2295 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
2296 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
2297 " class X {};\n"
2298 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
2299 " int *createScopDetectionPass() { return 0; }"));
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002300 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as
2301 // braces, so that inner block is indented one level more.
2302 EXPECT_EQ("int q() {\n"
2303 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
2304 " IPC_MESSAGE_HANDLER(xxx, qqq)\n"
2305 " IPC_END_MESSAGE_MAP()\n"
2306 "}",
2307 format("int q() {\n"
2308 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
2309 " IPC_MESSAGE_HANDLER(xxx, qqq)\n"
2310 " IPC_END_MESSAGE_MAP()\n"
2311 "}"));
Daniel Jasper545c6522013-09-17 09:26:07 +00002312
Daniel Jasper352dae12014-01-03 11:50:46 +00002313 // Same inside macros.
2314 EXPECT_EQ("#define LIST(L) \\\n"
2315 " L(A) \\\n"
2316 " L(B) \\\n"
2317 " L(C)",
2318 format("#define LIST(L) \\\n"
2319 " L(A) \\\n"
2320 " L(B) \\\n"
2321 " L(C)",
2322 getGoogleStyle()));
2323
Daniel Jasper545c6522013-09-17 09:26:07 +00002324 // These must not be recognized as macros.
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002325 EXPECT_EQ("int q() {\n"
2326 " f(x);\n"
2327 " f(x) {}\n"
2328 " f(x)->g();\n"
2329 " f(x)->*g();\n"
2330 " f(x).g();\n"
2331 " f(x) = x;\n"
2332 " f(x) += x;\n"
2333 " f(x) -= x;\n"
2334 " f(x) *= x;\n"
2335 " f(x) /= x;\n"
2336 " f(x) %= x;\n"
2337 " f(x) &= x;\n"
2338 " f(x) |= x;\n"
2339 " f(x) ^= x;\n"
2340 " f(x) >>= x;\n"
2341 " f(x) <<= x;\n"
2342 " f(x)[y].z();\n"
2343 " LOG(INFO) << x;\n"
2344 " ifstream(x) >> x;\n"
2345 "}\n",
2346 format("int q() {\n"
2347 " f(x)\n;\n"
2348 " f(x)\n {}\n"
2349 " f(x)\n->g();\n"
2350 " f(x)\n->*g();\n"
2351 " f(x)\n.g();\n"
2352 " f(x)\n = x;\n"
2353 " f(x)\n += x;\n"
2354 " f(x)\n -= x;\n"
2355 " f(x)\n *= x;\n"
2356 " f(x)\n /= x;\n"
2357 " f(x)\n %= x;\n"
2358 " f(x)\n &= x;\n"
2359 " f(x)\n |= x;\n"
2360 " f(x)\n ^= x;\n"
2361 " f(x)\n >>= x;\n"
2362 " f(x)\n <<= x;\n"
2363 " f(x)\n[y].z();\n"
2364 " LOG(INFO)\n << x;\n"
2365 " ifstream(x)\n >> x;\n"
2366 "}\n"));
2367 EXPECT_EQ("int q() {\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002368 " F(x)\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002369 " if (1) {\n"
2370 " }\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002371 " F(x)\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002372 " while (1) {\n"
2373 " }\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002374 " F(x)\n"
2375 " G(x);\n"
2376 " F(x)\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002377 " try {\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002378 " Q();\n"
Daniel Jasper04a71a42014-05-08 11:58:24 +00002379 " } catch (...) {\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002380 " }\n"
2381 "}\n",
2382 format("int q() {\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002383 "F(x)\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002384 "if (1) {}\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002385 "F(x)\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002386 "while (1) {}\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002387 "F(x)\n"
2388 "G(x);\n"
2389 "F(x)\n"
2390 "try { Q(); } catch (...) {}\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002391 "}\n"));
2392 EXPECT_EQ("class A {\n"
2393 " A() : t(0) {}\n"
Daniel Jasper5ebb2f32014-05-21 13:08:17 +00002394 " A(int i) noexcept() : {}\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002395 " A(X x)\n" // FIXME: function-level try blocks are broken.
2396 " try : t(0) {\n"
Daniel Jasper04a71a42014-05-08 11:58:24 +00002397 " } catch (...) {\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002398 " }\n"
2399 "};",
2400 format("class A {\n"
2401 " A()\n : t(0) {}\n"
Daniel Jasper5ebb2f32014-05-21 13:08:17 +00002402 " A(int i)\n noexcept() : {}\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002403 " A(X x)\n"
2404 " try : t(0) {} catch (...) {}\n"
2405 "};"));
Daniel Jaspera44991332015-04-29 13:06:49 +00002406 EXPECT_EQ("class SomeClass {\n"
2407 "public:\n"
2408 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
2409 "};",
2410 format("class SomeClass {\n"
2411 "public:\n"
2412 " SomeClass()\n"
2413 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
2414 "};"));
2415 EXPECT_EQ("class SomeClass {\n"
2416 "public:\n"
2417 " SomeClass()\n"
2418 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
2419 "};",
2420 format("class SomeClass {\n"
2421 "public:\n"
2422 " SomeClass()\n"
2423 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
2424 "};",
2425 getLLVMStyleWithColumns(40)));
Daniel Jasper7fa524b2015-11-20 15:26:50 +00002426
2427 verifyFormat("MACRO(>)");
Alexander Kornienkode644272013-04-08 22:16:06 +00002428}
2429
Manuel Klimek4fe43002013-05-22 12:51:29 +00002430TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) {
2431 verifyFormat("#define A \\\n"
2432 " f({ \\\n"
2433 " g(); \\\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00002434 " });",
2435 getLLVMStyleWithColumns(11));
Manuel Klimek4fe43002013-05-22 12:51:29 +00002436}
2437
Krasimir Georgievad47c902017-08-30 14:34:57 +00002438TEST_F(FormatTest, IndentPreprocessorDirectives) {
2439 FormatStyle Style = getLLVMStyle();
2440 Style.IndentPPDirectives = FormatStyle::PPDIS_None;
2441 Style.ColumnLimit = 40;
2442 verifyFormat("#ifdef _WIN32\n"
2443 "#define A 0\n"
2444 "#ifdef VAR2\n"
2445 "#define B 1\n"
2446 "#include <someheader.h>\n"
2447 "#define MACRO \\\n"
2448 " some_very_long_func_aaaaaaaaaa();\n"
2449 "#endif\n"
2450 "#else\n"
2451 "#define A 1\n"
2452 "#endif",
2453 Style);
Krasimir Georgievad47c902017-08-30 14:34:57 +00002454 Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash;
2455 verifyFormat("#ifdef _WIN32\n"
2456 "# define A 0\n"
2457 "# ifdef VAR2\n"
2458 "# define B 1\n"
2459 "# include <someheader.h>\n"
2460 "# define MACRO \\\n"
2461 " some_very_long_func_aaaaaaaaaa();\n"
2462 "# endif\n"
2463 "#else\n"
2464 "# define A 1\n"
2465 "#endif",
2466 Style);
2467 verifyFormat("#if A\n"
2468 "# define MACRO \\\n"
2469 " void a(int x) { \\\n"
2470 " b(); \\\n"
2471 " c(); \\\n"
2472 " d(); \\\n"
2473 " e(); \\\n"
2474 " f(); \\\n"
2475 " }\n"
2476 "#endif",
2477 Style);
2478 // Comments before include guard.
2479 verifyFormat("// file comment\n"
2480 "// file comment\n"
2481 "#ifndef HEADER_H\n"
2482 "#define HEADER_H\n"
2483 "code();\n"
2484 "#endif",
2485 Style);
2486 // Test with include guards.
2487 // EXPECT_EQ is used because verifyFormat() calls messUp() which incorrectly
2488 // merges lines.
2489 verifyFormat("#ifndef HEADER_H\n"
2490 "#define HEADER_H\n"
2491 "code();\n"
2492 "#endif",
2493 Style);
2494 // Include guards must have a #define with the same variable immediately
2495 // after #ifndef.
2496 verifyFormat("#ifndef NOT_GUARD\n"
2497 "# define FOO\n"
2498 "code();\n"
2499 "#endif",
2500 Style);
2501
2502 // Include guards must cover the entire file.
2503 verifyFormat("code();\n"
2504 "code();\n"
2505 "#ifndef NOT_GUARD\n"
2506 "# define NOT_GUARD\n"
2507 "code();\n"
2508 "#endif",
2509 Style);
2510 verifyFormat("#ifndef NOT_GUARD\n"
2511 "# define NOT_GUARD\n"
2512 "code();\n"
2513 "#endif\n"
2514 "code();",
2515 Style);
2516 // Test with trailing blank lines.
2517 verifyFormat("#ifndef HEADER_H\n"
2518 "#define HEADER_H\n"
2519 "code();\n"
2520 "#endif\n",
2521 Style);
2522 // Include guards don't have #else.
2523 verifyFormat("#ifndef NOT_GUARD\n"
2524 "# define NOT_GUARD\n"
2525 "code();\n"
2526 "#else\n"
2527 "#endif",
2528 Style);
2529 verifyFormat("#ifndef NOT_GUARD\n"
2530 "# define NOT_GUARD\n"
2531 "code();\n"
2532 "#elif FOO\n"
2533 "#endif",
2534 Style);
2535 // FIXME: This doesn't handle the case where there's code between the
2536 // #ifndef and #define but all other conditions hold. This is because when
2537 // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the
2538 // previous code line yet, so we can't detect it.
2539 EXPECT_EQ("#ifndef NOT_GUARD\n"
2540 "code();\n"
2541 "#define NOT_GUARD\n"
2542 "code();\n"
2543 "#endif",
2544 format("#ifndef NOT_GUARD\n"
2545 "code();\n"
2546 "# define NOT_GUARD\n"
2547 "code();\n"
2548 "#endif",
2549 Style));
2550 // FIXME: This doesn't handle cases where legitimate preprocessor lines may
2551 // be outside an include guard. Examples are #pragma once and
2552 // #pragma GCC diagnostic, or anything else that does not change the meaning
2553 // of the file if it's included multiple times.
2554 EXPECT_EQ("#ifdef WIN32\n"
2555 "# pragma once\n"
2556 "#endif\n"
2557 "#ifndef HEADER_H\n"
2558 "# define HEADER_H\n"
2559 "code();\n"
2560 "#endif",
2561 format("#ifdef WIN32\n"
2562 "# pragma once\n"
2563 "#endif\n"
2564 "#ifndef HEADER_H\n"
2565 "#define HEADER_H\n"
2566 "code();\n"
2567 "#endif",
2568 Style));
2569 // FIXME: This does not detect when there is a single non-preprocessor line
2570 // in front of an include-guard-like structure where other conditions hold
2571 // because ScopedLineState hides the line.
2572 EXPECT_EQ("code();\n"
2573 "#ifndef HEADER_H\n"
2574 "#define HEADER_H\n"
2575 "code();\n"
2576 "#endif",
2577 format("code();\n"
2578 "#ifndef HEADER_H\n"
2579 "# define HEADER_H\n"
2580 "code();\n"
2581 "#endif",
2582 Style));
2583 // FIXME: The comment indent corrector in TokenAnnotator gets thrown off by
2584 // preprocessor indentation.
2585 EXPECT_EQ("#if 1\n"
2586 " // comment\n"
2587 "# define A 0\n"
2588 "// comment\n"
2589 "# define B 0\n"
2590 "#endif",
2591 format("#if 1\n"
2592 "// comment\n"
2593 "# define A 0\n"
2594 " // comment\n"
2595 "# define B 0\n"
2596 "#endif",
2597 Style));
2598 // Test with tabs.
2599 Style.UseTab = FormatStyle::UT_Always;
2600 Style.IndentWidth = 8;
2601 Style.TabWidth = 8;
2602 verifyFormat("#ifdef _WIN32\n"
2603 "#\tdefine A 0\n"
2604 "#\tifdef VAR2\n"
2605 "#\t\tdefine B 1\n"
2606 "#\t\tinclude <someheader.h>\n"
2607 "#\t\tdefine MACRO \\\n"
2608 "\t\t\tsome_very_long_func_aaaaaaaaaa();\n"
2609 "#\tendif\n"
2610 "#else\n"
2611 "#\tdefine A 1\n"
2612 "#endif",
2613 Style);
Daniel Jasper4df130f2017-09-04 13:33:52 +00002614
2615 // Regression test: Multiline-macro inside include guards.
2616 verifyFormat("#ifndef HEADER_H\n"
2617 "#define HEADER_H\n"
2618 "#define A() \\\n"
2619 " int i; \\\n"
2620 " int j;\n"
2621 "#endif // HEADER_H",
2622 getLLVMStyleWithColumns(20));
Manuel Klimekef2cfb12013-01-05 22:14:16 +00002623}
2624
Manuel Klimek52d0fd82013-01-05 22:56:06 +00002625TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) {
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00002626 verifyFormat("{\n { a #c; }\n}");
Manuel Klimek52d0fd82013-01-05 22:56:06 +00002627}
2628
Manuel Klimek1058d982013-01-06 20:07:31 +00002629TEST_F(FormatTest, FormatUnbalancedStructuralElements) {
2630 EXPECT_EQ("#define A \\\n { \\\n {\nint i;",
2631 format("#define A { {\nint i;", getLLVMStyleWithColumns(11)));
2632 EXPECT_EQ("#define A \\\n } \\\n }\nint i;",
2633 format("#define A } }\nint i;", getLLVMStyleWithColumns(11)));
2634}
Manuel Klimek1abf7892013-01-04 23:34:14 +00002635
Daniel Jaspere2408e32015-05-06 11:16:43 +00002636TEST_F(FormatTest, EscapedNewlines) {
Krasimir Georgiev7f64fa82017-10-30 14:41:34 +00002637 FormatStyle Narrow = getLLVMStyleWithColumns(11);
2638 EXPECT_EQ("#define A \\\n int i; \\\n int j;",
2639 format("#define A \\\nint i;\\\n int j;", Narrow));
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00002640 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;"));
Alexander Kornienkoee4ca9b2013-06-07 17:45:07 +00002641 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
Krasimir Georgievbb99a362017-02-16 12:39:31 +00002642 EXPECT_EQ("/* \\ \\ \\\n */", format("\\\n/* \\ \\ \\\n */"));
Daniel Jaspere2408e32015-05-06 11:16:43 +00002643 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>"));
Jacob Bandes-Storchd6a7e982017-08-10 00:15:31 +00002644
Krasimir Georgiev7f64fa82017-10-30 14:41:34 +00002645 FormatStyle AlignLeft = getLLVMStyle();
2646 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
2647 EXPECT_EQ("#define MACRO(x) \\\n"
2648 "private: \\\n"
2649 " int x(int a);\n",
2650 format("#define MACRO(x) \\\n"
2651 "private: \\\n"
2652 " int x(int a);\n",
2653 AlignLeft));
2654
2655 // CRLF line endings
2656 EXPECT_EQ("#define A \\\r\n int i; \\\r\n int j;",
2657 format("#define A \\\r\nint i;\\\r\n int j;", Narrow));
2658 EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;"));
2659 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
2660 EXPECT_EQ("/* \\ \\ \\\r\n */", format("\\\r\n/* \\ \\ \\\r\n */"));
2661 EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>"));
2662 EXPECT_EQ("#define MACRO(x) \\\r\n"
2663 "private: \\\r\n"
2664 " int x(int a);\r\n",
2665 format("#define MACRO(x) \\\r\n"
2666 "private: \\\r\n"
2667 " int x(int a);\r\n",
2668 AlignLeft));
2669
Jacob Bandes-Storchd6a7e982017-08-10 00:15:31 +00002670 FormatStyle DontAlign = getLLVMStyle();
2671 DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
2672 DontAlign.MaxEmptyLinesToKeep = 3;
2673 // FIXME: can't use verifyFormat here because the newline before
2674 // "public:" is not inserted the first time it's reformatted
2675 EXPECT_EQ("#define A \\\n"
2676 " class Foo { \\\n"
2677 " void bar(); \\\n"
2678 "\\\n"
2679 "\\\n"
2680 "\\\n"
2681 " public: \\\n"
2682 " void baz(); \\\n"
2683 " };",
2684 format("#define A \\\n"
2685 " class Foo { \\\n"
2686 " void bar(); \\\n"
2687 "\\\n"
2688 "\\\n"
2689 "\\\n"
2690 " public: \\\n"
2691 " void baz(); \\\n"
Krasimir Georgiev7f64fa82017-10-30 14:41:34 +00002692 " };",
2693 DontAlign));
Alexander Kornienkobe633902013-06-14 11:46:10 +00002694}
2695
Manuel Klimek38ba11e2013-01-07 09:24:17 +00002696TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) {
2697 verifyFormat("#define A \\\n"
2698 " int v( \\\n"
2699 " a); \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002700 " int i;",
2701 getLLVMStyleWithColumns(11));
Manuel Klimek38ba11e2013-01-07 09:24:17 +00002702}
2703
Manuel Klimeka71e5d82013-01-02 16:30:12 +00002704TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) {
Manuel Klimek1abf7892013-01-04 23:34:14 +00002705 EXPECT_EQ(
2706 "#define ALooooooooooooooooooooooooooooooooooooooongMacro("
2707 " \\\n"
2708 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
2709 "\n"
2710 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
2711 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n",
2712 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro("
2713 "\\\n"
2714 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
2715 " \n"
2716 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
2717 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n"));
Manuel Klimeka71e5d82013-01-02 16:30:12 +00002718}
2719
Manuel Klimek52b15152013-01-09 15:25:02 +00002720TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {
2721 EXPECT_EQ("int\n"
2722 "#define A\n"
Daniel Jasper8e357692013-05-06 08:27:33 +00002723 " a;",
Daniel Jasper4355e7f2014-07-09 07:50:33 +00002724 format("int\n#define A\na;"));
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002725 verifyFormat("functionCallTo(\n"
2726 " someOtherFunction(\n"
2727 " withSomeParameters, whichInSequence,\n"
2728 " areLongerThanALine(andAnotherCall,\n"
2729 "#define A B\n"
2730 " withMoreParamters,\n"
2731 " whichStronglyInfluenceTheLayout),\n"
Daniel Jasper37905f72013-02-21 15:00:29 +00002732 " andMoreParameters),\n"
2733 " trailing);",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002734 getLLVMStyleWithColumns(69));
Daniel Jasperfb81b092013-09-17 09:52:48 +00002735 verifyFormat("Foo::Foo()\n"
2736 "#ifdef BAR\n"
2737 " : baz(0)\n"
2738 "#endif\n"
2739 "{\n"
2740 "}");
Manuel Klimek71814b42013-10-11 21:25:45 +00002741 verifyFormat("void f() {\n"
2742 " if (true)\n"
2743 "#ifdef A\n"
2744 " f(42);\n"
2745 " x();\n"
2746 "#else\n"
2747 " g();\n"
2748 " x();\n"
2749 "#endif\n"
2750 "}");
2751 verifyFormat("void f(param1, param2,\n"
2752 " param3,\n"
2753 "#ifdef A\n"
2754 " param4(param5,\n"
2755 "#ifdef A1\n"
2756 " param6,\n"
2757 "#ifdef A2\n"
2758 " param7),\n"
2759 "#else\n"
2760 " param8),\n"
2761 " param9,\n"
2762 "#endif\n"
2763 " param10,\n"
2764 "#endif\n"
2765 " param11)\n"
2766 "#else\n"
2767 " param12)\n"
2768 "#endif\n"
2769 "{\n"
2770 " x();\n"
2771 "}",
2772 getLLVMStyleWithColumns(28));
Daniel Jasper53bd1672013-10-12 13:32:56 +00002773 verifyFormat("#if 1\n"
2774 "int i;");
Daniel Jaspera44991332015-04-29 13:06:49 +00002775 verifyFormat("#if 1\n"
2776 "#endif\n"
2777 "#if 1\n"
2778 "#else\n"
2779 "#endif\n");
Daniel Jasper472da862013-10-24 15:23:11 +00002780 verifyFormat("DEBUG({\n"
2781 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2782 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
2783 "});\n"
2784 "#if a\n"
2785 "#else\n"
2786 "#endif");
Daniel Jasper193cdd32015-01-19 10:52:16 +00002787
Manuel Klimekec5c3db2015-05-07 12:26:30 +00002788 verifyIncompleteFormat("void f(\n"
2789 "#if A\n"
Martin Probst2c1cdae2017-05-15 11:15:29 +00002790 ");\n"
Manuel Klimekec5c3db2015-05-07 12:26:30 +00002791 "#else\n"
2792 "#endif");
Manuel Klimek52b15152013-01-09 15:25:02 +00002793}
2794
Manuel Klimek14bd9172014-01-29 08:49:02 +00002795TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) {
2796 verifyFormat("#endif\n"
2797 "#if B");
2798}
2799
Manuel Klimek88033d72013-10-21 08:11:15 +00002800TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) {
2801 FormatStyle SingleLine = getLLVMStyle();
2802 SingleLine.AllowShortIfStatementsOnASingleLine = true;
Daniel Jaspera44991332015-04-29 13:06:49 +00002803 verifyFormat("#if 0\n"
2804 "#elif 1\n"
2805 "#endif\n"
2806 "void foo() {\n"
2807 " if (test) foo2();\n"
2808 "}",
2809 SingleLine);
Manuel Klimek88033d72013-10-21 08:11:15 +00002810}
2811
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00002812TEST_F(FormatTest, LayoutBlockInsideParens) {
Daniel Jasperacf67e32015-04-07 08:20:35 +00002813 verifyFormat("functionCall({ int i; });");
2814 verifyFormat("functionCall({\n"
2815 " int i;\n"
2816 " int j;\n"
2817 "});");
Daniel Jasper100ffc62015-08-21 11:44:57 +00002818 verifyFormat("functionCall(\n"
2819 " {\n"
2820 " int i;\n"
2821 " int j;\n"
2822 " },\n"
2823 " aaaa, bbbb, cccc);");
Daniel Jasperacf67e32015-04-07 08:20:35 +00002824 verifyFormat("functionA(functionB({\n"
2825 " int i;\n"
2826 " int j;\n"
2827 " }),\n"
2828 " aaaa, bbbb, cccc);");
2829 verifyFormat("functionCall(\n"
2830 " {\n"
2831 " int i;\n"
2832 " int j;\n"
2833 " },\n"
2834 " aaaa, bbbb, // comment\n"
2835 " cccc);");
2836 verifyFormat("functionA(functionB({\n"
2837 " int i;\n"
2838 " int j;\n"
2839 " }),\n"
2840 " aaaa, bbbb, // comment\n"
2841 " cccc);");
2842 verifyFormat("functionCall(aaaa, bbbb, { int i; });");
2843 verifyFormat("functionCall(aaaa, bbbb, {\n"
2844 " int i;\n"
2845 " int j;\n"
2846 "});");
Daniel Jasper393564f2013-05-31 14:56:29 +00002847 verifyFormat(
Daniel Jaspera44991332015-04-29 13:06:49 +00002848 "Aaa(\n" // FIXME: There shouldn't be a linebreak here.
Daniel Jasper4b444492014-11-21 13:38:53 +00002849 " {\n"
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00002850 " int i; // break\n"
2851 " },\n"
Daniel Jasper393564f2013-05-31 14:56:29 +00002852 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
2853 " ccccccccccccccccc));");
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00002854 verifyFormat("DEBUG({\n"
2855 " if (a)\n"
2856 " f();\n"
2857 "});");
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00002858}
2859
2860TEST_F(FormatTest, LayoutBlockInsideStatement) {
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00002861 EXPECT_EQ("SOME_MACRO { int i; }\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002862 "int i;",
2863 format(" SOME_MACRO {int i;} int i;"));
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00002864}
2865
2866TEST_F(FormatTest, LayoutNestedBlocks) {
2867 verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
2868 " struct s {\n"
2869 " int i;\n"
2870 " };\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00002871 " s kBitsToOs[] = {{10}};\n"
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00002872 " for (int i = 0; i < 10; ++i)\n"
2873 " return;\n"
2874 "}");
Daniel Jasper1c5d9df2013-09-06 07:54:20 +00002875 verifyFormat("call(parameter, {\n"
2876 " something();\n"
2877 " // Comment using all columns.\n"
2878 " somethingelse();\n"
2879 "});",
2880 getLLVMStyleWithColumns(40));
Daniel Jaspere40caf92013-11-29 08:46:20 +00002881 verifyFormat("DEBUG( //\n"
2882 " { f(); }, a);");
2883 verifyFormat("DEBUG( //\n"
2884 " {\n"
2885 " f(); //\n"
2886 " },\n"
2887 " a);");
2888
Daniel Jasper1c5d9df2013-09-06 07:54:20 +00002889 EXPECT_EQ("call(parameter, {\n"
2890 " something();\n"
2891 " // Comment too\n"
2892 " // looooooooooong.\n"
2893 " somethingElse();\n"
2894 "});",
2895 format("call(parameter, {\n"
2896 " something();\n"
2897 " // Comment too looooooooooong.\n"
2898 " somethingElse();\n"
2899 "});",
2900 getLLVMStyleWithColumns(29)));
Daniel Jasper9b246e02013-09-08 14:07:57 +00002901 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });"));
Daniel Jasperdcd5da12013-10-20 17:28:32 +00002902 EXPECT_EQ("DEBUG({ // comment\n"
2903 " int i;\n"
2904 "});",
2905 format("DEBUG({ // comment\n"
2906 "int i;\n"
2907 "});"));
Daniel Jasper9b246e02013-09-08 14:07:57 +00002908 EXPECT_EQ("DEBUG({\n"
2909 " int i;\n"
2910 "\n"
2911 " // comment\n"
2912 " int j;\n"
2913 "});",
2914 format("DEBUG({\n"
2915 " int i;\n"
2916 "\n"
2917 " // comment\n"
2918 " int j;\n"
2919 "});"));
Daniel Jasperbbf5c1c2013-11-05 19:10:03 +00002920
2921 verifyFormat("DEBUG({\n"
2922 " if (a)\n"
2923 " return;\n"
2924 "});");
2925 verifyGoogleFormat("DEBUG({\n"
2926 " if (a) return;\n"
2927 "});");
2928 FormatStyle Style = getGoogleStyle();
2929 Style.ColumnLimit = 45;
Daniel Jasper100ffc62015-08-21 11:44:57 +00002930 verifyFormat("Debug(aaaaa,\n"
2931 " {\n"
2932 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n"
2933 " },\n"
2934 " a);",
Daniel Jasper4b444492014-11-21 13:38:53 +00002935 Style);
Daniel Jasper47b35ae2015-01-29 10:47:14 +00002936
Daniel Jaspera87af7a2015-06-30 11:32:22 +00002937 verifyFormat("SomeFunction({MACRO({ return output; }), b});");
2938
Daniel Jasper47b35ae2015-01-29 10:47:14 +00002939 verifyNoCrash("^{v^{a}}");
Daniel Jasper9c199562013-11-28 15:58:55 +00002940}
2941
Daniel Jasper5fc133e2015-05-12 10:16:02 +00002942TEST_F(FormatTest, FormatNestedBlocksInMacros) {
2943 EXPECT_EQ("#define MACRO() \\\n"
2944 " Debug(aaa, /* force line break */ \\\n"
2945 " { \\\n"
2946 " int i; \\\n"
2947 " int j; \\\n"
2948 " })",
2949 format("#define MACRO() Debug(aaa, /* force line break */ \\\n"
2950 " { int i; int j; })",
2951 getGoogleStyle()));
Daniel Jasper1a028222015-05-26 07:03:42 +00002952
2953 EXPECT_EQ("#define A \\\n"
2954 " [] { \\\n"
2955 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
2956 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n"
2957 " }",
2958 format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
2959 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }",
2960 getGoogleStyle()));
Daniel Jasper5fc133e2015-05-12 10:16:02 +00002961}
2962
Manuel Klimeke7d10a12013-01-10 13:24:24 +00002963TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) {
2964 EXPECT_EQ("{}", format("{}"));
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00002965 verifyFormat("enum E {};");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00002966 verifyFormat("enum E {}");
Manuel Klimeke7d10a12013-01-10 13:24:24 +00002967}
2968
Birunthan Mohanathasb001a0b2015-07-03 17:25:16 +00002969TEST_F(FormatTest, FormatBeginBlockEndMacros) {
2970 FormatStyle Style = getLLVMStyle();
2971 Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$";
2972 Style.MacroBlockEnd = "^[A-Z_]+_END$";
2973 verifyFormat("FOO_BEGIN\n"
2974 " FOO_ENTRY\n"
2975 "FOO_END", Style);
2976 verifyFormat("FOO_BEGIN\n"
2977 " NESTED_FOO_BEGIN\n"
2978 " NESTED_FOO_ENTRY\n"
2979 " NESTED_FOO_END\n"
2980 "FOO_END", Style);
2981 verifyFormat("FOO_BEGIN(Foo, Bar)\n"
2982 " int x;\n"
2983 " x = 1;\n"
2984 "FOO_END(Baz)", Style);
2985}
2986
Alexander Kornienko578fdd82012-12-06 18:03:27 +00002987//===----------------------------------------------------------------------===//
2988// Line break tests.
2989//===----------------------------------------------------------------------===//
2990
Daniel Jasperf79b0b12013-08-30 08:29:25 +00002991TEST_F(FormatTest, PreventConfusingIndents) {
Alexander Kornienko578fdd82012-12-06 18:03:27 +00002992 verifyFormat(
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00002993 "void f() {\n"
2994 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n"
2995 " parameter, parameter, parameter)),\n"
2996 " SecondLongCall(parameter));\n"
2997 "}");
Daniel Jasper7b5773e92013-01-28 07:35:34 +00002998 verifyFormat(
2999 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3000 " aaaaaaaaaaaaaaaaaaaaaaaa(\n"
3001 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3002 " aaaaaaaaaaaaaaaaaaaaaaaa);");
3003 verifyFormat(
Daniel Jasperaea3bde2013-07-12 11:19:37 +00003004 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3005 " [aaaaaaaaaaaaaaaaaaaaaaaa\n"
3006 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
3007 " [aaaaaaaaaaaaaaaaaaaaaaaa]];");
Daniel Jasper7b5773e92013-01-28 07:35:34 +00003008 verifyFormat(
3009 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
3010 " aaaaaaaaaaaaaaaaaaaaaaaa<\n"
3011 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n"
3012 " aaaaaaaaaaaaaaaaaaaaaaaa>;");
Daniel Jasper240527c2017-01-16 13:13:15 +00003013 verifyFormat("int a = bbbb && ccc &&\n"
3014 " fffff(\n"
Daniel Jasper20b09ef2013-01-28 09:35:24 +00003015 "#define A Just forcing a new line\n"
Daniel Jasper240527c2017-01-16 13:13:15 +00003016 " ddd);");
Daniel Jasper7b5773e92013-01-28 07:35:34 +00003017}
3018
Daniel Jasperd69fc772013-05-08 14:12:04 +00003019TEST_F(FormatTest, LineBreakingInBinaryExpressions) {
3020 verifyFormat(
3021 "bool aaaaaaa =\n"
3022 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n"
3023 " bbbbbbbb();");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00003024 verifyFormat(
3025 "bool aaaaaaa =\n"
3026 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n"
3027 " bbbbbbbb();");
3028
Daniel Jasperd69fc772013-05-08 14:12:04 +00003029 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
3030 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n"
3031 " ccccccccc == ddddddddddd;");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00003032 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
3033 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n"
3034 " ccccccccc == ddddddddddd;");
3035 verifyFormat(
3036 "bool aaaaaaaaaaaaaaaaaaaaa =\n"
3037 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n"
3038 " ccccccccc == ddddddddddd;");
Daniel Jasperd69fc772013-05-08 14:12:04 +00003039
3040 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
3041 " aaaaaa) &&\n"
3042 " bbbbbb && cccccc;");
Daniel Jasper9f82df22013-05-28 07:42:44 +00003043 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
3044 " aaaaaa) >>\n"
3045 " bbbbbb;");
Daniel Jasperf901a572015-12-07 19:50:48 +00003046 verifyFormat("aa = Whitespaces.addUntouchableComment(\n"
Daniel Jasperd69fc772013-05-08 14:12:04 +00003047 " SourceMgr.getSpellingColumnNumber(\n"
3048 " TheLine.Last->FormatTok.Tok.getLocation()) -\n"
3049 " 1);");
Daniel Jasper571f1af2013-05-14 20:39:56 +00003050
Daniel Jasper68d888c2013-06-03 08:42:05 +00003051 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3052 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n"
3053 " cccccc) {\n}");
Daniel Jasper6a7d5a72017-06-19 07:40:49 +00003054 verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3055 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
3056 " cccccc) {\n}");
Daniel Jasper3eb341c2014-11-11 23:04:51 +00003057 verifyFormat("b = a &&\n"
3058 " // Comment\n"
3059 " b.c && d;");
Daniel Jasper68d888c2013-06-03 08:42:05 +00003060
Daniel Jasper7ae41cd2013-07-03 10:34:47 +00003061 // If the LHS of a comparison is not a binary expression itself, the
3062 // additional linebreak confuses many people.
3063 verifyFormat(
3064 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3065 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n"
3066 "}");
3067 verifyFormat(
3068 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3069 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
3070 "}");
Daniel Jasper562ecd42013-09-06 08:08:14 +00003071 verifyFormat(
3072 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n"
3073 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
3074 "}");
Richard Smithc70f1d62017-12-14 15:16:18 +00003075 verifyFormat(
3076 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3077 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n"
3078 "}");
Daniel Jasper7ae41cd2013-07-03 10:34:47 +00003079 // Even explicit parentheses stress the precedence enough to make the
3080 // additional break unnecessary.
Daniel Jaspera44991332015-04-29 13:06:49 +00003081 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3082 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
3083 "}");
Daniel Jasper7ae41cd2013-07-03 10:34:47 +00003084 // This cases is borderline, but with the indentation it is still readable.
3085 verifyFormat(
3086 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3087 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3088 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
3089 "}",
3090 getLLVMStyleWithColumns(75));
3091
3092 // If the LHS is a binary expression, we should still use the additional break
3093 // as otherwise the formatting hides the operator precedence.
Daniel Jaspera44991332015-04-29 13:06:49 +00003094 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3095 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
3096 " 5) {\n"
3097 "}");
Richard Smithc70f1d62017-12-14 15:16:18 +00003098 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3099 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n"
3100 " 5) {\n"
3101 "}");
Daniel Jasper7ae41cd2013-07-03 10:34:47 +00003102
Daniel Jasper571f1af2013-05-14 20:39:56 +00003103 FormatStyle OnePerLine = getLLVMStyle();
3104 OnePerLine.BinPackParameters = false;
3105 verifyFormat(
3106 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3107 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3108 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}",
3109 OnePerLine);
Daniel Jaspere61f9f92017-01-13 23:18:16 +00003110
3111 verifyFormat("int i = someFunction(aaaaaaa, 0)\n"
3112 " .aaa(aaaaaaaaaaaaa) *\n"
3113 " aaaaaaa +\n"
3114 " aaaaaaa;",
3115 getLLVMStyleWithColumns(40));
Daniel Jasperd69fc772013-05-08 14:12:04 +00003116}
3117
Daniel Jasper6bee6822013-04-08 20:33:42 +00003118TEST_F(FormatTest, ExpressionIndentation) {
3119 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3120 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3121 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
3122 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
3123 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
3124 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n"
3125 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
3126 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n"
3127 " ccccccccccccccccccccccccccccccccccccccccc;");
3128 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
3129 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3130 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
3131 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
3132 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3133 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
3134 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
3135 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
3136 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
3137 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
3138 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3139 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
Daniel Jasper6dcecb62013-06-06 09:11:58 +00003140 verifyFormat("if () {\n"
Daniel Jasper21f7dea2017-02-01 09:23:39 +00003141 "} else if (aaaaa && bbbbb > // break\n"
3142 " ccccc) {\n"
3143 "}");
3144 verifyFormat("if () {\n"
Daniel Jasper5c332652014-04-03 12:00:33 +00003145 "} else if (aaaaa &&\n"
3146 " bbbbb > // break\n"
Daniel Jasper21f7dea2017-02-01 09:23:39 +00003147 " ccccc &&\n"
3148 " ddddd) {\n"
Daniel Jasper6dcecb62013-06-06 09:11:58 +00003149 "}");
Alexander Kornienkoafaa8f52013-06-17 13:19:53 +00003150
3151 // Presence of a trailing comment used to change indentation of b.
3152 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
3153 " b;\n"
3154 "return aaaaaaaaaaaaaaaaaaa +\n"
3155 " b; //",
3156 getLLVMStyleWithColumns(30));
Daniel Jasper6bee6822013-04-08 20:33:42 +00003157}
3158
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003159TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) {
3160 // Not sure what the best system is here. Like this, the LHS can be found
3161 // immediately above an operator (everything with the same or a higher
3162 // indent). The RHS is aligned right of the operator and so compasses
3163 // everything until something with the same indent as the operator is found.
3164 // FIXME: Is this a good system?
3165 FormatStyle Style = getLLVMStyle();
Daniel Jasperac043c92014-09-15 11:11:00 +00003166 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003167 verifyFormat(
3168 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00003169 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3170 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3171 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3172 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
3173 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003174 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00003175 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3176 " > ccccccccccccccccccccccccccccccccccccccccc;",
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003177 Style);
3178 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00003179 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3180 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003181 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
3182 Style);
3183 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00003184 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3185 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003186 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
3187 Style);
3188 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3189 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00003190 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3191 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003192 Style);
3193 verifyFormat("if () {\n"
Daniel Jasperc0d606a2014-04-14 11:08:45 +00003194 "} else if (aaaaa\n"
3195 " && bbbbb // break\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00003196 " > ccccc) {\n"
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003197 "}",
3198 Style);
Daniel Jasper119ff532014-11-14 12:31:14 +00003199 verifyFormat("return (a)\n"
3200 " // comment\n"
3201 " + b;",
3202 Style);
Daniel Jaspera44991332015-04-29 13:06:49 +00003203 verifyFormat(
3204 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3205 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
3206 " + cc;",
3207 Style);
Daniel Jasper9e5ede02013-11-08 19:56:28 +00003208
Daniel Jaspere92bf6f2015-05-06 14:23:38 +00003209 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3210 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
3211 Style);
3212
Daniel Jasper9e5ede02013-11-08 19:56:28 +00003213 // Forced by comments.
3214 verifyFormat(
3215 "unsigned ContentSize =\n"
3216 " sizeof(int16_t) // DWARF ARange version number\n"
3217 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
3218 " + sizeof(int8_t) // Pointer Size (in bytes)\n"
3219 " + sizeof(int8_t); // Segment Size (in bytes)");
Daniel Jasper446d1cd2013-11-23 14:45:49 +00003220
3221 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
3222 " == boost::fusion::at_c<1>(iiii).second;",
3223 Style);
Daniel Jasper0a1e5ac2014-05-13 08:01:47 +00003224
3225 Style.ColumnLimit = 60;
3226 verifyFormat("zzzzzzzzzz\n"
3227 " = bbbbbbbbbbbbbbbbb\n"
3228 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
3229 Style);
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003230}
3231
Daniel Jasperb1270392017-02-01 23:27:37 +00003232TEST_F(FormatTest, EnforcedOperatorWraps) {
3233 // Here we'd like to wrap after the || operators, but a comment is forcing an
3234 // earlier wrap.
3235 verifyFormat("bool x = aaaaa //\n"
3236 " || bbbbb\n"
3237 " //\n"
3238 " || cccc;");
3239}
3240
Daniel Jasper3219e432014-12-02 13:24:51 +00003241TEST_F(FormatTest, NoOperandAlignment) {
3242 FormatStyle Style = getLLVMStyle();
3243 Style.AlignOperands = false;
Daniel Jasperc3aa05c2017-02-02 08:30:21 +00003244 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n"
3245 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3246 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
3247 Style);
Daniel Jasper3219e432014-12-02 13:24:51 +00003248 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
Daniel Jaspera44991332015-04-29 13:06:49 +00003249 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3250 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3251 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3252 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3253 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
3254 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
3255 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3256 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3257 " > ccccccccccccccccccccccccccccccccccccccccc;",
3258 Style);
Daniel Jasper3219e432014-12-02 13:24:51 +00003259
3260 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3261 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
3262 " + cc;",
3263 Style);
3264 verifyFormat("int a = aa\n"
3265 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
Daniel Jasper21f7dea2017-02-01 09:23:39 +00003266 " * cccccccccccccccccccccccccccccccccccc;\n",
Daniel Jasper3219e432014-12-02 13:24:51 +00003267 Style);
Daniel Jasperc0956632014-12-03 14:02:59 +00003268
Daniel Jasper6501f7e2015-10-27 12:38:37 +00003269 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
Daniel Jasperc0956632014-12-03 14:02:59 +00003270 verifyFormat("return (a > b\n"
3271 " // comment1\n"
3272 " // comment2\n"
3273 " || c);",
3274 Style);
Daniel Jasper3219e432014-12-02 13:24:51 +00003275}
3276
Daniel Jasperac043c92014-09-15 11:11:00 +00003277TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) {
3278 FormatStyle Style = getLLVMStyle();
3279 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
3280 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
3281 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper3219e432014-12-02 13:24:51 +00003282 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
3283 Style);
Daniel Jasperac043c92014-09-15 11:11:00 +00003284}
3285
Daniel Jasper988e7e42017-05-08 15:07:52 +00003286TEST_F(FormatTest, AllowBinPackingInsideArguments) {
3287 FormatStyle Style = getLLVMStyle();
3288 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
3289 Style.BinPackArguments = false;
3290 Style.ColumnLimit = 40;
3291 verifyFormat("void test() {\n"
3292 " someFunction(\n"
3293 " this + argument + is + quite\n"
3294 " + long + so + it + gets + wrapped\n"
3295 " + but + remains + bin - packed);\n"
3296 "}",
3297 Style);
3298 verifyFormat("void test() {\n"
3299 " someFunction(arg1,\n"
3300 " this + argument + is\n"
3301 " + quite + long + so\n"
3302 " + it + gets + wrapped\n"
3303 " + but + remains + bin\n"
3304 " - packed,\n"
3305 " arg3);\n"
3306 "}",
3307 Style);
3308 verifyFormat("void test() {\n"
3309 " someFunction(\n"
3310 " arg1,\n"
3311 " this + argument + has\n"
3312 " + anotherFunc(nested,\n"
3313 " calls + whose\n"
3314 " + arguments\n"
3315 " + are + also\n"
3316 " + wrapped,\n"
3317 " in + addition)\n"
3318 " + to + being + bin - packed,\n"
3319 " arg3);\n"
3320 "}",
3321 Style);
3322
3323 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
3324 verifyFormat("void test() {\n"
3325 " someFunction(\n"
3326 " arg1,\n"
3327 " this + argument + has +\n"
3328 " anotherFunc(nested,\n"
3329 " calls + whose +\n"
3330 " arguments +\n"
3331 " are + also +\n"
3332 " wrapped,\n"
3333 " in + addition) +\n"
3334 " to + being + bin - packed,\n"
3335 " arg3);\n"
3336 "}",
3337 Style);
3338}
3339
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003340TEST_F(FormatTest, ConstructorInitializers) {
Manuel Klimeke7d10a12013-01-10 13:24:24 +00003341 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
Daniel Jasper2408a8c2013-01-11 11:37:55 +00003342 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
3343 getLLVMStyleWithColumns(45));
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003344 verifyFormat("Constructor()\n"
3345 " : Inttializer(FitsOnTheLine) {}",
Daniel Jasper2408a8c2013-01-11 11:37:55 +00003346 getLLVMStyleWithColumns(44));
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003347 verifyFormat("Constructor()\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003348 " : Inttializer(FitsOnTheLine) {}",
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003349 getLLVMStyleWithColumns(43));
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003350
Daniel Jasper7b259cd2015-08-27 11:59:31 +00003351 verifyFormat("template <typename T>\n"
3352 "Constructor() : Initializer(FitsOnTheLine) {}",
3353 getLLVMStyleWithColumns(45));
3354
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003355 verifyFormat(
3356 "SomeClass::Constructor()\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003357 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003358
3359 verifyFormat(
3360 "SomeClass::Constructor()\n"
Daniel Jasper2408a8c2013-01-11 11:37:55 +00003361 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003362 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}");
Daniel Jasper2408a8c2013-01-11 11:37:55 +00003363 verifyFormat(
3364 "SomeClass::Constructor()\n"
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003365 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003366 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
Daniel Jasper7b259cd2015-08-27 11:59:31 +00003367 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3368 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3369 " : aaaaaaaaaa(aaaaaa) {}");
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003370
3371 verifyFormat("Constructor()\n"
3372 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3373 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3374 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003375 " aaaaaaaaaaaaaaaaaaaaaaa() {}");
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003376
Daniel Jasper65585ed2013-01-28 13:31:35 +00003377 verifyFormat("Constructor()\n"
3378 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003379 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasper65585ed2013-01-28 13:31:35 +00003380
Daniel Jasper62e68172013-02-25 15:59:54 +00003381 verifyFormat("Constructor(int Parameter = 0)\n"
3382 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
3383 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}");
Daniel Jasper87f18f12013-09-06 21:46:41 +00003384 verifyFormat("Constructor()\n"
3385 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
3386 "}",
3387 getLLVMStyleWithColumns(60));
Daniel Jasper4fcc8b92013-11-07 17:52:51 +00003388 verifyFormat("Constructor()\n"
3389 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3390 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}");
Daniel Jasper62e68172013-02-25 15:59:54 +00003391
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003392 // Here a line could be saved by splitting the second initializer onto two
Alp Tokerf6a24ce2013-12-05 16:25:25 +00003393 // lines, but that is not desirable.
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003394 verifyFormat("Constructor()\n"
3395 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
3396 " aaaaaaaaaaa(aaaaaaaaaaa),\n"
3397 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003398
Daniel Jasper23e8e0c2013-02-15 16:49:44 +00003399 FormatStyle OnePerLine = getLLVMStyle();
3400 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
Daniel Jasper7bec87c2016-01-07 18:11:54 +00003401 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false;
Daniel Jasper23e8e0c2013-02-15 16:49:44 +00003402 verifyFormat("SomeClass::Constructor()\n"
3403 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
3404 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003405 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003406 OnePerLine);
Daniel Jasper23e8e0c2013-02-15 16:49:44 +00003407 verifyFormat("SomeClass::Constructor()\n"
3408 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
3409 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003410 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003411 OnePerLine);
Daniel Jasper23e8e0c2013-02-15 16:49:44 +00003412 verifyFormat("MyClass::MyClass(int var)\n"
3413 " : some_var_(var), // 4 space indent\n"
3414 " some_other_var_(var + 1) { // lined up\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003415 "}",
3416 OnePerLine);
Daniel Jasperead41b62013-02-28 09:39:12 +00003417 verifyFormat("Constructor()\n"
3418 " : aaaaa(aaaaaa),\n"
3419 " aaaaa(aaaaaa),\n"
3420 " aaaaa(aaaaaa),\n"
3421 " aaaaa(aaaaaa),\n"
3422 " aaaaa(aaaaaa) {}",
3423 OnePerLine);
Daniel Jaspercc960fa2013-04-22 07:59:53 +00003424 verifyFormat("Constructor()\n"
3425 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
3426 " aaaaaaaaaaaaaaaaaaaaaa) {}",
3427 OnePerLine);
Daniel Jasper7bec87c2016-01-07 18:11:54 +00003428 OnePerLine.BinPackParameters = false;
3429 verifyFormat(
3430 "Constructor()\n"
3431 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n"
3432 " aaaaaaaaaaa().aaa(),\n"
3433 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
3434 OnePerLine);
Daniel Jasperbd73bcf2015-10-27 13:42:08 +00003435 OnePerLine.ColumnLimit = 60;
3436 verifyFormat("Constructor()\n"
3437 " : aaaaaaaaaaaaaaaaaaaa(a),\n"
3438 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
3439 OnePerLine);
Daniel Jasperf6c7c182014-01-13 14:10:04 +00003440
3441 EXPECT_EQ("Constructor()\n"
3442 " : // Comment forcing unwanted break.\n"
3443 " aaaa(aaaa) {}",
3444 format("Constructor() :\n"
3445 " // Comment forcing unwanted break.\n"
3446 " aaaa(aaaa) {}"));
Daniel Jaspere3c0e012013-04-25 13:31:51 +00003447}
3448
Francois Ferranda6b6d512017-05-24 11:36:58 +00003449TEST_F(FormatTest, BreakConstructorInitializersAfterColon) {
3450 FormatStyle Style = getLLVMStyle();
3451 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
3452
3453 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
3454 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}",
3455 getStyleWithColumns(Style, 45));
3456 verifyFormat("Constructor() :\n"
3457 " Initializer(FitsOnTheLine) {}",
3458 getStyleWithColumns(Style, 44));
3459 verifyFormat("Constructor() :\n"
3460 " Initializer(FitsOnTheLine) {}",
3461 getStyleWithColumns(Style, 43));
3462
3463 verifyFormat("template <typename T>\n"
3464 "Constructor() : Initializer(FitsOnTheLine) {}",
3465 getStyleWithColumns(Style, 50));
3466
3467 verifyFormat(
3468 "SomeClass::Constructor() :\n"
3469 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
3470 Style);
3471
3472 verifyFormat(
3473 "SomeClass::Constructor() :\n"
3474 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
3475 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
3476 Style);
3477 verifyFormat(
3478 "SomeClass::Constructor() :\n"
3479 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3480 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
3481 Style);
3482 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3483 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
3484 " aaaaaaaaaa(aaaaaa) {}",
3485 Style);
3486
3487 verifyFormat("Constructor() :\n"
3488 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3489 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3490 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3491 " aaaaaaaaaaaaaaaaaaaaaaa() {}",
3492 Style);
3493
3494 verifyFormat("Constructor() :\n"
3495 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3496 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
3497 Style);
3498
3499 verifyFormat("Constructor(int Parameter = 0) :\n"
3500 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
3501 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}",
3502 Style);
3503 verifyFormat("Constructor() :\n"
3504 " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
3505 "}",
3506 getStyleWithColumns(Style, 60));
3507 verifyFormat("Constructor() :\n"
3508 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3509 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}",
3510 Style);
3511
3512 // Here a line could be saved by splitting the second initializer onto two
3513 // lines, but that is not desirable.
3514 verifyFormat("Constructor() :\n"
3515 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
3516 " aaaaaaaaaaa(aaaaaaaaaaa),\n"
3517 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
3518 Style);
3519
3520 FormatStyle OnePerLine = Style;
3521 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
3522 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false;
3523 verifyFormat("SomeClass::Constructor() :\n"
3524 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
3525 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
3526 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
3527 OnePerLine);
3528 verifyFormat("SomeClass::Constructor() :\n"
3529 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
3530 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
3531 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
3532 OnePerLine);
3533 verifyFormat("MyClass::MyClass(int var) :\n"
3534 " some_var_(var), // 4 space indent\n"
3535 " some_other_var_(var + 1) { // lined up\n"
3536 "}",
3537 OnePerLine);
3538 verifyFormat("Constructor() :\n"
3539 " aaaaa(aaaaaa),\n"
3540 " aaaaa(aaaaaa),\n"
3541 " aaaaa(aaaaaa),\n"
3542 " aaaaa(aaaaaa),\n"
3543 " aaaaa(aaaaaa) {}",
3544 OnePerLine);
3545 verifyFormat("Constructor() :\n"
3546 " aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
3547 " aaaaaaaaaaaaaaaaaaaaaa) {}",
3548 OnePerLine);
3549 OnePerLine.BinPackParameters = false;
3550 verifyFormat(
3551 "Constructor() :\n"
3552 " aaaaaaaaaaaaaaaaaaaaaaaa(\n"
3553 " aaaaaaaaaaa().aaa(),\n"
3554 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
3555 OnePerLine);
3556 OnePerLine.ColumnLimit = 60;
3557 verifyFormat("Constructor() :\n"
3558 " aaaaaaaaaaaaaaaaaaaa(a),\n"
3559 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
3560 OnePerLine);
3561
3562 EXPECT_EQ("Constructor() :\n"
3563 " // Comment forcing unwanted break.\n"
3564 " aaaa(aaaa) {}",
3565 format("Constructor() :\n"
3566 " // Comment forcing unwanted break.\n"
3567 " aaaa(aaaa) {}",
3568 Style));
3569
3570 Style.ColumnLimit = 0;
3571 verifyFormat("SomeClass::Constructor() :\n"
3572 " a(a) {}",
3573 Style);
3574 verifyFormat("SomeClass::Constructor() noexcept :\n"
3575 " a(a) {}",
3576 Style);
3577 verifyFormat("SomeClass::Constructor() :\n"
3578 " a(a), b(b), c(c) {}",
3579 Style);
3580 verifyFormat("SomeClass::Constructor() :\n"
3581 " a(a) {\n"
3582 " foo();\n"
3583 " bar();\n"
3584 "}",
3585 Style);
3586
3587 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
3588 verifyFormat("SomeClass::Constructor() :\n"
3589 " a(a), b(b), c(c) {\n"
3590 "}",
3591 Style);
3592 verifyFormat("SomeClass::Constructor() :\n"
3593 " a(a) {\n"
3594 "}",
3595 Style);
3596
3597 Style.ColumnLimit = 80;
3598 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
3599 Style.ConstructorInitializerIndentWidth = 2;
3600 verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}",
3601 Style);
3602 verifyFormat("SomeClass::Constructor() :\n"
3603 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3604 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}",
3605 Style);
3606}
3607
David Blaikieea95dd72017-08-31 18:49:34 +00003608#ifndef EXPENSIVE_CHECKS
3609// Expensive checks enables libstdc++ checking which includes validating the
3610// state of ranges used in std::priority_queue - this blows out the
3611// runtime/scalability of the function and makes this test unacceptably slow.
Daniel Jaspere3c0e012013-04-25 13:31:51 +00003612TEST_F(FormatTest, MemoizationTests) {
3613 // This breaks if the memoization lookup does not take \c Indent and
3614 // \c LastSpace into account.
3615 verifyFormat(
3616 "extern CFRunLoopTimerRef\n"
3617 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
3618 " CFTimeInterval interval, CFOptionFlags flags,\n"
3619 " CFIndex order, CFRunLoopTimerCallBack callout,\n"
Daniel Jasper8e357692013-05-06 08:27:33 +00003620 " CFRunLoopTimerContext *context) {}");
Daniel Jaspere3c0e012013-04-25 13:31:51 +00003621
3622 // Deep nesting somewhat works around our memoization.
3623 verifyFormat(
3624 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
3625 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
3626 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
3627 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
3628 " aaaaa())))))))))))))))))))))))))))))))))))))));",
3629 getLLVMStyleWithColumns(65));
Daniel Jaspercc3044c2013-05-13 09:19:24 +00003630 verifyFormat(
3631 "aaaaa(\n"
3632 " aaaaa,\n"
3633 " aaaaa(\n"
3634 " aaaaa,\n"
3635 " aaaaa(\n"
3636 " aaaaa,\n"
3637 " aaaaa(\n"
3638 " aaaaa,\n"
3639 " aaaaa(\n"
3640 " aaaaa,\n"
3641 " aaaaa(\n"
3642 " aaaaa,\n"
3643 " aaaaa(\n"
3644 " aaaaa,\n"
3645 " aaaaa(\n"
3646 " aaaaa,\n"
3647 " aaaaa(\n"
3648 " aaaaa,\n"
3649 " aaaaa(\n"
3650 " aaaaa,\n"
3651 " aaaaa(\n"
3652 " aaaaa,\n"
3653 " aaaaa(\n"
3654 " aaaaa,\n"
3655 " aaaaa))))))))))));",
3656 getLLVMStyleWithColumns(65));
Daniel Jasperf8114cf2013-05-22 05:27:42 +00003657 verifyFormat(
3658 "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"
3659 " a),\n"
3660 " a),\n"
3661 " a),\n"
3662 " a),\n"
3663 " a),\n"
3664 " a),\n"
3665 " a),\n"
3666 " a),\n"
3667 " a),\n"
3668 " a),\n"
3669 " a),\n"
3670 " a),\n"
3671 " a),\n"
3672 " a),\n"
3673 " a),\n"
3674 " a),\n"
3675 " a)",
3676 getLLVMStyleWithColumns(65));
Daniel Jasper7b7877a2013-01-12 07:36:22 +00003677
3678 // This test takes VERY long when memoization is broken.
Daniel Jaspere3c0e012013-04-25 13:31:51 +00003679 FormatStyle OnePerLine = getLLVMStyle();
3680 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003681 OnePerLine.BinPackParameters = false;
Daniel Jasper9278eb92013-01-16 14:59:02 +00003682 std::string input = "Constructor()\n"
Daniel Jasper7a31af12013-01-25 15:43:32 +00003683 " : aaaa(a,\n";
Daniel Jasper9278eb92013-01-16 14:59:02 +00003684 for (unsigned i = 0, e = 80; i != e; ++i) {
3685 input += " a,\n";
3686 }
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003687 input += " a) {}";
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003688 verifyFormat(input, OnePerLine);
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003689}
David Blaikieea95dd72017-08-31 18:49:34 +00003690#endif
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003691
Alexander Kornienko578fdd82012-12-06 18:03:27 +00003692TEST_F(FormatTest, BreaksAsHighAsPossible) {
3693 verifyFormat(
Alexander Kornienkoa5151272013-03-12 16:28:18 +00003694 "void f() {\n"
3695 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
3696 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
3697 " f();\n"
3698 "}");
Daniel Jasper70bc8742013-02-26 13:59:14 +00003699 verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00003700 " Intervals[i - 1].getRange().getLast()) {\n}");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00003701}
3702
Daniel Jasper6728fc12013-04-11 14:29:13 +00003703TEST_F(FormatTest, BreaksFunctionDeclarations) {
3704 // Principially, we break function declarations in a certain order:
3705 // 1) break amongst arguments.
3706 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
3707 " Cccccccccccccc cccccccccccccc);");
Daniel Jaspera44991332015-04-29 13:06:49 +00003708 verifyFormat("template <class TemplateIt>\n"
3709 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n"
3710 " TemplateIt *stop) {}");
Daniel Jasper6728fc12013-04-11 14:29:13 +00003711
3712 // 2) break after return type.
Daniel Jasper8e357692013-05-06 08:27:33 +00003713 verifyFormat(
Manuel Klimek836c2862013-06-21 17:25:42 +00003714 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00003715 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);",
Manuel Klimek836c2862013-06-21 17:25:42 +00003716 getGoogleStyle());
Daniel Jasper6728fc12013-04-11 14:29:13 +00003717
3718 // 3) break after (.
3719 verifyFormat(
3720 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
Manuel Klimek836c2862013-06-21 17:25:42 +00003721 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);",
3722 getGoogleStyle());
Daniel Jasper6728fc12013-04-11 14:29:13 +00003723
3724 // 4) break before after nested name specifiers.
3725 verifyFormat(
3726 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00003727 "SomeClasssssssssssssssssssssssssssssssssssssss::\n"
3728 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);",
Manuel Klimek836c2862013-06-21 17:25:42 +00003729 getGoogleStyle());
Daniel Jasper6728fc12013-04-11 14:29:13 +00003730
3731 // However, there are exceptions, if a sufficient amount of lines can be
3732 // saved.
3733 // FIXME: The precise cut-offs wrt. the number of saved lines might need some
3734 // more adjusting.
3735 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
3736 " Cccccccccccccc cccccccccc,\n"
3737 " Cccccccccccccc cccccccccc,\n"
3738 " Cccccccccccccc cccccccccc,\n"
3739 " Cccccccccccccc cccccccccc);");
3740 verifyFormat(
Manuel Klimek836c2862013-06-21 17:25:42 +00003741 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00003742 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3743 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3744 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);",
Manuel Klimek836c2862013-06-21 17:25:42 +00003745 getGoogleStyle());
Daniel Jasper6728fc12013-04-11 14:29:13 +00003746 verifyFormat(
3747 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
3748 " Cccccccccccccc cccccccccc,\n"
3749 " Cccccccccccccc cccccccccc,\n"
3750 " Cccccccccccccc cccccccccc,\n"
3751 " Cccccccccccccc cccccccccc,\n"
3752 " Cccccccccccccc cccccccccc,\n"
3753 " Cccccccccccccc cccccccccc);");
3754 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
3755 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3756 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3757 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3758 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
Daniel Jasper1b8e76f2013-04-15 22:36:37 +00003759
3760 // Break after multi-line parameters.
3761 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3762 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3763 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3764 " bbbb bbbb);");
Daniel Jasper6c0ee172014-11-14 13:14:45 +00003765 verifyFormat("void SomeLoooooooooooongFunction(\n"
3766 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
3767 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3768 " int bbbbbbbbbbbbb);");
Daniel Jasper6331da02013-07-09 07:43:55 +00003769
3770 // Treat overloaded operators like other functions.
3771 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
3772 "operator>(const SomeLoooooooooooooooooooooooooogType &other);");
Daniel Jasperd215b8b2013-08-28 07:27:35 +00003773 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
3774 "operator>>(const SomeLooooooooooooooooooooooooogType &other);");
Alexander Kornienko86b2dfd2014-03-06 15:13:08 +00003775 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
3776 "operator<<(const SomeLooooooooooooooooooooooooogType &other);");
3777 verifyGoogleFormat(
3778 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n"
3779 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
Daniel Jasper6331da02013-07-09 07:43:55 +00003780 verifyGoogleFormat(
3781 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n"
3782 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
Daniel Jasper126153a2013-12-27 06:39:56 +00003783 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3784 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);");
3785 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n"
3786 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);");
Daniel Jasperea79ea12014-08-15 05:00:39 +00003787 verifyGoogleFormat(
3788 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n"
3789 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3790 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}");
Daniel Jasper88db7602016-02-11 06:43:01 +00003791 verifyGoogleFormat(
3792 "template <typename T>\n"
3793 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3794 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n"
3795 " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);");
Daniel Jasper11309812015-03-18 14:20:13 +00003796
3797 FormatStyle Style = getLLVMStyle();
3798 Style.PointerAlignment = FormatStyle::PAS_Left;
3799 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3800 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}",
3801 Style);
Daniel Jaspera44991332015-04-29 13:06:49 +00003802 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
3803 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
3804 Style);
Daniel Jasper6728fc12013-04-11 14:29:13 +00003805}
3806
Daniel Jasper6cdec7c2013-07-09 14:36:48 +00003807TEST_F(FormatTest, TrailingReturnType) {
3808 verifyFormat("auto foo() -> int;\n");
3809 verifyFormat("struct S {\n"
3810 " auto bar() const -> int;\n"
3811 "};");
3812 verifyFormat("template <size_t Order, typename T>\n"
3813 "auto load_img(const std::string &filename)\n"
3814 " -> alias::tensor<Order, T, mem::tag::cpu> {}");
Daniel Jasperda07a722014-10-17 14:37:40 +00003815 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n"
3816 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}");
Daniel Jasperb52c69e2014-10-22 09:01:12 +00003817 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}");
Daniel Jasper6f2b88a2015-06-05 13:18:09 +00003818 verifyFormat("template <typename T>\n"
3819 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n"
3820 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());");
Daniel Jaspera3501d42013-07-11 14:33:06 +00003821
3822 // Not trailing return types.
3823 verifyFormat("void f() { auto a = b->c(); }");
Daniel Jasper6cdec7c2013-07-09 14:36:48 +00003824}
3825
Daniel Jasper5be31f72013-05-21 09:16:31 +00003826TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) {
Daniel Jasperd8c36d02013-10-18 16:34:40 +00003827 // Avoid breaking before trailing 'const' or other trailing annotations, if
3828 // they are not function-like.
Daniel Jasper13c37b32013-05-22 08:28:26 +00003829 FormatStyle Style = getGoogleStyle();
3830 Style.ColumnLimit = 47;
Daniel Jaspere068ac72014-10-27 17:13:59 +00003831 verifyFormat("void someLongFunction(\n"
3832 " int someLoooooooooooooongParameter) const {\n}",
Daniel Jasper13c37b32013-05-22 08:28:26 +00003833 getLLVMStyleWithColumns(47));
Daniel Jasper13c37b32013-05-22 08:28:26 +00003834 verifyFormat("LoooooongReturnType\n"
3835 "someLoooooooongFunction() const {}",
3836 getLLVMStyleWithColumns(47));
3837 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
3838 " const {}",
3839 Style);
Daniel Jasperd8c36d02013-10-18 16:34:40 +00003840 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
3841 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;");
3842 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
3843 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;");
3844 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
3845 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;");
Daniel Jasper43e6a282013-12-16 15:01:54 +00003846 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n"
3847 " aaaaaaaaaaa aaaaa) const override;");
3848 verifyGoogleFormat(
3849 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
3850 " const override;");
Daniel Jasper5be31f72013-05-21 09:16:31 +00003851
Daniel Jasper5550de62014-02-17 07:57:46 +00003852 // Even if the first parameter has to be wrapped.
3853 verifyFormat("void someLongFunction(\n"
3854 " int someLongParameter) const {}",
Daniel Jasperd8c36d02013-10-18 16:34:40 +00003855 getLLVMStyleWithColumns(46));
Daniel Jasper5550de62014-02-17 07:57:46 +00003856 verifyFormat("void someLongFunction(\n"
3857 " int someLongParameter) const {}",
Daniel Jasperd8c36d02013-10-18 16:34:40 +00003858 Style);
Daniel Jasper5550de62014-02-17 07:57:46 +00003859 verifyFormat("void someLongFunction(\n"
3860 " int someLongParameter) override {}",
3861 Style);
3862 verifyFormat("void someLongFunction(\n"
Daniel Jasperb48d3af2014-04-09 10:01:49 +00003863 " int someLongParameter) OVERRIDE {}",
3864 Style);
3865 verifyFormat("void someLongFunction(\n"
Daniel Jasper5550de62014-02-17 07:57:46 +00003866 " int someLongParameter) final {}",
3867 Style);
3868 verifyFormat("void someLongFunction(\n"
Daniel Jasperb48d3af2014-04-09 10:01:49 +00003869 " int someLongParameter) FINAL {}",
3870 Style);
3871 verifyFormat("void someLongFunction(\n"
Daniel Jasper5550de62014-02-17 07:57:46 +00003872 " int parameter) const override {}",
3873 Style);
3874
Daniel Jaspere3f907f2014-06-02 09:52:08 +00003875 Style.BreakBeforeBraces = FormatStyle::BS_Allman;
3876 verifyFormat("void someLongFunction(\n"
3877 " int someLongParameter) const\n"
3878 "{\n"
3879 "}",
3880 Style);
3881
Daniel Jasper5550de62014-02-17 07:57:46 +00003882 // Unless these are unknown annotations.
Daniel Jasperd8c36d02013-10-18 16:34:40 +00003883 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n"
3884 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3885 " LONG_AND_UGLY_ANNOTATION;");
Daniel Jasper718bd362013-07-11 21:02:56 +00003886
3887 // Breaking before function-like trailing annotations is fine to keep them
3888 // close to their arguments.
Daniel Jasper5be31f72013-05-21 09:16:31 +00003889 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3890 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
3891 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
3892 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
3893 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
3894 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}");
Daniel Jasperf9a09062014-04-09 10:29:11 +00003895 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n"
3896 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);");
Daniel Jasper8b76d602014-07-28 12:08:06 +00003897 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});");
Daniel Jasper5be31f72013-05-21 09:16:31 +00003898
3899 verifyFormat(
3900 "void aaaaaaaaaaaaaaaaaa()\n"
3901 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
3902 " aaaaaaaaaaaaaaaaaaaaaaaaa));");
3903 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3904 " __attribute__((unused));");
Daniel Jasper35ec2b22014-04-14 08:15:20 +00003905 verifyGoogleFormat(
Manuel Klimek836c2862013-06-21 17:25:42 +00003906 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper35ec2b22014-04-14 08:15:20 +00003907 " GUARDED_BY(aaaaaaaaaaaa);");
3908 verifyGoogleFormat(
Daniel Jasper40db06a2013-07-11 12:34:23 +00003909 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper35ec2b22014-04-14 08:15:20 +00003910 " GUARDED_BY(aaaaaaaaaaaa);");
3911 verifyGoogleFormat(
3912 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
3913 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper3ca283a2015-05-15 09:58:11 +00003914 verifyGoogleFormat(
3915 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
3916 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper5be31f72013-05-21 09:16:31 +00003917}
3918
Daniel Jasperf090f032015-05-18 09:47:22 +00003919TEST_F(FormatTest, FunctionAnnotations) {
3920 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
Daniel Jasper788ffd72015-08-24 15:10:01 +00003921 "int OldFunction(const string &parameter) {}");
3922 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
Daniel Jasperf090f032015-05-18 09:47:22 +00003923 "string OldFunction(const string &parameter) {}");
3924 verifyFormat("template <typename T>\n"
3925 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
3926 "string OldFunction(const string &parameter) {}");
Daniel Jasper47bbda02015-05-18 13:47:23 +00003927
3928 // Not function annotations.
3929 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3930 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
Daniel Jasper32739302015-05-27 04:55:47 +00003931 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n"
3932 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}");
Daniel Jasper19bc1d02016-04-06 13:58:09 +00003933 verifyFormat("MACRO(abc).function() // wrap\n"
3934 " << abc;");
3935 verifyFormat("MACRO(abc)->function() // wrap\n"
3936 " << abc;");
3937 verifyFormat("MACRO(abc)::function() // wrap\n"
3938 " << abc;");
Daniel Jasperf090f032015-05-18 09:47:22 +00003939}
3940
Daniel Jasperf7935112012-12-03 18:12:45 +00003941TEST_F(FormatTest, BreaksDesireably) {
3942 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
3943 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003944 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
Daniel Jasper39e27382013-01-23 20:41:06 +00003945 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3946 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
3947 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +00003948
3949 verifyFormat(
3950 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003951 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasperf7935112012-12-03 18:12:45 +00003952
3953 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3954 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3955 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jasper9b155472012-12-04 10:50:12 +00003956
3957 verifyFormat(
Daniel Jasper240527c2017-01-16 13:13:15 +00003958 "aaaaaaaa(aaaaaaaaaaaaa,\n"
3959 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3960 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
Daniel Jasper9b155472012-12-04 10:50:12 +00003961 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3962 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));");
Daniel Jasperaa1c9202012-12-05 14:57:28 +00003963
3964 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3965 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
3966
Daniel Jasper3d0c75c2013-01-02 14:40:02 +00003967 verifyFormat(
Alexander Kornienkoa5151272013-03-12 16:28:18 +00003968 "void f() {\n"
3969 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
3970 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
3971 "}");
Daniel Jasper7a31af12013-01-25 15:43:32 +00003972 verifyFormat(
3973 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3974 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
3975 verifyFormat(
Daniel Jasper21f7dea2017-02-01 09:23:39 +00003976 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3977 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
3978 verifyFormat(
Daniel Jasper240527c2017-01-16 13:13:15 +00003979 "aaaaaa(aaa,\n"
3980 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasper21f7dea2017-02-01 09:23:39 +00003981 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3982 " aaaa);");
Daniel Jaspera44991332015-04-29 13:06:49 +00003983 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3984 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3985 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper3d0c75c2013-01-02 14:40:02 +00003986
Daniel Jasper739b85f2015-06-29 10:42:59 +00003987 // Indent consistently independent of call expression and unary operator.
3988 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
3989 " dddddddddddddddddddddddddddddd));");
3990 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
3991 " dddddddddddddddddddddddddddddd));");
Daniel Jasperf79b0b12013-08-30 08:29:25 +00003992 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
Daniel Jasperf79b0b12013-08-30 08:29:25 +00003993 " dddddddddddddddddddddddddddddd));");
3994
Daniel Jasperaa1c9202012-12-05 14:57:28 +00003995 // This test case breaks on an incorrect memoization, i.e. an optimization not
3996 // taking into account the StopAt value.
3997 verifyFormat(
3998 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
Daniel Jasper2eda23e2012-12-24 13:43:52 +00003999 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
4000 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
4001 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper6d822722012-12-24 16:43:00 +00004002
Daniel Jasper8d1832e2013-01-07 13:26:07 +00004003 verifyFormat("{\n {\n {\n"
4004 " Annotation.SpaceRequiredBefore =\n"
4005 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
4006 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
4007 " }\n }\n}");
Alexander Kornienko4d26b6e2013-06-17 12:59:44 +00004008
4009 // Break on an outer level if there was a break on an inner level.
4010 EXPECT_EQ("f(g(h(a, // comment\n"
4011 " b, c),\n"
4012 " d, e),\n"
4013 " x, y);",
4014 format("f(g(h(a, // comment\n"
4015 " b, c), d, e), x, y);"));
Daniel Jasperee7539a2013-07-08 14:25:23 +00004016
4017 // Prefer breaking similar line breaks.
4018 verifyFormat(
4019 "const int kTrackingOptions = NSTrackingMouseMoved |\n"
4020 " NSTrackingMouseEnteredAndExited |\n"
4021 " NSTrackingActiveAlways;");
Daniel Jasperf7935112012-12-03 18:12:45 +00004022}
4023
Daniel Jasper18210d72014-10-09 09:52:05 +00004024TEST_F(FormatTest, FormatsDeclarationsOnePerLine) {
4025 FormatStyle NoBinPacking = getGoogleStyle();
4026 NoBinPacking.BinPackParameters = false;
4027 NoBinPacking.BinPackArguments = true;
4028 verifyFormat("void f() {\n"
4029 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n"
4030 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
4031 "}",
4032 NoBinPacking);
4033 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n"
4034 " int aaaaaaaaaaaaaaaaaaaa,\n"
4035 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4036 NoBinPacking);
Daniel Jasper06ca0fc2016-01-11 11:01:05 +00004037
Daniel Jasper00693b082016-01-09 15:56:47 +00004038 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
4039 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4040 " vector<int> bbbbbbbbbbbbbbb);",
4041 NoBinPacking);
Daniel Jasper06ca0fc2016-01-11 11:01:05 +00004042 // FIXME: This behavior difference is probably not wanted. However, currently
4043 // we cannot distinguish BreakBeforeParameter being set because of the wrapped
4044 // template arguments from BreakBeforeParameter being set because of the
4045 // one-per-line formatting.
4046 verifyFormat(
4047 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n"
4048 " aaaaaaaaaa> aaaaaaaaaa);",
4049 NoBinPacking);
4050 verifyFormat(
4051 "void fffffffffff(\n"
4052 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n"
4053 " aaaaaaaaaa);");
Daniel Jasper18210d72014-10-09 09:52:05 +00004054}
4055
Daniel Jasper9278eb92013-01-16 14:59:02 +00004056TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
Daniel Jaspera628c982013-04-03 13:36:17 +00004057 FormatStyle NoBinPacking = getGoogleStyle();
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004058 NoBinPacking.BinPackParameters = false;
Daniel Jasper18210d72014-10-09 09:52:05 +00004059 NoBinPacking.BinPackArguments = false;
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004060 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
4061 " aaaaaaaaaaaaaaaaaaaa,\n"
4062 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);",
4063 NoBinPacking);
4064 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
4065 " aaaaaaaaaaaaa,\n"
4066 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));",
4067 NoBinPacking);
4068 verifyFormat(
Daniel Jasper9278eb92013-01-16 14:59:02 +00004069 "aaaaaaaa(aaaaaaaaaaaaa,\n"
4070 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4071 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
4072 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004073 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));",
4074 NoBinPacking);
4075 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
4076 " .aaaaaaaaaaaaaaaaaa();",
4077 NoBinPacking);
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00004078 verifyFormat("void f() {\n"
4079 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4080 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n"
4081 "}",
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004082 NoBinPacking);
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00004083
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004084 verifyFormat(
Daniel Jaspere941b162013-01-23 10:08:28 +00004085 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4086 " aaaaaaaaaaaa,\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004087 " aaaaaaaaaaaa);",
4088 NoBinPacking);
4089 verifyFormat(
Daniel Jasper9278eb92013-01-16 14:59:02 +00004090 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
4091 " ddddddddddddddddddddddddddddd),\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004092 " test);",
4093 NoBinPacking);
Daniel Jasper9278eb92013-01-16 14:59:02 +00004094
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004095 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
4096 " aaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper253dad232015-11-23 15:55:45 +00004097 " aaaaaaaaaaaaaaaaaaaaaaa>\n"
4098 " aaaaaaaaaaaaaaaaaa;",
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004099 NoBinPacking);
4100 verifyFormat("a(\"a\"\n"
4101 " \"a\",\n"
4102 " a);");
Daniel Jaspere941b162013-01-23 10:08:28 +00004103
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004104 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
Daniel Jasperf7db4332013-01-29 16:03:49 +00004105 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
Daniel Jaspere941b162013-01-23 10:08:28 +00004106 " aaaaaaaaa,\n"
Daniel Jasperf7db4332013-01-29 16:03:49 +00004107 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004108 NoBinPacking);
Daniel Jasper687af3b2013-02-14 14:26:07 +00004109 verifyFormat(
4110 "void f() {\n"
4111 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
4112 " .aaaaaaa();\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00004113 "}",
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004114 NoBinPacking);
Daniel Jasper53e8d852013-05-22 08:55:55 +00004115 verifyFormat(
4116 "template <class SomeType, class SomeOtherType>\n"
4117 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
4118 NoBinPacking);
Daniel Jasper9278eb92013-01-16 14:59:02 +00004119}
4120
Daniel Jasperb10cbc42013-07-10 14:02:49 +00004121TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
4122 FormatStyle Style = getLLVMStyleWithColumns(15);
4123 Style.ExperimentalAutoDetectBinPacking = true;
4124 EXPECT_EQ("aaa(aaaa,\n"
4125 " aaaa,\n"
4126 " aaaa);\n"
4127 "aaa(aaaa,\n"
4128 " aaaa,\n"
4129 " aaaa);",
4130 format("aaa(aaaa,\n" // one-per-line
4131 " aaaa,\n"
4132 " aaaa );\n"
4133 "aaa(aaaa, aaaa, aaaa);", // inconclusive
4134 Style));
4135 EXPECT_EQ("aaa(aaaa, aaaa,\n"
4136 " aaaa);\n"
4137 "aaa(aaaa, aaaa,\n"
4138 " aaaa);",
4139 format("aaa(aaaa, aaaa,\n" // bin-packed
4140 " aaaa );\n"
4141 "aaa(aaaa, aaaa, aaaa);", // inconclusive
4142 Style));
4143}
4144
Daniel Jasper04468962013-01-18 10:56:38 +00004145TEST_F(FormatTest, FormatsBuilderPattern) {
Daniel Jaspera44991332015-04-29 13:06:49 +00004146 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n"
4147 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
4148 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
4149 " .StartsWith(\".init\", ORDER_INIT)\n"
4150 " .StartsWith(\".fini\", ORDER_FINI)\n"
4151 " .StartsWith(\".hash\", ORDER_HASH)\n"
4152 " .Default(ORDER_TEXT);\n");
Daniel Jasperc6fbc212013-05-15 09:35:08 +00004153
Daniel Jaspereb50c672013-02-15 20:33:06 +00004154 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00004155 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
Daniel Jasper9ed9ade2013-02-18 13:24:21 +00004156 verifyFormat(
Daniel Jasper801cdb22016-01-05 13:03:59 +00004157 "aaaaaaa->aaaaaaa\n"
4158 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4159 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
Daniel Jasper9ed9ade2013-02-18 13:24:21 +00004160 " ->aaaaaaaa(aaaaaaaaaaaaaaa);");
Daniel Jaspere53beb22013-02-18 13:52:06 +00004161 verifyFormat(
Daniel Jasperf901a572015-12-07 19:50:48 +00004162 "aaaaaaa->aaaaaaa\n"
4163 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4164 " ->aaaaaaaa(aaaaaaaaaaaaaaa);");
4165 verifyFormat(
Daniel Jaspere53beb22013-02-18 13:52:06 +00004166 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
Daniel Jasperf9a84b52013-03-01 16:48:32 +00004167 " aaaaaaaaaaaaaa);");
Daniel Jaspere53beb22013-02-18 13:52:06 +00004168 verifyFormat(
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004169 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n"
4170 " aaaaaa->aaaaaaaaaaaa()\n"
4171 " ->aaaaaaaaaaaaaaaa(\n"
Daniel Jasper9dedc7752015-04-07 06:41:24 +00004172 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004173 " ->aaaaaaaaaaaaaaaaa();");
Daniel Jasper33b909c2013-10-25 14:29:37 +00004174 verifyGoogleFormat(
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00004175 "void f() {\n"
4176 " someo->Add((new util::filetools::Handler(dir))\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004177 " ->OnEvent1(NewPermanentCallback(\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00004178 " this, &HandlerHolderClass::EventHandlerCBA))\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004179 " ->OnEvent2(NewPermanentCallback(\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00004180 " this, &HandlerHolderClass::EventHandlerCBB))\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004181 " ->OnEvent3(NewPermanentCallback(\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00004182 " this, &HandlerHolderClass::EventHandlerCBC))\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004183 " ->OnEvent5(NewPermanentCallback(\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00004184 " this, &HandlerHolderClass::EventHandlerCBD))\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004185 " ->OnEvent6(NewPermanentCallback(\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00004186 " this, &HandlerHolderClass::EventHandlerCBE)));\n"
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00004187 "}");
Daniel Jasper4c6e0052013-08-27 14:24:43 +00004188
4189 verifyFormat(
4190 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();");
4191 verifyFormat("aaaaaaaaaaaaaaa()\n"
4192 " .aaaaaaaaaaaaaaa()\n"
4193 " .aaaaaaaaaaaaaaa()\n"
4194 " .aaaaaaaaaaaaaaa()\n"
4195 " .aaaaaaaaaaaaaaa();");
4196 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
4197 " .aaaaaaaaaaaaaaa()\n"
4198 " .aaaaaaaaaaaaaaa()\n"
4199 " .aaaaaaaaaaaaaaa();");
4200 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
4201 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
4202 " .aaaaaaaaaaaaaaa();");
Daniel Jasperf8151e92013-08-30 07:12:40 +00004203 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
4204 " ->aaaaaaaaaaaaaae(0)\n"
4205 " ->aaaaaaaaaaaaaaa();");
Daniel Jasper36c28ce2013-09-06 08:54:24 +00004206
Daniel Jasper775954b2015-04-24 10:08:09 +00004207 // Don't linewrap after very short segments.
4208 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4209 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4210 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
4211 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4212 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4213 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
4214 verifyFormat("aaa()\n"
4215 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4216 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4217 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
4218
Daniel Jaspercc3114d2013-10-18 15:23:06 +00004219 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
4220 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4221 " .has<bbbbbbbbbbbbbbbbbbbbb>();");
4222 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
4223 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00004224 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();");
Daniel Jaspercc3114d2013-10-18 15:23:06 +00004225
Daniel Jaspera41aa532014-09-19 08:01:25 +00004226 // Prefer not to break after empty parentheses.
Daniel Jasper36c28ce2013-09-06 08:54:24 +00004227 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
4228 " First->LastNewlineOffset);");
Daniel Jasperf901a572015-12-07 19:50:48 +00004229
4230 // Prefer not to create "hanging" indents.
4231 verifyFormat(
4232 "return !soooooooooooooome_map\n"
4233 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4234 " .second;");
Daniel Jasper00492f92016-01-05 13:03:50 +00004235 verifyFormat(
4236 "return aaaaaaaaaaaaaaaa\n"
4237 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n"
4238 " .aaaa(aaaaaaaaaaaaaa);");
4239 // No hanging indent here.
4240 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n"
4241 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
4242 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n"
4243 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper801cdb22016-01-05 13:03:59 +00004244 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
4245 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4246 getLLVMStyleWithColumns(60));
4247 verifyFormat("aaaaaaaaaaaaaaaaaa\n"
4248 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
4249 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4250 getLLVMStyleWithColumns(59));
Daniel Jasper411af722016-01-05 16:10:39 +00004251 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4252 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4253 " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper04468962013-01-18 10:56:38 +00004254}
4255
Daniel Jasperde5c2072012-12-24 00:13:23 +00004256TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) {
4257 verifyFormat(
4258 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004259 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00004260 verifyFormat(
4261 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n"
4262 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}");
4263
Daniel Jasper8d1832e2013-01-07 13:26:07 +00004264 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004265 " ccccccccccccccccccccccccc) {\n}");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00004266 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n"
4267 " ccccccccccccccccccccccccc) {\n}");
4268
Daniel Jasper8d1832e2013-01-07 13:26:07 +00004269 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004270 " ccccccccccccccccccccccccc) {\n}");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00004271 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n"
4272 " ccccccccccccccccccccccccc) {\n}");
4273
Daniel Jasperde5c2072012-12-24 00:13:23 +00004274 verifyFormat(
4275 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004276 " ccccccccccccccccccccccccc) {\n}");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00004277 verifyFormat(
4278 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n"
4279 " ccccccccccccccccccccccccc) {\n}");
4280
Daniel Jasper400adc62013-02-08 15:28:42 +00004281 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
4282 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
4283 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
4284 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00004285 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n"
4286 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n"
4287 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n"
4288 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
4289
Daniel Jasper400adc62013-02-08 15:28:42 +00004290 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
4291 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
4292 " aaaaaaaaaaaaaaa != aa) {\n}");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00004293 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n"
4294 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n"
4295 " aaaaaaaaaaaaaaa != aa) {\n}");
Daniel Jasperde5c2072012-12-24 00:13:23 +00004296}
4297
Daniel Jasper43b65482013-01-23 12:27:43 +00004298TEST_F(FormatTest, BreaksAfterAssignments) {
Daniel Jasper206df732013-01-07 13:08:40 +00004299 verifyFormat(
Daniel Jasper43b65482013-01-23 12:27:43 +00004300 "unsigned Cost =\n"
4301 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
4302 " SI->getPointerAddressSpaceee());\n");
Daniel Jasper206df732013-01-07 13:08:40 +00004303 verifyFormat(
Daniel Jasper1565eb32013-01-23 15:55:19 +00004304 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
4305 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
Daniel Jaspera836b902013-01-23 16:58:21 +00004306
4307 verifyFormat(
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004308 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
4309 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper7b27a102013-05-27 12:45:09 +00004310 verifyFormat("unsigned OriginalStartColumn =\n"
4311 " SourceMgr.getSpellingColumnNumber(\n"
4312 " Current.FormatTok.getStartOfNonWhitespace()) -\n"
4313 " 1;");
Daniel Jasper206df732013-01-07 13:08:40 +00004314}
4315
Francois Ferrand9976efa2017-05-22 08:28:17 +00004316TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) {
4317 FormatStyle Style = getLLVMStyle();
4318 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
4319 " bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;",
4320 Style);
4321
4322 Style.PenaltyBreakAssignment = 20;
4323 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
4324 " cccccccccccccccccccccccccc;",
4325 Style);
4326}
4327
Daniel Jasper2eda23e2012-12-24 13:43:52 +00004328TEST_F(FormatTest, AlignsAfterAssignments) {
4329 verifyFormat(
4330 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper206df732013-01-07 13:08:40 +00004331 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00004332 verifyFormat(
4333 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper206df732013-01-07 13:08:40 +00004334 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00004335 verifyFormat(
4336 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper206df732013-01-07 13:08:40 +00004337 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00004338 verifyFormat(
4339 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper206df732013-01-07 13:08:40 +00004340 " aaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperee7539a2013-07-08 14:25:23 +00004341 verifyFormat(
4342 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n"
4343 " aaaaaaaaaaaaaaaaaaaaaaaa +\n"
4344 " aaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00004345}
4346
4347TEST_F(FormatTest, AlignsAfterReturn) {
4348 verifyFormat(
4349 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4350 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
4351 verifyFormat(
4352 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4353 " aaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperc238c872013-04-02 14:33:13 +00004354 verifyFormat(
4355 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00004356 " aaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasperc238c872013-04-02 14:33:13 +00004357 verifyFormat(
4358 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00004359 " aaaaaaaaaaaaaaaaaaaaaa());");
4360 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4361 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
4362 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4363 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
4364 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jaspereabede62013-09-30 08:29:03 +00004365 verifyFormat("return\n"
4366 " // true if code is one of a or b.\n"
4367 " code == a || code == b;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00004368}
4369
Daniel Jasper3aa9a6a2014-11-18 23:55:27 +00004370TEST_F(FormatTest, AlignsAfterOpenBracket) {
4371 verifyFormat(
4372 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
4373 " aaaaaaaaa aaaaaaa) {}");
4374 verifyFormat(
4375 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
4376 " aaaaaaaaaaa aaaaaaaaa);");
4377 verifyFormat(
4378 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
4379 " aaaaaaaaaaaaaaaaaaaaa));");
4380 FormatStyle Style = getLLVMStyle();
Daniel Jasper6501f7e2015-10-27 12:38:37 +00004381 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
Daniel Jaspera44991332015-04-29 13:06:49 +00004382 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4383 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}",
4384 Style);
4385 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
4386 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);",
4387 Style);
4388 verifyFormat("SomeLongVariableName->someFunction(\n"
4389 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));",
4390 Style);
Daniel Jasper3aa9a6a2014-11-18 23:55:27 +00004391 verifyFormat(
4392 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
4393 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4394 Style);
4395 verifyFormat(
4396 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
4397 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4398 Style);
4399 verifyFormat(
4400 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
4401 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
4402 Style);
Daniel Jasper870d1bc2015-12-14 08:41:18 +00004403
Daniel Jasper2a9f7202016-02-08 09:52:54 +00004404 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n"
4405 " ccccccc(aaaaaaaaaaaaaaaaa, //\n"
4406 " b));",
4407 Style);
4408
Daniel Jasper870d1bc2015-12-14 08:41:18 +00004409 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
4410 Style.BinPackArguments = false;
4411 Style.BinPackParameters = false;
4412 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4413 " aaaaaaaaaaa aaaaaaaa,\n"
4414 " aaaaaaaaa aaaaaaa,\n"
4415 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4416 Style);
4417 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
4418 " aaaaaaaaaaa aaaaaaaaa,\n"
4419 " aaaaaaaaaaa aaaaaaaaa,\n"
4420 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4421 Style);
Daniel Jasper710f8492016-03-17 12:00:22 +00004422 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n"
4423 " aaaaaaaaaaaaaaa,\n"
4424 " aaaaaaaaaaaaaaaaaaaaa,\n"
4425 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
Daniel Jasper870d1bc2015-12-14 08:41:18 +00004426 Style);
Daniel Jasper710f8492016-03-17 12:00:22 +00004427 verifyFormat(
4428 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n"
4429 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
4430 Style);
4431 verifyFormat(
4432 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n"
4433 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
4434 Style);
4435 verifyFormat(
4436 "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4437 " aaaaaaaaaaaaaaaaaaaaa(\n"
4438 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n"
4439 " aaaaaaaaaaaaaaaa);",
4440 Style);
4441 verifyFormat(
4442 "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4443 " aaaaaaaaaaaaaaaaaaaaa(\n"
4444 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n"
4445 " aaaaaaaaaaaaaaaa);",
4446 Style);
Daniel Jasper3aa9a6a2014-11-18 23:55:27 +00004447}
4448
Daniel Jasper3219e432014-12-02 13:24:51 +00004449TEST_F(FormatTest, ParenthesesAndOperandAlignment) {
4450 FormatStyle Style = getLLVMStyleWithColumns(40);
4451 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
4452 " bbbbbbbbbbbbbbbbbbbbbb);",
4453 Style);
Daniel Jasper6501f7e2015-10-27 12:38:37 +00004454 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
Daniel Jasper3219e432014-12-02 13:24:51 +00004455 Style.AlignOperands = false;
4456 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
4457 " bbbbbbbbbbbbbbbbbbbbbb);",
4458 Style);
Daniel Jasper6501f7e2015-10-27 12:38:37 +00004459 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
Daniel Jasper3219e432014-12-02 13:24:51 +00004460 Style.AlignOperands = true;
4461 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
4462 " bbbbbbbbbbbbbbbbbbbbbb);",
4463 Style);
Daniel Jasper6501f7e2015-10-27 12:38:37 +00004464 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
Daniel Jasper3219e432014-12-02 13:24:51 +00004465 Style.AlignOperands = false;
4466 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
4467 " bbbbbbbbbbbbbbbbbbbbbb);",
4468 Style);
4469}
4470
Daniel Jasper399d24b2013-01-09 07:06:56 +00004471TEST_F(FormatTest, BreaksConditionalExpressions) {
4472 verifyFormat(
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004473 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4474 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4475 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
4476 verifyFormat(
4477 "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
Daniel Jasper22ed2622016-11-29 09:40:32 +00004478 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4479 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper8c5fba92013-01-16 16:23:19 +00004480 verifyFormat(
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004481 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4482 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
4483 verifyFormat(
4484 "aaaa(aaaaaaaaa, aaaaaaaaa,\n"
Daniel Jasper22ed2622016-11-29 09:40:32 +00004485 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4486 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperca6623b2013-01-28 12:45:14 +00004487 verifyFormat(
4488 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
4489 " : aaaaaaaaaaaaa);");
4490 verifyFormat(
4491 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasperaab220f2013-03-20 13:53:11 +00004492 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasperca6623b2013-01-28 12:45:14 +00004493 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4494 " aaaaaaaaaaaaa);");
Daniel Jasperb1ae7342013-08-01 22:05:00 +00004495 verifyFormat(
4496 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4497 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4498 " aaaaaaaaaaaaa);");
Daniel Jasperca6623b2013-01-28 12:45:14 +00004499 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4500 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4501 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4502 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4503 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
4504 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4505 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4506 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4507 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4508 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4509 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4510 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperb1ae7342013-08-01 22:05:00 +00004511 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4512 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4513 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4514 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4515 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper54a86022013-02-15 11:07:25 +00004516 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4517 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4518 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasperc238c872013-04-02 14:33:13 +00004519 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
4520 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4521 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4522 " : aaaaaaaaaaaaaaaa;");
Daniel Jaspercd8599e2013-02-23 21:01:55 +00004523 verifyFormat(
4524 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4525 " ? aaaaaaaaaaaaaaa\n"
4526 " : aaaaaaaaaaaaaaa;");
4527 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00004528 " aaaaaaaaa\n"
Daniel Jaspere7de2a32013-04-08 10:45:44 +00004529 " ? b\n"
4530 " : c);");
Daniel Jasper119ff532014-11-14 12:31:14 +00004531 verifyFormat("return aaaa == bbbb\n"
4532 " // comment\n"
4533 " ? aaaa\n"
4534 " : bbbb;");
Daniel Jaspera44991332015-04-29 13:06:49 +00004535 verifyFormat("unsigned Indent =\n"
Daniel Jasper22ed2622016-11-29 09:40:32 +00004536 " format(TheLine.First,\n"
4537 " IndentForLevel[TheLine.Level] >= 0\n"
4538 " ? IndentForLevel[TheLine.Level]\n"
4539 " : TheLine * 2,\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004540 " TheLine.InPPDirective, PreviousEndOfLineColumn);",
Daniel Jasper22ed2622016-11-29 09:40:32 +00004541 getLLVMStyleWithColumns(60));
Daniel Jasper2c611c02013-05-31 14:56:12 +00004542 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
4543 " ? aaaaaaaaaaaaaaa\n"
4544 " : bbbbbbbbbbbbbbb //\n"
4545 " ? ccccccccccccccc\n"
4546 " : ddddddddddddddd;");
4547 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
4548 " ? aaaaaaaaaaaaaaa\n"
4549 " : (bbbbbbbbbbbbbbb //\n"
4550 " ? ccccccccccccccc\n"
4551 " : ddddddddddddddd);");
Daniel Jasperc0d606a2014-04-14 11:08:45 +00004552 verifyFormat(
4553 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4554 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4555 " aaaaaaaaaaaaaaaaaaaaa +\n"
4556 " aaaaaaaaaaaaaaaaaaaaa\n"
4557 " : aaaaaaaaaa;");
Daniel Jasperfc3861a2014-07-17 12:22:04 +00004558 verifyFormat(
Daniel Jasper240527c2017-01-16 13:13:15 +00004559 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4560 " : aaaaaaaaaaaaaaaaaaaaaa\n"
4561 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper54a86022013-02-15 11:07:25 +00004562
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004563 FormatStyle NoBinPacking = getLLVMStyle();
Daniel Jasper18210d72014-10-09 09:52:05 +00004564 NoBinPacking.BinPackArguments = false;
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004565 verifyFormat(
Daniel Jaspercd8599e2013-02-23 21:01:55 +00004566 "void f() {\n"
4567 " g(aaa,\n"
4568 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
4569 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4570 " ? aaaaaaaaaaaaaaa\n"
4571 " : aaaaaaaaaaaaaaa);\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004572 "}",
4573 NoBinPacking);
Daniel Jasperb1ae7342013-08-01 22:05:00 +00004574 verifyFormat(
4575 "void f() {\n"
4576 " g(aaa,\n"
4577 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
4578 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4579 " ?: aaaaaaaaaaaaaaa);\n"
4580 "}",
4581 NoBinPacking);
Daniel Jasper1a31bab2014-10-16 09:10:11 +00004582
4583 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n"
4584 " // comment.\n"
4585 " ccccccccccccccccccccccccccccccccccccccc\n"
4586 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4587 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);");
Daniel Jasper6c22c442014-11-14 13:03:40 +00004588
4589 // Assignments in conditional expressions. Apparently not uncommon :-(.
4590 verifyFormat("return a != b\n"
4591 " // comment\n"
4592 " ? a = b\n"
4593 " : a = b;");
4594 verifyFormat("return a != b\n"
4595 " // comment\n"
4596 " ? a = a != b\n"
4597 " // comment\n"
4598 " ? a = b\n"
4599 " : a\n"
4600 " : a;\n");
4601 verifyFormat("return a != b\n"
4602 " // comment\n"
4603 " ? a\n"
4604 " : a = a != b\n"
4605 " // comment\n"
4606 " ? a = b\n"
4607 " : a;");
Daniel Jasper399d24b2013-01-09 07:06:56 +00004608}
4609
Daniel Jasper165b29e2013-11-08 00:57:11 +00004610TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) {
4611 FormatStyle Style = getLLVMStyle();
4612 Style.BreakBeforeTernaryOperators = false;
4613 Style.ColumnLimit = 70;
4614 verifyFormat(
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004615 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4616 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4617 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4618 Style);
4619 verifyFormat(
4620 "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
Daniel Jasper22ed2622016-11-29 09:40:32 +00004621 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4622 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
Daniel Jasper165b29e2013-11-08 00:57:11 +00004623 Style);
4624 verifyFormat(
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004625 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4626 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4627 Style);
4628 verifyFormat(
4629 "aaaa(aaaaaaaa, aaaaaaaaaa,\n"
Daniel Jasper22ed2622016-11-29 09:40:32 +00004630 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4631 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
Daniel Jasper165b29e2013-11-08 00:57:11 +00004632 Style);
4633 verifyFormat(
4634 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n"
4635 " aaaaaaaaaaaaa);",
4636 Style);
4637 verifyFormat(
4638 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4639 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4640 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4641 " aaaaaaaaaaaaa);",
4642 Style);
4643 verifyFormat(
4644 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4645 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4646 " aaaaaaaaaaaaa);",
4647 Style);
4648 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4649 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4650 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
4651 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4652 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4653 Style);
4654 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4655 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4656 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4657 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
4658 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4659 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4660 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4661 Style);
4662 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4663 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n"
4664 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4665 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4666 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4667 Style);
4668 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4669 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4670 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4671 Style);
4672 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +00004673 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
Daniel Jasper165b29e2013-11-08 00:57:11 +00004674 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4675 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4676 Style);
4677 verifyFormat(
4678 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4679 " aaaaaaaaaaaaaaa :\n"
4680 " aaaaaaaaaaaaaaa;",
4681 Style);
4682 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
4683 " aaaaaaaaa ?\n"
4684 " b :\n"
4685 " c);",
4686 Style);
Daniel Jasper22ed2622016-11-29 09:40:32 +00004687 verifyFormat("unsigned Indent =\n"
4688 " format(TheLine.First,\n"
4689 " IndentForLevel[TheLine.Level] >= 0 ?\n"
4690 " IndentForLevel[TheLine.Level] :\n"
4691 " TheLine * 2,\n"
4692 " TheLine.InPPDirective, PreviousEndOfLineColumn);",
4693 Style);
Daniel Jasper165b29e2013-11-08 00:57:11 +00004694 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
4695 " aaaaaaaaaaaaaaa :\n"
4696 " bbbbbbbbbbbbbbb ? //\n"
4697 " ccccccccccccccc :\n"
4698 " ddddddddddddddd;",
4699 Style);
4700 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
4701 " aaaaaaaaaaaaaaa :\n"
4702 " (bbbbbbbbbbbbbbb ? //\n"
4703 " ccccccccccccccc :\n"
4704 " ddddddddddddddd);",
4705 Style);
Daniel Jasper45860fa2016-02-03 17:27:10 +00004706 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4707 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n"
4708 " ccccccccccccccccccccccccccc;",
4709 Style);
Daniel Jasper04b4e102016-03-01 04:19:59 +00004710 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4711 " aaaaa :\n"
4712 " bbbbbbbbbbbbbbb + cccccccccccccccc;",
4713 Style);
Daniel Jasper165b29e2013-11-08 00:57:11 +00004714}
4715
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004716TEST_F(FormatTest, DeclarationsOfMultipleVariables) {
4717 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
4718 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();");
4719 verifyFormat("bool a = true, b = false;");
4720
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004721 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Daniel Jaspera628c982013-04-03 13:36:17 +00004722 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004723 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
Daniel Jasperc238c872013-04-02 14:33:13 +00004724 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);");
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004725 verifyFormat(
Daniel Jasper37905f72013-02-21 15:00:29 +00004726 "bool aaaaaaaaaaaaaaaaaaaaa =\n"
Daniel Jaspera628c982013-04-03 13:36:17 +00004727 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
Daniel Jasper37905f72013-02-21 15:00:29 +00004728 " d = e && f;");
Daniel Jasper31c96b92013-04-05 09:38:50 +00004729 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
4730 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;");
4731 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
4732 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;");
4733 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
4734 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;");
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004735
Daniel Jasperbea1ab42015-03-01 18:55:26 +00004736 FormatStyle Style = getGoogleStyle();
4737 Style.PointerAlignment = FormatStyle::PAS_Left;
4738 Style.DerivePointerAlignment = false;
4739 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4740 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
4741 " *b = bbbbbbbbbbbbbbbbbbb;",
4742 Style);
Daniel Jaspera44991332015-04-29 13:06:49 +00004743 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
4744 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;",
4745 Style);
Daniel Jasper3f2cde92016-09-26 15:14:24 +00004746 verifyFormat("vector<int*> a, b;", Style);
Daniel Jasper85d1f0b2016-10-04 20:18:25 +00004747 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style);
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004748}
4749
Nico Weber4a5030c2013-01-12 01:28:06 +00004750TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
4751 verifyFormat("arr[foo ? bar : baz];");
4752 verifyFormat("f()[foo ? bar : baz];");
4753 verifyFormat("(a + b)[foo ? bar : baz];");
4754 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
4755}
4756
Daniel Jasperf7935112012-12-03 18:12:45 +00004757TEST_F(FormatTest, AlignsStringLiterals) {
4758 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
4759 " \"short literal\");");
4760 verifyFormat(
4761 "looooooooooooooooooooooooongFunction(\n"
4762 " \"short literal\"\n"
4763 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00004764 verifyFormat("someFunction(\"Always break between multi-line\"\n"
4765 " \" string literals\",\n"
4766 " and, other, parameters);");
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004767 EXPECT_EQ("fun + \"1243\" /* comment */\n"
4768 " \"5678\";",
Manuel Klimek02f640a2013-02-20 15:25:48 +00004769 format("fun + \"1243\" /* comment */\n"
Daniel Jasper240527c2017-01-16 13:13:15 +00004770 " \"5678\";",
Manuel Klimek02f640a2013-02-20 15:25:48 +00004771 getLLVMStyleWithColumns(28)));
4772 EXPECT_EQ(
4773 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
4774 " \"aaaaaaaaaaaaaaaaaaaaa\"\n"
4775 " \"aaaaaaaaaaaaaaaa\";",
4776 format("aaaaaa ="
4777 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
4778 "aaaaaaaaaaaaaaaaaaaaa\" "
4779 "\"aaaaaaaaaaaaaaaa\";"));
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004780 verifyFormat("a = a + \"a\"\n"
4781 " \"a\"\n"
4782 " \"a\";");
4783 verifyFormat("f(\"a\", \"b\"\n"
4784 " \"c\");");
Daniel Jasperaf5ba0e2013-02-23 07:46:38 +00004785
4786 verifyFormat(
4787 "#define LL_FORMAT \"ll\"\n"
4788 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
4789 " \"d, ddddddddd: %\" LL_FORMAT \"d\");");
Daniel Jasper47a04442013-05-13 20:50:15 +00004790
4791 verifyFormat("#define A(X) \\\n"
4792 " \"aaaaa\" #X \"bbbbbb\" \\\n"
4793 " \"ccccc\"",
4794 getLLVMStyleWithColumns(23));
4795 verifyFormat("#define A \"def\"\n"
4796 "f(\"abc\" A \"ghi\"\n"
4797 " \"jkl\");");
Daniel Jasper04b6a082013-12-20 06:22:01 +00004798
4799 verifyFormat("f(L\"a\"\n"
Daniel Jasper015c7a92015-05-11 15:15:48 +00004800 " L\"b\");");
Daniel Jasper04b6a082013-12-20 06:22:01 +00004801 verifyFormat("#define A(X) \\\n"
4802 " L\"aaaaa\" #X L\"bbbbbb\" \\\n"
4803 " L\"ccccc\"",
4804 getLLVMStyleWithColumns(25));
Daniel Jasper015c7a92015-05-11 15:15:48 +00004805
4806 verifyFormat("f(@\"a\"\n"
4807 " @\"b\");");
4808 verifyFormat("NSString s = @\"a\"\n"
Daniel Jasper09285532015-05-17 08:13:23 +00004809 " @\"b\"\n"
4810 " @\"c\";");
4811 verifyFormat("NSString s = @\"a\"\n"
4812 " \"b\"\n"
4813 " \"c\";");
Daniel Jasperf7935112012-12-03 18:12:45 +00004814}
4815
Zachary Turner448592e2015-12-18 22:20:15 +00004816TEST_F(FormatTest, ReturnTypeBreakingStyle) {
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004817 FormatStyle Style = getLLVMStyle();
Zachary Turner448592e2015-12-18 22:20:15 +00004818 // No declarations or definitions should be moved to own line.
4819 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
4820 verifyFormat("class A {\n"
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004821 " int f() { return 1; }\n"
Zachary Turner448592e2015-12-18 22:20:15 +00004822 " int g();\n"
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004823 "};\n"
Zachary Turner448592e2015-12-18 22:20:15 +00004824 "int f() { return 1; }\n"
4825 "int g();\n",
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004826 Style);
Zachary Turner448592e2015-12-18 22:20:15 +00004827
4828 // All declarations and definitions should have the return type moved to its
4829 // own
4830 // line.
4831 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
4832 verifyFormat("class E {\n"
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004833 " int\n"
4834 " f() {\n"
4835 " return 1;\n"
4836 " }\n"
Zachary Turner448592e2015-12-18 22:20:15 +00004837 " int\n"
4838 " g();\n"
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004839 "};\n"
4840 "int\n"
4841 "f() {\n"
4842 " return 1;\n"
Zachary Turner448592e2015-12-18 22:20:15 +00004843 "}\n"
4844 "int\n"
4845 "g();\n",
4846 Style);
4847
4848 // Top-level definitions, and no kinds of declarations should have the
4849 // return type moved to its own line.
4850 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions;
4851 verifyFormat("class B {\n"
4852 " int f() { return 1; }\n"
4853 " int g();\n"
4854 "};\n"
4855 "int\n"
4856 "f() {\n"
4857 " return 1;\n"
4858 "}\n"
4859 "int g();\n",
4860 Style);
4861
4862 // Top-level definitions and declarations should have the return type moved
4863 // to its own line.
4864 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel;
4865 verifyFormat("class C {\n"
4866 " int f() { return 1; }\n"
4867 " int g();\n"
4868 "};\n"
4869 "int\n"
4870 "f() {\n"
4871 " return 1;\n"
4872 "}\n"
4873 "int\n"
4874 "g();\n",
4875 Style);
4876
4877 // All definitions should have the return type moved to its own line, but no
4878 // kinds of declarations.
4879 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
4880 verifyFormat("class D {\n"
4881 " int\n"
4882 " f() {\n"
4883 " return 1;\n"
4884 " }\n"
4885 " int g();\n"
4886 "};\n"
4887 "int\n"
4888 "f() {\n"
4889 " return 1;\n"
4890 "}\n"
4891 "int g();\n",
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004892 Style);
Daniel Jasperca4ea1c2014-08-05 12:16:31 +00004893 verifyFormat("const char *\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004894 "f(void) {\n" // Break here.
Daniel Jasperca4ea1c2014-08-05 12:16:31 +00004895 " return \"\";\n"
4896 "}\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004897 "const char *bar(void);\n", // No break here.
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004898 Style);
Daniel Jasperdb764792014-08-14 11:36:03 +00004899 verifyFormat("template <class T>\n"
4900 "T *\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004901 "f(T &c) {\n" // Break here.
Daniel Jasperdb764792014-08-14 11:36:03 +00004902 " return NULL;\n"
4903 "}\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004904 "template <class T> T *f(T &c);\n", // No break here.
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004905 Style);
Birunthan Mohanathas525579d2015-07-15 19:11:58 +00004906 verifyFormat("class C {\n"
4907 " int\n"
4908 " operator+() {\n"
4909 " return 1;\n"
4910 " }\n"
4911 " int\n"
4912 " operator()() {\n"
4913 " return 1;\n"
4914 " }\n"
4915 "};\n",
4916 Style);
4917 verifyFormat("void\n"
4918 "A::operator()() {}\n"
4919 "void\n"
4920 "A::operator>>() {}\n"
4921 "void\n"
4922 "A::operator+() {}\n",
4923 Style);
4924 verifyFormat("void *operator new(std::size_t s);", // No break here.
4925 Style);
4926 verifyFormat("void *\n"
4927 "operator new(std::size_t s) {}",
4928 Style);
4929 verifyFormat("void *\n"
4930 "operator delete[](void *ptr) {}",
4931 Style);
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004932 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
Daniel Jasperdb764792014-08-14 11:36:03 +00004933 verifyFormat("const char *\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004934 "f(void)\n" // Break here.
Daniel Jasperdb764792014-08-14 11:36:03 +00004935 "{\n"
4936 " return \"\";\n"
4937 "}\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004938 "const char *bar(void);\n", // No break here.
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004939 Style);
Daniel Jasperdb764792014-08-14 11:36:03 +00004940 verifyFormat("template <class T>\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004941 "T *\n" // Problem here: no line break
4942 "f(T &c)\n" // Break here.
Daniel Jasperdb764792014-08-14 11:36:03 +00004943 "{\n"
4944 " return NULL;\n"
4945 "}\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004946 "template <class T> T *f(T &c);\n", // No break here.
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004947 Style);
Daniel Jasperca4ea1c2014-08-05 12:16:31 +00004948}
4949
Alexander Kornienko58611712013-07-04 12:02:44 +00004950TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) {
4951 FormatStyle NoBreak = getLLVMStyle();
4952 NoBreak.AlwaysBreakBeforeMultilineStrings = false;
4953 FormatStyle Break = getLLVMStyle();
4954 Break.AlwaysBreakBeforeMultilineStrings = true;
Daniel Jasperc834c702013-07-17 15:38:19 +00004955 verifyFormat("aaaa = \"bbbb\"\n"
4956 " \"cccc\";",
4957 NoBreak);
4958 verifyFormat("aaaa =\n"
4959 " \"bbbb\"\n"
4960 " \"cccc\";",
4961 Break);
4962 verifyFormat("aaaa(\"bbbb\"\n"
4963 " \"cccc\");",
4964 NoBreak);
4965 verifyFormat("aaaa(\n"
4966 " \"bbbb\"\n"
4967 " \"cccc\");",
4968 Break);
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004969 verifyFormat("aaaa(qqq, \"bbbb\"\n"
4970 " \"cccc\");",
Daniel Jasperc834c702013-07-17 15:38:19 +00004971 NoBreak);
Daniel Jasper1bf729c2015-06-18 16:05:17 +00004972 verifyFormat("aaaa(qqq,\n"
4973 " \"bbbb\"\n"
4974 " \"cccc\");",
Daniel Jasperc834c702013-07-17 15:38:19 +00004975 Break);
Daniel Jasper1bf729c2015-06-18 16:05:17 +00004976 verifyFormat("aaaa(qqq,\n"
4977 " L\"bbbb\"\n"
4978 " L\"cccc\");",
4979 Break);
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004980 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n"
4981 " \"bbbb\"));",
Daniel Jasper04b6a082013-12-20 06:22:01 +00004982 Break);
Daniel Jasper9fb676a2015-06-19 10:32:28 +00004983 verifyFormat("string s = someFunction(\n"
4984 " \"abc\"\n"
4985 " \"abc\");",
4986 Break);
Daniel Jasperc834c702013-07-17 15:38:19 +00004987
Daniel Jasper3251fff2014-06-10 06:27:23 +00004988 // As we break before unary operators, breaking right after them is bad.
4989 verifyFormat("string foo = abc ? \"x\"\n"
4990 " \"blah blah blah blah blah blah\"\n"
4991 " : \"y\";",
4992 Break);
4993
Daniel Jasperc834c702013-07-17 15:38:19 +00004994 // Don't break if there is no column gain.
4995 verifyFormat("f(\"aaaa\"\n"
4996 " \"bbbb\");",
4997 Break);
4998
4999 // Treat literals with escaped newlines like multi-line string literals.
Alexander Kornienko657c67b2013-07-16 21:06:13 +00005000 EXPECT_EQ("x = \"a\\\n"
5001 "b\\\n"
5002 "c\";",
5003 format("x = \"a\\\n"
5004 "b\\\n"
5005 "c\";",
5006 NoBreak));
Daniel Jasper2aaedd32015-06-18 09:12:47 +00005007 EXPECT_EQ("xxxx =\n"
Alexander Kornienko657c67b2013-07-16 21:06:13 +00005008 " \"a\\\n"
5009 "b\\\n"
5010 "c\";",
Daniel Jasper2aaedd32015-06-18 09:12:47 +00005011 format("xxxx = \"a\\\n"
Alexander Kornienko657c67b2013-07-16 21:06:13 +00005012 "b\\\n"
5013 "c\";",
5014 Break));
Daniel Jasper27943052013-11-09 03:08:25 +00005015
Alexander Kornienkod4fa2e62017-04-11 09:55:00 +00005016 EXPECT_EQ("NSString *const kString =\n"
5017 " @\"aaaa\"\n"
5018 " @\"bbbb\";",
Daniel Jasper27943052013-11-09 03:08:25 +00005019 format("NSString *const kString = @\"aaaa\"\n"
Daniel Jasper015c7a92015-05-11 15:15:48 +00005020 "@\"bbbb\";",
Daniel Jasper27943052013-11-09 03:08:25 +00005021 Break));
Daniel Jasper6fd5d642015-01-20 12:59:20 +00005022
5023 Break.ColumnLimit = 0;
5024 verifyFormat("const char *hello = \"hello llvm\";", Break);
Alexander Kornienko58611712013-07-04 12:02:44 +00005025}
5026
Alexander Kornienko578fdd82012-12-06 18:03:27 +00005027TEST_F(FormatTest, AlignsPipes) {
5028 verifyFormat(
5029 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5030 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5031 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5032 verifyFormat(
5033 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
5034 " << aaaaaaaaaaaaaaaaaaaa;");
5035 verifyFormat(
5036 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5037 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5038 verifyFormat(
Daniel Jasper7aacf462016-12-19 11:14:23 +00005039 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5040 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5041 verifyFormat(
Alexander Kornienko578fdd82012-12-06 18:03:27 +00005042 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
5043 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
5044 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";");
5045 verifyFormat(
5046 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5047 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5048 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jaspera44991332015-04-29 13:06:49 +00005049 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5050 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5051 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5052 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
Daniel Jasper2fd16632015-05-17 07:27:09 +00005053 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n"
5054 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);");
Daniel Jasper0e617842014-04-16 12:26:54 +00005055 verifyFormat(
5056 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5057 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper04bbda92017-03-16 07:54:11 +00005058 verifyFormat(
5059 "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n"
5060 " aaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper2603ee02013-02-04 07:34:48 +00005061
Daniel Jasperc0d606a2014-04-14 11:08:45 +00005062 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n"
5063 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();");
Daniel Jasper173504e2015-05-10 21:15:07 +00005064 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5065 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5066 " aaaaaaaaaaaaaaaaaaaaa)\n"
5067 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper5962fa82015-06-03 09:26:03 +00005068 verifyFormat("LOG_IF(aaa == //\n"
5069 " bbb)\n"
5070 " << a << b;");
Daniel Jasperc238c872013-04-02 14:33:13 +00005071
Daniel Jasper467ddb12013-08-12 12:58:05 +00005072 // But sometimes, breaking before the first "<<" is desirable.
Daniel Jasper004177e2013-12-19 16:06:40 +00005073 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
5074 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);");
Daniel Jasper77d5d312013-07-12 15:14:05 +00005075 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
5076 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5077 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper467ddb12013-08-12 12:58:05 +00005078 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
5079 " << BEF << IsTemplate << Description << E->getType();");
Daniel Jasper602a7272016-02-11 13:15:14 +00005080 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
5081 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5082 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5083 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
5084 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5085 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5086 " << aaa;");
Daniel Jasper77d5d312013-07-12 15:14:05 +00005087
Daniel Jasperc238c872013-04-02 14:33:13 +00005088 verifyFormat(
5089 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5090 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper0b1f76b2013-09-29 12:02:57 +00005091
5092 // Incomplete string literal.
5093 EXPECT_EQ("llvm::errs() << \"\n"
5094 " << a;",
5095 format("llvm::errs() << \"\n<<a;"));
Manuel Klimek06c84f22013-11-20 11:20:32 +00005096
5097 verifyFormat("void f() {\n"
5098 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n"
5099 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n"
5100 "}");
Daniel Jasperd05d3a82015-01-08 13:56:57 +00005101
5102 // Handle 'endl'.
Daniel Jasper69963122015-02-17 10:05:15 +00005103 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n"
5104 " << bbbbbbbbbbbbbbbbbbbbbb << endl;");
5105 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;");
Daniel Jasper0a589412016-01-05 13:06:27 +00005106
5107 // Handle '\n'.
5108 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n"
5109 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
5110 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n"
5111 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';");
5112 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n"
5113 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";");
5114 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00005115}
5116
Daniel Jasper7209bb92016-12-13 11:16:42 +00005117TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) {
5118 verifyFormat("return out << \"somepacket = {\\n\"\n"
5119 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
5120 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
5121 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
5122 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
5123 " << \"}\";");
5124
5125 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
5126 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
5127 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;");
5128 verifyFormat(
5129 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
5130 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
5131 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
5132 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
5133 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;");
5134 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
5135 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
5136 verifyFormat(
5137 "void f() {\n"
5138 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n"
5139 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5140 "}");
5141
5142 // Breaking before the first "<<" is generally not desirable.
5143 verifyFormat(
5144 "llvm::errs()\n"
5145 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5146 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5147 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5148 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
5149 getLLVMStyleWithColumns(70));
5150 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
5151 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5152 " << \"aaaaaaaaaaaaaaaaaaa: \"\n"
5153 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5154 " << \"aaaaaaaaaaaaaaaaaaa: \"\n"
5155 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
5156 getLLVMStyleWithColumns(70));
5157
5158 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
5159 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
5160 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;");
5161 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
5162 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
5163 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);");
Daniel Jasperf789f052016-12-20 15:27:46 +00005164 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n"
5165 " (aaaa + aaaa);",
5166 getLLVMStyleWithColumns(40));
5167 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n"
5168 " (aaaaaaa + aaaaa));",
5169 getLLVMStyleWithColumns(40));
Daniel Jasper23888612016-12-22 12:37:06 +00005170 verifyFormat(
5171 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n"
5172 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n"
5173 " bbbbbbbbbbbbbbbbbbbbbbb);");
Daniel Jasper7209bb92016-12-13 11:16:42 +00005174}
5175
Daniel Jasperf7935112012-12-03 18:12:45 +00005176TEST_F(FormatTest, UnderstandsEquals) {
5177 verifyFormat(
5178 "aaaaaaaaaaaaaaaaa =\n"
5179 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5180 verifyFormat(
5181 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00005182 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasperf7935112012-12-03 18:12:45 +00005183 verifyFormat(
5184 "if (a) {\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005185 " f();\n"
Daniel Jasperf7935112012-12-03 18:12:45 +00005186 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00005187 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
5188 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +00005189
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005190 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5191 " 100000000 + 10000000) {\n}");
Daniel Jasperf7935112012-12-03 18:12:45 +00005192}
5193
Daniel Jasper5485d0c2012-12-17 14:34:14 +00005194TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00005195 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
5196 " .looooooooooooooooooooooooooooooooooooooongFunction();");
Daniel Jasper5485d0c2012-12-17 14:34:14 +00005197
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00005198 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
5199 " ->looooooooooooooooooooooooooooooooooooooongFunction();");
Daniel Jasper5485d0c2012-12-17 14:34:14 +00005200
5201 verifyFormat(
5202 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
5203 " Parameter2);");
5204
5205 verifyFormat(
5206 "ShortObject->shortFunction(\n"
5207 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
5208 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);");
5209
5210 verifyFormat("loooooooooooooongFunction(\n"
5211 " LoooooooooooooongObject->looooooooooooooooongFunction());");
5212
5213 verifyFormat(
5214 "function(LoooooooooooooooooooooooooooooooooooongObject\n"
5215 " ->loooooooooooooooooooooooooooooooooooooooongFunction());");
5216
Daniel Jasper687af3b2013-02-14 14:26:07 +00005217 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
5218 " .WillRepeatedly(Return(SomeValue));");
Daniel Jasperd6f17d82014-09-12 16:35:28 +00005219 verifyFormat("void f() {\n"
5220 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
5221 " .Times(2)\n"
5222 " .WillRepeatedly(Return(SomeValue));\n"
5223 "}");
Daniel Jasper4d7a97a2014-01-10 08:40:17 +00005224 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n"
5225 " ccccccccccccccccccccccc);");
Daniel Jasper32a796b2013-05-27 11:50:16 +00005226 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper05cd9292015-03-26 18:46:28 +00005227 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5228 " .aaaaa(aaaaa),\n"
Daniel Jasper32a796b2013-05-27 11:50:16 +00005229 " aaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00005230 verifyFormat("void f() {\n"
5231 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5232 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n"
5233 "}");
Daniel Jaspera44991332015-04-29 13:06:49 +00005234 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5235 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5236 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5237 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5238 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jasperc238c872013-04-02 14:33:13 +00005239 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5240 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5241 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5242 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
5243 "}");
Daniel Jasper687af3b2013-02-14 14:26:07 +00005244
Daniel Jasperc7345cc2013-01-07 07:13:20 +00005245 // Here, it is not necessary to wrap at "." or "->".
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00005246 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00005247 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasperc7345cc2013-01-07 07:13:20 +00005248 verifyFormat(
5249 "aaaaaaaaaaa->aaaaaaaaa(\n"
5250 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5251 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
Daniel Jaspere11095a2013-02-14 15:01:34 +00005252
5253 verifyFormat(
5254 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5255 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
Daniel Jasper8f6ae192013-03-13 15:37:48 +00005256 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
5257 " aaaaaaaaa()->aaaaaa()->aaaaa());");
5258 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
5259 " aaaaaaaaa()->aaaaaa()->aaaaa());");
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00005260
Daniel Jasper9b334242013-03-15 14:57:30 +00005261 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper05cd9292015-03-26 18:46:28 +00005262 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5263 " .a();");
Daniel Jasper9b334242013-03-15 14:57:30 +00005264
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00005265 FormatStyle NoBinPacking = getLLVMStyle();
5266 NoBinPacking.BinPackParameters = false;
5267 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
5268 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
5269 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
5270 " aaaaaaaaaaaaaaaaaaa,\n"
5271 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5272 NoBinPacking);
Daniel Jasperbd058882013-07-09 11:57:27 +00005273
5274 // If there is a subsequent call, change to hanging indentation.
5275 verifyFormat(
5276 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5277 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n"
5278 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5279 verifyFormat(
5280 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5281 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));");
Daniel Jasper96964352013-12-18 10:44:36 +00005282 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5283 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5284 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5285 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5286 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5287 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
Daniel Jasper5485d0c2012-12-17 14:34:14 +00005288}
5289
Daniel Jasperac5c1c22013-01-02 15:08:56 +00005290TEST_F(FormatTest, WrapsTemplateDeclarations) {
5291 verifyFormat("template <typename T>\n"
5292 "virtual void loooooooooooongFunction(int Param1, int Param2);");
Daniel Jasper69bd8fb2013-09-27 07:49:08 +00005293 verifyFormat("template <typename T>\n"
5294 "// T should be one of {A, B}.\n"
5295 "virtual void loooooooooooongFunction(int Param1, int Param2);");
Daniel Jasperac5c1c22013-01-02 15:08:56 +00005296 verifyFormat(
Daniel Jasper04468962013-01-18 10:56:38 +00005297 "template <typename T>\n"
Daniel Jasper400adc62013-02-08 15:28:42 +00005298 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;");
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005299 verifyFormat("template <typename T>\n"
5300 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
5301 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);");
Daniel Jasperac5c1c22013-01-02 15:08:56 +00005302 verifyFormat(
5303 "template <typename T>\n"
5304 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
5305 " int Paaaaaaaaaaaaaaaaaaaaram2);");
Daniel Jasper90e51fd2013-01-02 18:30:06 +00005306 verifyFormat(
5307 "template <typename T>\n"
5308 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
5309 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
5310 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper89058942013-01-09 09:50:48 +00005311 verifyFormat("template <typename T>\n"
5312 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jaspera628c982013-04-03 13:36:17 +00005313 " int aaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperbcab4302013-01-09 10:40:23 +00005314 verifyFormat(
5315 "template <typename T1, typename T2 = char, typename T3 = char,\n"
5316 " typename T4 = char>\n"
5317 "void f();");
Daniel Jasper298c3402013-11-22 07:48:15 +00005318 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n"
5319 " template <typename> class cccccccccccccccccccccc,\n"
5320 " typename ddddddddddddd>\n"
5321 "class C {};");
Daniel Jasper7a31af12013-01-25 15:43:32 +00005322 verifyFormat(
5323 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
5324 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper3a9370c2013-02-04 07:21:18 +00005325
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00005326 verifyFormat("void f() {\n"
5327 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
5328 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n"
5329 "}");
Daniel Jasper61e6bbf2013-05-29 12:07:31 +00005330
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00005331 verifyFormat("template <typename T> class C {};");
Daniel Jasper61e6bbf2013-05-29 12:07:31 +00005332 verifyFormat("template <typename T> void f();");
5333 verifyFormat("template <typename T> void f() {}");
Daniel Jasper0e90c3d2013-07-05 09:14:35 +00005334 verifyFormat(
5335 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
5336 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5337 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
5338 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
5339 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5340 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
5341 " bbbbbbbbbbbbbbbbbbbbbbbb);",
5342 getLLVMStyleWithColumns(72));
Daniel Jasperfcfac102014-07-15 09:00:34 +00005343 EXPECT_EQ("static_cast<A< //\n"
5344 " B> *>(\n"
5345 "\n"
Martin Probst2c1cdae2017-05-15 11:15:29 +00005346 ");",
Daniel Jasperfcfac102014-07-15 09:00:34 +00005347 format("static_cast<A<//\n"
5348 " B>*>(\n"
5349 "\n"
5350 " );"));
Daniel Jasper598dd332014-08-12 13:22:26 +00005351 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5352 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);");
Daniel Jasper5c9e3cd2013-09-14 08:13:22 +00005353
5354 FormatStyle AlwaysBreak = getLLVMStyle();
5355 AlwaysBreak.AlwaysBreakTemplateDeclarations = true;
5356 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
5357 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
5358 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
5359 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5360 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
5361 " ccccccccccccccccccccccccccccccccccccccccccccccc);");
5362 verifyFormat("template <template <typename> class Fooooooo,\n"
5363 " template <typename> class Baaaaaaar>\n"
5364 "struct C {};",
5365 AlwaysBreak);
Daniel Jasperd3e014d2013-10-09 15:06:17 +00005366 verifyFormat("template <typename T> // T can be A, B or C.\n"
5367 "struct C {};",
5368 AlwaysBreak);
Daniel Jaspera7900ad2016-05-08 18:12:22 +00005369 verifyFormat("template <enum E> class A {\n"
5370 "public:\n"
5371 " E *f();\n"
5372 "};");
Daniel Jasperac5c1c22013-01-02 15:08:56 +00005373}
5374
Daniel Jasper2db1b4a2017-02-06 10:55:49 +00005375TEST_F(FormatTest, WrapsTemplateParameters) {
5376 FormatStyle Style = getLLVMStyle();
5377 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5378 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
5379 verifyFormat(
5380 "template <typename... a> struct q {};\n"
5381 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
5382 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
5383 " y;",
5384 Style);
5385 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5386 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
5387 verifyFormat(
5388 "template <typename... a> struct r {};\n"
5389 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
5390 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
5391 " y;",
5392 Style);
5393 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
5394 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
5395 verifyFormat(
5396 "template <typename... a> struct s {};\n"
5397 "extern s<\n"
5398 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
5399 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n"
5400 " y;",
5401 Style);
5402 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
5403 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
5404 verifyFormat(
5405 "template <typename... a> struct t {};\n"
5406 "extern t<\n"
5407 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
5408 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n"
5409 " y;",
5410 Style);
5411}
5412
Daniel Jasper45797022013-01-25 10:57:27 +00005413TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
5414 verifyFormat(
5415 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
5416 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5417 verifyFormat(
5418 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
5419 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5420 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
5421
Daniel Jasper0f0234e2013-05-08 10:00:18 +00005422 // FIXME: Should we have the extra indent after the second break?
Daniel Jasper45797022013-01-25 10:57:27 +00005423 verifyFormat(
5424 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
5425 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
Daniel Jasper0f0234e2013-05-08 10:00:18 +00005426 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper45797022013-01-25 10:57:27 +00005427
Daniel Jasper45797022013-01-25 10:57:27 +00005428 verifyFormat(
5429 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
Daniel Jasper4ad42352013-01-28 07:43:15 +00005430 " cccccccccccccccccccccccccccccccccccccccccccccc());");
Daniel Jasper45797022013-01-25 10:57:27 +00005431
5432 // Breaking at nested name specifiers is generally not desirable.
5433 verifyFormat(
5434 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5435 " aaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperca6623b2013-01-28 12:45:14 +00005436
5437 verifyFormat(
Daniel Jasper240527c2017-01-16 13:13:15 +00005438 "aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n"
5439 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
5440 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasperca6623b2013-01-28 12:45:14 +00005441 " aaaaaaaaaaaaaaaaaaaaa);",
5442 getLLVMStyleWithColumns(74));
Daniel Jasperc238c872013-04-02 14:33:13 +00005443
5444 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
5445 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5446 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper45797022013-01-25 10:57:27 +00005447}
5448
Daniel Jasperf7935112012-12-03 18:12:45 +00005449TEST_F(FormatTest, UnderstandsTemplateParameters) {
5450 verifyFormat("A<int> a;");
Chandler Carruthf8b72662014-03-02 12:37:31 +00005451 verifyFormat("A<A<A<int>>> a;");
Daniel Jasperf7935112012-12-03 18:12:45 +00005452 verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
5453 verifyFormat("bool x = a < 1 || 2 > a;");
5454 verifyFormat("bool x = 5 < f<int>();");
5455 verifyFormat("bool x = f<int>() > 5;");
5456 verifyFormat("bool x = 5 < a<int>::x;");
5457 verifyFormat("bool x = a < 4 ? a > 2 : false;");
5458 verifyFormat("bool x = f() ? a < 2 : a > 2;");
5459
5460 verifyGoogleFormat("A<A<int>> a;");
5461 verifyGoogleFormat("A<A<A<int>>> a;");
5462 verifyGoogleFormat("A<A<A<A<int>>>> a;");
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005463 verifyGoogleFormat("A<A<int> > a;");
5464 verifyGoogleFormat("A<A<A<int> > > a;");
5465 verifyGoogleFormat("A<A<A<A<int> > > > a;");
Daniel Jasperfba84ff2013-10-12 05:16:06 +00005466 verifyGoogleFormat("A<::A<int>> a;");
5467 verifyGoogleFormat("A<::A> a;");
5468 verifyGoogleFormat("A< ::A> a;");
5469 verifyGoogleFormat("A< ::A<int> > a;");
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005470 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
5471 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
Daniel Jasperfba84ff2013-10-12 05:16:06 +00005472 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle()));
5473 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle()));
Daniel Jasper352f0df2015-07-18 16:35:30 +00005474 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };",
5475 format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle()));
Daniel Jasperf7935112012-12-03 18:12:45 +00005476
Nico Weber7533b4d2014-09-24 17:17:32 +00005477 verifyFormat("A<A>> a;", getChromiumStyle(FormatStyle::LK_Cpp));
5478
Daniel Jasperf7935112012-12-03 18:12:45 +00005479 verifyFormat("test >> a >> b;");
5480 verifyFormat("test << a >> b;");
5481
5482 verifyFormat("f<int>();");
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005483 verifyFormat("template <typename T> void f() {}");
Daniel Jasperb13135b2015-01-08 08:48:21 +00005484 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;");
Daniel Jasper112b50e2015-05-06 14:53:50 +00005485 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : "
5486 "sizeof(char)>::type>;");
Daniel Jasperadba2aa2015-05-18 12:52:00 +00005487 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};");
Daniel Jasper0c9772e2016-02-05 14:17:16 +00005488 verifyFormat("f(a.operator()<A>());");
5489 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5490 " .template operator()<A>());",
5491 getLLVMStyleWithColumns(35));
Daniel Jasperd5893912013-06-01 18:56:00 +00005492
5493 // Not template parameters.
5494 verifyFormat("return a < b && c > d;");
5495 verifyFormat("void f() {\n"
5496 " while (a < b && c > d) {\n"
5497 " }\n"
5498 "}");
Daniel Jasper62c0ac02013-07-30 22:37:19 +00005499 verifyFormat("template <typename... Types>\n"
5500 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}");
Daniel Jasper0de8efa2013-09-17 08:15:46 +00005501
5502 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5503 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);",
5504 getLLVMStyleWithColumns(60));
Daniel Jasper6ba16382014-07-28 13:19:58 +00005505 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");");
Daniel Jasper65df5aa2014-08-04 14:51:02 +00005506 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}");
Daniel Jasper4d9ec172015-05-06 08:38:24 +00005507 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <");
Daniel Jasperf7935112012-12-03 18:12:45 +00005508}
5509
Malcolm Parsons6af3f142016-11-03 16:57:30 +00005510TEST_F(FormatTest, BitshiftOperatorWidth) {
5511 EXPECT_EQ("int a = 1 << 2; /* foo\n"
5512 " bar */",
5513 format("int a=1<<2; /* foo\n"
5514 " bar */"));
5515
5516 EXPECT_EQ("int b = 256 >> 1; /* foo\n"
5517 " bar */",
5518 format("int b =256>>1 ; /* foo\n"
5519 " bar */"));
5520}
5521
Daniel Jasperd8ffcfa2013-02-28 09:21:10 +00005522TEST_F(FormatTest, UnderstandsBinaryOperators) {
5523 verifyFormat("COMPARE(a, ==, b);");
Daniel Jasper594be2f2016-06-13 07:49:09 +00005524 verifyFormat("auto s = sizeof...(Ts) - 1;");
Alexander Kornienko674be0a2013-03-20 16:41:56 +00005525}
5526
5527TEST_F(FormatTest, UnderstandsPointersToMembers) {
5528 verifyFormat("int A::*x;");
Daniel Jaspercfda5172013-05-08 14:58:20 +00005529 verifyFormat("int (S::*func)(void *);");
Daniel Jasper37194282013-05-28 08:33:00 +00005530 verifyFormat("void f() { int (S::*func)(void *); }");
Daniel Jasper2f34cac2013-05-08 15:06:58 +00005531 verifyFormat("typedef bool *(Class::*Member)() const;");
Daniel Jaspercfda5172013-05-08 14:58:20 +00005532 verifyFormat("void f() {\n"
5533 " (a->*f)();\n"
5534 " a->*x;\n"
5535 " (a.*f)();\n"
5536 " ((*a).*f)();\n"
5537 " a.*x;\n"
5538 "}");
Daniel Jasper998cabc2013-07-18 14:46:07 +00005539 verifyFormat("void f() {\n"
5540 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
5541 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n"
5542 "}");
Daniel Jasper85bcadc2014-07-09 13:07:57 +00005543 verifyFormat(
5544 "(aaaaaaaaaa->*bbbbbbb)(\n"
5545 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jasper2f34cac2013-05-08 15:06:58 +00005546 FormatStyle Style = getLLVMStyle();
Daniel Jasper553d4872014-06-17 12:40:34 +00005547 Style.PointerAlignment = FormatStyle::PAS_Left;
Daniel Jasper2f34cac2013-05-08 15:06:58 +00005548 verifyFormat("typedef bool* (Class::*Member)() const;", Style);
Daniel Jasperd8ffcfa2013-02-28 09:21:10 +00005549}
5550
Daniel Jasper8dd40472012-12-21 09:41:31 +00005551TEST_F(FormatTest, UnderstandsUnaryOperators) {
Daniel Jasperf7935112012-12-03 18:12:45 +00005552 verifyFormat("int a = -2;");
Daniel Jasper8b529712012-12-04 13:02:32 +00005553 verifyFormat("f(-1, -2, -3);");
5554 verifyFormat("a[-1] = 5;");
5555 verifyFormat("int a = 5 + -2;");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00005556 verifyFormat("if (i == -1) {\n}");
5557 verifyFormat("if (i != -1) {\n}");
5558 verifyFormat("if (i > -1) {\n}");
5559 verifyFormat("if (i < -1) {\n}");
Daniel Jasper26333c32012-12-06 13:16:39 +00005560 verifyFormat("++(a->f());");
5561 verifyFormat("--(a->f());");
Daniel Jasper13f23e12013-01-14 12:18:19 +00005562 verifyFormat("(a->f())++;");
5563 verifyFormat("a[42]++;");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00005564 verifyFormat("if (!(a->f())) {\n}");
Daniel Jasper8dd40472012-12-21 09:41:31 +00005565
5566 verifyFormat("a-- > b;");
5567 verifyFormat("b ? -a : c;");
5568 verifyFormat("n * sizeof char16;");
Alexander Kornienko1e808872013-06-28 12:51:24 +00005569 verifyFormat("n * alignof char16;", getGoogleStyle());
Daniel Jasper8dd40472012-12-21 09:41:31 +00005570 verifyFormat("sizeof(char);");
Alexander Kornienko1e808872013-06-28 12:51:24 +00005571 verifyFormat("alignof(char);", getGoogleStyle());
Daniel Jasperda1c68a2013-01-02 15:26:16 +00005572
5573 verifyFormat("return -1;");
5574 verifyFormat("switch (a) {\n"
5575 "case -1:\n"
5576 " break;\n"
5577 "}");
Daniel Jasper399d1ee2013-03-22 10:44:43 +00005578 verifyFormat("#define X -1");
5579 verifyFormat("#define X -kConstant");
Nico Weber63a54eb2013-01-12 05:41:23 +00005580
Chandler Carruthf8b72662014-03-02 12:37:31 +00005581 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};");
5582 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};");
Daniel Jasper71945272013-01-15 14:27:39 +00005583
5584 verifyFormat("int a = /* confusing comment */ -1;");
5585 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case.
5586 verifyFormat("int a = i /* confusing comment */++;");
Daniel Jasperf7935112012-12-03 18:12:45 +00005587}
5588
Daniel Jasper0c214fa2014-02-05 13:43:04 +00005589TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) {
Daniel Jasperf110e202013-08-21 08:39:01 +00005590 verifyFormat("if (!aaaaaaaaaa( // break\n"
Daniel Jasper0c214fa2014-02-05 13:43:04 +00005591 " aaaaa)) {\n"
Daniel Jasperf110e202013-08-21 08:39:01 +00005592 "}");
5593 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
Daniel Jasper739b85f2015-06-29 10:42:59 +00005594 " aaaaa));");
Daniel Jasper0649d362013-08-23 15:14:03 +00005595 verifyFormat("*aaa = aaaaaaa( // break\n"
5596 " bbbbbb);");
Daniel Jasperf110e202013-08-21 08:39:01 +00005597}
5598
Daniel Jasper8863ada2013-08-26 08:10:17 +00005599TEST_F(FormatTest, UnderstandsOverloadedOperators) {
Daniel Jasper537a2962012-12-24 10:56:04 +00005600 verifyFormat("bool operator<();");
5601 verifyFormat("bool operator>();");
5602 verifyFormat("bool operator=();");
5603 verifyFormat("bool operator==();");
5604 verifyFormat("bool operator!=();");
5605 verifyFormat("int operator+();");
5606 verifyFormat("int operator++();");
Daniel Jasperbbf5f4e2017-11-06 12:11:51 +00005607 verifyFormat("int operator++(int) volatile noexcept;");
Daniel Jasper804a2762016-01-09 15:56:40 +00005608 verifyFormat("bool operator,();");
Daniel Jasper537a2962012-12-24 10:56:04 +00005609 verifyFormat("bool operator();");
5610 verifyFormat("bool operator()();");
5611 verifyFormat("bool operator[]();");
5612 verifyFormat("operator bool();");
Daniel Jasper35d2dc72013-02-11 08:01:18 +00005613 verifyFormat("operator int();");
5614 verifyFormat("operator void *();");
Daniel Jasper537a2962012-12-24 10:56:04 +00005615 verifyFormat("operator SomeType<int>();");
Daniel Jasper35d2dc72013-02-11 08:01:18 +00005616 verifyFormat("operator SomeType<int, int>();");
Chandler Carruthf8b72662014-03-02 12:37:31 +00005617 verifyFormat("operator SomeType<SomeType<int>>();");
Daniel Jasper537a2962012-12-24 10:56:04 +00005618 verifyFormat("void *operator new(std::size_t size);");
5619 verifyFormat("void *operator new[](std::size_t size);");
5620 verifyFormat("void operator delete(void *ptr);");
5621 verifyFormat("void operator delete[](void *ptr);");
Daniel Jasper8f9624b2013-05-10 07:59:58 +00005622 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
5623 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);");
Daniel Jasper804a2762016-01-09 15:56:40 +00005624 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n"
Daniel Jasperdf51f2e62016-01-11 12:55:33 +00005625 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;");
Daniel Jasper35d2dc72013-02-11 08:01:18 +00005626
Daniel Jasper0af92eb2013-02-15 19:24:08 +00005627 verifyFormat(
5628 "ostream &operator<<(ostream &OutputStream,\n"
5629 " SomeReallyLongType WithSomeReallyLongValue);");
Daniel Jasper54ac8202013-04-05 17:21:59 +00005630 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
5631 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
5632 " return left.group < right.group;\n"
5633 "}");
Daniel Jasper6e8f4ed2013-04-11 08:48:20 +00005634 verifyFormat("SomeType &operator=(const SomeType &S);");
Daniel Jasper8835a322014-10-20 13:56:30 +00005635 verifyFormat("f.template operator()<int>();");
Daniel Jasper0af92eb2013-02-15 19:24:08 +00005636
Daniel Jasper35d2dc72013-02-11 08:01:18 +00005637 verifyGoogleFormat("operator void*();");
5638 verifyGoogleFormat("operator SomeType<SomeType<int>>();");
Daniel Jasperedc5f092013-10-29 12:24:23 +00005639 verifyGoogleFormat("operator ::A();");
Daniel Jasper42401c82013-09-02 09:20:39 +00005640
5641 verifyFormat("using A::operator+;");
Daniel Jasper5af04a42015-10-07 03:43:10 +00005642 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n"
5643 "int i;");
Daniel Jasperf7935112012-12-03 18:12:45 +00005644}
5645
Daniel Jasper1c220482015-02-25 10:30:06 +00005646TEST_F(FormatTest, UnderstandsFunctionRefQualification) {
Daniel Jasperaf642c62015-08-25 13:40:51 +00005647 verifyFormat("Deleted &operator=(const Deleted &) & = default;");
5648 verifyFormat("Deleted &operator=(const Deleted &) && = delete;");
5649 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;");
5650 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;");
5651 verifyFormat("Deleted &operator=(const Deleted &) &;");
5652 verifyFormat("Deleted &operator=(const Deleted &) &&;");
5653 verifyFormat("SomeType MemberFunction(const Deleted &) &;");
5654 verifyFormat("SomeType MemberFunction(const Deleted &) &&;");
5655 verifyFormat("SomeType MemberFunction(const Deleted &) && {}");
5656 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}");
5657 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}");
Jacob Bandes-Storch58933c52017-08-10 01:30:22 +00005658 verifyFormat("void Fn(T const &) const &;");
5659 verifyFormat("void Fn(T const volatile &&) const volatile &&;");
Daniel Jasper28b4d512016-11-01 06:23:19 +00005660 verifyFormat("template <typename T>\n"
5661 "void F(T) && = delete;",
5662 getGoogleStyle());
Daniel Jasper1c220482015-02-25 10:30:06 +00005663
Daniel Jasperaf642c62015-08-25 13:40:51 +00005664 FormatStyle AlignLeft = getLLVMStyle();
5665 AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
Daniel Jasper2b4d6ea2016-06-08 08:23:46 +00005666 verifyFormat("void A::b() && {}", AlignLeft);
Daniel Jasperaf642c62015-08-25 13:40:51 +00005667 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft);
5668 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;",
5669 AlignLeft);
5670 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft);
5671 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft);
Daniel Jasperc3ff0cd2016-04-18 11:31:21 +00005672 verifyFormat("auto Function(T t) & -> void {}", AlignLeft);
5673 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft);
5674 verifyFormat("auto Function(T) & -> void {}", AlignLeft);
5675 verifyFormat("auto Function(T) & -> void;", AlignLeft);
Jacob Bandes-Storch58933c52017-08-10 01:30:22 +00005676 verifyFormat("void Fn(T const&) const&;", AlignLeft);
5677 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft);
Daniel Jasper1c220482015-02-25 10:30:06 +00005678
5679 FormatStyle Spaces = getLLVMStyle();
5680 Spaces.SpacesInCStyleCastParentheses = true;
Daniel Jasperaf642c62015-08-25 13:40:51 +00005681 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces);
5682 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces);
5683 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces);
5684 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces);
Daniel Jasper1c220482015-02-25 10:30:06 +00005685
5686 Spaces.SpacesInCStyleCastParentheses = false;
5687 Spaces.SpacesInParentheses = true;
Daniel Jasperaf642c62015-08-25 13:40:51 +00005688 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces);
5689 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", Spaces);
5690 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces);
5691 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces);
Daniel Jasper1c220482015-02-25 10:30:06 +00005692}
5693
Daniel Jasperd6a947f2013-01-11 16:09:04 +00005694TEST_F(FormatTest, UnderstandsNewAndDelete) {
Daniel Jasperba0bda92013-02-23 08:07:18 +00005695 verifyFormat("void f() {\n"
5696 " A *a = new A;\n"
5697 " A *a = new (placement) A;\n"
5698 " delete a;\n"
5699 " delete (A *)a;\n"
5700 "}");
Daniel Jasper71646ec2014-07-30 12:14:10 +00005701 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
5702 " typename aaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper316ab382014-08-06 13:14:58 +00005703 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5704 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
5705 " typename aaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper80222262014-11-02 22:46:42 +00005706 verifyFormat("delete[] h->p;");
Daniel Jasperd6a947f2013-01-11 16:09:04 +00005707}
5708
Daniel Jasper22bcf8a2013-01-02 08:57:10 +00005709TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005710 verifyFormat("int *f(int *a) {}");
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005711 verifyFormat("int main(int argc, char **argv) {}");
Daniel Jasper5065bc42013-02-18 12:44:35 +00005712 verifyFormat("Test::Test(int b) : a(b * b) {}");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005713 verifyIndependentOfContext("f(a, *a);");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005714 verifyFormat("void g() { f(*a); }");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005715 verifyIndependentOfContext("int a = b * 10;");
5716 verifyIndependentOfContext("int a = 10 * b;");
5717 verifyIndependentOfContext("int a = b * c;");
5718 verifyIndependentOfContext("int a += b * c;");
5719 verifyIndependentOfContext("int a -= b * c;");
5720 verifyIndependentOfContext("int a *= b * c;");
5721 verifyIndependentOfContext("int a /= b * c;");
5722 verifyIndependentOfContext("int a = *b;");
5723 verifyIndependentOfContext("int a = *b * c;");
5724 verifyIndependentOfContext("int a = b * *c;");
Daniel Jasper93101662015-05-19 12:29:27 +00005725 verifyIndependentOfContext("int a = b * (10);");
5726 verifyIndependentOfContext("S << b * (10);");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005727 verifyIndependentOfContext("return 10 * b;");
5728 verifyIndependentOfContext("return *b * *c;");
5729 verifyIndependentOfContext("return a & ~b;");
5730 verifyIndependentOfContext("f(b ? *c : *d);");
5731 verifyIndependentOfContext("int a = b ? *c : *d;");
5732 verifyIndependentOfContext("*b = a;");
5733 verifyIndependentOfContext("a * ~b;");
5734 verifyIndependentOfContext("a * !b;");
5735 verifyIndependentOfContext("a * +b;");
5736 verifyIndependentOfContext("a * -b;");
5737 verifyIndependentOfContext("a * ++b;");
5738 verifyIndependentOfContext("a * --b;");
5739 verifyIndependentOfContext("a[4] * b;");
Daniel Jasper8e559272013-02-27 11:43:50 +00005740 verifyIndependentOfContext("a[a * a] = 1;");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005741 verifyIndependentOfContext("f() * b;");
5742 verifyIndependentOfContext("a * [self dostuff];");
Daniel Jasper6e42b1e2013-04-01 17:13:26 +00005743 verifyIndependentOfContext("int x = a * (a + b);");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005744 verifyIndependentOfContext("(a *)(a + b);");
Daniel Jasper942d9712014-04-28 09:19:28 +00005745 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005746 verifyIndependentOfContext("int *pa = (int *)&a;");
Nico Weber44449172013-02-12 16:17:07 +00005747 verifyIndependentOfContext("return sizeof(int **);");
5748 verifyIndependentOfContext("return sizeof(int ******);");
5749 verifyIndependentOfContext("return (int **&)a;");
Daniel Jasper4d03d3b2013-05-28 15:27:10 +00005750 verifyIndependentOfContext("f((*PointerToArray)[10]);");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005751 verifyFormat("void f(Type (*parameter)[10]) {}");
Daniel Jasper4bc013e2015-10-07 01:41:22 +00005752 verifyFormat("void f(Type (&parameter)[10]) {}");
Nico Weber44449172013-02-12 16:17:07 +00005753 verifyGoogleFormat("return sizeof(int**);");
5754 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);");
5755 verifyGoogleFormat("Type** A = static_cast<Type**>(P);");
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00005756 verifyFormat("auto a = [](int **&, int ***) {};");
Daniel Jasperd46e07e2013-10-20 18:15:30 +00005757 verifyFormat("auto PointerBinding = [](const char *S) {};");
Daniel Jasper71665cd2013-09-10 10:26:38 +00005758 verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
Daniel Jasper4ac7de72014-06-11 07:35:16 +00005759 verifyFormat("[](const decltype(*a) &value) {}");
Daniel Jasper033181b2015-08-13 13:43:51 +00005760 verifyFormat("decltype(a * b) F();");
Daniel Jasper99b5a462015-05-12 10:20:32 +00005761 verifyFormat("#define MACRO() [](A *a) { return 1; }");
Daniel Jasperd27df3d2016-02-01 11:21:07 +00005762 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}");
Daniel Jasper3682fcd2013-12-16 08:36:18 +00005763 verifyIndependentOfContext("typedef void (*f)(int *a);");
Daniel Jasper39485162014-05-22 09:00:33 +00005764 verifyIndependentOfContext("int i{a * b};");
Daniel Jasper7d028292014-06-02 11:54:20 +00005765 verifyIndependentOfContext("aaa && aaa->f();");
Daniel Jasper2ac3fdf2014-07-28 12:08:16 +00005766 verifyIndependentOfContext("int x = ~*p;");
Daniel Jasperd127e3b2014-11-14 17:26:49 +00005767 verifyFormat("Constructor() : a(a), area(width * height) {}");
Daniel Jaspere1e348b2014-11-17 18:42:22 +00005768 verifyFormat("Constructor() : a(a), area(a, width * height) {}");
Daniel Jaspere4ab49e2015-04-20 12:54:29 +00005769 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}");
Daniel Jasper6a3fd832014-11-17 13:55:04 +00005770 verifyFormat("void f() { f(a, c * d); }");
Daniel Jasper3a26a8d2015-05-13 12:54:30 +00005771 verifyFormat("void f() { f(new a(), c * d); }");
Daniel Jasperc941e7d2017-01-09 11:04:07 +00005772 verifyFormat("void f(const MyOverride &override);");
5773 verifyFormat("void f(const MyFinal &final);");
5774 verifyIndependentOfContext("bool a = f() && override.f();");
5775 verifyIndependentOfContext("bool a = f() && final.f();");
Daniel Jasper27234032012-12-07 09:52:15 +00005776
Daniel Jasper5b49f472013-01-23 12:10:53 +00005777 verifyIndependentOfContext("InvalidRegions[*R] = 0;");
Daniel Jasper3c2557d2013-01-04 20:46:38 +00005778
Daniel Jasper5b49f472013-01-23 12:10:53 +00005779 verifyIndependentOfContext("A<int *> a;");
5780 verifyIndependentOfContext("A<int **> a;");
5781 verifyIndependentOfContext("A<int *, int *> a;");
Daniel Jasper139d4a32014-04-08 13:07:41 +00005782 verifyIndependentOfContext("A<int *[]> a;");
Daniel Jasperc697ad22013-02-06 10:05:46 +00005783 verifyIndependentOfContext(
5784 "const char *const p = reinterpret_cast<const char *const>(q);");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005785 verifyIndependentOfContext("A<int **, int **> a;");
Daniel Jasper8035b0a2013-02-06 10:57:42 +00005786 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);");
Daniel Jasperae907642013-03-14 10:50:25 +00005787 verifyFormat("for (char **a = b; *a; ++a) {\n}");
Daniel Jasperc37de302013-05-03 14:41:24 +00005788 verifyFormat("for (; a && b;) {\n}");
Daniel Jasperea2d0422014-05-08 08:50:10 +00005789 verifyFormat("bool foo = true && [] { return false; }();");
Daniel Jaspera4396862012-12-10 18:59:13 +00005790
Daniel Jasper66dcb1c2013-01-08 20:03:18 +00005791 verifyFormat(
5792 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5793 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5794
Daniel Jasper1f5d6372016-06-13 14:45:12 +00005795 verifyGoogleFormat("int const* a = &b;");
Daniel Jasper6a968202015-01-07 12:19:53 +00005796 verifyGoogleFormat("**outparam = 1;");
Daniel Jasper75092162015-01-23 19:04:49 +00005797 verifyGoogleFormat("*outparam = a * b;");
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005798 verifyGoogleFormat("int main(int argc, char** argv) {}");
Daniel Jaspera4396862012-12-10 18:59:13 +00005799 verifyGoogleFormat("A<int*> a;");
5800 verifyGoogleFormat("A<int**> a;");
5801 verifyGoogleFormat("A<int*, int*> a;");
5802 verifyGoogleFormat("A<int**, int**> a;");
Daniel Jasper22bcf8a2013-01-02 08:57:10 +00005803 verifyGoogleFormat("f(b ? *c : *d);");
5804 verifyGoogleFormat("int a = b ? *c : *d;");
Daniel Jaspera1dc93a2013-01-16 16:04:06 +00005805 verifyGoogleFormat("Type* t = **x;");
5806 verifyGoogleFormat("Type* t = *++*x;");
5807 verifyGoogleFormat("*++*x;");
5808 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);");
5809 verifyGoogleFormat("Type* t = x++ * y;");
Daniel Jasperc697ad22013-02-06 10:05:46 +00005810 verifyGoogleFormat(
5811 "const char* const p = reinterpret_cast<const char* const>(q);");
Daniel Jasper8184d662014-07-28 12:24:21 +00005812 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);");
Daniel Jasper0bd9a192014-11-10 16:57:30 +00005813 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);");
5814 verifyGoogleFormat("template <typename T>\n"
5815 "void f(int i = 0, SomeType** temps = NULL);");
Manuel Klimek557811f2013-01-14 10:58:01 +00005816
Daniel Jasper1904e9b2014-08-14 10:53:19 +00005817 FormatStyle Left = getLLVMStyle();
5818 Left.PointerAlignment = FormatStyle::PAS_Left;
5819 verifyFormat("x = *a(x) = *a(y);", Left);
Daniel Jasper28b4d512016-11-01 06:23:19 +00005820 verifyFormat("for (;; *a = b) {\n}", Left);
Daniel Jasper95516cd2015-12-23 18:01:29 +00005821 verifyFormat("return *this += 1;", Left);
Manuel Klimek06b575c2017-07-17 15:27:53 +00005822 verifyFormat("throw *x;", Left);
Krasimir Georgiev9b5a89b2017-08-14 11:06:07 +00005823 verifyFormat("delete *x;", Left);
5824 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left);
5825 verifyFormat("[](const decltype(*a)* ptr) {}", Left);
5826 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left);
Daniel Jasper1904e9b2014-08-14 10:53:19 +00005827
Daniel Jasper5b49f472013-01-23 12:10:53 +00005828 verifyIndependentOfContext("a = *(x + y);");
5829 verifyIndependentOfContext("a = &(x + y);");
5830 verifyIndependentOfContext("*(x + y).call();");
5831 verifyIndependentOfContext("&(x + y)->call();");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005832 verifyFormat("void f() { &(*I).first; }");
Daniel Jasper71945272013-01-15 14:27:39 +00005833
Daniel Jasper5b49f472013-01-23 12:10:53 +00005834 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
Daniel Jasper71945272013-01-15 14:27:39 +00005835 verifyFormat(
Daniel Jasperf9fc2152014-04-09 13:18:49 +00005836 "int *MyValues = {\n"
5837 " *A, // Operator detection might be confused by the '{'\n"
5838 " *BB // Operator detection might be confused by previous comment\n"
Daniel Jasper71945272013-01-15 14:27:39 +00005839 "};");
Nico Weber80a82762013-01-17 17:17:19 +00005840
Daniel Jasper5b49f472013-01-23 12:10:53 +00005841 verifyIndependentOfContext("if (int *a = &b)");
5842 verifyIndependentOfContext("if (int &a = *b)");
5843 verifyIndependentOfContext("if (a & b[i])");
5844 verifyIndependentOfContext("if (a::b::c::d & b[i])");
5845 verifyIndependentOfContext("if (*b[i])");
5846 verifyIndependentOfContext("if (int *a = (&b))");
5847 verifyIndependentOfContext("while (int *a = &b)");
Daniel Jasperdf620b22013-09-21 17:31:51 +00005848 verifyIndependentOfContext("size = sizeof *a;");
Daniel Jasperdc4f7252015-03-11 12:59:49 +00005849 verifyIndependentOfContext("if (a && (b = c))");
Daniel Jasper420d7d32013-01-23 12:58:14 +00005850 verifyFormat("void f() {\n"
5851 " for (const int &v : Values) {\n"
5852 " }\n"
5853 "}");
Daniel Jasper5065bc42013-02-18 12:44:35 +00005854 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
5855 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
Daniel Jasper5ca9b712013-09-11 20:37:10 +00005856 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}");
Daniel Jasper0b820602013-01-22 11:46:26 +00005857
Daniel Jaspera98da3d2013-11-07 19:56:07 +00005858 verifyFormat("#define A (!a * b)");
Daniel Jasperb910bbb2013-05-13 07:14:40 +00005859 verifyFormat("#define MACRO \\\n"
5860 " int *i = a * b; \\\n"
5861 " void f(a *b);",
5862 getLLVMStyleWithColumns(19));
5863
Daniel Jasper97b89482013-03-13 07:49:51 +00005864 verifyIndependentOfContext("A = new SomeType *[Length];");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005865 verifyIndependentOfContext("A = new SomeType *[Length]();");
Daniel Jasper6f9c8d22013-07-05 13:30:40 +00005866 verifyIndependentOfContext("T **t = new T *;");
5867 verifyIndependentOfContext("T **t = new T *();");
Daniel Jasper532a0312015-04-23 10:23:53 +00005868 verifyGoogleFormat("A = new SomeType*[Length]();");
5869 verifyGoogleFormat("A = new SomeType*[Length];");
Daniel Jasper6f9c8d22013-07-05 13:30:40 +00005870 verifyGoogleFormat("T** t = new T*;");
5871 verifyGoogleFormat("T** t = new T*();");
Daniel Jasperb910bbb2013-05-13 07:14:40 +00005872
Daniel Jaspera65e8872014-03-25 10:52:45 +00005873 verifyFormat("STATIC_ASSERT((a & b) == 0);");
5874 verifyFormat("STATIC_ASSERT(0 == (a & b));");
Manuel Klimekf81e5c02014-03-27 11:17:36 +00005875 verifyFormat("template <bool a, bool b> "
Daniel Jasper4afc6b32014-06-02 10:57:55 +00005876 "typename t::if<x && y>::type f() {}");
5877 verifyFormat("template <int *y> f() {}");
Manuel Klimekf81e5c02014-03-27 11:17:36 +00005878 verifyFormat("vector<int *> v;");
5879 verifyFormat("vector<int *const> v;");
5880 verifyFormat("vector<int *const **const *> v;");
5881 verifyFormat("vector<int *volatile> v;");
5882 verifyFormat("vector<a * b> v;");
Manuel Klimek1f9d80a2014-03-27 19:00:52 +00005883 verifyFormat("foo<b && false>();");
5884 verifyFormat("foo<b & 1>();");
Daniel Jasper73e171f2014-08-29 12:54:38 +00005885 verifyFormat("decltype(*::std::declval<const T &>()) void F();");
Daniel Jasper13a7f462014-10-28 18:11:52 +00005886 verifyFormat(
Daniel Jasper21f7dea2017-02-01 09:23:39 +00005887 "template <class T, class = typename std::enable_if<\n"
5888 " std::is_integral<T>::value &&\n"
5889 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n"
5890 "void F();",
5891 getLLVMStyleWithColumns(70));
5892 verifyFormat(
Daniel Jasper22ed2622016-11-29 09:40:32 +00005893 "template <class T,\n"
5894 " class = typename std::enable_if<\n"
5895 " std::is_integral<T>::value &&\n"
Daniel Jasper21f7dea2017-02-01 09:23:39 +00005896 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n"
5897 " class U>\n"
Daniel Jasperf0c809a2014-10-28 18:28:22 +00005898 "void F();",
Daniel Jasper22ed2622016-11-29 09:40:32 +00005899 getLLVMStyleWithColumns(70));
Daniel Jasperf0c809a2014-10-28 18:28:22 +00005900 verifyFormat(
5901 "template <class T,\n"
5902 " class = typename ::std::enable_if<\n"
5903 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n"
5904 "void F();",
5905 getGoogleStyleWithColumns(68));
Manuel Klimek1f9d80a2014-03-27 19:00:52 +00005906
Daniel Jaspercc7bf7f2014-04-03 09:00:49 +00005907 verifyIndependentOfContext("MACRO(int *i);");
5908 verifyIndependentOfContext("MACRO(auto *a);");
5909 verifyIndependentOfContext("MACRO(const A *a);");
Daniel Jasper628dd852017-03-08 09:49:12 +00005910 verifyIndependentOfContext("MACRO(A *const a);");
Daniel Jasper91beebd2014-06-30 13:44:47 +00005911 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');");
Daniel Jasperd0d27aa2016-11-01 06:23:14 +00005912 verifyFormat("void f() { f(float{1}, a * a); }");
Daniel Jaspercc7bf7f2014-04-03 09:00:49 +00005913 // FIXME: Is there a way to make this work?
5914 // verifyIndependentOfContext("MACRO(A *a);");
5915
Daniel Jasper32ccb032014-06-23 07:36:18 +00005916 verifyFormat("DatumHandle const *operator->() const { return input_; }");
Daniel Jasper0ea4d792015-10-07 01:41:14 +00005917 verifyFormat("return options != nullptr && operator==(*options);");
Daniel Jasper32ccb032014-06-23 07:36:18 +00005918
Daniel Jasper866468a2014-04-14 13:15:29 +00005919 EXPECT_EQ("#define OP(x) \\\n"
5920 " ostream &operator<<(ostream &s, const A &a) { \\\n"
5921 " return s << a.DebugString(); \\\n"
5922 " }",
5923 format("#define OP(x) \\\n"
5924 " ostream &operator<<(ostream &s, const A &a) { \\\n"
5925 " return s << a.DebugString(); \\\n"
5926 " }",
5927 getLLVMStyleWithColumns(50)));
5928
Manuel Klimek1f9d80a2014-03-27 19:00:52 +00005929 // FIXME: We cannot handle this case yet; we might be able to figure out that
5930 // foo<x> d > v; doesn't make sense.
Daniel Jasper6ba16382014-07-28 13:19:58 +00005931 verifyFormat("foo<a<b && c> d> v;");
Daniel Jasper553d4872014-06-17 12:40:34 +00005932
5933 FormatStyle PointerMiddle = getLLVMStyle();
5934 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
5935 verifyFormat("delete *x;", PointerMiddle);
5936 verifyFormat("int * x;", PointerMiddle);
5937 verifyFormat("template <int * y> f() {}", PointerMiddle);
5938 verifyFormat("int * f(int * a) {}", PointerMiddle);
5939 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle);
5940 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle);
5941 verifyFormat("A<int *> a;", PointerMiddle);
5942 verifyFormat("A<int **> a;", PointerMiddle);
5943 verifyFormat("A<int *, int *> a;", PointerMiddle);
5944 verifyFormat("A<int * []> a;", PointerMiddle);
Daniel Jasper532a0312015-04-23 10:23:53 +00005945 verifyFormat("A = new SomeType *[Length]();", PointerMiddle);
5946 verifyFormat("A = new SomeType *[Length];", PointerMiddle);
Daniel Jasper553d4872014-06-17 12:40:34 +00005947 verifyFormat("T ** t = new T *;", PointerMiddle);
Daniel Jasper3992e2c2015-07-01 21:02:24 +00005948
5949 // Member function reference qualifiers aren't binary operators.
5950 verifyFormat("string // break\n"
Daniel Jasperaf642c62015-08-25 13:40:51 +00005951 "operator()() & {}");
Daniel Jasper3992e2c2015-07-01 21:02:24 +00005952 verifyFormat("string // break\n"
Daniel Jasperaf642c62015-08-25 13:40:51 +00005953 "operator()() && {}");
Daniel Jasper3992e2c2015-07-01 21:02:24 +00005954 verifyGoogleFormat("template <typename T>\n"
Daniel Jasperaf642c62015-08-25 13:40:51 +00005955 "auto x() & -> int {}");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005956}
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005957
Daniel Jasperee6d6502013-07-17 20:25:02 +00005958TEST_F(FormatTest, UnderstandsAttributes) {
5959 verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
Daniel Jasper559b63c2014-01-28 20:13:43 +00005960 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
5961 "aaaaaaaaaaaaaaaaaaaaaaa(int i);");
Daniel Jaspera5fa4d12015-07-06 11:30:34 +00005962 FormatStyle AfterType = getLLVMStyle();
Zachary Turner448592e2015-12-18 22:20:15 +00005963 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
Daniel Jaspera5fa4d12015-07-06 11:30:34 +00005964 verifyFormat("__attribute__((nodebug)) void\n"
5965 "foo() {}\n",
5966 AfterType);
Daniel Jasperee6d6502013-07-17 20:25:02 +00005967}
5968
Daniel Jasper10cd5812013-05-06 06:35:44 +00005969TEST_F(FormatTest, UnderstandsEllipsis) {
5970 verifyFormat("int printf(const char *fmt, ...);");
5971 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
Daniel Jasperbafa6b72013-07-01 09:47:25 +00005972 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}");
5973
5974 FormatStyle PointersLeft = getLLVMStyle();
Daniel Jasper553d4872014-06-17 12:40:34 +00005975 PointersLeft.PointerAlignment = FormatStyle::PAS_Left;
Daniel Jasperbafa6b72013-07-01 09:47:25 +00005976 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft);
Daniel Jasper10cd5812013-05-06 06:35:44 +00005977}
5978
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005979TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005980 EXPECT_EQ("int *a;\n"
5981 "int *a;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005982 "int *a;",
5983 format("int *a;\n"
5984 "int* a;\n"
5985 "int *a;",
5986 getGoogleStyle()));
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005987 EXPECT_EQ("int* a;\n"
5988 "int* a;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005989 "int* a;",
5990 format("int* a;\n"
5991 "int* a;\n"
5992 "int *a;",
5993 getGoogleStyle()));
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005994 EXPECT_EQ("int *a;\n"
5995 "int *a;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005996 "int *a;",
5997 format("int *a;\n"
5998 "int * a;\n"
5999 "int * a;",
6000 getGoogleStyle()));
Daniel Jasper352f0df2015-07-18 16:35:30 +00006001 EXPECT_EQ("auto x = [] {\n"
6002 " int *a;\n"
6003 " int *a;\n"
6004 " int *a;\n"
6005 "};",
6006 format("auto x=[]{int *a;\n"
6007 "int * a;\n"
6008 "int * a;};",
6009 getGoogleStyle()));
Daniel Jasperf7935112012-12-03 18:12:45 +00006010}
6011
Alexander Kornienkoa5151272013-03-12 16:28:18 +00006012TEST_F(FormatTest, UnderstandsRvalueReferences) {
6013 verifyFormat("int f(int &&a) {}");
6014 verifyFormat("int f(int a, char &&b) {}");
6015 verifyFormat("void f() { int &&a = b; }");
6016 verifyGoogleFormat("int f(int a, char&& b) {}");
6017 verifyGoogleFormat("void f() { int&& a = b; }");
6018
Daniel Jasper1eff9082013-05-27 16:36:33 +00006019 verifyIndependentOfContext("A<int &&> a;");
6020 verifyIndependentOfContext("A<int &&, int &&> a;");
6021 verifyGoogleFormat("A<int&&> a;");
6022 verifyGoogleFormat("A<int&&, int&&> a;");
Daniel Jasper8b1c6352013-08-01 17:58:23 +00006023
6024 // Not rvalue references:
6025 verifyFormat("template <bool B, bool C> class A {\n"
6026 " static_assert(B && C, \"Something is wrong\");\n"
6027 "};");
Daniel Jasper29a98cf2013-08-13 09:09:09 +00006028 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))");
6029 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))");
Daniel Jasper72ab43b2014-04-14 12:50:02 +00006030 verifyFormat("#define A(a, b) (a && b)");
Alexander Kornienkoa5151272013-03-12 16:28:18 +00006031}
6032
Manuel Klimekc1237a82013-01-23 14:08:21 +00006033TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
6034 verifyFormat("void f() {\n"
6035 " x[aaaaaaaaa -\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00006036 " b] = 23;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006037 "}",
6038 getLLVMStyleWithColumns(15));
Manuel Klimekc1237a82013-01-23 14:08:21 +00006039}
6040
Daniel Jasperef906a92013-01-13 08:01:36 +00006041TEST_F(FormatTest, FormatsCasts) {
6042 verifyFormat("Type *A = static_cast<Type *>(P);");
6043 verifyFormat("Type *A = (Type *)P;");
6044 verifyFormat("Type *A = (vector<Type *, int *>)P;");
6045 verifyFormat("int a = (int)(2.0f);");
Daniel Jasperda6f2252013-05-31 16:14:28 +00006046 verifyFormat("int a = (int)2.0f;");
6047 verifyFormat("x[(int32)y];");
6048 verifyFormat("x = (int32)y;");
6049 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
6050 verifyFormat("int a = (int)*b;");
6051 verifyFormat("int a = (int)2.0f;");
6052 verifyFormat("int a = (int)~0;");
6053 verifyFormat("int a = (int)++a;");
6054 verifyFormat("int a = (int)sizeof(int);");
6055 verifyFormat("int a = (int)+2;");
6056 verifyFormat("my_int a = (my_int)2.0f;");
6057 verifyFormat("my_int a = (my_int)sizeof(int);");
Daniel Jasper05866372013-06-06 08:20:20 +00006058 verifyFormat("return (my_int)aaa;");
Daniel Jasper49a94482013-07-15 15:04:42 +00006059 verifyFormat("#define x ((int)-1)");
Daniel Jaspera45eb4c2014-10-06 13:16:43 +00006060 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1");
Daniel Jasper49a94482013-07-15 15:04:42 +00006061 verifyFormat("#define p(q) ((int *)&q)");
Daniel Jasper30646202014-07-14 12:38:38 +00006062 verifyFormat("fn(a)(b) + 1;");
Daniel Jasperef906a92013-01-13 08:01:36 +00006063
Dinesh Dwivedi76f98f82014-05-05 13:14:35 +00006064 verifyFormat("void f() { my_int a = (my_int)*b; }");
6065 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }");
6066 verifyFormat("my_int a = (my_int)~0;");
6067 verifyFormat("my_int a = (my_int)++a;");
Daniel Jaspera45eb4c2014-10-06 13:16:43 +00006068 verifyFormat("my_int a = (my_int)-2;");
Dinesh Dwivedi76f98f82014-05-05 13:14:35 +00006069 verifyFormat("my_int a = (my_int)1;");
6070 verifyFormat("my_int a = (my_int *)1;");
6071 verifyFormat("my_int a = (const my_int)-1;");
6072 verifyFormat("my_int a = (const my_int *)-1;");
Daniel Jasper4b3ba212014-08-25 09:36:07 +00006073 verifyFormat("my_int a = (my_int)(my_int)-1;");
Daniel Jasperf5e5ee62015-05-19 11:18:39 +00006074 verifyFormat("my_int a = (ns::my_int)-2;");
Daniel Jasper554e49f2015-06-12 07:15:33 +00006075 verifyFormat("case (my_int)ONE:");
Daniel Jasper94b1bdf2016-04-05 11:46:06 +00006076 verifyFormat("auto x = (X)this;");
Dinesh Dwivedi76f98f82014-05-05 13:14:35 +00006077
6078 // FIXME: single value wrapped with paren will be treated as cast.
6079 verifyFormat("void f(int i = (kValue)*kMask) {}");
Daniel Jasperef906a92013-01-13 08:01:36 +00006080
Dinesh Dwivedi2e92e662014-05-06 11:46:49 +00006081 verifyFormat("{ (void)F; }");
6082
Daniel Jasper998cabc2013-07-18 14:46:07 +00006083 // Don't break after a cast's
6084 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
6085 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
6086 " bbbbbbbbbbbbbbbbbbbbbb);");
6087
Daniel Jasperef906a92013-01-13 08:01:36 +00006088 // These are not casts.
6089 verifyFormat("void f(int *) {}");
Nico Weber4401b2a2013-02-13 04:32:57 +00006090 verifyFormat("f(foo)->b;");
6091 verifyFormat("f(foo).b;");
6092 verifyFormat("f(foo)(b);");
6093 verifyFormat("f(foo)[b];");
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00006094 verifyFormat("[](foo) { return 4; }(bar);");
Nico Weber4401b2a2013-02-13 04:32:57 +00006095 verifyFormat("(*funptr)(foo)[4];");
6096 verifyFormat("funptrs[4](foo)[4];");
Daniel Jasperef906a92013-01-13 08:01:36 +00006097 verifyFormat("void f(int *);");
6098 verifyFormat("void f(int *) = 0;");
6099 verifyFormat("void f(SmallVector<int>) {}");
6100 verifyFormat("void f(SmallVector<int>);");
6101 verifyFormat("void f(SmallVector<int>) = 0;");
Nico Weber06fcec12013-02-09 18:02:07 +00006102 verifyFormat("void f(int i = (kA * kB) & kMask) {}");
Nico Weber4401b2a2013-02-13 04:32:57 +00006103 verifyFormat("int a = sizeof(int) * b;");
Alexander Kornienko1e808872013-06-28 12:51:24 +00006104 verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
Daniel Jasper05866372013-06-06 08:20:20 +00006105 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
6106 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
Aaron Ballman61005bc2015-02-16 14:14:01 +00006107 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00006108
Daniel Jasperba0bda92013-02-23 08:07:18 +00006109 // These are not casts, but at some point were confused with casts.
6110 verifyFormat("virtual void foo(int *) override;");
6111 verifyFormat("virtual void foo(char &) const;");
6112 verifyFormat("virtual void foo(int *a, char *) const;");
Daniel Jasper8a68b952013-03-13 17:13:53 +00006113 verifyFormat("int a = sizeof(int *) + b;");
Alexander Kornienko1e808872013-06-28 12:51:24 +00006114 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
Daniel Jasper9bb30012015-11-23 15:55:50 +00006115 verifyFormat("bool b = f(g<int>) && c;");
Daniel Jasper8e8b4fb2015-11-23 19:11:45 +00006116 verifyFormat("typedef void (*f)(int i) func;");
Daniel Jasper1bc1b502013-07-05 07:58:34 +00006117
6118 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
6119 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
Daniel Jasperaea3bde2013-07-12 11:19:37 +00006120 // FIXME: The indentation here is not ideal.
Daniel Jasper0e90c3d2013-07-05 09:14:35 +00006121 verifyFormat(
Daniel Jasperaea3bde2013-07-12 11:19:37 +00006122 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6123 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
6124 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];");
Daniel Jasperef906a92013-01-13 08:01:36 +00006125}
6126
Daniel Jasperc1fa2812013-01-10 13:08:12 +00006127TEST_F(FormatTest, FormatsFunctionTypes) {
Daniel Jasperc1fa2812013-01-10 13:08:12 +00006128 verifyFormat("A<bool()> a;");
6129 verifyFormat("A<SomeType()> a;");
Daniel Jasper37194282013-05-28 08:33:00 +00006130 verifyFormat("A<void (*)(int, std::string)> a;");
Daniel Jasperb8914dd2013-03-20 09:53:18 +00006131 verifyFormat("A<void *(int)>;");
Daniel Jasper6e42b1e2013-04-01 17:13:26 +00006132 verifyFormat("void *(*a)(int *, SomeType *);");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00006133 verifyFormat("int (*func)(void *);");
Daniel Jasper37194282013-05-28 08:33:00 +00006134 verifyFormat("void f() { int (*func)(void *); }");
Daniel Jasper59036852013-08-12 12:16:34 +00006135 verifyFormat("template <class CallbackClass>\n"
6136 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);");
Daniel Jasperb8914dd2013-03-20 09:53:18 +00006137
Daniel Jasper6e42b1e2013-04-01 17:13:26 +00006138 verifyGoogleFormat("A<void*(int*, SomeType*)>;");
6139 verifyGoogleFormat("void* (*a)(int);");
Daniel Jasper59036852013-08-12 12:16:34 +00006140 verifyGoogleFormat(
6141 "template <class CallbackClass>\n"
6142 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);");
Daniel Jasperabc34212013-05-14 08:34:47 +00006143
Daniel Jasper5dad58e2013-05-15 07:51:51 +00006144 // Other constructs can look somewhat like function types:
Daniel Jasperabc34212013-05-14 08:34:47 +00006145 verifyFormat("A<sizeof(*x)> a;");
Daniel Jasper5dad58e2013-05-15 07:51:51 +00006146 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
Daniel Jasper655d96a2013-07-16 11:37:21 +00006147 verifyFormat("some_var = function(*some_pointer_var)[0];");
6148 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
Daniel Jaspera85c3312015-12-28 07:44:25 +00006149 verifyFormat("int x = f(&h)();");
Daniel Jasper21561662016-06-13 07:49:35 +00006150 verifyFormat("returnsFunction(&param1, &param2)(param);");
Daniel Jaspercab46172017-04-24 14:28:49 +00006151 verifyFormat("std::function<\n"
6152 " LooooooooooongTemplatedType<\n"
6153 " SomeType>*(\n"
6154 " LooooooooooooooooongType type)>\n"
6155 " function;",
6156 getGoogleStyleWithColumns(40));
Daniel Jasperc1fa2812013-01-10 13:08:12 +00006157}
6158
Daniel Jasperbeaa3222015-02-26 11:30:50 +00006159TEST_F(FormatTest, FormatsPointersToArrayTypes) {
6160 verifyFormat("A (*foo_)[6];");
6161 verifyFormat("vector<int> (*foo_)[6];");
6162}
6163
Daniel Jasper4355e7f2014-07-09 07:50:33 +00006164TEST_F(FormatTest, BreaksLongVariableDeclarations) {
6165 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
6166 " LoooooooooooooooooooooooooooooooooooooooongVariable;");
6167 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
6168 " LoooooooooooooooooooooooooooooooooooooooongVariable;");
Daniel Jasperb754a742015-03-12 15:04:53 +00006169 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
6170 " *LoooooooooooooooooooooooooooooooooooooooongVariable;");
Daniel Jasper4355e7f2014-07-09 07:50:33 +00006171
6172 // Different ways of ()-initializiation.
6173 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
6174 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);");
6175 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
6176 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);");
6177 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
6178 " LoooooooooooooooooooooooooooooooooooooooongVariable({});");
Daniel Jasper0faa9132015-04-23 13:58:40 +00006179 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
6180 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);");
Daniel Jasper697a8ec2017-02-07 21:38:16 +00006181
6182 // Lambdas should not confuse the variable declaration heuristic.
6183 verifyFormat("LooooooooooooooooongType\n"
6184 " variable(nullptr, [](A *a) {});",
6185 getLLVMStyleWithColumns(40));
Daniel Jasper4355e7f2014-07-09 07:50:33 +00006186}
6187
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00006188TEST_F(FormatTest, BreaksLongDeclarations) {
Daniel Jasper8e357692013-05-06 08:27:33 +00006189 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00006190 " AnotherNameForTheLongType;");
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00006191 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00006192 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper8e357692013-05-06 08:27:33 +00006193 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00006194 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
Daniel Jasperb754a742015-03-12 15:04:53 +00006195 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n"
6196 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
Daniel Jasper8e357692013-05-06 08:27:33 +00006197 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
6198 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasper2ad0aba2014-10-28 17:06:04 +00006199 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n"
6200 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasperdba1c552013-07-02 09:47:29 +00006201 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
6202 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasperf10a28d2014-05-05 13:48:09 +00006203 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
6204 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasperc3ff0cd2016-04-18 11:31:21 +00006205 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
6206 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);");
6207 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
6208 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}");
Daniel Jasperc75e1ef2014-07-09 08:42:42 +00006209 FormatStyle Indented = getLLVMStyle();
6210 Indented.IndentWrappedFunctionNames = true;
6211 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
6212 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();",
6213 Indented);
6214 verifyFormat(
6215 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
6216 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
6217 Indented);
6218 verifyFormat(
6219 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
6220 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
6221 Indented);
6222 verifyFormat(
6223 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
6224 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
6225 Indented);
Daniel Jasper8e357692013-05-06 08:27:33 +00006226
6227 // FIXME: Without the comment, this breaks after "(".
Manuel Klimek836c2862013-06-21 17:25:42 +00006228 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n"
6229 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();",
6230 getGoogleStyle());
Daniel Jasper8e357692013-05-06 08:27:33 +00006231
Daniel Jasperd2639ef2013-01-28 15:16:31 +00006232 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00006233 " int LoooooooooooooooooooongParam2) {}");
Daniel Jasperd1926a32013-01-02 08:44:14 +00006234 verifyFormat(
Daniel Jasper6728fc12013-04-11 14:29:13 +00006235 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
6236 " SourceLocation L, IdentifierIn *II,\n"
6237 " Type *T) {}");
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00006238 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
Daniel Jasperb754a742015-03-12 15:04:53 +00006239 "ReallyReaaallyLongFunctionName(\n"
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00006240 " const std::string &SomeParameter,\n"
Daniel Jasperb754a742015-03-12 15:04:53 +00006241 " const SomeType<string, SomeOtherTemplateParameter>\n"
6242 " &ReallyReallyLongParameterName,\n"
6243 " const SomeType<string, SomeOtherTemplateParameter>\n"
6244 " &AnotherLongParameterName) {}");
Daniel Jasperc6fbc212013-05-15 09:35:08 +00006245 verifyFormat("template <typename A>\n"
6246 "SomeLoooooooooooooooooooooongType<\n"
6247 " typename some_namespace::SomeOtherType<A>::Type>\n"
6248 "Function() {}");
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00006249
Daniel Jasperd36ef5e2013-01-28 15:40:20 +00006250 verifyGoogleFormat(
Daniel Jasper53643062013-08-19 10:16:18 +00006251 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
6252 " aaaaaaaaaaaaaaaaaaaaaaa;");
6253 verifyGoogleFormat(
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00006254 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
6255 " SourceLocation L) {}");
Daniel Jasperb9caeac2013-02-13 20:33:44 +00006256 verifyGoogleFormat(
6257 "some_namespace::LongReturnType\n"
6258 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00006259 " int first_long_parameter, int second_parameter) {}");
Daniel Jasperb9caeac2013-02-13 20:33:44 +00006260
6261 verifyGoogleFormat("template <typename T>\n"
6262 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00006263 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
Daniel Jasper57d4a582013-02-28 10:06:05 +00006264 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6265 " int aaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper78b45332014-08-14 10:52:56 +00006266
6267 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
Daniel Jasperb754a742015-03-12 15:04:53 +00006268 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6269 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperde7ca752015-05-04 07:39:00 +00006270 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6271 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
6272 " aaaaaaaaaaaaaaaaaaaaaaaa);");
6273 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6274 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
6275 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n"
6276 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Andi-Bogdan Postelnicu67329892017-03-07 14:48:02 +00006277
Andi-Bogdan Postelnicu4743e2d2017-03-07 15:20:31 +00006278 verifyFormat("template <typename T> // Templates on own line.\n"
6279 "static int // Some comment.\n"
Andi-Bogdan Postelnicu67329892017-03-07 14:48:02 +00006280 "MyFunction(int a);",
6281 getLLVMStyle());
Daniel Jasperd1926a32013-01-02 08:44:14 +00006282}
6283
Daniel Jasperaea3bde2013-07-12 11:19:37 +00006284TEST_F(FormatTest, FormatsArrays) {
6285 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
6286 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
Daniel Jasper362a1bf2015-12-23 18:01:43 +00006287 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n"
6288 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;");
Daniel Jaspere1afb9b2015-12-30 12:23:00 +00006289 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n"
6290 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}");
Daniel Jasperaea3bde2013-07-12 11:19:37 +00006291 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6292 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
6293 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6294 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
6295 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6296 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
6297 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
6298 verifyFormat(
6299 "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
6300 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
6301 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
Daniel Jasperf9168de2016-03-01 04:19:55 +00006302 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n"
6303 " .aaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jaspere0ab9e72013-12-06 15:19:50 +00006304
6305 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n"
6306 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];");
Daniel Jasperecaba172014-06-10 13:27:57 +00006307 verifyFormat(
6308 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n"
6309 " .aaaaaaa[0]\n"
6310 " .aaaaaaaaaaaaaaaaaaaaaa();");
Manuel Klimek27f278182016-01-19 14:05:32 +00006311 verifyFormat("a[::b::c];");
Daniel Jasper675b4f82015-01-19 10:51:23 +00006312
6313 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10));
Daniel Jaspera3cd21642016-01-14 13:36:46 +00006314
6315 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0);
6316 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit);
Daniel Jasperaea3bde2013-07-12 11:19:37 +00006317}
6318
Daniel Jaspere9de2602012-12-06 09:56:08 +00006319TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
6320 verifyFormat("(a)->b();");
6321 verifyFormat("--a;");
6322}
6323
Daniel Jasper8b529712012-12-04 13:02:32 +00006324TEST_F(FormatTest, HandlesIncludeDirectives) {
Daniel Jasper2ab0d012013-01-14 15:52:06 +00006325 verifyFormat("#include <string>\n"
6326 "#include <a/b/c.h>\n"
6327 "#include \"a/b/string\"\n"
6328 "#include \"string.h\"\n"
6329 "#include \"string.h\"\n"
Manuel Klimek99c7baa2013-01-15 15:50:27 +00006330 "#include <a-a>\n"
Daniel Jasperaf5ba0e2013-02-23 07:46:38 +00006331 "#include < path with space >\n"
Daniel Jasperfa3f8fb2015-05-19 11:22:29 +00006332 "#include_next <test.h>"
Daniel Jasper4a4be012013-05-06 10:24:51 +00006333 "#include \"abc.h\" // this is included for ABC\n"
Daniel Jasper8bb99e82013-05-16 12:59:13 +00006334 "#include \"some long include\" // with a comment\n"
Manuel Klimek45ab5592017-11-14 09:19:53 +00006335 "#include \"some very long include path\"\n"
6336 "#include <some/very/long/include/path>\n",
Daniel Jasperaf5ba0e2013-02-23 07:46:38 +00006337 getLLVMStyleWithColumns(35));
Daniel Jasper98857842013-10-30 13:54:53 +00006338 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\""));
6339 EXPECT_EQ("#include <a>", format("#include<a>"));
Nico Weber8f83ee42012-12-21 18:21:56 +00006340
Daniel Jasper5ef433f2013-01-13 08:12:18 +00006341 verifyFormat("#import <string>");
6342 verifyFormat("#import <a/b/c.h>");
6343 verifyFormat("#import \"a/b/string\"");
6344 verifyFormat("#import \"string.h\"");
6345 verifyFormat("#import \"string.h\"");
Daniel Jaspered8f1c62013-08-28 08:24:04 +00006346 verifyFormat("#if __has_include(<strstream>)\n"
6347 "#include <strstream>\n"
6348 "#endif");
Daniel Jasper47ef6dd2014-01-17 16:21:39 +00006349
Daniel Jasper343643b2014-08-13 08:29:18 +00006350 verifyFormat("#define MY_IMPORT <a/b>");
6351
Nico Weber21088802017-02-10 19:36:52 +00006352 verifyFormat("#if __has_include(<a/b>)");
6353 verifyFormat("#if __has_include_next(<a/b>)");
6354 verifyFormat("#define F __has_include(<a/b>)");
6355 verifyFormat("#define F __has_include_next(<a/b>)");
6356
Daniel Jasper47ef6dd2014-01-17 16:21:39 +00006357 // Protocol buffer definition or missing "#".
6358 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";",
6359 getLLVMStyleWithColumns(30));
Daniel Jasper9509f182014-05-05 08:08:07 +00006360
6361 FormatStyle Style = getLLVMStyle();
6362 Style.AlwaysBreakBeforeMultilineStrings = true;
6363 Style.ColumnLimit = 0;
6364 verifyFormat("#import \"abc.h\"", Style);
Daniel Jasper86ee0b62014-12-04 08:57:27 +00006365
6366 // But 'import' might also be a regular C++ namespace.
6367 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6368 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper8b529712012-12-04 13:02:32 +00006369}
6370
Alexander Kornienko578fdd82012-12-06 18:03:27 +00006371//===----------------------------------------------------------------------===//
6372// Error recovery tests.
6373//===----------------------------------------------------------------------===//
6374
Daniel Jasper66e9dee2013-02-14 09:19:04 +00006375TEST_F(FormatTest, IncompleteParameterLists) {
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00006376 FormatStyle NoBinPacking = getLLVMStyle();
6377 NoBinPacking.BinPackParameters = false;
6378 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
6379 " double *min_x,\n"
6380 " double *max_x,\n"
6381 " double *min_y,\n"
6382 " double *max_y,\n"
6383 " double *min_z,\n"
6384 " double *max_z, ) {}",
6385 NoBinPacking);
Daniel Jasper66e9dee2013-02-14 09:19:04 +00006386}
6387
Daniel Jasper83a54d22013-01-10 09:26:47 +00006388TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
Alexander Kornienkoae6e53c2013-01-16 11:45:16 +00006389 verifyFormat("void f() { return; }\n42");
6390 verifyFormat("void f() {\n"
6391 " if (0)\n"
6392 " return;\n"
6393 "}\n"
6394 "42");
Alexander Kornienko1231e062013-01-16 11:43:46 +00006395 verifyFormat("void f() { return }\n42");
6396 verifyFormat("void f() {\n"
6397 " if (0)\n"
6398 " return\n"
6399 "}\n"
6400 "42");
6401}
6402
6403TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
6404 EXPECT_EQ("void f() { return }", format("void f ( ) { return }"));
6405 EXPECT_EQ("void f() {\n"
6406 " if (a)\n"
6407 " return\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006408 "}",
6409 format("void f ( ) { if ( a ) return }"));
Daniel Jasperabca58c2013-05-15 14:09:55 +00006410 EXPECT_EQ("namespace N {\n"
6411 "void f()\n"
6412 "}",
6413 format("namespace N { void f() }"));
Alexander Kornienko1231e062013-01-16 11:43:46 +00006414 EXPECT_EQ("namespace N {\n"
6415 "void f() {}\n"
6416 "void g()\n"
Krasimir Georgiev9163fe22017-03-02 09:54:44 +00006417 "} // namespace N",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006418 format("namespace N { void f( ) { } void g( ) }"));
Daniel Jasper83a54d22013-01-10 09:26:47 +00006419}
6420
Daniel Jasper2df93312013-01-09 10:16:05 +00006421TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
6422 verifyFormat("int aaaaaaaa =\n"
Alexander Kornienkoffd6d042013-03-27 11:52:18 +00006423 " // Overlylongcomment\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006424 " b;",
6425 getLLVMStyleWithColumns(20));
Daniel Jasper2df93312013-01-09 10:16:05 +00006426 verifyFormat("function(\n"
6427 " ShortArgument,\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006428 " LoooooooooooongArgument);\n",
6429 getLLVMStyleWithColumns(20));
Daniel Jasper2df93312013-01-09 10:16:05 +00006430}
6431
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00006432TEST_F(FormatTest, IncorrectAccessSpecifier) {
6433 verifyFormat("public:");
6434 verifyFormat("class A {\n"
6435 "public\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00006436 " void f() {}\n"
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00006437 "};");
6438 verifyFormat("public\n"
6439 "int qwerty;");
6440 verifyFormat("public\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00006441 "B {}");
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00006442 verifyFormat("public\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00006443 "{}");
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00006444 verifyFormat("public\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00006445 "B { int x; }");
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00006446}
Daniel Jasperf7935112012-12-03 18:12:45 +00006447
Daniel Jasper291f9362013-03-20 15:58:10 +00006448TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
6449 verifyFormat("{");
6450 verifyFormat("#})");
Daniel Jasperd97d5d52015-02-17 09:58:03 +00006451 verifyNoCrash("(/**/[:!] ?[).");
Daniel Jasper291f9362013-03-20 15:58:10 +00006452}
Alexander Kornienko0ea8e102012-12-04 15:40:36 +00006453
6454TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00006455 verifyFormat("do {\n}");
6456 verifyFormat("do {\n}\n"
Alexander Kornienko0ea8e102012-12-04 15:40:36 +00006457 "f();");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00006458 verifyFormat("do {\n}\n"
Alexander Kornienko0ea8e102012-12-04 15:40:36 +00006459 "wheeee(fun);");
6460 verifyFormat("do {\n"
6461 " f();\n"
Manuel Klimek28cacc72013-01-07 18:10:23 +00006462 "}");
Alexander Kornienko0ea8e102012-12-04 15:40:36 +00006463}
6464
Manuel Klimek9fa8d552013-01-11 19:23:05 +00006465TEST_F(FormatTest, IncorrectCodeMissingParens) {
Manuel Klimekadededf2013-01-11 18:28:36 +00006466 verifyFormat("if {\n foo;\n foo();\n}");
Manuel Klimek9fa8d552013-01-11 19:23:05 +00006467 verifyFormat("switch {\n foo;\n foo();\n}");
Manuel Klimekec5c3db2015-05-07 12:26:30 +00006468 verifyIncompleteFormat("for {\n foo;\n foo();\n}");
Manuel Klimek9fa8d552013-01-11 19:23:05 +00006469 verifyFormat("while {\n foo;\n foo();\n}");
6470 verifyFormat("do {\n foo;\n foo();\n} while;");
Manuel Klimekadededf2013-01-11 18:28:36 +00006471}
6472
Daniel Jasperc0880a92013-01-04 18:52:56 +00006473TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
Manuel Klimekec5c3db2015-05-07 12:26:30 +00006474 verifyIncompleteFormat("namespace {\n"
6475 "class Foo { Foo (\n"
6476 "};\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00006477 "} // namespace");
Daniel Jasperc0880a92013-01-04 18:52:56 +00006478}
6479
Alexander Kornienko870f9eb2012-12-04 17:27:50 +00006480TEST_F(FormatTest, IncorrectCodeErrorDetection) {
Daniel Jasperfbc057e2013-10-18 17:20:57 +00006481 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n"));
Manuel Klimeke7d10a12013-01-10 13:24:24 +00006482 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n"));
6483 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n"));
Daniel Jasperfbc057e2013-10-18 17:20:57 +00006484 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n"));
Alexander Kornienko870f9eb2012-12-04 17:27:50 +00006485
Alexander Kornienko870f9eb2012-12-04 17:27:50 +00006486 EXPECT_EQ("{\n"
Daniel Jasperfbc057e2013-10-18 17:20:57 +00006487 " {\n"
6488 " breakme(\n"
6489 " qwe);\n"
6490 " }\n",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006491 format("{\n"
6492 " {\n"
6493 " breakme(qwe);\n"
6494 "}\n",
6495 getLLVMStyleWithColumns(10)));
Alexander Kornienko870f9eb2012-12-04 17:27:50 +00006496}
6497
Manuel Klimek73a2fdf2013-01-10 14:36:46 +00006498TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006499 verifyFormat("int x = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006500 " avariable,\n"
6501 " b(alongervariable)};",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006502 getLLVMStyleWithColumns(25));
Manuel Klimek73a2fdf2013-01-10 14:36:46 +00006503}
6504
Manuel Klimek762dd182013-01-21 10:07:49 +00006505TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
Daniel Jasper4afc6b32014-06-02 10:57:55 +00006506 verifyFormat("return (a)(b){1, 2, 3};");
Manuel Klimek762dd182013-01-21 10:07:49 +00006507}
6508
Daniel Jasperae8e0d82014-04-17 11:32:02 +00006509TEST_F(FormatTest, LayoutCxx11BraceInitializers) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00006510 verifyFormat("vector<int> x{1, 2, 3, 4};");
Daniel Jaspera125d532014-03-21 12:38:57 +00006511 verifyFormat("vector<int> x{\n"
Francois Ferrandd2130f52017-06-30 20:00:02 +00006512 " 1,\n"
6513 " 2,\n"
6514 " 3,\n"
6515 " 4,\n"
Daniel Jaspera125d532014-03-21 12:38:57 +00006516 "};");
Chandler Carruthf8b72662014-03-02 12:37:31 +00006517 verifyFormat("vector<T> x{{}, {}, {}, {}};");
6518 verifyFormat("f({1, 2});");
6519 verifyFormat("auto v = Foo{-1};");
6520 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});");
6521 verifyFormat("Class::Class : member{1, 2, 3} {}");
6522 verifyFormat("new vector<int>{1, 2, 3};");
6523 verifyFormat("new int[3]{1, 2, 3};");
Daniel Jasper7a2d60e2014-05-07 07:59:03 +00006524 verifyFormat("new int{1};");
Chandler Carruthf8b72662014-03-02 12:37:31 +00006525 verifyFormat("return {arg1, arg2};");
6526 verifyFormat("return {arg1, SomeType{parameter}};");
6527 verifyFormat("int count = set<int>{f(), g(), h()}.size();");
6528 verifyFormat("new T{arg1, arg2};");
6529 verifyFormat("f(MyMap[{composite, key}]);");
6530 verifyFormat("class Class {\n"
6531 " T member = {arg1, arg2};\n"
6532 "};");
6533 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};");
Francois Ferrand5f07f442017-06-19 14:41:21 +00006534 verifyFormat("const struct A a = {.a = 1, .b = 2};");
6535 verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
Daniel Jasper91b032a2014-05-22 12:46:38 +00006536 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");");
6537 verifyFormat("int a = std::is_integral<int>{} + 0;");
Daniel Jaspere5777d22013-05-23 10:15:45 +00006538
Daniel Jasper438059e2014-05-22 12:11:13 +00006539 verifyFormat("int foo(int i) { return fo1{}(i); }");
6540 verifyFormat("int foo(int i) { return fo1{}(i); }");
Daniel Jasper4afc6b32014-06-02 10:57:55 +00006541 verifyFormat("auto i = decltype(x){};");
Daniel Jasper610381f2014-08-26 09:37:52 +00006542 verifyFormat("std::vector<int> v = {1, 0 /* comment */};");
Daniel Jasper168c8aa2014-08-27 11:53:26 +00006543 verifyFormat("Node n{1, Node{1000}, //\n"
6544 " 2};");
Daniel Jasperb812e322015-02-26 11:46:29 +00006545 verifyFormat("Aaaa aaaaaaa{\n"
6546 " {\n"
6547 " aaaa,\n"
6548 " },\n"
6549 "};");
Daniel Jaspercec9ffd2015-05-18 14:12:24 +00006550 verifyFormat("class C : public D {\n"
6551 " SomeClass SC{2};\n"
6552 "};");
Daniel Jasper3c883d12015-05-18 14:49:19 +00006553 verifyFormat("class C : public A {\n"
6554 " class D : public B {\n"
6555 " void f() { int i{2}; }\n"
6556 " };\n"
6557 "};");
Daniel Jasperb86e2722015-08-24 13:23:37 +00006558 verifyFormat("#define A {a, a},");
Daniel Jasper438059e2014-05-22 12:11:13 +00006559
Francois Ferrandd2130f52017-06-30 20:00:02 +00006560 // Binpacking only if there is no trailing comma
6561 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n"
6562 " cccccccccc, dddddddddd};",
6563 getLLVMStyleWithColumns(50));
6564 verifyFormat("const Aaaaaa aaaaa = {\n"
6565 " aaaaaaaaaaa,\n"
6566 " bbbbbbbbbbb,\n"
6567 " ccccccccccc,\n"
6568 " ddddddddddd,\n"
6569 "};", getLLVMStyleWithColumns(50));
6570
Daniel Jaspere4ada022016-12-13 10:05:03 +00006571 // Cases where distinguising braced lists and blocks is hard.
6572 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);");
6573 verifyFormat("void f() {\n"
6574 " return; // comment\n"
6575 "}\n"
6576 "SomeType t;");
6577 verifyFormat("void f() {\n"
6578 " if (a) {\n"
6579 " f();\n"
6580 " }\n"
6581 "}\n"
6582 "SomeType t;");
6583
Daniel Jasper08434342015-05-26 07:26:26 +00006584 // In combination with BinPackArguments = false.
Daniel Jasperae8e0d82014-04-17 11:32:02 +00006585 FormatStyle NoBinPacking = getLLVMStyle();
Daniel Jasper08434342015-05-26 07:26:26 +00006586 NoBinPacking.BinPackArguments = false;
Daniel Jasperae8e0d82014-04-17 11:32:02 +00006587 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n"
6588 " bbbbb,\n"
6589 " ccccc,\n"
6590 " ddddd,\n"
6591 " eeeee,\n"
6592 " ffffff,\n"
6593 " ggggg,\n"
6594 " hhhhhh,\n"
6595 " iiiiii,\n"
6596 " jjjjjj,\n"
6597 " kkkkkk};",
6598 NoBinPacking);
6599 verifyFormat("const Aaaaaa aaaaa = {\n"
6600 " aaaaa,\n"
6601 " bbbbb,\n"
6602 " ccccc,\n"
6603 " ddddd,\n"
6604 " eeeee,\n"
6605 " ffffff,\n"
6606 " ggggg,\n"
6607 " hhhhhh,\n"
6608 " iiiiii,\n"
6609 " jjjjjj,\n"
6610 " kkkkkk,\n"
6611 "};",
6612 NoBinPacking);
Daniel Jasper839922e2014-08-13 08:46:21 +00006613 verifyFormat(
6614 "const Aaaaaa aaaaa = {\n"
6615 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n"
6616 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n"
6617 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n"
6618 "};",
6619 NoBinPacking);
Daniel Jasperae8e0d82014-04-17 11:32:02 +00006620
Chandler Carruthf8b72662014-03-02 12:37:31 +00006621 // FIXME: The alignment of these trailing comments might be bad. Then again,
6622 // this might be utterly useless in real code.
6623 verifyFormat("Constructor::Constructor()\n"
Daniel Jasper64a328e2014-11-11 19:34:57 +00006624 " : some_value{ //\n"
6625 " aaaaaaa, //\n"
6626 " bbbbbbb} {}");
Daniel Jasper5a611392013-12-19 21:41:37 +00006627
Chandler Carruthf8b72662014-03-02 12:37:31 +00006628 // In braced lists, the first comment is always assumed to belong to the
6629 // first element. Thus, it can be moved to the next or previous line as
6630 // appropriate.
6631 EXPECT_EQ("function({// First element:\n"
6632 " 1,\n"
6633 " // Second element:\n"
6634 " 2});",
6635 format("function({\n"
6636 " // First element:\n"
6637 " 1,\n"
6638 " // Second element:\n"
6639 " 2});"));
6640 EXPECT_EQ("std::vector<int> MyNumbers{\n"
6641 " // First element:\n"
6642 " 1,\n"
6643 " // Second element:\n"
6644 " 2};",
6645 format("std::vector<int> MyNumbers{// First element:\n"
6646 " 1,\n"
6647 " // Second element:\n"
6648 " 2};",
6649 getLLVMStyleWithColumns(30)));
Francois Ferrandd2130f52017-06-30 20:00:02 +00006650 // A trailing comma should still lead to an enforced line break and no
6651 // binpacking.
Daniel Jasper64a328e2014-11-11 19:34:57 +00006652 EXPECT_EQ("vector<int> SomeVector = {\n"
6653 " // aaa\n"
Francois Ferrandd2130f52017-06-30 20:00:02 +00006654 " 1,\n"
6655 " 2,\n"
Daniel Jasper64a328e2014-11-11 19:34:57 +00006656 "};",
6657 format("vector<int> SomeVector = { // aaa\n"
6658 " 1, 2, };"));
Daniel Jasper5a611392013-12-19 21:41:37 +00006659
Chandler Carruthf8b72662014-03-02 12:37:31 +00006660 FormatStyle ExtraSpaces = getLLVMStyle();
6661 ExtraSpaces.Cpp11BracedListStyle = false;
6662 ExtraSpaces.ColumnLimit = 75;
6663 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces);
6664 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces);
6665 verifyFormat("f({ 1, 2 });", ExtraSpaces);
6666 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces);
6667 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces);
6668 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces);
6669 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces);
6670 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces);
6671 verifyFormat("return { arg1, arg2 };", ExtraSpaces);
6672 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces);
6673 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces);
6674 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces);
6675 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces);
6676 verifyFormat("class Class {\n"
6677 " T member = { arg1, arg2 };\n"
6678 "};",
6679 ExtraSpaces);
6680 verifyFormat(
6681 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6682 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
6683 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
6684 " bbbbbbbbbbbbbbbbbbbb, bbbbb };",
6685 ExtraSpaces);
6686 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces);
Daniel Jasper610381f2014-08-26 09:37:52 +00006687 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });",
Chandler Carruthf8b72662014-03-02 12:37:31 +00006688 ExtraSpaces);
6689 verifyFormat(
6690 "someFunction(OtherParam,\n"
6691 " BracedList{ // comment 1 (Forcing interesting break)\n"
6692 " param1, param2,\n"
6693 " // comment 2\n"
Daniel Jasper11a0ac62014-12-12 09:40:58 +00006694 " param3, param4 });",
Chandler Carruthf8b72662014-03-02 12:37:31 +00006695 ExtraSpaces);
6696 verifyFormat(
6697 "std::this_thread::sleep_for(\n"
6698 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);",
6699 ExtraSpaces);
Daniel Jasperff8d61362016-12-19 08:40:56 +00006700 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n"
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00006701 " aaaaaaa,\n"
6702 " aaaaaaaaaa,\n"
6703 " aaaaa,\n"
6704 " aaaaaaaaaaaaaaa,\n"
6705 " aaa,\n"
6706 " aaaaaaaaaa,\n"
6707 " a,\n"
6708 " aaaaaaaaaaaaaaaaaaaaa,\n"
6709 " aaaaaaaaaaaa,\n"
6710 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n"
6711 " aaaaaaa,\n"
6712 " a};");
Chandler Carruthf8b72662014-03-02 12:37:31 +00006713 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces);
Francois Ferrand5f07f442017-06-19 14:41:21 +00006714 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces);
6715 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces);
Manuel Klimekab419912013-05-23 09:41:43 +00006716}
6717
Daniel Jasper33b909c2013-10-25 14:29:37 +00006718TEST_F(FormatTest, FormatsBracedListsInColumnLayout) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00006719 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6720 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6721 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6722 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6723 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6724 " 1, 22, 333, 4444, 55555, 666666, 7777777};");
Daniel Jasper731dde92015-05-15 09:41:59 +00006725 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006726 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
Daniel Jasper731dde92015-05-15 09:41:59 +00006727 " 1, 22, 333, 4444, 55555, //\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006728 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6729 " 1, 22, 333, 4444, 55555, 666666, 7777777};");
Daniel Jasper8de9ed02013-08-22 15:00:41 +00006730 verifyFormat(
Chandler Carruthf8b72662014-03-02 12:37:31 +00006731 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6732 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6733 " 1, 22, 333, 4444, 55555, 666666, // comment\n"
6734 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
6735 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
6736 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
6737 " 7777777};");
Daniel Jasper8de9ed02013-08-22 15:00:41 +00006738 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006739 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
6740 " X86::R8, X86::R9, X86::R10, X86::R11, 0};");
Daniel Jasper731dde92015-05-15 09:41:59 +00006741 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
6742 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
6743 " // Separating comment.\n"
6744 " X86::R8, X86::R9, X86::R10, X86::R11, 0};");
6745 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
6746 " // Leading comment\n"
6747 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
6748 " X86::R8, X86::R9, X86::R10, X86::R11, 0};");
Chandler Carruthf8b72662014-03-02 12:37:31 +00006749 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
6750 " 1, 1, 1, 1};",
Daniel Jasper8de9ed02013-08-22 15:00:41 +00006751 getLLVMStyleWithColumns(39));
Chandler Carruthf8b72662014-03-02 12:37:31 +00006752 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
6753 " 1, 1, 1, 1};",
Daniel Jasper8de9ed02013-08-22 15:00:41 +00006754 getLLVMStyleWithColumns(38));
6755 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006756 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};",
6757 getLLVMStyleWithColumns(43));
Daniel Jaspere4c16c72015-05-08 13:51:14 +00006758 verifyFormat(
6759 "static unsigned SomeValues[10][3] = {\n"
6760 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n"
6761 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};");
6762 verifyFormat("static auto fields = new vector<string>{\n"
6763 " \"aaaaaaaaaaaaa\",\n"
6764 " \"aaaaaaaaaaaaa\",\n"
6765 " \"aaaaaaaaaaaa\",\n"
6766 " \"aaaaaaaaaaaaaa\",\n"
6767 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
6768 " \"aaaaaaaaaaaa\",\n"
6769 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
6770 "};");
Daniel Jasperd57843d2015-05-11 13:35:40 +00006771 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};");
6772 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n"
6773 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n"
6774 " 3, cccccccccccccccccccccc};",
6775 getLLVMStyleWithColumns(60));
Daniel Jasperf93551c2013-08-23 10:05:49 +00006776
6777 // Trailing commas.
Daniel Jaspera125d532014-03-21 12:38:57 +00006778 verifyFormat("vector<int> x = {\n"
6779 " 1, 1, 1, 1, 1, 1, 1, 1,\n"
6780 "};",
Daniel Jasperf93551c2013-08-23 10:05:49 +00006781 getLLVMStyleWithColumns(39));
Daniel Jasperb175d572014-04-09 09:53:23 +00006782 verifyFormat("vector<int> x = {\n"
6783 " 1, 1, 1, 1, 1, 1, 1, 1, //\n"
Daniel Jasperf93551c2013-08-23 10:05:49 +00006784 "};",
6785 getLLVMStyleWithColumns(39));
Daniel Jasper610381f2014-08-26 09:37:52 +00006786 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
6787 " 1, 1, 1, 1,\n"
6788 " /**/ /**/};",
Daniel Jasper8863ada2013-08-26 08:10:17 +00006789 getLLVMStyleWithColumns(39));
Daniel Jaspere4c16c72015-05-08 13:51:14 +00006790
Daniel Jasper60c27072015-05-13 08:16:00 +00006791 // Trailing comment in the first line.
6792 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n"
6793 " 1111111111, 2222222222, 33333333333, 4444444444, //\n"
6794 " 111111111, 222222222, 3333333333, 444444444, //\n"
6795 " 11111111, 22222222, 333333333, 44444444};");
Daniel Jasper00fb2a12015-07-15 16:26:47 +00006796 // Trailing comment in the last line.
6797 verifyFormat("int aaaaa[] = {\n"
6798 " 1, 2, 3, // comment\n"
6799 " 4, 5, 6 // comment\n"
6800 "};");
Daniel Jasper60c27072015-05-13 08:16:00 +00006801
Daniel Jaspere4c16c72015-05-08 13:51:14 +00006802 // With nested lists, we should either format one item per line or all nested
6803 // lists one on line.
6804 // FIXME: For some nested lists, we can do better.
Chandler Carruthf8b72662014-03-02 12:37:31 +00006805 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
6806 " {aaaaaaaaaaaaaaaaaaa},\n"
6807 " {aaaaaaaaaaaaaaaaaaaaa},\n"
6808 " {aaaaaaaaaaaaaaaaa}};",
Daniel Jaspercb3f0ed2013-08-27 08:43:47 +00006809 getLLVMStyleWithColumns(60));
Daniel Jasper63af7c42013-12-09 14:40:19 +00006810 verifyFormat(
6811 "SomeStruct my_struct_array = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006812 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n"
6813 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n"
6814 " {aaa, aaa},\n"
6815 " {aaa, aaa},\n"
6816 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n"
6817 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n"
6818 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};");
Daniel Jasper01603472014-01-09 13:42:56 +00006819
6820 // No column layout should be used here.
Francois Ferrandd2130f52017-06-30 20:00:02 +00006821 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006822 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};");
Daniel Jasper20e8c3b2015-01-19 10:51:42 +00006823
6824 verifyNoCrash("a<,");
Daniel Jasperabd1f572016-03-02 22:44:03 +00006825
Daniel Jaspereb65e912015-12-21 18:31:15 +00006826 // No braced initializer here.
6827 verifyFormat("void f() {\n"
6828 " struct Dummy {};\n"
6829 " f(v);\n"
6830 "}");
Daniel Jasper55582072016-01-04 07:30:44 +00006831
6832 // Long lists should be formatted in columns even if they are nested.
6833 verifyFormat(
6834 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6835 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6836 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6837 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6838 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6839 " 1, 22, 333, 4444, 55555, 666666, 7777777});");
Daniel Jaspere6169662016-12-19 07:26:11 +00006840
6841 // Allow "single-column" layout even if that violates the column limit. There
6842 // isn't going to be a better way.
6843 verifyFormat("std::vector<int> a = {\n"
6844 " aaaaaaaa,\n"
6845 " aaaaaaaa,\n"
6846 " aaaaaaaa,\n"
6847 " aaaaaaaa,\n"
6848 " aaaaaaaaaa,\n"
6849 " aaaaaaaa,\n"
6850 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};",
6851 getLLVMStyleWithColumns(30));
Daniel Jasper083d1702016-12-21 17:02:06 +00006852 verifyFormat("vector<int> aaaa = {\n"
6853 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6854 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6855 " aaaaaa.aaaaaaa,\n"
6856 " aaaaaa.aaaaaaa,\n"
6857 " aaaaaa.aaaaaaa,\n"
6858 " aaaaaa.aaaaaaa,\n"
6859 "};");
Daniel Jasperd1a9d8acd2017-01-12 19:35:26 +00006860
6861 // Don't create hanging lists.
Daniel Jasper21f7dea2017-02-01 09:23:39 +00006862 verifyFormat("someFunction(Param, {List1, List2,\n"
6863 " List3});",
6864 getLLVMStyleWithColumns(35));
6865 verifyFormat("someFunction(Param, Param,\n"
Daniel Jasperd1a9d8acd2017-01-12 19:35:26 +00006866 " {List1, List2,\n"
6867 " List3});",
6868 getLLVMStyleWithColumns(35));
Daniel Jaspere3710102017-01-12 20:06:28 +00006869 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n"
6870 " aaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper8de9ed02013-08-22 15:00:41 +00006871}
6872
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00006873TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00006874 FormatStyle DoNotMerge = getLLVMStyle();
Daniel Jasperd74cf402014-04-08 12:46:38 +00006875 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00006876
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00006877 verifyFormat("void f() { return 42; }");
6878 verifyFormat("void f() {\n"
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00006879 " return 42;\n"
6880 "}",
6881 DoNotMerge);
6882 verifyFormat("void f() {\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00006883 " // Comment\n"
6884 "}");
6885 verifyFormat("{\n"
6886 "#error {\n"
6887 " int a;\n"
6888 "}");
6889 verifyFormat("{\n"
6890 " int a;\n"
6891 "#error {\n"
6892 "}");
Daniel Jasperf9eb9b12013-05-16 10:17:39 +00006893 verifyFormat("void f() {} // comment");
6894 verifyFormat("void f() { int a; } // comment");
Daniel Jasper92716502013-05-16 16:54:34 +00006895 verifyFormat("void f() {\n"
6896 "} // comment",
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00006897 DoNotMerge);
6898 verifyFormat("void f() {\n"
6899 " int a;\n"
6900 "} // comment",
6901 DoNotMerge);
6902 verifyFormat("void f() {\n"
6903 "} // comment",
Daniel Jasper92716502013-05-16 16:54:34 +00006904 getLLVMStyleWithColumns(15));
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00006905
6906 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
6907 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22));
6908
6909 verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
6910 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
Alexander Kornienko06dd15a2013-12-04 13:58:27 +00006911 verifyFormat("class C {\n"
6912 " C()\n"
6913 " : iiiiiiii(nullptr),\n"
6914 " kkkkkkk(nullptr),\n"
6915 " mmmmmmm(nullptr),\n"
6916 " nnnnnnn(nullptr) {}\n"
6917 "};",
6918 getGoogleStyle());
Alexander Kornienko31e95542013-12-04 12:21:08 +00006919
6920 FormatStyle NoColumnLimit = getLLVMStyle();
6921 NoColumnLimit.ColumnLimit = 0;
6922 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));
6923 EXPECT_EQ("class C {\n"
6924 " A() : b(0) {}\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00006925 "};",
6926 format("class C{A():b(0){}};", NoColumnLimit));
Alexander Kornienko31e95542013-12-04 12:21:08 +00006927 EXPECT_EQ("A()\n"
6928 " : b(0) {\n"
6929 "}",
6930 format("A()\n:b(0)\n{\n}", NoColumnLimit));
6931
6932 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit;
Daniel Jasperd74cf402014-04-08 12:46:38 +00006933 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine =
6934 FormatStyle::SFS_None;
Alexander Kornienko31e95542013-12-04 12:21:08 +00006935 EXPECT_EQ("A()\n"
6936 " : b(0) {\n"
6937 "}",
6938 format("A():b(0){}", DoNotMergeNoColumnLimit));
6939 EXPECT_EQ("A()\n"
6940 " : b(0) {\n"
6941 "}",
6942 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit));
Daniel Jasper64989962014-02-07 13:45:27 +00006943
6944 verifyFormat("#define A \\\n"
6945 " void f() { \\\n"
6946 " int i; \\\n"
6947 " }",
6948 getLLVMStyleWithColumns(20));
6949 verifyFormat("#define A \\\n"
6950 " void f() { int i; }",
6951 getLLVMStyleWithColumns(21));
6952 verifyFormat("#define A \\\n"
6953 " void f() { \\\n"
6954 " int i; \\\n"
6955 " } \\\n"
6956 " int j;",
6957 getLLVMStyleWithColumns(22));
6958 verifyFormat("#define A \\\n"
6959 " void f() { int i; } \\\n"
6960 " int j;",
6961 getLLVMStyleWithColumns(23));
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00006962}
6963
Francois Ferrand2a81ca82017-06-13 07:02:43 +00006964TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) {
6965 FormatStyle MergeEmptyOnly = getLLVMStyle();
6966 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
6967 verifyFormat("class C {\n"
6968 " int f() {}\n"
6969 "};",
6970 MergeEmptyOnly);
6971 verifyFormat("class C {\n"
6972 " int f() {\n"
6973 " return 42;\n"
6974 " }\n"
6975 "};",
6976 MergeEmptyOnly);
6977 verifyFormat("int f() {}", MergeEmptyOnly);
6978 verifyFormat("int f() {\n"
6979 " return 42;\n"
6980 "}",
6981 MergeEmptyOnly);
6982
6983 // Also verify behavior when BraceWrapping.AfterFunction = true
6984 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
6985 MergeEmptyOnly.BraceWrapping.AfterFunction = true;
6986 verifyFormat("int f() {}", MergeEmptyOnly);
6987 verifyFormat("class C {\n"
6988 " int f() {}\n"
6989 "};",
6990 MergeEmptyOnly);
6991}
6992
Daniel Jasperd74cf402014-04-08 12:46:38 +00006993TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) {
6994 FormatStyle MergeInlineOnly = getLLVMStyle();
6995 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
6996 verifyFormat("class C {\n"
6997 " int f() { return 42; }\n"
6998 "};",
6999 MergeInlineOnly);
7000 verifyFormat("int f() {\n"
7001 " return 42;\n"
7002 "}",
7003 MergeInlineOnly);
Francois Ferrand2a81ca82017-06-13 07:02:43 +00007004
7005 // SFS_Inline implies SFS_Empty
7006 verifyFormat("class C {\n"
7007 " int f() {}\n"
7008 "};",
7009 MergeInlineOnly);
7010 verifyFormat("int f() {}", MergeInlineOnly);
7011
7012 // Also verify behavior when BraceWrapping.AfterFunction = true
7013 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
7014 MergeInlineOnly.BraceWrapping.AfterFunction = true;
7015 verifyFormat("class C {\n"
7016 " int f() { return 42; }\n"
7017 "};",
7018 MergeInlineOnly);
7019 verifyFormat("int f()\n"
7020 "{\n"
7021 " return 42;\n"
7022 "}",
7023 MergeInlineOnly);
7024
7025 // SFS_Inline implies SFS_Empty
7026 verifyFormat("int f() {}", MergeInlineOnly);
7027 verifyFormat("class C {\n"
7028 " int f() {}\n"
7029 "};",
7030 MergeInlineOnly);
7031}
7032
Francois Ferrandd3f0e3d2017-06-21 13:56:02 +00007033TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) {
7034 FormatStyle MergeInlineOnly = getLLVMStyle();
7035 MergeInlineOnly.AllowShortFunctionsOnASingleLine =
7036 FormatStyle::SFS_InlineOnly;
7037 verifyFormat("class C {\n"
7038 " int f() { return 42; }\n"
7039 "};",
7040 MergeInlineOnly);
7041 verifyFormat("int f() {\n"
7042 " return 42;\n"
7043 "}",
7044 MergeInlineOnly);
7045
7046 // SFS_InlineOnly does not imply SFS_Empty
7047 verifyFormat("class C {\n"
7048 " int f() {}\n"
7049 "};",
7050 MergeInlineOnly);
7051 verifyFormat("int f() {\n"
7052 "}",
7053 MergeInlineOnly);
7054
7055 // Also verify behavior when BraceWrapping.AfterFunction = true
7056 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
7057 MergeInlineOnly.BraceWrapping.AfterFunction = true;
7058 verifyFormat("class C {\n"
7059 " int f() { return 42; }\n"
7060 "};",
7061 MergeInlineOnly);
7062 verifyFormat("int f()\n"
7063 "{\n"
7064 " return 42;\n"
7065 "}",
7066 MergeInlineOnly);
7067
7068 // SFS_InlineOnly does not imply SFS_Empty
7069 verifyFormat("int f()\n"
7070 "{\n"
7071 "}",
7072 MergeInlineOnly);
7073 verifyFormat("class C {\n"
7074 " int f() {}\n"
7075 "};",
7076 MergeInlineOnly);
7077}
7078
Francois Ferrandad722562017-06-30 20:25:55 +00007079TEST_F(FormatTest, SplitEmptyFunction) {
Francois Ferrand2a81ca82017-06-13 07:02:43 +00007080 FormatStyle Style = getLLVMStyle();
7081 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
7082 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
7083 Style.BraceWrapping.AfterFunction = true;
Francois Ferrandad722562017-06-30 20:25:55 +00007084 Style.BraceWrapping.SplitEmptyFunction = false;
Francois Ferrand2a81ca82017-06-13 07:02:43 +00007085 Style.ColumnLimit = 40;
7086
7087 verifyFormat("int f()\n"
7088 "{}",
7089 Style);
7090 verifyFormat("int f()\n"
7091 "{\n"
7092 " return 42;\n"
7093 "}",
7094 Style);
7095 verifyFormat("int f()\n"
7096 "{\n"
7097 " // some comment\n"
7098 "}",
7099 Style);
7100
7101 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
7102 verifyFormat("int f() {}", Style);
7103 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
7104 "{}",
7105 Style);
7106 verifyFormat("int f()\n"
7107 "{\n"
7108 " return 0;\n"
7109 "}",
7110 Style);
7111
7112 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
7113 verifyFormat("class Foo {\n"
7114 " int f() {}\n"
7115 "};\n",
7116 Style);
7117 verifyFormat("class Foo {\n"
7118 " int f() { return 0; }\n"
7119 "};\n",
7120 Style);
7121 verifyFormat("class Foo {\n"
7122 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
7123 " {}\n"
7124 "};\n",
7125 Style);
7126 verifyFormat("class Foo {\n"
7127 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
7128 " {\n"
7129 " return 0;\n"
7130 " }\n"
7131 "};\n",
7132 Style);
7133
7134 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
7135 verifyFormat("int f() {}", Style);
7136 verifyFormat("int f() { return 0; }", Style);
7137 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
7138 "{}",
7139 Style);
7140 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
7141 "{\n"
7142 " return 0;\n"
7143 "}",
7144 Style);
Daniel Jasperd74cf402014-04-08 12:46:38 +00007145}
Krasimir Georgiev6a1c9d52017-10-02 15:53:37 +00007146TEST_F(FormatTest, KeepShortFunctionAfterPPElse) {
7147 FormatStyle Style = getLLVMStyle();
7148 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
7149 verifyFormat("#ifdef A\n"
7150 "int f() {}\n"
7151 "#else\n"
7152 "int g() {}\n"
7153 "#endif",
7154 Style);
7155}
Daniel Jasperd74cf402014-04-08 12:46:38 +00007156
Francois Ferrandad722562017-06-30 20:25:55 +00007157TEST_F(FormatTest, SplitEmptyClass) {
7158 FormatStyle Style = getLLVMStyle();
7159 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
7160 Style.BraceWrapping.AfterClass = true;
7161 Style.BraceWrapping.SplitEmptyRecord = false;
7162
7163 verifyFormat("class Foo\n"
7164 "{};",
7165 Style);
7166 verifyFormat("/* something */ class Foo\n"
7167 "{};",
7168 Style);
7169 verifyFormat("template <typename X> class Foo\n"
7170 "{};",
7171 Style);
7172 verifyFormat("class Foo\n"
7173 "{\n"
7174 " Foo();\n"
7175 "};",
7176 Style);
7177 verifyFormat("typedef class Foo\n"
7178 "{\n"
7179 "} Foo_t;",
7180 Style);
7181}
7182
7183TEST_F(FormatTest, SplitEmptyStruct) {
7184 FormatStyle Style = getLLVMStyle();
7185 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
7186 Style.BraceWrapping.AfterStruct = true;
7187 Style.BraceWrapping.SplitEmptyRecord = false;
7188
7189 verifyFormat("struct Foo\n"
7190 "{};",
7191 Style);
7192 verifyFormat("/* something */ struct Foo\n"
7193 "{};",
7194 Style);
7195 verifyFormat("template <typename X> struct Foo\n"
7196 "{};",
7197 Style);
7198 verifyFormat("struct Foo\n"
7199 "{\n"
7200 " Foo();\n"
7201 "};",
7202 Style);
7203 verifyFormat("typedef struct Foo\n"
7204 "{\n"
7205 "} Foo_t;",
7206 Style);
7207 //typedef struct Bar {} Bar_t;
7208}
7209
7210TEST_F(FormatTest, SplitEmptyUnion) {
7211 FormatStyle Style = getLLVMStyle();
7212 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
7213 Style.BraceWrapping.AfterUnion = true;
7214 Style.BraceWrapping.SplitEmptyRecord = false;
7215
7216 verifyFormat("union Foo\n"
7217 "{};",
7218 Style);
7219 verifyFormat("/* something */ union Foo\n"
7220 "{};",
7221 Style);
7222 verifyFormat("union Foo\n"
7223 "{\n"
7224 " A,\n"
7225 "};",
7226 Style);
7227 verifyFormat("typedef union Foo\n"
7228 "{\n"
7229 "} Foo_t;",
7230 Style);
7231}
7232
7233TEST_F(FormatTest, SplitEmptyNamespace) {
7234 FormatStyle Style = getLLVMStyle();
7235 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
7236 Style.BraceWrapping.AfterNamespace = true;
7237 Style.BraceWrapping.SplitEmptyNamespace = false;
7238
7239 verifyFormat("namespace Foo\n"
7240 "{};",
7241 Style);
7242 verifyFormat("/* something */ namespace Foo\n"
7243 "{};",
7244 Style);
7245 verifyFormat("inline namespace Foo\n"
7246 "{};",
7247 Style);
7248 verifyFormat("namespace Foo\n"
7249 "{\n"
7250 "void Bar();\n"
7251 "};",
7252 Style);
7253}
7254
7255TEST_F(FormatTest, NeverMergeShortRecords) {
7256 FormatStyle Style = getLLVMStyle();
7257
7258 verifyFormat("class Foo {\n"
7259 " Foo();\n"
7260 "};",
7261 Style);
7262 verifyFormat("typedef class Foo {\n"
7263 " Foo();\n"
7264 "} Foo_t;",
7265 Style);
7266 verifyFormat("struct Foo {\n"
7267 " Foo();\n"
7268 "};",
7269 Style);
7270 verifyFormat("typedef struct Foo {\n"
7271 " Foo();\n"
7272 "} Foo_t;",
7273 Style);
7274 verifyFormat("union Foo {\n"
7275 " A,\n"
7276 "};",
7277 Style);
7278 verifyFormat("typedef union Foo {\n"
7279 " A,\n"
7280 "} Foo_t;",
7281 Style);
7282 verifyFormat("namespace Foo {\n"
7283 "void Bar();\n"
7284 "};",
7285 Style);
7286
7287 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
7288 Style.BraceWrapping.AfterClass = true;
7289 Style.BraceWrapping.AfterStruct = true;
7290 Style.BraceWrapping.AfterUnion = true;
7291 Style.BraceWrapping.AfterNamespace = true;
7292 verifyFormat("class Foo\n"
7293 "{\n"
7294 " Foo();\n"
7295 "};",
7296 Style);
7297 verifyFormat("typedef class Foo\n"
7298 "{\n"
7299 " Foo();\n"
7300 "} Foo_t;",
7301 Style);
7302 verifyFormat("struct Foo\n"
7303 "{\n"
7304 " Foo();\n"
7305 "};",
7306 Style);
7307 verifyFormat("typedef struct Foo\n"
7308 "{\n"
7309 " Foo();\n"
7310 "} Foo_t;",
7311 Style);
7312 verifyFormat("union Foo\n"
7313 "{\n"
7314 " A,\n"
7315 "};",
7316 Style);
7317 verifyFormat("typedef union Foo\n"
7318 "{\n"
7319 " A,\n"
7320 "} Foo_t;",
7321 Style);
7322 verifyFormat("namespace Foo\n"
7323 "{\n"
7324 "void Bar();\n"
7325 "};",
7326 Style);
7327}
7328
Manuel Klimeke01bab52013-01-15 13:38:33 +00007329TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
7330 // Elaborate type variable declarations.
Chandler Carruthf8b72662014-03-02 12:37:31 +00007331 verifyFormat("struct foo a = {bar};\nint n;");
7332 verifyFormat("class foo a = {bar};\nint n;");
7333 verifyFormat("union foo a = {bar};\nint n;");
Manuel Klimeke01bab52013-01-15 13:38:33 +00007334
7335 // Elaborate types inside function definitions.
7336 verifyFormat("struct foo f() {}\nint n;");
7337 verifyFormat("class foo f() {}\nint n;");
7338 verifyFormat("union foo f() {}\nint n;");
7339
7340 // Templates.
7341 verifyFormat("template <class X> void f() {}\nint n;");
7342 verifyFormat("template <struct X> void f() {}\nint n;");
7343 verifyFormat("template <union X> void f() {}\nint n;");
7344
7345 // Actual definitions...
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00007346 verifyFormat("struct {\n} n;");
7347 verifyFormat(
7348 "template <template <class T, class Y>, class Z> class X {\n} n;");
Manuel Klimeke01bab52013-01-15 13:38:33 +00007349 verifyFormat("union Z {\n int n;\n} x;");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00007350 verifyFormat("class MACRO Z {\n} n;");
7351 verifyFormat("class MACRO(X) Z {\n} n;");
7352 verifyFormat("class __attribute__(X) Z {\n} n;");
7353 verifyFormat("class __declspec(X) Z {\n} n;");
Manuel Klimekd2650902013-02-06 15:57:54 +00007354 verifyFormat("class A##B##C {\n} n;");
Manuel Klimek91e48582013-10-07 09:15:41 +00007355 verifyFormat("class alignas(16) Z {\n} n;");
Daniel Jasper04785d02015-05-06 14:03:02 +00007356 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;");
7357 verifyFormat("class MACROA MACRO(X) Z {\n} n;");
Manuel Klimeke01bab52013-01-15 13:38:33 +00007358
Manuel Klimek3c6b7c72013-01-21 10:17:14 +00007359 // Redefinition from nested context:
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00007360 verifyFormat("class A::B::C {\n} n;");
Manuel Klimek3c6b7c72013-01-21 10:17:14 +00007361
Manuel Klimekcdee74d2013-01-21 13:58:54 +00007362 // Template definitions.
Daniel Jasper6f05e592013-05-15 13:46:48 +00007363 verifyFormat(
7364 "template <typename F>\n"
7365 "Matcher(const Matcher<F> &Other,\n"
7366 " typename enable_if_c<is_base_of<F, T>::value &&\n"
7367 " !is_same<F, T>::value>::type * = 0)\n"
7368 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
7369
Manuel Klimekcdee74d2013-01-21 13:58:54 +00007370 // FIXME: This is still incorrectly handled at the formatter side.
Daniel Jasper62c0ac02013-07-30 22:37:19 +00007371 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
Daniel Jasper6f2b88a2015-06-05 13:18:09 +00007372 verifyFormat("int i = SomeFunction(a<b, a> b);");
Manuel Klimekcdee74d2013-01-21 13:58:54 +00007373
7374 // FIXME:
7375 // This now gets parsed incorrectly as class definition.
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00007376 // verifyFormat("class A<int> f() {\n}\nint n;");
Manuel Klimekcdee74d2013-01-21 13:58:54 +00007377
Manuel Klimeke01bab52013-01-15 13:38:33 +00007378 // Elaborate types where incorrectly parsing the structural element would
7379 // break the indent.
7380 verifyFormat("if (true)\n"
7381 " class X x;\n"
7382 "else\n"
7383 " f();\n");
Daniel Jasper1a32a612013-03-20 15:12:38 +00007384
7385 // This is simply incomplete. Formatting is not important, but must not crash.
Daniel Jaspercdaffa42013-08-13 10:58:30 +00007386 verifyFormat("class A:");
Manuel Klimekd5e5f8f2013-01-11 18:13:04 +00007387}
7388
Manuel Klimek99c7baa2013-01-15 15:50:27 +00007389TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
Manuel Klimek71814b42013-10-11 21:25:45 +00007390 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n",
7391 format("#error Leave all white!!!!! space* alone!\n"));
7392 EXPECT_EQ(
7393 "#warning Leave all white!!!!! space* alone!\n",
7394 format("#warning Leave all white!!!!! space* alone!\n"));
Manuel Klimek99c7baa2013-01-15 15:50:27 +00007395 EXPECT_EQ("#error 1", format(" # error 1"));
7396 EXPECT_EQ("#warning 1", format(" # warning 1"));
7397}
7398
Daniel Jasper4431aa92013-04-23 13:54:04 +00007399TEST_F(FormatTest, FormatHashIfExpressions) {
Daniel Jasper7cfde412014-01-21 08:56:09 +00007400 verifyFormat("#if AAAA && BBBB");
Daniel Jasperd7884572015-08-14 12:44:06 +00007401 verifyFormat("#if (AAAA && BBBB)");
7402 verifyFormat("#elif (AAAA && BBBB)");
Daniel Jasper4431aa92013-04-23 13:54:04 +00007403 // FIXME: Come up with a better indentation for #elif.
7404 verifyFormat(
7405 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n"
7406 " defined(BBBBBBBB)\n"
7407 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n"
7408 " defined(BBBBBBBB)\n"
7409 "#endif",
7410 getLLVMStyleWithColumns(65));
7411}
7412
Manuel Klimekd3b92fa2013-01-18 14:04:34 +00007413TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
7414 FormatStyle AllowsMergedIf = getGoogleStyle();
7415 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true;
7416 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
7417 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
Manuel Klimekda087612013-01-18 14:46:43 +00007418 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf);
7419 EXPECT_EQ("if (true) return 42;",
7420 format("if (true)\nreturn 42;", AllowsMergedIf));
7421 FormatStyle ShortMergedIf = AllowsMergedIf;
7422 ShortMergedIf.ColumnLimit = 25;
Daniel Jasper6fe2f002013-04-25 08:56:26 +00007423 verifyFormat("#define A \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00007424 " if (true) return 42;",
7425 ShortMergedIf);
Daniel Jasper6fe2f002013-04-25 08:56:26 +00007426 verifyFormat("#define A \\\n"
7427 " f(); \\\n"
Manuel Klimekda087612013-01-18 14:46:43 +00007428 " if (true)\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00007429 "#define B",
7430 ShortMergedIf);
Daniel Jasper6fe2f002013-04-25 08:56:26 +00007431 verifyFormat("#define A \\\n"
7432 " f(); \\\n"
Manuel Klimekda087612013-01-18 14:46:43 +00007433 " if (true)\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00007434 "g();",
7435 ShortMergedIf);
Manuel Klimekd5e782b2013-01-21 14:16:56 +00007436 verifyFormat("{\n"
7437 "#ifdef A\n"
7438 " // Comment\n"
7439 " if (true) continue;\n"
7440 "#endif\n"
7441 " // Comment\n"
Manuel Klimek71814b42013-10-11 21:25:45 +00007442 " if (true) continue;\n"
7443 "}",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00007444 ShortMergedIf);
Daniel Jasper6a7d5a72017-06-19 07:40:49 +00007445 ShortMergedIf.ColumnLimit = 33;
7446 verifyFormat("#define A \\\n"
7447 " if constexpr (true) return 42;",
7448 ShortMergedIf);
Daniel Jasper64989962014-02-07 13:45:27 +00007449 ShortMergedIf.ColumnLimit = 29;
7450 verifyFormat("#define A \\\n"
7451 " if (aaaaaaaaaa) return 1; \\\n"
7452 " return 2;",
7453 ShortMergedIf);
7454 ShortMergedIf.ColumnLimit = 28;
7455 verifyFormat("#define A \\\n"
7456 " if (aaaaaaaaaa) \\\n"
7457 " return 1; \\\n"
7458 " return 2;",
7459 ShortMergedIf);
Daniel Jasper6a7d5a72017-06-19 07:40:49 +00007460 verifyFormat("#define A \\\n"
7461 " if constexpr (aaaaaaa) \\\n"
7462 " return 1; \\\n"
7463 " return 2;",
7464 ShortMergedIf);
Manuel Klimekd3b92fa2013-01-18 14:04:34 +00007465}
7466
Manuel Klimekd33516e2013-01-23 10:09:28 +00007467TEST_F(FormatTest, FormatStarDependingOnContext) {
Manuel Klimek0a3a3c92013-01-23 09:32:48 +00007468 verifyFormat("void f(int *a);");
7469 verifyFormat("void f() { f(fint * b); }");
Manuel Klimek39080572013-01-23 11:03:04 +00007470 verifyFormat("class A {\n void f(int *a);\n};");
7471 verifyFormat("class A {\n int *a;\n};");
7472 verifyFormat("namespace a {\n"
7473 "namespace b {\n"
7474 "class A {\n"
7475 " void f() {}\n"
7476 " int *a;\n"
7477 "};\n"
Krasimir Georgiev9163fe22017-03-02 09:54:44 +00007478 "} // namespace b\n"
7479 "} // namespace a");
Manuel Klimek0a3a3c92013-01-23 09:32:48 +00007480}
7481
Manuel Klimekd33516e2013-01-23 10:09:28 +00007482TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
7483 verifyFormat("while");
7484 verifyFormat("operator");
7485}
7486
Daniel Jasperfda47cd2016-10-31 13:23:00 +00007487TEST_F(FormatTest, SkipsDeeplyNestedLines) {
7488 // This code would be painfully slow to format if we didn't skip it.
7489 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
7490 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
7491 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
7492 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
7493 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
7494 "A(1, 1)\n"
7495 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x
7496 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7497 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7498 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7499 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7500 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7501 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7502 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7503 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7504 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n");
7505 // Deeply nested part is untouched, rest is formatted.
7506 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n",
7507 format(std::string("int i;\n") + Code + "int j;\n",
Krasimir Georgievbcda54b2017-04-21 14:35:20 +00007508 getLLVMStyle(), SC_ExpectIncomplete));
Daniel Jasperfda47cd2016-10-31 13:23:00 +00007509}
7510
Nico Weber7e6a7a12013-01-08 17:56:31 +00007511//===----------------------------------------------------------------------===//
7512// Objective-C tests.
7513//===----------------------------------------------------------------------===//
7514
Fariborz Jahanian68a542a2012-12-20 19:54:13 +00007515TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
7516 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
7517 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
7518 format("-(NSUInteger)indexOfObject:(id)anObject;"));
Daniel Jasper8d1832e2013-01-07 13:26:07 +00007519 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
Fariborz Jahanian68a542a2012-12-20 19:54:13 +00007520 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
7521 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
7522 format("-(NSInteger)Method3:(id)anObject;"));
7523 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
7524 format("-(NSInteger)Method4:(id)anObject;"));
7525 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
7526 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
7527 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
7528 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
Daniel Jaspera44991332015-04-29 13:06:49 +00007529 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "
7530 "forAllCells:(BOOL)flag;",
7531 format("- (void)sendAction:(SEL)aSelector to:(id)anObject "
7532 "forAllCells:(BOOL)flag;"));
Fariborz Jahanian9017ec32012-12-21 22:51:18 +00007533
7534 // Very long objectiveC method declaration.
Daniel Jasper55ca6082015-03-12 22:13:45 +00007535 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
7536 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;");
Daniel Jasper1ac3e052013-02-05 10:07:47 +00007537 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
7538 " inRange:(NSRange)range\n"
7539 " outRange:(NSRange)out_range\n"
7540 " outRange1:(NSRange)out_range1\n"
7541 " outRange2:(NSRange)out_range2\n"
7542 " outRange3:(NSRange)out_range3\n"
7543 " outRange4:(NSRange)out_range4\n"
7544 " outRange5:(NSRange)out_range5\n"
7545 " outRange6:(NSRange)out_range6\n"
7546 " outRange7:(NSRange)out_range7\n"
7547 " outRange8:(NSRange)out_range8\n"
7548 " outRange9:(NSRange)out_range9;");
Nico Weberd6f962f2013-01-10 20:18:33 +00007549
Daniel Jaspera2a4d9c2015-05-13 09:38:25 +00007550 // When the function name has to be wrapped.
7551 FormatStyle Style = getLLVMStyle();
7552 Style.IndentWrappedFunctionNames = false;
7553 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
7554 "veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
7555 " anotherName:(NSString)bbbbbbbbbbbbbb {\n"
7556 "}",
7557 Style);
7558 Style.IndentWrappedFunctionNames = true;
7559 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
7560 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
7561 " anotherName:(NSString)bbbbbbbbbbbbbb {\n"
7562 "}",
7563 Style);
7564
Nico Weberd6f962f2013-01-10 20:18:33 +00007565 verifyFormat("- (int)sum:(vector<int>)numbers;");
Nico Weber772fbfd2013-01-17 06:14:50 +00007566 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
Nico Weberd6f962f2013-01-10 20:18:33 +00007567 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
7568 // protocol lists (but not for template classes):
Daniel Jaspera44991332015-04-29 13:06:49 +00007569 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
Nico Weber9efe2912013-01-10 23:11:41 +00007570
Daniel Jasper37194282013-05-28 08:33:00 +00007571 verifyFormat("- (int (*)())foo:(int (*)())f;");
7572 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
Nico Weber9efe2912013-01-10 23:11:41 +00007573
7574 // If there's no return type (very rare in practice!), LLVM and Google style
7575 // agree.
Daniel Jasperdd9276e2013-03-22 16:55:40 +00007576 verifyFormat("- foo;");
Nico Weber9efe2912013-01-10 23:11:41 +00007577 verifyFormat("- foo:(int)f;");
7578 verifyGoogleFormat("- foo:(int)foo;");
Fariborz Jahanian68a542a2012-12-20 19:54:13 +00007579}
7580
Nico Weber0588b502013-02-07 00:19:29 +00007581
Alexander Kornienko64a42b82014-04-15 14:52:43 +00007582TEST_F(FormatTest, BreaksStringLiterals) {
Manuel Klimek1998ea22013-02-20 10:15:13 +00007583 EXPECT_EQ("\"some text \"\n"
7584 "\"other\";",
7585 format("\"some text other\";", getLLVMStyleWithColumns(12)));
Alexander Kornienko9e90b622013-04-17 17:34:05 +00007586 EXPECT_EQ("\"some text \"\n"
7587 "\"other\";",
7588 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
Manuel Klimek1998ea22013-02-20 10:15:13 +00007589 EXPECT_EQ(
7590 "#define A \\\n"
7591 " \"some \" \\\n"
7592 " \"text \" \\\n"
7593 " \"other\";",
7594 format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
7595 EXPECT_EQ(
7596 "#define A \\\n"
7597 " \"so \" \\\n"
7598 " \"text \" \\\n"
7599 " \"other\";",
7600 format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
7601
7602 EXPECT_EQ("\"some text\"",
7603 format("\"some text\"", getLLVMStyleWithColumns(1)));
7604 EXPECT_EQ("\"some text\"",
7605 format("\"some text\"", getLLVMStyleWithColumns(11)));
7606 EXPECT_EQ("\"some \"\n"
7607 "\"text\"",
7608 format("\"some text\"", getLLVMStyleWithColumns(10)));
7609 EXPECT_EQ("\"some \"\n"
7610 "\"text\"",
7611 format("\"some text\"", getLLVMStyleWithColumns(7)));
Manuel Klimekb176cff2013-03-01 13:14:08 +00007612 EXPECT_EQ("\"some\"\n"
Alexander Kornienkocb45bc12013-04-15 14:28:00 +00007613 "\" tex\"\n"
7614 "\"t\"",
Manuel Klimek1998ea22013-02-20 10:15:13 +00007615 format("\"some text\"", getLLVMStyleWithColumns(6)));
Manuel Klimekabf6e032013-03-04 20:03:38 +00007616 EXPECT_EQ("\"some\"\n"
7617 "\" tex\"\n"
7618 "\" and\"",
7619 format("\"some tex and\"", getLLVMStyleWithColumns(6)));
7620 EXPECT_EQ("\"some\"\n"
7621 "\"/tex\"\n"
7622 "\"/and\"",
7623 format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
Manuel Klimek1998ea22013-02-20 10:15:13 +00007624
7625 EXPECT_EQ("variable =\n"
7626 " \"long string \"\n"
7627 " \"literal\";",
7628 format("variable = \"long string literal\";",
7629 getLLVMStyleWithColumns(20)));
7630
7631 EXPECT_EQ("variable = f(\n"
7632 " \"long string \"\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00007633 " \"literal\",\n"
7634 " short,\n"
Manuel Klimek1998ea22013-02-20 10:15:13 +00007635 " loooooooooooooooooooong);",
7636 format("variable = f(\"long string literal\", short, "
7637 "loooooooooooooooooooong);",
7638 getLLVMStyleWithColumns(20)));
Alexander Kornienko4d26b6e2013-06-17 12:59:44 +00007639
Daniel Jaspera44991332015-04-29 13:06:49 +00007640 EXPECT_EQ(
7641 "f(g(\"long string \"\n"
7642 " \"literal\"),\n"
7643 " b);",
7644 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20)));
Alexander Kornienko4d26b6e2013-06-17 12:59:44 +00007645 EXPECT_EQ("f(g(\"long string \"\n"
7646 " \"literal\",\n"
7647 " a),\n"
7648 " b);",
7649 format("f(g(\"long string literal\", a), b);",
7650 getLLVMStyleWithColumns(20)));
Manuel Klimek1998ea22013-02-20 10:15:13 +00007651 EXPECT_EQ(
7652 "f(\"one two\".split(\n"
Daniel Jasperf79b0b12013-08-30 08:29:25 +00007653 " variable));",
Manuel Klimek1998ea22013-02-20 10:15:13 +00007654 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
7655 EXPECT_EQ("f(\"one two three four five six \"\n"
7656 " \"seven\".split(\n"
7657 " really_looooong_variable));",
7658 format("f(\"one two three four five six seven\"."
7659 "split(really_looooong_variable));",
7660 getLLVMStyleWithColumns(33)));
7661
7662 EXPECT_EQ("f(\"some \"\n"
7663 " \"text\",\n"
7664 " other);",
7665 format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
Daniel Jasper5497fce2013-02-26 12:52:34 +00007666
7667 // Only break as a last resort.
7668 verifyFormat(
7669 "aaaaaaaaaaaaaaaaaaaa(\n"
7670 " aaaaaaaaaaaaaaaaaaaa,\n"
7671 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
Manuel Klimekb176cff2013-03-01 13:14:08 +00007672
Daniel Jaspera44991332015-04-29 13:06:49 +00007673 EXPECT_EQ("\"splitmea\"\n"
7674 "\"trandomp\"\n"
7675 "\"oint\"",
7676 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
Manuel Klimeke317d1b2013-03-01 13:29:19 +00007677
Daniel Jaspera44991332015-04-29 13:06:49 +00007678 EXPECT_EQ("\"split/\"\n"
7679 "\"pathat/\"\n"
7680 "\"slashes\"",
7681 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
Daniel Jasper6fe2f002013-04-25 08:56:26 +00007682
Daniel Jaspera44991332015-04-29 13:06:49 +00007683 EXPECT_EQ("\"split/\"\n"
7684 "\"pathat/\"\n"
7685 "\"slashes\"",
7686 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
Alexander Kornienko72852072013-06-19 14:22:47 +00007687 EXPECT_EQ("\"split at \"\n"
7688 "\"spaces/at/\"\n"
7689 "\"slashes.at.any$\"\n"
7690 "\"non-alphanumeric%\"\n"
7691 "\"1111111111characte\"\n"
7692 "\"rs\"",
7693 format("\"split at "
7694 "spaces/at/"
7695 "slashes.at."
7696 "any$non-"
7697 "alphanumeric%"
7698 "1111111111characte"
7699 "rs\"",
7700 getLLVMStyleWithColumns(20)));
7701
Daniel Jasper5aad4e52013-07-12 11:37:05 +00007702 // Verify that splitting the strings understands
7703 // Style::AlwaysBreakBeforeMultilineStrings.
Daniel Jasper2aaedd32015-06-18 09:12:47 +00007704 EXPECT_EQ(
7705 "aaaaaaaaaaaa(\n"
7706 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
7707 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
7708 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
7709 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
7710 "aaaaaaaaaaaaaaaaaaaaaa\");",
7711 getGoogleStyle()));
Daniel Jasper2436fe92013-10-18 16:47:55 +00007712 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
7713 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",
7714 format("return \"aaaaaaaaaaaaaaaaaaaaaa "
7715 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
7716 "aaaaaaaaaaaaaaaaaaaaaa\";",
7717 getGoogleStyle()));
Daniel Jasper3dcd7ec2013-08-02 11:01:15 +00007718 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
7719 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
7720 format("llvm::outs() << "
7721 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
7722 "aaaaaaaaaaaaaaaaaaa\";"));
Daniel Jasperf438cb72013-08-23 11:57:34 +00007723 EXPECT_EQ("ffff(\n"
7724 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
7725 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
7726 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
7727 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
7728 getGoogleStyle()));
Daniel Jasper5aad4e52013-07-12 11:37:05 +00007729
Daniel Jaspere1a7b762016-02-01 11:21:02 +00007730 FormatStyle Style = getLLVMStyleWithColumns(12);
7731 Style.BreakStringLiterals = false;
7732 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style));
7733
Daniel Jasper6fe2f002013-04-25 08:56:26 +00007734 FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +00007735 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
Daniel Jaspera44991332015-04-29 13:06:49 +00007736 EXPECT_EQ("#define A \\\n"
7737 " \"some \" \\\n"
7738 " \"text \" \\\n"
7739 " \"other\";",
7740 format("#define A \"some text other\";", AlignLeft));
Manuel Klimek1998ea22013-02-20 10:15:13 +00007741}
7742
Manuel Klimek93699f42017-11-29 14:29:43 +00007743TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) {
7744 EXPECT_EQ("C a = \"some more \"\n"
7745 " \"text\";",
7746 format("C a = \"some more text\";", getLLVMStyleWithColumns(18)));
7747}
7748
Manuel Klimek9e321992015-07-28 15:50:24 +00007749TEST_F(FormatTest, FullyRemoveEmptyLines) {
7750 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80);
7751 NoEmptyLines.MaxEmptyLinesToKeep = 0;
7752 EXPECT_EQ("int i = a(b());",
7753 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines));
7754}
7755
Alexander Kornienko64a42b82014-04-15 14:52:43 +00007756TEST_F(FormatTest, BreaksStringLiteralsWithTabs) {
7757 EXPECT_EQ(
7758 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
7759 "(\n"
7760 " \"x\t\");",
7761 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
7762 "aaaaaaa("
7763 "\"x\t\");"));
7764}
7765
Daniel Jasper174b0122014-01-09 14:18:12 +00007766TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {
Alexander Kornienko81e32942013-09-16 20:20:49 +00007767 EXPECT_EQ(
7768 "u8\"utf8 string \"\n"
7769 "u8\"literal\";",
7770 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
7771 EXPECT_EQ(
7772 "u\"utf16 string \"\n"
7773 "u\"literal\";",
7774 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
7775 EXPECT_EQ(
7776 "U\"utf32 string \"\n"
7777 "U\"literal\";",
7778 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
7779 EXPECT_EQ("L\"wide string \"\n"
7780 "L\"literal\";",
7781 format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
Daniel Jasper174b0122014-01-09 14:18:12 +00007782 EXPECT_EQ("@\"NSString \"\n"
7783 "@\"literal\";",
Daniel Jasperd07c2ee2014-01-14 09:53:07 +00007784 format("@\"NSString literal\";", getGoogleStyleWithColumns(19)));
Alexander Kornienkod4fa2e62017-04-11 09:55:00 +00007785 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26));
Daniel Jaspere4b48c62015-01-21 19:50:35 +00007786
7787 // This input makes clang-format try to split the incomplete unicode escape
7788 // sequence, which used to lead to a crasher.
7789 verifyNoCrash(
7790 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
7791 getLLVMStyleWithColumns(60));
Alexander Kornienko81e32942013-09-16 20:20:49 +00007792}
7793
Alexander Kornienko732b6bd2014-12-14 20:47:11 +00007794TEST_F(FormatTest, DoesNotBreakRawStringLiterals) {
7795 FormatStyle Style = getGoogleStyleWithColumns(15);
7796 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style));
7797 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style));
7798 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style));
7799 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style));
7800 EXPECT_EQ("u8R\"x(raw literal)x\";",
7801 format("u8R\"x(raw literal)x\";", Style));
Alexander Kornienko81e32942013-09-16 20:20:49 +00007802}
7803
7804TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
7805 FormatStyle Style = getLLVMStyleWithColumns(20);
7806 EXPECT_EQ(
7807 "_T(\"aaaaaaaaaaaaaa\")\n"
7808 "_T(\"aaaaaaaaaaaaaa\")\n"
7809 "_T(\"aaaaaaaaaaaa\")",
7810 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
Krasimir Georgievbc05eba2017-03-08 12:54:50 +00007811 EXPECT_EQ("f(x,\n"
7812 " _T(\"aaaaaaaaaaaa\")\n"
7813 " _T(\"aaa\"),\n"
Alexander Kornienko81e32942013-09-16 20:20:49 +00007814 " z);",
7815 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
7816
7817 // FIXME: Handle embedded spaces in one iteration.
7818 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
7819 // "_T(\"aaaaaaaaaaaaa\")\n"
7820 // "_T(\"aaaaaaaaaaaaa\")\n"
7821 // "_T(\"a\")",
7822 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
7823 // getLLVMStyleWithColumns(20)));
7824 EXPECT_EQ(
7825 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
7826 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
Daniel Jaspere99c72f2015-03-26 14:47:35 +00007827 EXPECT_EQ("f(\n"
7828 "#if !TEST\n"
7829 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
7830 "#endif\n"
Martin Probst2c1cdae2017-05-15 11:15:29 +00007831 ");",
Daniel Jaspere99c72f2015-03-26 14:47:35 +00007832 format("f(\n"
7833 "#if !TEST\n"
7834 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
7835 "#endif\n"
7836 ");"));
7837 EXPECT_EQ("f(\n"
7838 "\n"
7839 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));",
7840 format("f(\n"
7841 "\n"
7842 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));"));
Alexander Kornienko81e32942013-09-16 20:20:49 +00007843}
7844
Krasimir Georgievbc05eba2017-03-08 12:54:50 +00007845TEST_F(FormatTest, BreaksStringLiteralOperands) {
7846 // In a function call with two operands, the second can be broken with no line
7847 // break before it.
7848 EXPECT_EQ("func(a, \"long long \"\n"
7849 " \"long long\");",
7850 format("func(a, \"long long long long\");",
7851 getLLVMStyleWithColumns(24)));
7852 // In a function call with three operands, the second must be broken with a
7853 // line break before it.
7854 EXPECT_EQ("func(a,\n"
7855 " \"long long long \"\n"
7856 " \"long\",\n"
7857 " c);",
7858 format("func(a, \"long long long long\", c);",
7859 getLLVMStyleWithColumns(24)));
7860 // In a function call with three operands, the third must be broken with a
7861 // line break before it.
7862 EXPECT_EQ("func(a, b,\n"
7863 " \"long long long \"\n"
7864 " \"long\");",
7865 format("func(a, b, \"long long long long\");",
7866 getLLVMStyleWithColumns(24)));
7867 // In a function call with three operands, both the second and the third must
7868 // be broken with a line break before them.
7869 EXPECT_EQ("func(a,\n"
7870 " \"long long long \"\n"
7871 " \"long\",\n"
7872 " \"long long long \"\n"
7873 " \"long\");",
7874 format("func(a, \"long long long long\", \"long long long long\");",
7875 getLLVMStyleWithColumns(24)));
7876 // In a chain of << with two operands, the second can be broken with no line
7877 // break before it.
7878 EXPECT_EQ("a << \"line line \"\n"
7879 " \"line\";",
7880 format("a << \"line line line\";",
7881 getLLVMStyleWithColumns(20)));
7882 // In a chain of << with three operands, the second can be broken with no line
7883 // break before it.
7884 EXPECT_EQ("abcde << \"line \"\n"
7885 " \"line line\"\n"
7886 " << c;",
7887 format("abcde << \"line line line\" << c;",
7888 getLLVMStyleWithColumns(20)));
7889 // In a chain of << with three operands, the third must be broken with a line
7890 // break before it.
7891 EXPECT_EQ("a << b\n"
7892 " << \"line line \"\n"
7893 " \"line\";",
7894 format("a << b << \"line line line\";",
7895 getLLVMStyleWithColumns(20)));
7896 // In a chain of << with three operands, the second can be broken with no line
7897 // break before it and the third must be broken with a line break before it.
7898 EXPECT_EQ("abcd << \"line line \"\n"
7899 " \"line\"\n"
7900 " << \"line line \"\n"
7901 " \"line\";",
7902 format("abcd << \"line line line\" << \"line line line\";",
7903 getLLVMStyleWithColumns(20)));
7904 // In a chain of binary operators with two operands, the second can be broken
7905 // with no line break before it.
7906 EXPECT_EQ("abcd + \"line line \"\n"
7907 " \"line line\";",
7908 format("abcd + \"line line line line\";",
7909 getLLVMStyleWithColumns(20)));
7910 // In a chain of binary operators with three operands, the second must be
7911 // broken with a line break before it.
7912 EXPECT_EQ("abcd +\n"
7913 " \"line line \"\n"
7914 " \"line line\" +\n"
7915 " e;",
7916 format("abcd + \"line line line line\" + e;",
7917 getLLVMStyleWithColumns(20)));
7918 // In a function call with two operands, with AlignAfterOpenBracket enabled,
7919 // the first must be broken with a line break before it.
7920 FormatStyle Style = getLLVMStyleWithColumns(25);
7921 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7922 EXPECT_EQ("someFunction(\n"
7923 " \"long long long \"\n"
7924 " \"long\",\n"
7925 " a);",
7926 format("someFunction(\"long long long long\", a);", Style));
7927}
7928
Alexander Kornienko657c67b2013-07-16 21:06:13 +00007929TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
Alexander Kornienkod7b837e2013-08-29 17:32:57 +00007930 EXPECT_EQ(
7931 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
7932 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
7933 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
7934 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
7935 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
7936 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
7937}
7938
7939TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
7940 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
Daniel Jasperc39b56f2013-12-16 07:23:08 +00007941 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle()));
Alexander Kornienkod7b837e2013-08-29 17:32:57 +00007942 EXPECT_EQ("fffffffffff(g(R\"x(\n"
7943 "multiline raw string literal xxxxxxxxxxxxxx\n"
7944 ")x\",\n"
7945 " a),\n"
7946 " b);",
7947 format("fffffffffff(g(R\"x(\n"
7948 "multiline raw string literal xxxxxxxxxxxxxx\n"
7949 ")x\", a), b);",
7950 getGoogleStyleWithColumns(20)));
7951 EXPECT_EQ("fffffffffff(\n"
7952 " g(R\"x(qqq\n"
7953 "multiline raw string literal xxxxxxxxxxxxxx\n"
7954 ")x\",\n"
7955 " a),\n"
7956 " b);",
7957 format("fffffffffff(g(R\"x(qqq\n"
7958 "multiline raw string literal xxxxxxxxxxxxxx\n"
7959 ")x\", a), b);",
7960 getGoogleStyleWithColumns(20)));
7961
7962 EXPECT_EQ("fffffffffff(R\"x(\n"
7963 "multiline raw string literal xxxxxxxxxxxxxx\n"
7964 ")x\");",
7965 format("fffffffffff(R\"x(\n"
7966 "multiline raw string literal xxxxxxxxxxxxxx\n"
7967 ")x\");",
7968 getGoogleStyleWithColumns(20)));
7969 EXPECT_EQ("fffffffffff(R\"x(\n"
7970 "multiline raw string literal xxxxxxxxxxxxxx\n"
Daniel Jasper5d2587d2014-03-27 16:14:13 +00007971 ")x\" + bbbbbb);",
Alexander Kornienkod7b837e2013-08-29 17:32:57 +00007972 format("fffffffffff(R\"x(\n"
7973 "multiline raw string literal xxxxxxxxxxxxxx\n"
Daniel Jasper5d2587d2014-03-27 16:14:13 +00007974 ")x\" + bbbbbb);",
Alexander Kornienkod7b837e2013-08-29 17:32:57 +00007975 getGoogleStyleWithColumns(20)));
Daniel Jasperc39b56f2013-12-16 07:23:08 +00007976 EXPECT_EQ("fffffffffff(\n"
7977 " R\"x(\n"
7978 "multiline raw string literal xxxxxxxxxxxxxx\n"
7979 ")x\" +\n"
7980 " bbbbbb);",
7981 format("fffffffffff(\n"
7982 " R\"x(\n"
7983 "multiline raw string literal xxxxxxxxxxxxxx\n"
7984 ")x\" + bbbbbb);",
7985 getGoogleStyleWithColumns(20)));
Alexander Kornienko657c67b2013-07-16 21:06:13 +00007986}
7987
Alexander Kornienkobe633902013-06-14 11:46:10 +00007988TEST_F(FormatTest, SkipsUnknownStringLiterals) {
Daniel Jasper8369aa52013-07-16 20:28:33 +00007989 verifyFormat("string a = \"unterminated;");
7990 EXPECT_EQ("function(\"unterminated,\n"
7991 " OtherParameter);",
7992 format("function( \"unterminated,\n"
7993 " OtherParameter);"));
Alexander Kornienko1e808872013-06-28 12:51:24 +00007994}
7995
7996TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00007997 FormatStyle Style = getLLVMStyle();
7998 Style.Standard = FormatStyle::LS_Cpp03;
Alexander Kornienko1e808872013-06-28 12:51:24 +00007999 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
Chandler Carruthf8b72662014-03-02 12:37:31 +00008000 format("#define x(_a) printf(\"foo\"_a);", Style));
Alexander Kornienkobe633902013-06-14 11:46:10 +00008001}
8002
Daniel Jaspera44991332015-04-29 13:06:49 +00008003TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }
Daniel Jasper20fd3c62014-04-15 08:49:21 +00008004
Manuel Klimek5ecb5fd2013-05-14 09:04:24 +00008005TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
8006 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
8007 " \"ddeeefff\");",
8008 format("someFunction(\"aaabbbcccdddeeefff\");",
8009 getLLVMStyleWithColumns(25)));
8010 EXPECT_EQ("someFunction1234567890(\n"
8011 " \"aaabbbcccdddeeefff\");",
8012 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
8013 getLLVMStyleWithColumns(26)));
8014 EXPECT_EQ("someFunction1234567890(\n"
8015 " \"aaabbbcccdddeeeff\"\n"
8016 " \"f\");",
8017 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
8018 getLLVMStyleWithColumns(25)));
8019 EXPECT_EQ("someFunction1234567890(\n"
8020 " \"aaabbbcccdddeeeff\"\n"
8021 " \"f\");",
8022 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
8023 getLLVMStyleWithColumns(24)));
Manuel Klimek77866142017-11-17 11:17:15 +00008024 EXPECT_EQ("someFunction(\n"
8025 " \"aaabbbcc ddde \"\n"
8026 " \"efff\");",
Daniel Jasper2739af32013-08-28 10:03:58 +00008027 format("someFunction(\"aaabbbcc ddde efff\");",
Manuel Klimek5ecb5fd2013-05-14 09:04:24 +00008028 getLLVMStyleWithColumns(25)));
8029 EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
8030 " \"ddeeefff\");",
8031 format("someFunction(\"aaabbbccc ddeeefff\");",
8032 getLLVMStyleWithColumns(25)));
8033 EXPECT_EQ("someFunction1234567890(\n"
8034 " \"aaabb \"\n"
8035 " \"cccdddeeefff\");",
8036 format("someFunction1234567890(\"aaabb cccdddeeefff\");",
8037 getLLVMStyleWithColumns(25)));
8038 EXPECT_EQ("#define A \\\n"
8039 " string s = \\\n"
8040 " \"123456789\" \\\n"
8041 " \"0\"; \\\n"
8042 " int i;",
8043 format("#define A string s = \"1234567890\"; int i;",
8044 getLLVMStyleWithColumns(20)));
Manuel Klimek77866142017-11-17 11:17:15 +00008045 EXPECT_EQ("someFunction(\n"
8046 " \"aaabbbcc \"\n"
8047 " \"dddeeefff\");",
Daniel Jasper2739af32013-08-28 10:03:58 +00008048 format("someFunction(\"aaabbbcc dddeeefff\");",
8049 getLLVMStyleWithColumns(25)));
Manuel Klimek5ecb5fd2013-05-14 09:04:24 +00008050}
8051
Manuel Klimek5085d9b2013-03-08 18:59:48 +00008052TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
Daniel Jaspera44991332015-04-29 13:06:49 +00008053 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3)));
8054 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2)));
Manuel Klimek5085d9b2013-03-08 18:59:48 +00008055 EXPECT_EQ("\"test\"\n"
8056 "\"\\n\"",
8057 format("\"test\\n\"", getLLVMStyleWithColumns(7)));
8058 EXPECT_EQ("\"tes\\\\\"\n"
8059 "\"n\"",
8060 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
8061 EXPECT_EQ("\"\\\\\\\\\"\n"
8062 "\"\\n\"",
8063 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
Daniel Jaspera44991332015-04-29 13:06:49 +00008064 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
Manuel Klimek5085d9b2013-03-08 18:59:48 +00008065 EXPECT_EQ("\"\\uff01\"\n"
8066 "\"test\"",
8067 format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
8068 EXPECT_EQ("\"\\Uff01ff02\"",
8069 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
8070 EXPECT_EQ("\"\\x000000000001\"\n"
8071 "\"next\"",
8072 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
8073 EXPECT_EQ("\"\\x000000000001next\"",
8074 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
8075 EXPECT_EQ("\"\\x000000000001\"",
8076 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
8077 EXPECT_EQ("\"test\"\n"
8078 "\"\\000000\"\n"
8079 "\"000001\"",
8080 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
8081 EXPECT_EQ("\"test\\000\"\n"
Alexander Kornienkocb45bc12013-04-15 14:28:00 +00008082 "\"00000000\"\n"
8083 "\"1\"",
Manuel Klimek5085d9b2013-03-08 18:59:48 +00008084 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
Manuel Klimek5085d9b2013-03-08 18:59:48 +00008085}
8086
Manuel Klimeka3ff45e2013-04-10 09:52:05 +00008087TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
8088 verifyFormat("void f() {\n"
8089 " return g() {}\n"
8090 " void h() {}");
Daniel Jasper4afc6b32014-06-02 10:57:55 +00008091 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
Daniel Jasper1ec31062013-05-28 18:50:02 +00008092 "g();\n"
Manuel Klimeka3ff45e2013-04-10 09:52:05 +00008093 "}");
8094}
8095
Manuel Klimek421147e2014-01-24 09:25:23 +00008096TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) {
8097 verifyFormat(
Daniel Jasper39485162014-05-22 09:00:33 +00008098 "void f() { return C{param1, param2}.SomeCall(param1, param2); }");
Manuel Klimek421147e2014-01-24 09:25:23 +00008099}
8100
Manuel Klimek13b97d82013-05-13 08:42:42 +00008101TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
8102 verifyFormat("class X {\n"
8103 " void f() {\n"
8104 " }\n"
8105 "};",
8106 getLLVMStyleWithColumns(12));
8107}
8108
8109TEST_F(FormatTest, ConfigurableIndentWidth) {
8110 FormatStyle EightIndent = getLLVMStyleWithColumns(18);
8111 EightIndent.IndentWidth = 8;
Chandler Carruthf8b72662014-03-02 12:37:31 +00008112 EightIndent.ContinuationIndentWidth = 8;
Manuel Klimek13b97d82013-05-13 08:42:42 +00008113 verifyFormat("void f() {\n"
8114 " someFunction();\n"
8115 " if (true) {\n"
8116 " f();\n"
8117 " }\n"
8118 "}",
8119 EightIndent);
8120 verifyFormat("class X {\n"
8121 " void f() {\n"
8122 " }\n"
8123 "};",
8124 EightIndent);
8125 verifyFormat("int x[] = {\n"
8126 " call(),\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00008127 " call()};",
Manuel Klimek13b97d82013-05-13 08:42:42 +00008128 EightIndent);
8129}
8130
Alexander Kornienko34a87e82013-06-22 01:35:36 +00008131TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
Daniel Jaspere068ac72014-10-27 17:13:59 +00008132 verifyFormat("double\n"
Manuel Klimek836c2862013-06-21 17:25:42 +00008133 "f();",
8134 getLLVMStyleWithColumns(8));
8135}
8136
Manuel Klimekb9eae4c2013-05-13 09:22:11 +00008137TEST_F(FormatTest, ConfigurableUseOfTab) {
8138 FormatStyle Tab = getLLVMStyleWithColumns(42);
8139 Tab.IndentWidth = 8;
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00008140 Tab.UseTab = FormatStyle::UT_Always;
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +00008141 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left;
Alexander Kornienkodb4c21f2013-09-27 09:45:40 +00008142
8143 EXPECT_EQ("if (aaaaaaaa && // q\n"
8144 " bb)\t\t// w\n"
8145 "\t;",
8146 format("if (aaaaaaaa &&// q\n"
8147 "bb)// w\n"
8148 ";",
8149 Tab));
8150 EXPECT_EQ("if (aaa && bbb) // w\n"
8151 "\t;",
8152 format("if(aaa&&bbb)// w\n"
8153 ";",
8154 Tab));
8155
Manuel Klimekb9eae4c2013-05-13 09:22:11 +00008156 verifyFormat("class X {\n"
8157 "\tvoid f() {\n"
8158 "\t\tsomeFunction(parameter1,\n"
8159 "\t\t\t parameter2);\n"
8160 "\t}\n"
8161 "};",
8162 Tab);
8163 verifyFormat("#define A \\\n"
8164 "\tvoid f() { \\\n"
8165 "\t\tsomeFunction( \\\n"
8166 "\t\t parameter1, \\\n"
8167 "\t\t parameter2); \\\n"
8168 "\t}",
8169 Tab);
Manuel Klimek34d15152013-05-28 10:01:59 +00008170
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +00008171 Tab.TabWidth = 4;
8172 Tab.IndentWidth = 8;
8173 verifyFormat("class TabWidth4Indent8 {\n"
8174 "\t\tvoid f() {\n"
8175 "\t\t\t\tsomeFunction(parameter1,\n"
8176 "\t\t\t\t\t\t\t parameter2);\n"
8177 "\t\t}\n"
8178 "};",
8179 Tab);
8180
8181 Tab.TabWidth = 4;
8182 Tab.IndentWidth = 4;
8183 verifyFormat("class TabWidth4Indent4 {\n"
8184 "\tvoid f() {\n"
8185 "\t\tsomeFunction(parameter1,\n"
8186 "\t\t\t\t\t parameter2);\n"
8187 "\t}\n"
8188 "};",
8189 Tab);
8190
8191 Tab.TabWidth = 8;
8192 Tab.IndentWidth = 4;
8193 verifyFormat("class TabWidth8Indent4 {\n"
8194 " void f() {\n"
8195 "\tsomeFunction(parameter1,\n"
8196 "\t\t parameter2);\n"
8197 " }\n"
8198 "};",
8199 Tab);
8200
Alexander Kornienko39856b72013-09-10 09:38:25 +00008201 Tab.TabWidth = 8;
8202 Tab.IndentWidth = 8;
8203 EXPECT_EQ("/*\n"
8204 "\t a\t\tcomment\n"
8205 "\t in multiple lines\n"
8206 " */",
8207 format(" /*\t \t \n"
8208 " \t \t a\t\tcomment\t \t\n"
8209 " \t \t in multiple lines\t\n"
8210 " \t */",
8211 Tab));
Alexander Kornienkodb4c21f2013-09-27 09:45:40 +00008212
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00008213 Tab.UseTab = FormatStyle::UT_ForIndentation;
Chandler Carruthf8b72662014-03-02 12:37:31 +00008214 verifyFormat("{\n"
8215 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8216 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8217 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8218 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8219 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8220 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
Alexander Kornienkoe2e03872013-10-14 00:46:35 +00008221 "};",
8222 Tab);
Daniel Jasper411af722016-01-05 16:10:39 +00008223 verifyFormat("enum AA {\n"
Daniel Jasper96972812014-01-05 12:38:10 +00008224 "\ta1, // Force multiple lines\n"
Alexander Kornienkoe2e03872013-10-14 00:46:35 +00008225 "\ta2,\n"
8226 "\ta3\n"
8227 "};",
8228 Tab);
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00008229 EXPECT_EQ("if (aaaaaaaa && // q\n"
8230 " bb) // w\n"
8231 "\t;",
8232 format("if (aaaaaaaa &&// q\n"
8233 "bb)// w\n"
8234 ";",
8235 Tab));
8236 verifyFormat("class X {\n"
8237 "\tvoid f() {\n"
8238 "\t\tsomeFunction(parameter1,\n"
8239 "\t\t parameter2);\n"
8240 "\t}\n"
8241 "};",
8242 Tab);
8243 verifyFormat("{\n"
Daniel Jasper100ffc62015-08-21 11:44:57 +00008244 "\tQ(\n"
8245 "\t {\n"
8246 "\t\t int a;\n"
8247 "\t\t someFunction(aaaaaaaa,\n"
8248 "\t\t bbbbbbb);\n"
8249 "\t },\n"
8250 "\t p);\n"
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00008251 "}",
8252 Tab);
8253 EXPECT_EQ("{\n"
8254 "\t/* aaaa\n"
8255 "\t bbbb */\n"
8256 "}",
8257 format("{\n"
8258 "/* aaaa\n"
8259 " bbbb */\n"
8260 "}",
8261 Tab));
8262 EXPECT_EQ("{\n"
8263 "\t/*\n"
8264 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8265 "\t bbbbbbbbbbbbb\n"
8266 "\t*/\n"
8267 "}",
8268 format("{\n"
8269 "/*\n"
8270 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
8271 "*/\n"
8272 "}",
8273 Tab));
8274 EXPECT_EQ("{\n"
8275 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8276 "\t// bbbbbbbbbbbbb\n"
8277 "}",
8278 format("{\n"
8279 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
8280 "}",
8281 Tab));
8282 EXPECT_EQ("{\n"
8283 "\t/*\n"
8284 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8285 "\t bbbbbbbbbbbbb\n"
8286 "\t*/\n"
8287 "}",
8288 format("{\n"
8289 "\t/*\n"
8290 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
8291 "\t*/\n"
8292 "}",
8293 Tab));
8294 EXPECT_EQ("{\n"
8295 "\t/*\n"
8296 "\n"
8297 "\t*/\n"
8298 "}",
8299 format("{\n"
8300 "\t/*\n"
8301 "\n"
8302 "\t*/\n"
Alexander Kornienko45dc1b22013-09-27 16:40:11 +00008303 "}",
8304 Tab));
8305 EXPECT_EQ("{\n"
8306 "\t/*\n"
8307 " asdf\n"
8308 "\t*/\n"
8309 "}",
8310 format("{\n"
8311 "\t/*\n"
8312 " asdf\n"
8313 "\t*/\n"
8314 "}",
8315 Tab));
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00008316
8317 Tab.UseTab = FormatStyle::UT_Never;
Alexander Kornienko39856b72013-09-10 09:38:25 +00008318 EXPECT_EQ("/*\n"
8319 " a\t\tcomment\n"
8320 " in multiple lines\n"
8321 " */",
8322 format(" /*\t \t \n"
8323 " \t \t a\t\tcomment\t \t\n"
8324 " \t \t in multiple lines\t\n"
8325 " \t */",
8326 Tab));
8327 EXPECT_EQ("/* some\n"
8328 " comment */",
Daniel Jaspera44991332015-04-29 13:06:49 +00008329 format(" \t \t /* some\n"
8330 " \t \t comment */",
8331 Tab));
Alexander Kornienko39856b72013-09-10 09:38:25 +00008332 EXPECT_EQ("int a; /* some\n"
8333 " comment */",
Daniel Jaspera44991332015-04-29 13:06:49 +00008334 format(" \t \t int a; /* some\n"
8335 " \t \t comment */",
8336 Tab));
Manuel Klimek34d15152013-05-28 10:01:59 +00008337
Alexander Kornienko39856b72013-09-10 09:38:25 +00008338 EXPECT_EQ("int a; /* some\n"
8339 "comment */",
Daniel Jaspera44991332015-04-29 13:06:49 +00008340 format(" \t \t int\ta; /* some\n"
8341 " \t \t comment */",
8342 Tab));
Alexander Kornienko39856b72013-09-10 09:38:25 +00008343 EXPECT_EQ("f(\"\t\t\"); /* some\n"
8344 " comment */",
Daniel Jaspera44991332015-04-29 13:06:49 +00008345 format(" \t \t f(\"\t\t\"); /* some\n"
8346 " \t \t comment */",
8347 Tab));
Manuel Klimek34d15152013-05-28 10:01:59 +00008348 EXPECT_EQ("{\n"
8349 " /*\n"
8350 " * Comment\n"
8351 " */\n"
8352 " int i;\n"
8353 "}",
8354 format("{\n"
8355 "\t/*\n"
8356 "\t * Comment\n"
8357 "\t */\n"
8358 "\t int i;\n"
8359 "}"));
Marianne Mailhot-Sarrasin51fe2792016-04-14 14:52:26 +00008360
8361 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
8362 Tab.TabWidth = 8;
8363 Tab.IndentWidth = 8;
8364 EXPECT_EQ("if (aaaaaaaa && // q\n"
8365 " bb) // w\n"
8366 "\t;",
8367 format("if (aaaaaaaa &&// q\n"
8368 "bb)// w\n"
8369 ";",
8370 Tab));
8371 EXPECT_EQ("if (aaa && bbb) // w\n"
8372 "\t;",
8373 format("if(aaa&&bbb)// w\n"
8374 ";",
8375 Tab));
8376 verifyFormat("class X {\n"
8377 "\tvoid f() {\n"
8378 "\t\tsomeFunction(parameter1,\n"
8379 "\t\t\t parameter2);\n"
8380 "\t}\n"
8381 "};",
8382 Tab);
8383 verifyFormat("#define A \\\n"
8384 "\tvoid f() { \\\n"
8385 "\t\tsomeFunction( \\\n"
8386 "\t\t parameter1, \\\n"
8387 "\t\t parameter2); \\\n"
8388 "\t}",
8389 Tab);
8390 Tab.TabWidth = 4;
8391 Tab.IndentWidth = 8;
8392 verifyFormat("class TabWidth4Indent8 {\n"
8393 "\t\tvoid f() {\n"
8394 "\t\t\t\tsomeFunction(parameter1,\n"
8395 "\t\t\t\t\t\t\t parameter2);\n"
8396 "\t\t}\n"
8397 "};",
8398 Tab);
8399 Tab.TabWidth = 4;
8400 Tab.IndentWidth = 4;
8401 verifyFormat("class TabWidth4Indent4 {\n"
8402 "\tvoid f() {\n"
8403 "\t\tsomeFunction(parameter1,\n"
8404 "\t\t\t\t\t parameter2);\n"
8405 "\t}\n"
8406 "};",
8407 Tab);
8408 Tab.TabWidth = 8;
8409 Tab.IndentWidth = 4;
8410 verifyFormat("class TabWidth8Indent4 {\n"
8411 " void f() {\n"
8412 "\tsomeFunction(parameter1,\n"
8413 "\t\t parameter2);\n"
8414 " }\n"
8415 "};",
8416 Tab);
8417 Tab.TabWidth = 8;
8418 Tab.IndentWidth = 8;
8419 EXPECT_EQ("/*\n"
8420 "\t a\t\tcomment\n"
8421 "\t in multiple lines\n"
8422 " */",
8423 format(" /*\t \t \n"
8424 " \t \t a\t\tcomment\t \t\n"
8425 " \t \t in multiple lines\t\n"
8426 " \t */",
8427 Tab));
8428 verifyFormat("{\n"
8429 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8430 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8431 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8432 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8433 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8434 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8435 "};",
8436 Tab);
8437 verifyFormat("enum AA {\n"
8438 "\ta1, // Force multiple lines\n"
8439 "\ta2,\n"
8440 "\ta3\n"
8441 "};",
8442 Tab);
8443 EXPECT_EQ("if (aaaaaaaa && // q\n"
8444 " bb) // w\n"
8445 "\t;",
8446 format("if (aaaaaaaa &&// q\n"
8447 "bb)// w\n"
8448 ";",
8449 Tab));
8450 verifyFormat("class X {\n"
8451 "\tvoid f() {\n"
8452 "\t\tsomeFunction(parameter1,\n"
8453 "\t\t\t parameter2);\n"
8454 "\t}\n"
8455 "};",
8456 Tab);
8457 verifyFormat("{\n"
8458 "\tQ(\n"
8459 "\t {\n"
8460 "\t\t int a;\n"
8461 "\t\t someFunction(aaaaaaaa,\n"
8462 "\t\t\t\t bbbbbbb);\n"
8463 "\t },\n"
8464 "\t p);\n"
8465 "}",
8466 Tab);
8467 EXPECT_EQ("{\n"
8468 "\t/* aaaa\n"
8469 "\t bbbb */\n"
8470 "}",
8471 format("{\n"
8472 "/* aaaa\n"
8473 " bbbb */\n"
8474 "}",
8475 Tab));
8476 EXPECT_EQ("{\n"
8477 "\t/*\n"
8478 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8479 "\t bbbbbbbbbbbbb\n"
8480 "\t*/\n"
8481 "}",
8482 format("{\n"
8483 "/*\n"
8484 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
8485 "*/\n"
8486 "}",
8487 Tab));
8488 EXPECT_EQ("{\n"
8489 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8490 "\t// bbbbbbbbbbbbb\n"
8491 "}",
8492 format("{\n"
8493 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
8494 "}",
8495 Tab));
8496 EXPECT_EQ("{\n"
8497 "\t/*\n"
8498 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8499 "\t bbbbbbbbbbbbb\n"
8500 "\t*/\n"
8501 "}",
8502 format("{\n"
8503 "\t/*\n"
8504 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
8505 "\t*/\n"
8506 "}",
8507 Tab));
8508 EXPECT_EQ("{\n"
8509 "\t/*\n"
8510 "\n"
8511 "\t*/\n"
8512 "}",
8513 format("{\n"
8514 "\t/*\n"
8515 "\n"
8516 "\t*/\n"
8517 "}",
8518 Tab));
8519 EXPECT_EQ("{\n"
8520 "\t/*\n"
8521 " asdf\n"
8522 "\t*/\n"
8523 "}",
8524 format("{\n"
8525 "\t/*\n"
8526 " asdf\n"
8527 "\t*/\n"
8528 "}",
8529 Tab));
8530 EXPECT_EQ("/*\n"
8531 "\t a\t\tcomment\n"
8532 "\t in multiple lines\n"
8533 " */",
8534 format(" /*\t \t \n"
8535 " \t \t a\t\tcomment\t \t\n"
8536 " \t \t in multiple lines\t\n"
8537 " \t */",
8538 Tab));
8539 EXPECT_EQ("/* some\n"
8540 " comment */",
8541 format(" \t \t /* some\n"
8542 " \t \t comment */",
8543 Tab));
8544 EXPECT_EQ("int a; /* some\n"
8545 " comment */",
8546 format(" \t \t int a; /* some\n"
8547 " \t \t comment */",
8548 Tab));
8549 EXPECT_EQ("int a; /* some\n"
8550 "comment */",
8551 format(" \t \t int\ta; /* some\n"
8552 " \t \t comment */",
8553 Tab));
8554 EXPECT_EQ("f(\"\t\t\"); /* some\n"
8555 " comment */",
8556 format(" \t \t f(\"\t\t\"); /* some\n"
8557 " \t \t comment */",
8558 Tab));
8559 EXPECT_EQ("{\n"
8560 " /*\n"
8561 " * Comment\n"
8562 " */\n"
8563 " int i;\n"
8564 "}",
8565 format("{\n"
8566 "\t/*\n"
8567 "\t * Comment\n"
8568 "\t */\n"
8569 "\t int i;\n"
8570 "}"));
8571 Tab.AlignConsecutiveAssignments = true;
8572 Tab.AlignConsecutiveDeclarations = true;
8573 Tab.TabWidth = 4;
8574 Tab.IndentWidth = 4;
8575 verifyFormat("class Assign {\n"
8576 "\tvoid f() {\n"
8577 "\t\tint x = 123;\n"
8578 "\t\tint random = 4;\n"
8579 "\t\tstd::string alphabet =\n"
8580 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
8581 "\t}\n"
8582 "};",
8583 Tab);
Manuel Klimekb9eae4c2013-05-13 09:22:11 +00008584}
8585
Alexander Kornienko917f9e02013-09-10 12:29:48 +00008586TEST_F(FormatTest, CalculatesOriginalColumn) {
8587 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8588 "q\"; /* some\n"
8589 " comment */",
8590 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8591 "q\"; /* some\n"
8592 " comment */",
8593 getLLVMStyle()));
8594 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
8595 "/* some\n"
8596 " comment */",
8597 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
8598 " /* some\n"
8599 " comment */",
8600 getLLVMStyle()));
8601 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8602 "qqq\n"
8603 "/* some\n"
8604 " comment */",
8605 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8606 "qqq\n"
8607 " /* some\n"
8608 " comment */",
8609 getLLVMStyle()));
8610 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8611 "wwww; /* some\n"
8612 " comment */",
8613 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8614 "wwww; /* some\n"
8615 " comment */",
8616 getLLVMStyle()));
8617}
8618
Alexander Kornienkofdca83d2013-12-10 10:18:34 +00008619TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
Daniel Jasperb55acad2013-08-20 12:36:34 +00008620 FormatStyle NoSpace = getLLVMStyle();
Alexander Kornienkofdca83d2013-12-10 10:18:34 +00008621 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never;
Daniel Jasperb55acad2013-08-20 12:36:34 +00008622
8623 verifyFormat("while(true)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008624 " continue;",
8625 NoSpace);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008626 verifyFormat("for(;;)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008627 " continue;",
8628 NoSpace);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008629 verifyFormat("if(true)\n"
8630 " f();\n"
8631 "else if(true)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008632 " f();",
8633 NoSpace);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008634 verifyFormat("do {\n"
8635 " do_something();\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008636 "} while(something());",
8637 NoSpace);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008638 verifyFormat("switch(x) {\n"
8639 "default:\n"
8640 " break;\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008641 "}",
8642 NoSpace);
Chad Rosier0a84f172014-08-05 17:58:54 +00008643 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace);
Daniel Jasper78b194992014-08-06 14:15:41 +00008644 verifyFormat("size_t x = sizeof(x);", NoSpace);
8645 verifyFormat("auto f(int x) -> decltype(x);", NoSpace);
8646 verifyFormat("int f(T x) noexcept(x.create());", NoSpace);
8647 verifyFormat("alignas(128) char a[128];", NoSpace);
8648 verifyFormat("size_t x = alignof(MyType);", NoSpace);
8649 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace);
8650 verifyFormat("int f() throw(Deprecated);", NoSpace);
Anders Waldenborgb09075a2015-05-19 16:54:26 +00008651 verifyFormat("typedef void (*cb)(int);", NoSpace);
Daniel Jaspera804d1e2015-08-11 20:32:24 +00008652 verifyFormat("T A::operator()();", NoSpace);
8653 verifyFormat("X A::operator++(T);", NoSpace);
Alexander Kornienkofdca83d2013-12-10 10:18:34 +00008654
8655 FormatStyle Space = getLLVMStyle();
8656 Space.SpaceBeforeParens = FormatStyle::SBPO_Always;
8657
8658 verifyFormat("int f ();", Space);
8659 verifyFormat("void f (int a, T b) {\n"
8660 " while (true)\n"
8661 " continue;\n"
8662 "}",
8663 Space);
8664 verifyFormat("if (true)\n"
8665 " f ();\n"
8666 "else if (true)\n"
8667 " f ();",
8668 Space);
8669 verifyFormat("do {\n"
8670 " do_something ();\n"
8671 "} while (something ());",
8672 Space);
8673 verifyFormat("switch (x) {\n"
8674 "default:\n"
8675 " break;\n"
8676 "}",
8677 Space);
8678 verifyFormat("A::A () : a (1) {}", Space);
8679 verifyFormat("void f () __attribute__ ((asdf));", Space);
8680 verifyFormat("*(&a + 1);\n"
8681 "&((&a)[1]);\n"
8682 "a[(b + c) * d];\n"
8683 "(((a + 1) * 2) + 3) * 4;",
8684 Space);
8685 verifyFormat("#define A(x) x", Space);
8686 verifyFormat("#define A (x) x", Space);
8687 verifyFormat("#if defined(x)\n"
8688 "#endif",
8689 Space);
Chad Rosier0a84f172014-08-05 17:58:54 +00008690 verifyFormat("auto i = std::make_unique<int> (5);", Space);
Daniel Jasper78b194992014-08-06 14:15:41 +00008691 verifyFormat("size_t x = sizeof (x);", Space);
8692 verifyFormat("auto f (int x) -> decltype (x);", Space);
8693 verifyFormat("int f (T x) noexcept (x.create ());", Space);
8694 verifyFormat("alignas (128) char a[128];", Space);
8695 verifyFormat("size_t x = alignof (MyType);", Space);
8696 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space);
8697 verifyFormat("int f () throw (Deprecated);", Space);
Anders Waldenborgb09075a2015-05-19 16:54:26 +00008698 verifyFormat("typedef void (*cb) (int);", Space);
Daniel Jaspera804d1e2015-08-11 20:32:24 +00008699 verifyFormat("T A::operator() ();", Space);
8700 verifyFormat("X A::operator++ (T);", Space);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008701}
8702
8703TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
8704 FormatStyle Spaces = getLLVMStyle();
8705
8706 Spaces.SpacesInParentheses = true;
8707 verifyFormat("call( x, y, z );", Spaces);
Daniel Jasper92e09822015-03-18 12:59:19 +00008708 verifyFormat("call();", Spaces);
8709 verifyFormat("std::function<void( int, int )> callback;", Spaces);
Daniel Jasper74331d42015-10-26 12:08:47 +00008710 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }",
8711 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008712 verifyFormat("while ( (bool)1 )\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008713 " continue;",
8714 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008715 verifyFormat("for ( ;; )\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008716 " continue;",
8717 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008718 verifyFormat("if ( true )\n"
8719 " f();\n"
8720 "else if ( true )\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008721 " f();",
8722 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008723 verifyFormat("do {\n"
8724 " do_something( (int)i );\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008725 "} while ( something() );",
8726 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008727 verifyFormat("switch ( x ) {\n"
8728 "default:\n"
8729 " break;\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008730 "}",
8731 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008732
8733 Spaces.SpacesInParentheses = false;
8734 Spaces.SpacesInCStyleCastParentheses = true;
8735 verifyFormat("Type *A = ( Type * )P;", Spaces);
8736 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
8737 verifyFormat("x = ( int32 )y;", Spaces);
8738 verifyFormat("int a = ( int )(2.0f);", Spaces);
8739 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
8740 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
8741 verifyFormat("#define x (( int )-1)", Spaces);
8742
Daniel Jasper92e09822015-03-18 12:59:19 +00008743 // Run the first set of tests again with:
Richard Trieucc3949d2016-02-18 22:34:54 +00008744 Spaces.SpacesInParentheses = false;
8745 Spaces.SpaceInEmptyParentheses = true;
Daniel Jasperb55acad2013-08-20 12:36:34 +00008746 Spaces.SpacesInCStyleCastParentheses = true;
8747 verifyFormat("call(x, y, z);", Spaces);
Daniel Jasper92e09822015-03-18 12:59:19 +00008748 verifyFormat("call( );", Spaces);
8749 verifyFormat("std::function<void(int, int)> callback;", Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008750 verifyFormat("while (( bool )1)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008751 " continue;",
8752 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008753 verifyFormat("for (;;)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008754 " continue;",
8755 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008756 verifyFormat("if (true)\n"
8757 " f( );\n"
8758 "else if (true)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008759 " f( );",
8760 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008761 verifyFormat("do {\n"
8762 " do_something(( int )i);\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008763 "} while (something( ));",
8764 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008765 verifyFormat("switch (x) {\n"
8766 "default:\n"
8767 " break;\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008768 "}",
8769 Spaces);
Daniel Jasperdb986eb2014-09-03 07:37:29 +00008770
Daniel Jasper92e09822015-03-18 12:59:19 +00008771 // Run the first set of tests again with:
Daniel Jasperdb986eb2014-09-03 07:37:29 +00008772 Spaces.SpaceAfterCStyleCast = true;
8773 verifyFormat("call(x, y, z);", Spaces);
Daniel Jasper92e09822015-03-18 12:59:19 +00008774 verifyFormat("call( );", Spaces);
8775 verifyFormat("std::function<void(int, int)> callback;", Spaces);
Daniel Jasperdb986eb2014-09-03 07:37:29 +00008776 verifyFormat("while (( bool ) 1)\n"
8777 " continue;",
8778 Spaces);
8779 verifyFormat("for (;;)\n"
8780 " continue;",
8781 Spaces);
8782 verifyFormat("if (true)\n"
8783 " f( );\n"
8784 "else if (true)\n"
8785 " f( );",
8786 Spaces);
8787 verifyFormat("do {\n"
8788 " do_something(( int ) i);\n"
8789 "} while (something( ));",
8790 Spaces);
8791 verifyFormat("switch (x) {\n"
8792 "default:\n"
8793 " break;\n"
8794 "}",
8795 Spaces);
Daniel Jasper92e09822015-03-18 12:59:19 +00008796
8797 // Run subset of tests again with:
Daniel Jasperdb986eb2014-09-03 07:37:29 +00008798 Spaces.SpacesInCStyleCastParentheses = false;
8799 Spaces.SpaceAfterCStyleCast = true;
8800 verifyFormat("while ((bool) 1)\n"
8801 " continue;",
8802 Spaces);
8803 verifyFormat("do {\n"
8804 " do_something((int) i);\n"
8805 "} while (something( ));",
8806 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008807}
8808
Daniel Jasperad981f82014-08-26 11:41:14 +00008809TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) {
8810 verifyFormat("int a[5];");
8811 verifyFormat("a[3] += 42;");
8812
8813 FormatStyle Spaces = getLLVMStyle();
8814 Spaces.SpacesInSquareBrackets = true;
8815 // Lambdas unchanged.
8816 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces);
8817 verifyFormat("return [i, args...] {};", Spaces);
8818
8819 // Not lambdas.
8820 verifyFormat("int a[ 5 ];", Spaces);
8821 verifyFormat("a[ 3 ] += 42;", Spaces);
8822 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces);
8823 verifyFormat("double &operator[](int i) { return 0; }\n"
8824 "int i;",
8825 Spaces);
8826 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces);
8827 verifyFormat("int i = a[ a ][ a ]->f();", Spaces);
8828 verifyFormat("int i = (*b)[ a ]->f();", Spaces);
8829}
8830
Daniel Jasperd94bff32013-09-25 15:15:02 +00008831TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
8832 verifyFormat("int a = 5;");
8833 verifyFormat("a += 42;");
8834 verifyFormat("a or_eq 8;");
8835
8836 FormatStyle Spaces = getLLVMStyle();
8837 Spaces.SpaceBeforeAssignmentOperators = false;
8838 verifyFormat("int a= 5;", Spaces);
8839 verifyFormat("a+= 42;", Spaces);
8840 verifyFormat("a or_eq 8;", Spaces);
8841}
8842
Daniel Jaspera44991332015-04-29 13:06:49 +00008843TEST_F(FormatTest, AlignConsecutiveAssignments) {
8844 FormatStyle Alignment = getLLVMStyle();
8845 Alignment.AlignConsecutiveAssignments = false;
8846 verifyFormat("int a = 5;\n"
8847 "int oneTwoThree = 123;",
8848 Alignment);
8849 verifyFormat("int a = 5;\n"
8850 "int oneTwoThree = 123;",
8851 Alignment);
8852
8853 Alignment.AlignConsecutiveAssignments = true;
8854 verifyFormat("int a = 5;\n"
8855 "int oneTwoThree = 123;",
8856 Alignment);
8857 verifyFormat("int a = method();\n"
8858 "int oneTwoThree = 133;",
8859 Alignment);
8860 verifyFormat("a &= 5;\n"
8861 "bcd *= 5;\n"
8862 "ghtyf += 5;\n"
8863 "dvfvdb -= 5;\n"
8864 "a /= 5;\n"
8865 "vdsvsv %= 5;\n"
8866 "sfdbddfbdfbb ^= 5;\n"
8867 "dvsdsv |= 5;\n"
8868 "int dsvvdvsdvvv = 123;",
8869 Alignment);
8870 verifyFormat("int i = 1, j = 10;\n"
8871 "something = 2000;",
8872 Alignment);
8873 verifyFormat("something = 2000;\n"
8874 "int i = 1, j = 10;\n",
8875 Alignment);
8876 verifyFormat("something = 2000;\n"
8877 "another = 911;\n"
8878 "int i = 1, j = 10;\n"
8879 "oneMore = 1;\n"
8880 "i = 2;",
8881 Alignment);
8882 verifyFormat("int a = 5;\n"
8883 "int one = 1;\n"
8884 "method();\n"
8885 "int oneTwoThree = 123;\n"
8886 "int oneTwo = 12;",
8887 Alignment);
Daniel Jasperbbfd20d2015-09-22 09:32:00 +00008888 verifyFormat("int oneTwoThree = 123;\n"
8889 "int oneTwo = 12;\n"
8890 "method();\n",
8891 Alignment);
Daniel Jaspera44991332015-04-29 13:06:49 +00008892 verifyFormat("int oneTwoThree = 123; // comment\n"
8893 "int oneTwo = 12; // comment",
8894 Alignment);
8895 EXPECT_EQ("int a = 5;\n"
8896 "\n"
8897 "int oneTwoThree = 123;",
8898 format("int a = 5;\n"
8899 "\n"
8900 "int oneTwoThree= 123;",
8901 Alignment));
8902 EXPECT_EQ("int a = 5;\n"
8903 "int one = 1;\n"
8904 "\n"
8905 "int oneTwoThree = 123;",
8906 format("int a = 5;\n"
8907 "int one = 1;\n"
8908 "\n"
8909 "int oneTwoThree = 123;",
8910 Alignment));
8911 EXPECT_EQ("int a = 5;\n"
8912 "int one = 1;\n"
8913 "\n"
8914 "int oneTwoThree = 123;\n"
8915 "int oneTwo = 12;",
8916 format("int a = 5;\n"
8917 "int one = 1;\n"
8918 "\n"
8919 "int oneTwoThree = 123;\n"
8920 "int oneTwo = 12;",
8921 Alignment));
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +00008922 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
8923 verifyFormat("#define A \\\n"
8924 " int aaaa = 12; \\\n"
8925 " int b = 23; \\\n"
8926 " int ccc = 234; \\\n"
8927 " int dddddddddd = 2345;",
8928 Alignment);
8929 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
Daniel Jaspera44991332015-04-29 13:06:49 +00008930 verifyFormat("#define A \\\n"
8931 " int aaaa = 12; \\\n"
8932 " int b = 23; \\\n"
8933 " int ccc = 234; \\\n"
8934 " int dddddddddd = 2345;",
8935 Alignment);
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +00008936 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
Daniel Jaspera44991332015-04-29 13:06:49 +00008937 verifyFormat("#define A "
8938 " \\\n"
8939 " int aaaa = 12; "
8940 " \\\n"
8941 " int b = 23; "
8942 " \\\n"
8943 " int ccc = 234; "
8944 " \\\n"
8945 " int dddddddddd = 2345;",
8946 Alignment);
8947 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
8948 "k = 4, int l = 5,\n"
8949 " int m = 6) {\n"
8950 " int j = 10;\n"
8951 " otherThing = 1;\n"
8952 "}",
8953 Alignment);
8954 verifyFormat("void SomeFunction(int parameter = 0) {\n"
8955 " int i = 1;\n"
8956 " int j = 2;\n"
8957 " int big = 10000;\n"
8958 "}",
8959 Alignment);
8960 verifyFormat("class C {\n"
8961 "public:\n"
Daniel Jasperec90e512015-12-01 12:00:43 +00008962 " int i = 1;\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008963 " virtual void f() = 0;\n"
8964 "};",
8965 Alignment);
8966 verifyFormat("int i = 1;\n"
8967 "if (SomeType t = getSomething()) {\n"
8968 "}\n"
8969 "int j = 2;\n"
8970 "int big = 10000;",
8971 Alignment);
8972 verifyFormat("int j = 7;\n"
8973 "for (int k = 0; k < N; ++k) {\n"
8974 "}\n"
8975 "int j = 2;\n"
8976 "int big = 10000;\n"
8977 "}",
8978 Alignment);
8979 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
8980 verifyFormat("int i = 1;\n"
8981 "LooooooooooongType loooooooooooooooooooooongVariable\n"
8982 " = someLooooooooooooooooongFunction();\n"
8983 "int j = 2;",
8984 Alignment);
8985 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
8986 verifyFormat("int i = 1;\n"
8987 "LooooooooooongType loooooooooooooooooooooongVariable =\n"
8988 " someLooooooooooooooooongFunction();\n"
8989 "int j = 2;",
8990 Alignment);
Daniel Jasper39828252015-10-07 15:03:26 +00008991
8992 verifyFormat("auto lambda = []() {\n"
8993 " auto i = 0;\n"
8994 " return 0;\n"
8995 "};\n"
8996 "int i = 0;\n"
8997 "auto v = type{\n"
8998 " i = 1, //\n"
8999 " (i = 2), //\n"
9000 " i = 3 //\n"
9001 "};",
9002 Alignment);
9003
Daniel Jaspera44991332015-04-29 13:06:49 +00009004 verifyFormat(
9005 "int i = 1;\n"
9006 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
9007 " loooooooooooooooooooooongParameterB);\n"
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00009008 "int j = 2;",
Daniel Jaspera44991332015-04-29 13:06:49 +00009009 Alignment);
Daniel Jasperec90e512015-12-01 12:00:43 +00009010
9011 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
9012 " typename B = very_long_type_name_1,\n"
9013 " typename T_2 = very_long_type_name_2>\n"
9014 "auto foo() {}\n",
9015 Alignment);
9016 verifyFormat("int a, b = 1;\n"
9017 "int c = 2;\n"
9018 "int dd = 3;\n",
9019 Alignment);
9020 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n"
9021 "float b[1][] = {{3.f}};\n",
9022 Alignment);
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00009023 verifyFormat("for (int i = 0; i < 1; i++)\n"
9024 " int x = 1;\n",
9025 Alignment);
9026 verifyFormat("for (i = 0; i < 1; i++)\n"
9027 " x = 1;\n"
9028 "y = 1;\n",
9029 Alignment);
Daniel Jaspera44991332015-04-29 13:06:49 +00009030}
9031
Daniel Jaspere12597c2015-10-01 10:06:54 +00009032TEST_F(FormatTest, AlignConsecutiveDeclarations) {
9033 FormatStyle Alignment = getLLVMStyle();
9034 Alignment.AlignConsecutiveDeclarations = false;
9035 verifyFormat("float const a = 5;\n"
9036 "int oneTwoThree = 123;",
9037 Alignment);
9038 verifyFormat("int a = 5;\n"
9039 "float const oneTwoThree = 123;",
9040 Alignment);
9041
9042 Alignment.AlignConsecutiveDeclarations = true;
9043 verifyFormat("float const a = 5;\n"
9044 "int oneTwoThree = 123;",
9045 Alignment);
9046 verifyFormat("int a = method();\n"
9047 "float const oneTwoThree = 133;",
9048 Alignment);
9049 verifyFormat("int i = 1, j = 10;\n"
9050 "something = 2000;",
9051 Alignment);
9052 verifyFormat("something = 2000;\n"
9053 "int i = 1, j = 10;\n",
9054 Alignment);
9055 verifyFormat("float something = 2000;\n"
9056 "double another = 911;\n"
9057 "int i = 1, j = 10;\n"
9058 "const int *oneMore = 1;\n"
9059 "unsigned i = 2;",
9060 Alignment);
9061 verifyFormat("float a = 5;\n"
9062 "int one = 1;\n"
9063 "method();\n"
9064 "const double oneTwoThree = 123;\n"
9065 "const unsigned int oneTwo = 12;",
9066 Alignment);
9067 verifyFormat("int oneTwoThree{0}; // comment\n"
9068 "unsigned oneTwo; // comment",
9069 Alignment);
9070 EXPECT_EQ("float const a = 5;\n"
9071 "\n"
9072 "int oneTwoThree = 123;",
9073 format("float const a = 5;\n"
9074 "\n"
9075 "int oneTwoThree= 123;",
9076 Alignment));
9077 EXPECT_EQ("float a = 5;\n"
9078 "int one = 1;\n"
9079 "\n"
9080 "unsigned oneTwoThree = 123;",
9081 format("float a = 5;\n"
9082 "int one = 1;\n"
9083 "\n"
9084 "unsigned oneTwoThree = 123;",
9085 Alignment));
9086 EXPECT_EQ("float a = 5;\n"
9087 "int one = 1;\n"
9088 "\n"
9089 "unsigned oneTwoThree = 123;\n"
9090 "int oneTwo = 12;",
9091 format("float a = 5;\n"
9092 "int one = 1;\n"
9093 "\n"
9094 "unsigned oneTwoThree = 123;\n"
9095 "int oneTwo = 12;",
9096 Alignment));
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00009097 // Function prototype alignment
9098 verifyFormat("int a();\n"
9099 "double b();",
9100 Alignment);
9101 verifyFormat("int a(int x);\n"
9102 "double b();",
9103 Alignment);
9104 unsigned OldColumnLimit = Alignment.ColumnLimit;
9105 // We need to set ColumnLimit to zero, in order to stress nested alignments,
9106 // otherwise the function parameters will be re-flowed onto a single line.
9107 Alignment.ColumnLimit = 0;
9108 EXPECT_EQ("int a(int x,\n"
9109 " float y);\n"
9110 "double b(int x,\n"
9111 " double y);",
9112 format("int a(int x,\n"
9113 " float y);\n"
9114 "double b(int x,\n"
9115 " double y);",
9116 Alignment));
9117 // This ensures that function parameters of function declarations are
9118 // correctly indented when their owning functions are indented.
9119 // The failure case here is for 'double y' to not be indented enough.
9120 EXPECT_EQ("double a(int x);\n"
9121 "int b(int y,\n"
9122 " double z);",
9123 format("double a(int x);\n"
9124 "int b(int y,\n"
9125 " double z);",
9126 Alignment));
9127 // Set ColumnLimit low so that we induce wrapping immediately after
9128 // the function name and opening paren.
9129 Alignment.ColumnLimit = 13;
9130 verifyFormat("int function(\n"
9131 " int x,\n"
9132 " bool y);",
9133 Alignment);
9134 Alignment.ColumnLimit = OldColumnLimit;
9135 // Ensure function pointers don't screw up recursive alignment
9136 verifyFormat("int a(int x, void (*fp)(int y));\n"
9137 "double b();",
9138 Alignment);
Daniel Jaspere12597c2015-10-01 10:06:54 +00009139 Alignment.AlignConsecutiveAssignments = true;
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00009140 // Ensure recursive alignment is broken by function braces, so that the
9141 // "a = 1" does not align with subsequent assignments inside the function
9142 // body.
9143 verifyFormat("int func(int a = 1) {\n"
9144 " int b = 2;\n"
9145 " int cc = 3;\n"
9146 "}",
9147 Alignment);
Daniel Jaspere12597c2015-10-01 10:06:54 +00009148 verifyFormat("float something = 2000;\n"
9149 "double another = 911;\n"
9150 "int i = 1, j = 10;\n"
9151 "const int *oneMore = 1;\n"
9152 "unsigned i = 2;",
9153 Alignment);
9154 verifyFormat("int oneTwoThree = {0}; // comment\n"
9155 "unsigned oneTwo = 0; // comment",
9156 Alignment);
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00009157 // Make sure that scope is correctly tracked, in the absence of braces
9158 verifyFormat("for (int i = 0; i < n; i++)\n"
9159 " j = i;\n"
9160 "double x = 1;\n",
9161 Alignment);
9162 verifyFormat("if (int i = 0)\n"
9163 " j = i;\n"
9164 "double x = 1;\n",
9165 Alignment);
9166 // Ensure operator[] and operator() are comprehended
9167 verifyFormat("struct test {\n"
9168 " long long int foo();\n"
9169 " int operator[](int a);\n"
9170 " double bar();\n"
9171 "};\n",
9172 Alignment);
9173 verifyFormat("struct test {\n"
9174 " long long int foo();\n"
9175 " int operator()(int a);\n"
9176 " double bar();\n"
9177 "};\n",
9178 Alignment);
Daniel Jaspere12597c2015-10-01 10:06:54 +00009179 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
9180 " int const i = 1;\n"
9181 " int * j = 2;\n"
9182 " int big = 10000;\n"
9183 "\n"
9184 " unsigned oneTwoThree = 123;\n"
9185 " int oneTwo = 12;\n"
9186 " method();\n"
9187 " float k = 2;\n"
9188 " int ll = 10000;\n"
9189 "}",
9190 format("void SomeFunction(int parameter= 0) {\n"
9191 " int const i= 1;\n"
9192 " int *j=2;\n"
9193 " int big = 10000;\n"
9194 "\n"
9195 "unsigned oneTwoThree =123;\n"
9196 "int oneTwo = 12;\n"
9197 " method();\n"
9198 "float k= 2;\n"
9199 "int ll=10000;\n"
9200 "}",
9201 Alignment));
9202 Alignment.AlignConsecutiveAssignments = false;
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +00009203 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
9204 verifyFormat("#define A \\\n"
9205 " int aaaa = 12; \\\n"
9206 " float b = 23; \\\n"
9207 " const int ccc = 234; \\\n"
9208 " unsigned dddddddddd = 2345;",
9209 Alignment);
9210 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
Daniel Jaspere12597c2015-10-01 10:06:54 +00009211 verifyFormat("#define A \\\n"
9212 " int aaaa = 12; \\\n"
9213 " float b = 23; \\\n"
9214 " const int ccc = 234; \\\n"
9215 " unsigned dddddddddd = 2345;",
9216 Alignment);
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +00009217 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
Daniel Jaspere12597c2015-10-01 10:06:54 +00009218 Alignment.ColumnLimit = 30;
9219 verifyFormat("#define A \\\n"
9220 " int aaaa = 12; \\\n"
9221 " float b = 23; \\\n"
9222 " const int ccc = 234; \\\n"
9223 " int dddddddddd = 2345;",
9224 Alignment);
9225 Alignment.ColumnLimit = 80;
9226 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
9227 "k = 4, int l = 5,\n"
9228 " int m = 6) {\n"
9229 " const int j = 10;\n"
9230 " otherThing = 1;\n"
9231 "}",
9232 Alignment);
9233 verifyFormat("void SomeFunction(int parameter = 0) {\n"
9234 " int const i = 1;\n"
9235 " int * j = 2;\n"
9236 " int big = 10000;\n"
9237 "}",
9238 Alignment);
9239 verifyFormat("class C {\n"
9240 "public:\n"
9241 " int i = 1;\n"
9242 " virtual void f() = 0;\n"
9243 "};",
9244 Alignment);
9245 verifyFormat("float i = 1;\n"
9246 "if (SomeType t = getSomething()) {\n"
9247 "}\n"
9248 "const unsigned j = 2;\n"
9249 "int big = 10000;",
9250 Alignment);
9251 verifyFormat("float j = 7;\n"
9252 "for (int k = 0; k < N; ++k) {\n"
9253 "}\n"
9254 "unsigned j = 2;\n"
9255 "int big = 10000;\n"
9256 "}",
9257 Alignment);
9258 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
9259 verifyFormat("float i = 1;\n"
9260 "LooooooooooongType loooooooooooooooooooooongVariable\n"
9261 " = someLooooooooooooooooongFunction();\n"
9262 "int j = 2;",
9263 Alignment);
9264 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
9265 verifyFormat("int i = 1;\n"
9266 "LooooooooooongType loooooooooooooooooooooongVariable =\n"
9267 " someLooooooooooooooooongFunction();\n"
9268 "int j = 2;",
9269 Alignment);
Daniel Jasper39828252015-10-07 15:03:26 +00009270
9271 Alignment.AlignConsecutiveAssignments = true;
9272 verifyFormat("auto lambda = []() {\n"
9273 " auto ii = 0;\n"
9274 " float j = 0;\n"
9275 " return 0;\n"
9276 "};\n"
9277 "int i = 0;\n"
9278 "float i2 = 0;\n"
9279 "auto v = type{\n"
9280 " i = 1, //\n"
9281 " (i = 2), //\n"
9282 " i = 3 //\n"
9283 "};",
9284 Alignment);
9285 Alignment.AlignConsecutiveAssignments = false;
9286
Daniel Jaspere12597c2015-10-01 10:06:54 +00009287 verifyFormat(
9288 "int i = 1;\n"
9289 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
9290 " loooooooooooooooooooooongParameterB);\n"
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00009291 "int j = 2;",
Daniel Jaspere12597c2015-10-01 10:06:54 +00009292 Alignment);
9293
9294 // Test interactions with ColumnLimit and AlignConsecutiveAssignments:
9295 // We expect declarations and assignments to align, as long as it doesn't
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00009296 // exceed the column limit, starting a new alignment sequence whenever it
Daniel Jaspere12597c2015-10-01 10:06:54 +00009297 // happens.
9298 Alignment.AlignConsecutiveAssignments = true;
9299 Alignment.ColumnLimit = 30;
9300 verifyFormat("float ii = 1;\n"
9301 "unsigned j = 2;\n"
9302 "int someVerylongVariable = 1;\n"
9303 "AnotherLongType ll = 123456;\n"
9304 "VeryVeryLongType k = 2;\n"
9305 "int myvar = 1;",
9306 Alignment);
9307 Alignment.ColumnLimit = 80;
Daniel Jasperec90e512015-12-01 12:00:43 +00009308 Alignment.AlignConsecutiveAssignments = false;
9309
9310 verifyFormat(
9311 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n"
9312 " typename LongType, typename B>\n"
9313 "auto foo() {}\n",
9314 Alignment);
9315 verifyFormat("float a, b = 1;\n"
9316 "int c = 2;\n"
9317 "int dd = 3;\n",
9318 Alignment);
9319 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n"
9320 "float b[1][] = {{3.f}};\n",
9321 Alignment);
9322 Alignment.AlignConsecutiveAssignments = true;
9323 verifyFormat("float a, b = 1;\n"
9324 "int c = 2;\n"
9325 "int dd = 3;\n",
9326 Alignment);
9327 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n"
9328 "float b[1][] = {{3.f}};\n",
9329 Alignment);
9330 Alignment.AlignConsecutiveAssignments = false;
9331
9332 Alignment.ColumnLimit = 30;
9333 Alignment.BinPackParameters = false;
9334 verifyFormat("void foo(float a,\n"
9335 " float b,\n"
9336 " int c,\n"
9337 " uint32_t *d) {\n"
9338 " int * e = 0;\n"
9339 " float f = 0;\n"
9340 " double g = 0;\n"
9341 "}\n"
9342 "void bar(ino_t a,\n"
9343 " int b,\n"
9344 " uint32_t *c,\n"
9345 " bool d) {}\n",
9346 Alignment);
9347 Alignment.BinPackParameters = true;
9348 Alignment.ColumnLimit = 80;
Daniel Jasper4917af62017-08-25 19:14:53 +00009349
9350 // Bug 33507
9351 Alignment.PointerAlignment = FormatStyle::PAS_Middle;
9352 verifyFormat(
9353 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n"
9354 " static const Version verVs2017;\n"
9355 " return true;\n"
9356 "});\n",
9357 Alignment);
9358 Alignment.PointerAlignment = FormatStyle::PAS_Right;
Daniel Jaspere12597c2015-10-01 10:06:54 +00009359}
9360
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009361TEST_F(FormatTest, LinuxBraceBreaking) {
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009362 FormatStyle LinuxBraceStyle = getLLVMStyle();
9363 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009364 verifyFormat("namespace a\n"
9365 "{\n"
9366 "class A\n"
9367 "{\n"
9368 " void f()\n"
9369 " {\n"
9370 " if (true) {\n"
9371 " a();\n"
9372 " b();\n"
Daniel Jasper96cbb502015-12-14 08:33:07 +00009373 " } else {\n"
9374 " a();\n"
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009375 " }\n"
9376 " }\n"
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00009377 " void g() { return; }\n"
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009378 "};\n"
9379 "struct B {\n"
9380 " int x;\n"
9381 "};\n"
Marek Kurdejcaf6fd52017-09-27 07:51:51 +00009382 "} // namespace a\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009383 LinuxBraceStyle);
9384 verifyFormat("enum X {\n"
9385 " Y = 0,\n"
9386 "}\n",
9387 LinuxBraceStyle);
9388 verifyFormat("struct S {\n"
9389 " int Type;\n"
9390 " union {\n"
9391 " int x;\n"
9392 " double y;\n"
9393 " } Value;\n"
9394 " class C\n"
9395 " {\n"
9396 " MyFavoriteType Value;\n"
9397 " } Class;\n"
9398 "}\n",
9399 LinuxBraceStyle);
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009400}
9401
Birunthan Mohanathas305fa9c2015-07-12 03:13:54 +00009402TEST_F(FormatTest, MozillaBraceBreaking) {
9403 FormatStyle MozillaBraceStyle = getLLVMStyle();
9404 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00009405 MozillaBraceStyle.FixNamespaceComments = false;
Birunthan Mohanathas305fa9c2015-07-12 03:13:54 +00009406 verifyFormat("namespace a {\n"
9407 "class A\n"
9408 "{\n"
9409 " void f()\n"
9410 " {\n"
9411 " if (true) {\n"
9412 " a();\n"
9413 " b();\n"
9414 " }\n"
9415 " }\n"
9416 " void g() { return; }\n"
9417 "};\n"
9418 "enum E\n"
9419 "{\n"
9420 " A,\n"
9421 " // foo\n"
9422 " B,\n"
9423 " C\n"
9424 "};\n"
9425 "struct B\n"
9426 "{\n"
9427 " int x;\n"
9428 "};\n"
9429 "}\n",
9430 MozillaBraceStyle);
9431 verifyFormat("struct S\n"
9432 "{\n"
9433 " int Type;\n"
9434 " union\n"
9435 " {\n"
9436 " int x;\n"
9437 " double y;\n"
9438 " } Value;\n"
9439 " class C\n"
9440 " {\n"
9441 " MyFavoriteType Value;\n"
9442 " } Class;\n"
9443 "}\n",
9444 MozillaBraceStyle);
9445}
9446
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009447TEST_F(FormatTest, StroustrupBraceBreaking) {
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009448 FormatStyle StroustrupBraceStyle = getLLVMStyle();
9449 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009450 verifyFormat("namespace a {\n"
9451 "class A {\n"
9452 " void f()\n"
9453 " {\n"
9454 " if (true) {\n"
9455 " a();\n"
9456 " b();\n"
9457 " }\n"
9458 " }\n"
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00009459 " void g() { return; }\n"
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009460 "};\n"
9461 "struct B {\n"
9462 " int x;\n"
9463 "};\n"
Krasimir Georgiev9163fe22017-03-02 09:54:44 +00009464 "} // namespace a\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009465 StroustrupBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009466
Daniel Jasperd9670872014-08-05 12:06:20 +00009467 verifyFormat("void foo()\n"
9468 "{\n"
9469 " if (a) {\n"
9470 " a();\n"
9471 " }\n"
9472 " else {\n"
9473 " b();\n"
9474 " }\n"
9475 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009476 StroustrupBraceStyle);
Daniel Jasperd9670872014-08-05 12:06:20 +00009477
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009478 verifyFormat("#ifdef _DEBUG\n"
9479 "int foo(int i = 0)\n"
9480 "#else\n"
9481 "int foo(int i = 5)\n"
9482 "#endif\n"
9483 "{\n"
9484 " return i;\n"
9485 "}",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009486 StroustrupBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009487
9488 verifyFormat("void foo() {}\n"
9489 "void bar()\n"
9490 "#ifdef _DEBUG\n"
9491 "{\n"
9492 " foo();\n"
9493 "}\n"
9494 "#else\n"
9495 "{\n"
9496 "}\n"
9497 "#endif",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009498 StroustrupBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009499
9500 verifyFormat("void foobar() { int i = 5; }\n"
9501 "#ifdef _DEBUG\n"
9502 "void bar() {}\n"
9503 "#else\n"
9504 "void bar() { foobar(); }\n"
9505 "#endif",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009506 StroustrupBraceStyle);
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009507}
9508
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00009509TEST_F(FormatTest, AllmanBraceBreaking) {
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009510 FormatStyle AllmanBraceStyle = getLLVMStyle();
9511 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;
Marek Kurdejcaf6fd52017-09-27 07:51:51 +00009512
9513 EXPECT_EQ("namespace a\n"
9514 "{\n"
9515 "void f();\n"
9516 "void g();\n"
9517 "} // namespace a\n",
9518 format("namespace a\n"
9519 "{\n"
9520 "void f();\n"
9521 "void g();\n"
9522 "}\n",
9523 AllmanBraceStyle));
9524
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00009525 verifyFormat("namespace a\n"
9526 "{\n"
9527 "class A\n"
9528 "{\n"
9529 " void f()\n"
9530 " {\n"
9531 " if (true)\n"
9532 " {\n"
9533 " a();\n"
9534 " b();\n"
9535 " }\n"
9536 " }\n"
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00009537 " void g() { return; }\n"
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009538 "};\n"
9539 "struct B\n"
9540 "{\n"
9541 " int x;\n"
9542 "};\n"
Marek Kurdejcaf6fd52017-09-27 07:51:51 +00009543 "} // namespace a",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009544 AllmanBraceStyle);
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00009545
9546 verifyFormat("void f()\n"
9547 "{\n"
9548 " if (true)\n"
9549 " {\n"
9550 " a();\n"
9551 " }\n"
9552 " else if (false)\n"
9553 " {\n"
9554 " b();\n"
9555 " }\n"
9556 " else\n"
9557 " {\n"
9558 " c();\n"
9559 " }\n"
9560 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009561 AllmanBraceStyle);
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00009562
9563 verifyFormat("void f()\n"
9564 "{\n"
9565 " for (int i = 0; i < 10; ++i)\n"
9566 " {\n"
9567 " a();\n"
9568 " }\n"
9569 " while (false)\n"
9570 " {\n"
9571 " b();\n"
9572 " }\n"
9573 " do\n"
9574 " {\n"
9575 " c();\n"
9576 " } while (false)\n"
9577 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009578 AllmanBraceStyle);
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00009579
9580 verifyFormat("void f(int a)\n"
9581 "{\n"
9582 " switch (a)\n"
9583 " {\n"
9584 " case 0:\n"
9585 " break;\n"
9586 " case 1:\n"
9587 " {\n"
9588 " break;\n"
9589 " }\n"
9590 " case 2:\n"
9591 " {\n"
9592 " }\n"
9593 " break;\n"
9594 " default:\n"
9595 " break;\n"
9596 " }\n"
9597 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009598 AllmanBraceStyle);
Manuel Klimeka027f302013-08-07 19:20:45 +00009599
9600 verifyFormat("enum X\n"
9601 "{\n"
9602 " Y = 0,\n"
9603 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009604 AllmanBraceStyle);
Daniel Jaspere18ff372014-06-02 10:17:32 +00009605 verifyFormat("enum X\n"
9606 "{\n"
9607 " Y = 0\n"
9608 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009609 AllmanBraceStyle);
Manuel Klimeka027f302013-08-07 19:20:45 +00009610
Dinesh Dwivediea3aca82014-05-02 17:01:46 +00009611 verifyFormat("@interface BSApplicationController ()\n"
9612 "{\n"
9613 "@private\n"
9614 " id _extraIvar;\n"
9615 "}\n"
9616 "@end\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009617 AllmanBraceStyle);
Dinesh Dwivediea3aca82014-05-02 17:01:46 +00009618
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009619 verifyFormat("#ifdef _DEBUG\n"
9620 "int foo(int i = 0)\n"
9621 "#else\n"
9622 "int foo(int i = 5)\n"
9623 "#endif\n"
9624 "{\n"
9625 " return i;\n"
9626 "}",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009627 AllmanBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009628
9629 verifyFormat("void foo() {}\n"
9630 "void bar()\n"
9631 "#ifdef _DEBUG\n"
9632 "{\n"
9633 " foo();\n"
9634 "}\n"
9635 "#else\n"
9636 "{\n"
9637 "}\n"
9638 "#endif",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009639 AllmanBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009640
9641 verifyFormat("void foobar() { int i = 5; }\n"
9642 "#ifdef _DEBUG\n"
9643 "void bar() {}\n"
9644 "#else\n"
9645 "void bar() { foobar(); }\n"
9646 "#endif",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009647 AllmanBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009648
Daniel Jasperba1b6bb2014-05-26 07:24:34 +00009649 // This shouldn't affect ObjC blocks..
Daniel Jasper565ed5e2014-05-22 13:53:55 +00009650 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +00009651 " // ...\n"
9652 " int i;\n"
Daniel Jasperba1b6bb2014-05-26 07:24:34 +00009653 "}];",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009654 AllmanBraceStyle);
Daniel Jasper565ed5e2014-05-22 13:53:55 +00009655 verifyFormat("void (^block)(void) = ^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +00009656 " // ...\n"
9657 " int i;\n"
Daniel Jasperba1b6bb2014-05-26 07:24:34 +00009658 "};",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009659 AllmanBraceStyle);
Daniel Jasperba1b6bb2014-05-26 07:24:34 +00009660 // .. or dict literals.
9661 verifyFormat("void f()\n"
9662 "{\n"
Alexander Kornienkod4fa2e62017-04-11 09:55:00 +00009663 " // ...\n"
9664 " [object someMethod:@{@\"a\" : @\"b\"}];\n"
9665 "}",
9666 AllmanBraceStyle);
9667 verifyFormat("void f()\n"
9668 "{\n"
9669 " // ...\n"
9670 " [object someMethod:@{a : @\"b\"}];\n"
Daniel Jasperba1b6bb2014-05-26 07:24:34 +00009671 "}",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009672 AllmanBraceStyle);
Daniel Jasper55aed672014-12-07 16:44:49 +00009673 verifyFormat("int f()\n"
9674 "{ // comment\n"
9675 " return 42;\n"
9676 "}",
9677 AllmanBraceStyle);
Daniel Jasper565ed5e2014-05-22 13:53:55 +00009678
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009679 AllmanBraceStyle.ColumnLimit = 19;
9680 verifyFormat("void f() { int i; }", AllmanBraceStyle);
9681 AllmanBraceStyle.ColumnLimit = 18;
Daniel Jasper234379f2013-12-24 13:31:25 +00009682 verifyFormat("void f()\n"
9683 "{\n"
9684 " int i;\n"
9685 "}",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009686 AllmanBraceStyle);
9687 AllmanBraceStyle.ColumnLimit = 80;
Daniel Jasper234379f2013-12-24 13:31:25 +00009688
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009689 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle;
Manuel Klimeka027f302013-08-07 19:20:45 +00009690 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = true;
9691 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
9692 verifyFormat("void f(bool b)\n"
9693 "{\n"
9694 " if (b)\n"
9695 " {\n"
9696 " return;\n"
9697 " }\n"
9698 "}\n",
9699 BreakBeforeBraceShortIfs);
9700 verifyFormat("void f(bool b)\n"
9701 "{\n"
Daniel Jasper6a7d5a72017-06-19 07:40:49 +00009702 " if constexpr (b)\n"
9703 " {\n"
9704 " return;\n"
9705 " }\n"
9706 "}\n",
9707 BreakBeforeBraceShortIfs);
9708 verifyFormat("void f(bool b)\n"
9709 "{\n"
Manuel Klimeka027f302013-08-07 19:20:45 +00009710 " if (b) return;\n"
9711 "}\n",
9712 BreakBeforeBraceShortIfs);
9713 verifyFormat("void f(bool b)\n"
9714 "{\n"
Daniel Jasper6a7d5a72017-06-19 07:40:49 +00009715 " if constexpr (b) return;\n"
9716 "}\n",
9717 BreakBeforeBraceShortIfs);
9718 verifyFormat("void f(bool b)\n"
9719 "{\n"
Manuel Klimeka027f302013-08-07 19:20:45 +00009720 " while (b)\n"
9721 " {\n"
9722 " return;\n"
9723 " }\n"
9724 "}\n",
9725 BreakBeforeBraceShortIfs);
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00009726}
9727
Alexander Kornienko3a33f022013-12-12 09:49:52 +00009728TEST_F(FormatTest, GNUBraceBreaking) {
9729 FormatStyle GNUBraceStyle = getLLVMStyle();
9730 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU;
9731 verifyFormat("namespace a\n"
9732 "{\n"
9733 "class A\n"
9734 "{\n"
9735 " void f()\n"
9736 " {\n"
9737 " int a;\n"
9738 " {\n"
9739 " int b;\n"
9740 " }\n"
9741 " if (true)\n"
9742 " {\n"
9743 " a();\n"
9744 " b();\n"
9745 " }\n"
9746 " }\n"
9747 " void g() { return; }\n"
9748 "}\n"
Marek Kurdejcaf6fd52017-09-27 07:51:51 +00009749 "} // namespace a",
Alexander Kornienko3a33f022013-12-12 09:49:52 +00009750 GNUBraceStyle);
9751
9752 verifyFormat("void f()\n"
9753 "{\n"
9754 " if (true)\n"
9755 " {\n"
9756 " a();\n"
9757 " }\n"
9758 " else if (false)\n"
9759 " {\n"
9760 " b();\n"
9761 " }\n"
9762 " else\n"
9763 " {\n"
9764 " c();\n"
9765 " }\n"
9766 "}\n",
9767 GNUBraceStyle);
9768
9769 verifyFormat("void f()\n"
9770 "{\n"
9771 " for (int i = 0; i < 10; ++i)\n"
9772 " {\n"
9773 " a();\n"
9774 " }\n"
9775 " while (false)\n"
9776 " {\n"
9777 " b();\n"
9778 " }\n"
9779 " do\n"
9780 " {\n"
9781 " c();\n"
9782 " }\n"
9783 " while (false);\n"
9784 "}\n",
9785 GNUBraceStyle);
9786
9787 verifyFormat("void f(int a)\n"
9788 "{\n"
9789 " switch (a)\n"
9790 " {\n"
9791 " case 0:\n"
9792 " break;\n"
9793 " case 1:\n"
9794 " {\n"
9795 " break;\n"
9796 " }\n"
9797 " case 2:\n"
9798 " {\n"
9799 " }\n"
9800 " break;\n"
9801 " default:\n"
9802 " break;\n"
9803 " }\n"
9804 "}\n",
9805 GNUBraceStyle);
9806
9807 verifyFormat("enum X\n"
9808 "{\n"
9809 " Y = 0,\n"
9810 "}\n",
9811 GNUBraceStyle);
Dinesh Dwivediea3aca82014-05-02 17:01:46 +00009812
9813 verifyFormat("@interface BSApplicationController ()\n"
9814 "{\n"
9815 "@private\n"
9816 " id _extraIvar;\n"
9817 "}\n"
9818 "@end\n",
9819 GNUBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009820
9821 verifyFormat("#ifdef _DEBUG\n"
9822 "int foo(int i = 0)\n"
9823 "#else\n"
9824 "int foo(int i = 5)\n"
9825 "#endif\n"
9826 "{\n"
9827 " return i;\n"
9828 "}",
9829 GNUBraceStyle);
9830
9831 verifyFormat("void foo() {}\n"
9832 "void bar()\n"
9833 "#ifdef _DEBUG\n"
9834 "{\n"
9835 " foo();\n"
9836 "}\n"
9837 "#else\n"
9838 "{\n"
9839 "}\n"
9840 "#endif",
9841 GNUBraceStyle);
9842
9843 verifyFormat("void foobar() { int i = 5; }\n"
9844 "#ifdef _DEBUG\n"
9845 "void bar() {}\n"
9846 "#else\n"
9847 "void bar() { foobar(); }\n"
9848 "#endif",
9849 GNUBraceStyle);
Alexander Kornienko3a33f022013-12-12 09:49:52 +00009850}
Roman Kashitsyn291f64f2015-08-10 13:43:19 +00009851
9852TEST_F(FormatTest, WebKitBraceBreaking) {
9853 FormatStyle WebKitBraceStyle = getLLVMStyle();
9854 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit;
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00009855 WebKitBraceStyle.FixNamespaceComments = false;
Roman Kashitsyn291f64f2015-08-10 13:43:19 +00009856 verifyFormat("namespace a {\n"
9857 "class A {\n"
9858 " void f()\n"
9859 " {\n"
9860 " if (true) {\n"
9861 " a();\n"
9862 " b();\n"
9863 " }\n"
9864 " }\n"
9865 " void g() { return; }\n"
9866 "};\n"
9867 "enum E {\n"
9868 " A,\n"
9869 " // foo\n"
9870 " B,\n"
9871 " C\n"
9872 "};\n"
9873 "struct B {\n"
9874 " int x;\n"
9875 "};\n"
9876 "}\n",
9877 WebKitBraceStyle);
9878 verifyFormat("struct S {\n"
9879 " int Type;\n"
9880 " union {\n"
9881 " int x;\n"
9882 " double y;\n"
9883 " } Value;\n"
9884 " class C {\n"
9885 " MyFavoriteType Value;\n"
9886 " } Class;\n"
9887 "};\n",
9888 WebKitBraceStyle);
9889}
9890
Manuel Klimekd5735502013-08-12 03:51:17 +00009891TEST_F(FormatTest, CatchExceptionReferenceBinding) {
9892 verifyFormat("void f() {\n"
9893 " try {\n"
Daniel Jasper04a71a42014-05-08 11:58:24 +00009894 " } catch (const Exception &e) {\n"
Manuel Klimekd5735502013-08-12 03:51:17 +00009895 " }\n"
9896 "}\n",
9897 getLLVMStyle());
9898}
9899
Daniel Jasper9613c812013-08-07 16:29:23 +00009900TEST_F(FormatTest, UnderstandsPragmas) {
9901 verifyFormat("#pragma omp reduction(| : var)");
9902 verifyFormat("#pragma omp reduction(+ : var)");
Daniel Jasperdc32c1b2014-01-09 13:56:49 +00009903
9904 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
9905 "(including parentheses).",
9906 format("#pragma mark Any non-hyphenated or hyphenated string "
9907 "(including parentheses)."));
Daniel Jasper9613c812013-08-07 16:29:23 +00009908}
9909
Daniel Jasperee4a8a12015-04-22 09:45:42 +00009910TEST_F(FormatTest, UnderstandPragmaOption) {
9911 verifyFormat("#pragma option -C -A");
9912
9913 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A"));
9914}
9915
Manuel Klimek77866142017-11-17 11:17:15 +00009916TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) {
9917 FormatStyle Style = getLLVMStyle();
9918 Style.ColumnLimit = 20;
9919
9920 verifyFormat("int a; // the\n"
9921 " // comment", Style);
9922 EXPECT_EQ("int a; /* first line\n"
9923 " * second\n"
9924 " * line third\n"
9925 " * line\n"
9926 " */",
9927 format("int a; /* first line\n"
9928 " * second\n"
9929 " * line third\n"
9930 " * line\n"
9931 " */",
9932 Style));
9933 EXPECT_EQ("int a; // first line\n"
9934 " // second\n"
9935 " // line third\n"
9936 " // line",
9937 format("int a; // first line\n"
9938 " // second line\n"
9939 " // third line",
9940 Style));
9941
9942 Style.PenaltyExcessCharacter = 90;
9943 verifyFormat("int a; // the comment", Style);
Manuel Klimek93699f42017-11-29 14:29:43 +00009944 EXPECT_EQ("int a; // the comment\n"
Manuel Klimek0b58c322017-12-01 13:28:08 +00009945 " // aaa",
9946 format("int a; // the comment aaa", Style));
Manuel Klimek77866142017-11-17 11:17:15 +00009947 EXPECT_EQ("int a; /* first line\n"
9948 " * second line\n"
9949 " * third line\n"
9950 " */",
9951 format("int a; /* first line\n"
9952 " * second line\n"
9953 " * third line\n"
9954 " */",
9955 Style));
Manuel Klimek93699f42017-11-29 14:29:43 +00009956 EXPECT_EQ("int a; // first line\n"
9957 " // second line\n"
9958 " // third line",
9959 format("int a; // first line\n"
9960 " // second line\n"
9961 " // third line",
9962 Style));
Manuel Klimek77866142017-11-17 11:17:15 +00009963 // FIXME: Investigate why this is not getting the same layout as the test
9964 // above.
9965 EXPECT_EQ("int a; /* first line\n"
Manuel Klimek93699f42017-11-29 14:29:43 +00009966 " * second line\n"
9967 " * third line\n"
Manuel Klimek77866142017-11-17 11:17:15 +00009968 " */",
9969 format("int a; /* first line second line third line"
9970 "\n*/",
9971 Style));
9972
9973 EXPECT_EQ("// foo bar baz bazfoo\n"
Manuel Klimek0b58c322017-12-01 13:28:08 +00009974 "// foo bar foo bar\n",
Manuel Klimek77866142017-11-17 11:17:15 +00009975 format("// foo bar baz bazfoo\n"
Manuel Klimek0b58c322017-12-01 13:28:08 +00009976 "// foo bar foo bar\n",
Manuel Klimek77866142017-11-17 11:17:15 +00009977 Style));
9978 EXPECT_EQ("// foo bar baz bazfoo\n"
Manuel Klimek0b58c322017-12-01 13:28:08 +00009979 "// foo bar foo bar\n",
Manuel Klimek77866142017-11-17 11:17:15 +00009980 format("// foo bar baz bazfoo\n"
Manuel Klimek0b58c322017-12-01 13:28:08 +00009981 "// foo bar foo bar\n",
Manuel Klimek77866142017-11-17 11:17:15 +00009982 Style));
9983
9984 // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the
9985 // next one.
Manuel Klimek93699f42017-11-29 14:29:43 +00009986 EXPECT_EQ("// foo bar baz bazfoo\n"
9987 "// bar foo bar\n",
Manuel Klimek77866142017-11-17 11:17:15 +00009988 format("// foo bar baz bazfoo bar\n"
9989 "// foo bar\n",
9990 Style));
9991
9992 EXPECT_EQ("// foo bar baz bazfoo\n"
Manuel Klimek93699f42017-11-29 14:29:43 +00009993 "// foo bar baz bazfoo\n"
9994 "// bar foo bar\n",
Manuel Klimek77866142017-11-17 11:17:15 +00009995 format("// foo bar baz bazfoo\n"
9996 "// foo bar baz bazfoo bar\n"
9997 "// foo bar\n",
9998 Style));
9999
Manuel Klimek77866142017-11-17 11:17:15 +000010000 EXPECT_EQ("// foo bar baz bazfoo\n"
Manuel Klimek93699f42017-11-29 14:29:43 +000010001 "// foo bar baz bazfoo\n"
10002 "// bar foo bar\n",
Manuel Klimek77866142017-11-17 11:17:15 +000010003 format("// foo bar baz bazfoo\n"
10004 "// foo bar baz bazfoo bar\n"
10005 "// foo bar\n",
10006 Style));
Manuel Klimek0b58c322017-12-01 13:28:08 +000010007
10008 // Make sure we do not keep protruding characters if strict mode reflow is
10009 // cheaper than keeping protruding characters.
10010 Style.ColumnLimit = 21;
10011 EXPECT_EQ("// foo foo foo foo\n"
10012 "// foo foo foo foo\n"
10013 "// foo foo foo foo\n",
10014 format("// foo foo foo foo foo foo foo foo foo foo foo foo\n",
10015 Style));
10016
10017 EXPECT_EQ("int a = /* long block\n"
10018 " comment */\n"
10019 " 42;",
10020 format("int a = /* long block comment */ 42;", Style));
Manuel Klimek77866142017-11-17 11:17:15 +000010021}
10022
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010023#define EXPECT_ALL_STYLES_EQUAL(Styles) \
10024 for (size_t i = 1; i < Styles.size(); ++i) \
Daniel Jaspera44991332015-04-29 13:06:49 +000010025 EXPECT_EQ(Styles[0], Styles[i]) << "Style #" << i << " of " << Styles.size() \
10026 << " differs from Style #0"
Alexander Kornienkod6538332013-05-07 15:32:14 +000010027
10028TEST_F(FormatTest, GetsPredefinedStyleByName) {
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010029 SmallVector<FormatStyle, 3> Styles;
10030 Styles.resize(3);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010031
Alexander Kornienko006b5c82013-05-19 00:53:30 +000010032 Styles[0] = getLLVMStyle();
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010033 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
10034 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
10035 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010036
Alexander Kornienko006b5c82013-05-19 00:53:30 +000010037 Styles[0] = getGoogleStyle();
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010038 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
10039 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
10040 EXPECT_ALL_STYLES_EQUAL(Styles);
10041
Nico Weber514ecc82014-02-02 20:50:45 +000010042 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010043 EXPECT_TRUE(
10044 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
10045 EXPECT_TRUE(
10046 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
10047 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010048
Nico Weber514ecc82014-02-02 20:50:45 +000010049 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010050 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
10051 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
10052 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienko006b5c82013-05-19 00:53:30 +000010053
10054 Styles[0] = getMozillaStyle();
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010055 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
10056 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
10057 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienko006b5c82013-05-19 00:53:30 +000010058
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010059 Styles[0] = getWebKitStyle();
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010060 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
10061 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
10062 EXPECT_ALL_STYLES_EQUAL(Styles);
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010063
Alexander Kornienkofe7a57f2013-12-10 15:42:15 +000010064 Styles[0] = getGNUStyle();
10065 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
10066 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
10067 EXPECT_ALL_STYLES_EQUAL(Styles);
10068
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010069 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
10070}
10071
10072TEST_F(FormatTest, GetsCorrectBasedOnStyle) {
10073 SmallVector<FormatStyle, 8> Styles;
10074 Styles.resize(2);
10075
10076 Styles[0] = getGoogleStyle();
10077 Styles[1] = getLLVMStyle();
10078 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
10079 EXPECT_ALL_STYLES_EQUAL(Styles);
10080
10081 Styles.resize(5);
Nico Weber514ecc82014-02-02 20:50:45 +000010082 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010083 Styles[1] = getLLVMStyle();
10084 Styles[1].Language = FormatStyle::LK_JavaScript;
10085 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
10086
10087 Styles[2] = getLLVMStyle();
10088 Styles[2].Language = FormatStyle::LK_JavaScript;
10089 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
10090 "BasedOnStyle: Google",
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +000010091 &Styles[2])
10092 .value());
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010093
10094 Styles[3] = getLLVMStyle();
10095 Styles[3].Language = FormatStyle::LK_JavaScript;
10096 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
10097 "Language: JavaScript",
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +000010098 &Styles[3])
10099 .value());
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010100
10101 Styles[4] = getLLVMStyle();
10102 Styles[4].Language = FormatStyle::LK_JavaScript;
10103 EXPECT_EQ(0, parseConfiguration("---\n"
10104 "BasedOnStyle: LLVM\n"
10105 "IndentWidth: 123\n"
10106 "---\n"
10107 "BasedOnStyle: Google\n"
10108 "Language: JavaScript",
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +000010109 &Styles[4])
10110 .value());
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010111 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010112}
10113
Daniel Jasper91881d92014-09-29 08:07:46 +000010114#define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \
Alexander Kornienkod6538332013-05-07 15:32:14 +000010115 Style.FIELD = false; \
Daniel Jasper91881d92014-09-29 08:07:46 +000010116 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \
Alexander Kornienko006b5c82013-05-19 00:53:30 +000010117 EXPECT_TRUE(Style.FIELD); \
Daniel Jasper91881d92014-09-29 08:07:46 +000010118 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \
Patrik Hagglund76aca642013-05-14 07:53:53 +000010119 EXPECT_FALSE(Style.FIELD);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010120
Daniel Jasper91881d92014-09-29 08:07:46 +000010121#define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
10122
Daniel Jasperc1bc38e2015-09-29 14:57:55 +000010123#define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \
10124 Style.STRUCT.FIELD = false; \
10125 EXPECT_EQ(0, \
10126 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \
10127 .value()); \
10128 EXPECT_TRUE(Style.STRUCT.FIELD); \
10129 EXPECT_EQ(0, \
10130 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \
10131 .value()); \
10132 EXPECT_FALSE(Style.STRUCT.FIELD);
10133
10134#define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \
10135 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD)
10136
Daniel Jasper00853002014-09-16 16:22:30 +000010137#define CHECK_PARSE(TEXT, FIELD, VALUE) \
10138 EXPECT_NE(VALUE, Style.FIELD); \
10139 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \
10140 EXPECT_EQ(VALUE, Style.FIELD)
10141
Alexander Kornienkoc6221a52014-08-14 13:07:35 +000010142TEST_F(FormatTest, ParsesConfigurationBools) {
Alexander Kornienkocabdd732013-11-29 15:19:43 +000010143 FormatStyle Style = {};
10144 Style.Language = FormatStyle::LK_Cpp;
Daniel Jasper3219e432014-12-02 13:24:51 +000010145 CHECK_PARSE_BOOL(AlignOperands);
Daniel Jasper552f4a72013-07-31 23:55:15 +000010146 CHECK_PARSE_BOOL(AlignTrailingComments);
Daniel Jaspera44991332015-04-29 13:06:49 +000010147 CHECK_PARSE_BOOL(AlignConsecutiveAssignments);
Daniel Jaspere12597c2015-10-01 10:06:54 +000010148 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010149 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
Daniel Jasper17605d32014-05-14 09:33:35 +000010150 CHECK_PARSE_BOOL(AllowShortBlocksOnASingleLine);
Daniel Jasperb87899b2014-09-10 13:11:45 +000010151 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010152 CHECK_PARSE_BOOL(AllowShortIfStatementsOnASingleLine);
Daniel Jasper997af662013-05-16 12:16:23 +000010153 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
Daniel Jasper61e6bbf2013-05-29 12:07:31 +000010154 CHECK_PARSE_BOOL(AlwaysBreakTemplateDeclarations);
Daniel Jasper18210d72014-10-09 09:52:05 +000010155 CHECK_PARSE_BOOL(BinPackArguments);
Daniel Jasper6501f7e2015-10-27 12:38:37 +000010156 CHECK_PARSE_BOOL(BinPackParameters);
Daniel Jaspere1a7b762016-02-01 11:21:02 +000010157 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
Daniel Jasper165b29e2013-11-08 00:57:11 +000010158 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
Daniel Jaspere1a7b762016-02-01 11:21:02 +000010159 CHECK_PARSE_BOOL(BreakStringLiterals);
Andi-Bogdan Postelnicu0ef8ee12017-03-10 15:10:37 +000010160 CHECK_PARSE_BOOL(BreakBeforeInheritanceComma)
Francois Ferrande56a8292017-06-14 12:29:47 +000010161 CHECK_PARSE_BOOL(CompactNamespaces);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010162 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
Daniel Jasper553d4872014-06-17 12:40:34 +000010163 CHECK_PARSE_BOOL(DerivePointerAlignment);
Daniel Jasper91881d92014-09-29 08:07:46 +000010164 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
Daniel Jasperda446772015-11-16 12:38:56 +000010165 CHECK_PARSE_BOOL(DisableFormat);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010166 CHECK_PARSE_BOOL(IndentCaseLabels);
Daniel Jasperc75e1ef2014-07-09 08:42:42 +000010167 CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
Daniel Jaspera26fc5c2014-03-21 13:43:14 +000010168 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
Daniel Jaspere9beea22014-01-28 15:20:33 +000010169 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010170 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
Daniel Jasper6ab54682013-07-16 18:22:10 +000010171 CHECK_PARSE_BOOL(Cpp11BracedListStyle);
Daniel Jaspera0a50392015-12-01 13:28:53 +000010172 CHECK_PARSE_BOOL(ReflowComments);
Daniel Jasperda446772015-11-16 12:38:56 +000010173 CHECK_PARSE_BOOL(SortIncludes);
Krasimir Georgievac16a202017-06-23 11:46:03 +000010174 CHECK_PARSE_BOOL(SortUsingDeclarations);
Daniel Jasperb55acad2013-08-20 12:36:34 +000010175 CHECK_PARSE_BOOL(SpacesInParentheses);
Daniel Jasperad981f82014-08-26 11:41:14 +000010176 CHECK_PARSE_BOOL(SpacesInSquareBrackets);
Daniel Jasperdd978ae2013-10-29 14:52:02 +000010177 CHECK_PARSE_BOOL(SpacesInAngles);
Daniel Jasperb55acad2013-08-20 12:36:34 +000010178 CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
Daniel Jasperb2e10a52014-01-15 15:09:08 +000010179 CHECK_PARSE_BOOL(SpacesInContainerLiterals);
Daniel Jasperb55acad2013-08-20 12:36:34 +000010180 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
Daniel Jasperdb986eb2014-09-03 07:37:29 +000010181 CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
Sylvestre Ledru83bbd572016-08-09 14:24:40 +000010182 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
Daniel Jasperd94bff32013-09-25 15:15:02 +000010183 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
Daniel Jasperc1bc38e2015-09-29 14:57:55 +000010184
10185 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass);
10186 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterControlStatement);
10187 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum);
10188 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction);
10189 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace);
10190 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration);
10191 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct);
10192 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion);
Krasimir Georgievd6ce9372017-09-15 11:23:50 +000010193 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock);
Daniel Jasperc1bc38e2015-09-29 14:57:55 +000010194 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch);
10195 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse);
10196 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces);
Francois Ferrandad722562017-06-30 20:25:55 +000010197 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction);
10198 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord);
10199 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace);
Alexander Kornienkoc6221a52014-08-14 13:07:35 +000010200}
Alexander Kornienkod6538332013-05-07 15:32:14 +000010201
Alexander Kornienkoc6221a52014-08-14 13:07:35 +000010202#undef CHECK_PARSE_BOOL
10203
Alexander Kornienkoc6221a52014-08-14 13:07:35 +000010204TEST_F(FormatTest, ParsesConfiguration) {
10205 FormatStyle Style = {};
10206 Style.Language = FormatStyle::LK_Cpp;
Alexander Kornienkod6538332013-05-07 15:32:14 +000010207 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010208 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
10209 ConstructorInitializerIndentWidth, 1234u);
Daniel Jasper50d634b2014-10-28 16:53:38 +000010210 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010211 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
10212 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
Francois Ferrand9976efa2017-05-22 08:28:17 +000010213 CHECK_PARSE("PenaltyBreakAssignment: 1234",
10214 PenaltyBreakAssignment, 1234u);
Daniel Jasper33b909c2013-10-25 14:29:37 +000010215 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
10216 PenaltyBreakBeforeFirstCallParameter, 1234u);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010217 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
10218 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
10219 PenaltyReturnTypeOnItsOwnLine, 1234u);
10220 CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
10221 SpacesBeforeTrailingComments, 1234u);
Manuel Klimek13b97d82013-05-13 08:42:42 +000010222 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
Daniel Jasper6633ab82013-10-18 10:38:14 +000010223 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
Daniel Jasper9c8ff352016-03-21 14:11:27 +000010224 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
Alexander Kornienkod6538332013-05-07 15:32:14 +000010225
Daniel Jasper553d4872014-06-17 12:40:34 +000010226 Style.PointerAlignment = FormatStyle::PAS_Middle;
Daniel Jasperac043c92014-09-15 11:11:00 +000010227 CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
10228 FormatStyle::PAS_Left);
10229 CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
10230 FormatStyle::PAS_Right);
10231 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
10232 FormatStyle::PAS_Middle);
Daniel Jasper00853002014-09-16 16:22:30 +000010233 // For backward compatibility:
10234 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
10235 FormatStyle::PAS_Left);
10236 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
10237 FormatStyle::PAS_Right);
10238 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
10239 FormatStyle::PAS_Middle);
Daniel Jasper553d4872014-06-17 12:40:34 +000010240
Alexander Kornienkod6538332013-05-07 15:32:14 +000010241 Style.Standard = FormatStyle::LS_Auto;
Alexander Kornienkob40cfe42013-09-04 14:09:13 +000010242 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
10243 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Cpp11);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010244 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
10245 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
10246 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
10247
Daniel Jasperac043c92014-09-15 11:11:00 +000010248 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
Daniel Jasperac043c92014-09-15 11:11:00 +000010249 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
10250 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
Daniel Jasperac043c92014-09-15 11:11:00 +000010251 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
10252 FormatStyle::BOS_None);
10253 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
10254 FormatStyle::BOS_All);
Daniel Jasper00853002014-09-16 16:22:30 +000010255 // For backward compatibility:
10256 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
10257 FormatStyle::BOS_None);
10258 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
10259 FormatStyle::BOS_All);
Daniel Jasperac043c92014-09-15 11:11:00 +000010260
Francois Ferranda6b6d512017-05-24 11:36:58 +000010261 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
10262 CHECK_PARSE("BreakConstructorInitializers: BeforeComma",
10263 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
10264 CHECK_PARSE("BreakConstructorInitializers: AfterColon",
10265 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon);
10266 CHECK_PARSE("BreakConstructorInitializers: BeforeColon",
10267 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon);
10268 // For backward compatibility:
10269 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true",
10270 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
10271
Daniel Jasper6501f7e2015-10-27 12:38:37 +000010272 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
10273 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
10274 FormatStyle::BAS_Align);
10275 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket,
10276 FormatStyle::BAS_DontAlign);
10277 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket,
10278 FormatStyle::BAS_AlwaysBreak);
10279 // For backward compatibility:
10280 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
10281 FormatStyle::BAS_DontAlign);
10282 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
10283 FormatStyle::BAS_Align);
10284
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +000010285 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10286 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines,
10287 FormatStyle::ENAS_DontAlign);
10288 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines,
10289 FormatStyle::ENAS_Left);
10290 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines,
10291 FormatStyle::ENAS_Right);
10292 // For backward compatibility:
10293 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines,
10294 FormatStyle::ENAS_Left);
10295 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines,
10296 FormatStyle::ENAS_Right);
10297
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +000010298 Style.UseTab = FormatStyle::UT_ForIndentation;
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +000010299 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
10300 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
10301 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
Marianne Mailhot-Sarrasin51fe2792016-04-14 14:52:26 +000010302 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
10303 FormatStyle::UT_ForContinuationAndIndentation);
Daniel Jasper00853002014-09-16 16:22:30 +000010304 // For backward compatibility:
10305 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
10306 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +000010307
Daniel Jasperd74cf402014-04-08 12:46:38 +000010308 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
Daniel Jasperd74cf402014-04-08 12:46:38 +000010309 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
10310 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
10311 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
10312 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
Daniel Jasper9e709352014-11-26 10:43:58 +000010313 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
10314 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
Daniel Jasperd74cf402014-04-08 12:46:38 +000010315 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
10316 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
Daniel Jasper00853002014-09-16 16:22:30 +000010317 // For backward compatibility:
10318 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
10319 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
10320 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
10321 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
Daniel Jasperd74cf402014-04-08 12:46:38 +000010322
Alexander Kornienkofdca83d2013-12-10 10:18:34 +000010323 Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
10324 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
10325 FormatStyle::SBPO_Never);
10326 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
10327 FormatStyle::SBPO_Always);
10328 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
10329 FormatStyle::SBPO_ControlStatements);
10330 // For backward compatibility:
10331 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
10332 FormatStyle::SBPO_Never);
10333 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
10334 FormatStyle::SBPO_ControlStatements);
10335
Alexander Kornienkod6538332013-05-07 15:32:14 +000010336 Style.ColumnLimit = 123;
10337 FormatStyle BaseStyle = getLLVMStyle();
10338 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
10339 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
10340
Manuel Klimeka8eb9142013-05-13 12:51:40 +000010341 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
10342 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
10343 FormatStyle::BS_Attach);
10344 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
10345 FormatStyle::BS_Linux);
Birunthan Mohanathas305fa9c2015-07-12 03:13:54 +000010346 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces,
10347 FormatStyle::BS_Mozilla);
Manuel Klimeka8eb9142013-05-13 12:51:40 +000010348 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
10349 FormatStyle::BS_Stroustrup);
Alexander Kornienko3a33f022013-12-12 09:49:52 +000010350 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
10351 FormatStyle::BS_Allman);
10352 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
Daniel Jasperc1bc38e2015-09-29 14:57:55 +000010353 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces,
10354 FormatStyle::BS_WebKit);
10355 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces,
10356 FormatStyle::BS_Custom);
Manuel Klimeka8eb9142013-05-13 12:51:40 +000010357
Zachary Turner448592e2015-12-18 22:20:15 +000010358 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
10359 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
10360 FormatStyle::RTBS_None);
10361 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
10362 FormatStyle::RTBS_All);
10363 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",
Zachary Turner6bc7f972015-12-18 22:58:42 +000010364 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel);
Zachary Turner448592e2015-12-18 22:20:15 +000010365 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions",
10366 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions);
10367 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions",
10368 AlwaysBreakAfterReturnType,
10369 FormatStyle::RTBS_TopLevelDefinitions);
10370
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +000010371 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
10372 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None",
10373 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None);
10374 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All",
10375 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All);
10376 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel",
10377 AlwaysBreakAfterDefinitionReturnType,
10378 FormatStyle::DRTBS_TopLevel);
10379
Daniel Jasper65ee3472013-07-31 23:16:02 +000010380 Style.NamespaceIndentation = FormatStyle::NI_All;
10381 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
10382 FormatStyle::NI_None);
10383 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
10384 FormatStyle::NI_Inner);
10385 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
10386 FormatStyle::NI_All);
Daniel Jaspere1e43192014-04-01 12:55:11 +000010387
Daniel Jasper8ce1b8d2015-10-06 11:54:18 +000010388 // FIXME: This is required because parsing a configuration simply overwrites
10389 // the first N elements of the list instead of resetting it.
Daniel Jaspere1e43192014-04-01 12:55:11 +000010390 Style.ForEachMacros.clear();
Aaron Ballman2b9036d2014-04-01 16:30:35 +000010391 std::vector<std::string> BoostForeach;
10392 BoostForeach.push_back("BOOST_FOREACH");
Daniel Jaspere1e43192014-04-01 12:55:11 +000010393 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
Aaron Ballman2b9036d2014-04-01 16:30:35 +000010394 std::vector<std::string> BoostAndQForeach;
10395 BoostAndQForeach.push_back("BOOST_FOREACH");
10396 BoostAndQForeach.push_back("Q_FOREACH");
Daniel Jaspere1e43192014-04-01 12:55:11 +000010397 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
10398 BoostAndQForeach);
Daniel Jasper8ce1b8d2015-10-06 11:54:18 +000010399
10400 Style.IncludeCategories.clear();
10401 std::vector<FormatStyle::IncludeCategory> ExpectedCategories = {{"abc/.*", 2},
10402 {".*", 1}};
10403 CHECK_PARSE("IncludeCategories:\n"
10404 " - Regex: abc/.*\n"
10405 " Priority: 2\n"
10406 " - Regex: .*\n"
10407 " Priority: 1",
10408 IncludeCategories, ExpectedCategories);
Daniel Jasper9c8ff352016-03-21 14:11:27 +000010409 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeIsMainRegex, "abc$");
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +000010410
10411 Style.RawStringFormats.clear();
10412 std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = {
10413 {"pb", FormatStyle::LK_TextProto, "llvm"},
10414 {"cpp", FormatStyle::LK_Cpp, "google"}};
10415
10416 CHECK_PARSE("RawStringFormats:\n"
10417 " - Delimiter: 'pb'\n"
10418 " Language: TextProto\n"
10419 " BasedOnStyle: llvm\n"
10420 " - Delimiter: 'cpp'\n"
10421 " Language: Cpp\n"
10422 " BasedOnStyle: google",
10423 RawStringFormats, ExpectedRawStringFormats);
Alexander Kornienkocabdd732013-11-29 15:19:43 +000010424}
10425
10426TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
10427 FormatStyle Style = {};
10428 Style.Language = FormatStyle::LK_Cpp;
10429 CHECK_PARSE("Language: Cpp\n"
10430 "IndentWidth: 12",
10431 IndentWidth, 12u);
Rafael Espindola1f243172014-06-12 11:35:17 +000010432 EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
10433 "IndentWidth: 34",
10434 &Style),
10435 ParseError::Unsuitable);
Alexander Kornienkocabdd732013-11-29 15:19:43 +000010436 EXPECT_EQ(12u, Style.IndentWidth);
10437 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
10438 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
10439
10440 Style.Language = FormatStyle::LK_JavaScript;
10441 CHECK_PARSE("Language: JavaScript\n"
10442 "IndentWidth: 12",
10443 IndentWidth, 12u);
10444 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
Rafael Espindola1f243172014-06-12 11:35:17 +000010445 EXPECT_EQ(parseConfiguration("Language: Cpp\n"
10446 "IndentWidth: 34",
10447 &Style),
10448 ParseError::Unsuitable);
Alexander Kornienkocabdd732013-11-29 15:19:43 +000010449 EXPECT_EQ(23u, Style.IndentWidth);
10450 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
10451 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
10452
10453 CHECK_PARSE("BasedOnStyle: LLVM\n"
10454 "IndentWidth: 67",
10455 IndentWidth, 67u);
10456
10457 CHECK_PARSE("---\n"
10458 "Language: JavaScript\n"
10459 "IndentWidth: 12\n"
10460 "---\n"
10461 "Language: Cpp\n"
10462 "IndentWidth: 34\n"
10463 "...\n",
10464 IndentWidth, 12u);
10465
10466 Style.Language = FormatStyle::LK_Cpp;
10467 CHECK_PARSE("---\n"
10468 "Language: JavaScript\n"
10469 "IndentWidth: 12\n"
10470 "---\n"
10471 "Language: Cpp\n"
10472 "IndentWidth: 34\n"
10473 "...\n",
10474 IndentWidth, 34u);
10475 CHECK_PARSE("---\n"
10476 "IndentWidth: 78\n"
10477 "---\n"
10478 "Language: JavaScript\n"
10479 "IndentWidth: 56\n"
10480 "...\n",
10481 IndentWidth, 78u);
10482
10483 Style.ColumnLimit = 123;
10484 Style.IndentWidth = 234;
10485 Style.BreakBeforeBraces = FormatStyle::BS_Linux;
10486 Style.TabWidth = 345;
Rafael Espindola3ae06202014-05-31 03:20:52 +000010487 EXPECT_FALSE(parseConfiguration("---\n"
10488 "IndentWidth: 456\n"
10489 "BreakBeforeBraces: Allman\n"
10490 "---\n"
10491 "Language: JavaScript\n"
10492 "IndentWidth: 111\n"
10493 "TabWidth: 111\n"
10494 "---\n"
10495 "Language: Cpp\n"
10496 "BreakBeforeBraces: Stroustrup\n"
10497 "TabWidth: 789\n"
10498 "...\n",
10499 &Style));
Alexander Kornienkocabdd732013-11-29 15:19:43 +000010500 EXPECT_EQ(123u, Style.ColumnLimit);
10501 EXPECT_EQ(456u, Style.IndentWidth);
10502 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
10503 EXPECT_EQ(789u, Style.TabWidth);
10504
Rafael Espindola1f243172014-06-12 11:35:17 +000010505 EXPECT_EQ(parseConfiguration("---\n"
10506 "Language: JavaScript\n"
10507 "IndentWidth: 56\n"
10508 "---\n"
10509 "IndentWidth: 78\n"
10510 "...\n",
10511 &Style),
10512 ParseError::Error);
10513 EXPECT_EQ(parseConfiguration("---\n"
10514 "Language: JavaScript\n"
10515 "IndentWidth: 56\n"
10516 "---\n"
10517 "Language: JavaScript\n"
10518 "IndentWidth: 78\n"
10519 "...\n",
10520 &Style),
10521 ParseError::Error);
Alexander Kornienkocabdd732013-11-29 15:19:43 +000010522
10523 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
10524}
Daniel Jasper65ee3472013-07-31 23:16:02 +000010525
Alexander Kornienkod6bd7472013-12-30 16:11:28 +000010526#undef CHECK_PARSE
Alexander Kornienkod6bd7472013-12-30 16:11:28 +000010527
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010528TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
10529 FormatStyle Style = {};
10530 Style.Language = FormatStyle::LK_JavaScript;
10531 Style.BreakBeforeTernaryOperators = true;
Alexander Kornienkod6bd7472013-12-30 16:11:28 +000010532 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
Daniel Jaspere551bb72014-11-05 17:22:31 +000010533 EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
Alexander Kornienkod6bd7472013-12-30 16:11:28 +000010534
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010535 Style.BreakBeforeTernaryOperators = true;
Alexander Kornienkod6bd7472013-12-30 16:11:28 +000010536 EXPECT_EQ(0, parseConfiguration("---\n"
Daniel Jaspera44991332015-04-29 13:06:49 +000010537 "BasedOnStyle: Google\n"
10538 "---\n"
10539 "Language: JavaScript\n"
10540 "IndentWidth: 76\n"
10541 "...\n",
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +000010542 &Style)
10543 .value());
Daniel Jaspere551bb72014-11-05 17:22:31 +000010544 EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010545 EXPECT_EQ(76u, Style.IndentWidth);
10546 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
10547}
10548
Alexander Kornienkod6538332013-05-07 15:32:14 +000010549TEST_F(FormatTest, ConfigurationRoundTripTest) {
10550 FormatStyle Style = getLLVMStyle();
10551 std::string YAML = configurationAsText(Style);
10552 FormatStyle ParsedStyle = {};
Alexander Kornienkocabdd732013-11-29 15:19:43 +000010553 ParsedStyle.Language = FormatStyle::LK_Cpp;
Alexander Kornienkod6538332013-05-07 15:32:14 +000010554 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
10555 EXPECT_EQ(Style, ParsedStyle);
10556}
10557
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010558TEST_F(FormatTest, WorksFor8bitEncodings) {
10559 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
10560 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
10561 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
10562 "\"\xef\xee\xf0\xf3...\"",
10563 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
10564 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
10565 "\xef\xee\xf0\xf3...\"",
10566 getLLVMStyleWithColumns(12)));
10567}
10568
Alexander Kornienko393e3082013-11-13 14:04:17 +000010569TEST_F(FormatTest, HandlesUTF8BOM) {
10570 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
10571 EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
10572 format("\xef\xbb\xbf#include <iostream>"));
10573 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
10574 format("\xef\xbb\xbf\n#include <iostream>"));
10575}
10576
NAKAMURA Takumi5238eba2013-06-06 01:14:58 +000010577// FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
10578#if !defined(_MSC_VER)
10579
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010580TEST_F(FormatTest, CountsUTF8CharactersProperly) {
10581 verifyFormat("\"Однажды в студёную зимнюю пору...\"",
10582 getLLVMStyleWithColumns(35));
10583 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010584 getLLVMStyleWithColumns(31));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010585 verifyFormat("// Однажды в студёную зимнюю пору...",
10586 getLLVMStyleWithColumns(36));
Daniel Jaspera44991332015-04-29 13:06:49 +000010587 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010588 verifyFormat("/* Однажды в студёную зимнюю пору... */",
10589 getLLVMStyleWithColumns(39));
10590 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010591 getLLVMStyleWithColumns(35));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010592}
10593
10594TEST_F(FormatTest, SplitsUTF8Strings) {
Alexander Kornienko71d95d62013-11-26 10:38:53 +000010595 // Non-printable characters' width is currently considered to be the length in
10596 // bytes in UTF8. The characters can be displayed in very different manner
10597 // (zero-width, single width with a substitution glyph, expanded to their code
10598 // (e.g. "<8d>"), so there's no single correct way to handle them.
10599 EXPECT_EQ("\"aaaaÄ\"\n"
Alexander Kornienkofd1d7002013-11-26 13:31:46 +000010600 "\"\xc2\x8d\";",
10601 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
Alexander Kornienko71d95d62013-11-26 10:38:53 +000010602 EXPECT_EQ("\"aaaaaaaÄ\"\n"
Alexander Kornienkofd1d7002013-11-26 13:31:46 +000010603 "\"\xc2\x8d\";",
10604 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
Daniel Jaspera44991332015-04-29 13:06:49 +000010605 EXPECT_EQ("\"Однажды, в \"\n"
10606 "\"студёную \"\n"
10607 "\"зимнюю \"\n"
10608 "\"пору,\"",
10609 format("\"Однажды, в студёную зимнюю пору,\"",
10610 getLLVMStyleWithColumns(13)));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010611 EXPECT_EQ(
Daniel Jaspera44991332015-04-29 13:06:49 +000010612 "\"一 二 三 \"\n"
10613 "\"四 五六 \"\n"
10614 "\"七 八 九 \"\n"
10615 "\"十\"",
10616 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
Manuel Klimek93699f42017-11-29 14:29:43 +000010617 EXPECT_EQ("\"一\t\"\n"
10618 "\"二 \t\"\n"
10619 "\"三 四 \"\n"
10620 "\"五\t\"\n"
10621 "\"六 \t\"\n"
10622 "\"七 \"\n"
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010623 "\"八九十\tqq\"",
10624 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
10625 getLLVMStyleWithColumns(11)));
Daniel Jaspere35c2202015-07-20 23:28:07 +000010626
10627 // UTF8 character in an escape sequence.
10628 EXPECT_EQ("\"aaaaaa\"\n"
10629 "\"\\\xC2\x8D\"",
10630 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10)));
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010631}
10632
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010633TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
10634 EXPECT_EQ("const char *sssss =\n"
10635 " \"一二三四五六七八\\\n"
10636 " 九 十\";",
10637 format("const char *sssss = \"一二三四五六七八\\\n"
10638 " 九 十\";",
10639 getLLVMStyleWithColumns(30)));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010640}
10641
10642TEST_F(FormatTest, SplitsUTF8LineComments) {
Alexander Kornienkofd1d7002013-11-26 13:31:46 +000010643 EXPECT_EQ("// aaaaÄ\xc2\x8d",
10644 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010645 EXPECT_EQ("// Я из лесу\n"
10646 "// вышел; был\n"
10647 "// сильный\n"
10648 "// мороз.",
10649 format("// Я из лесу вышел; был сильный мороз.",
10650 getLLVMStyleWithColumns(13)));
10651 EXPECT_EQ("// 一二三\n"
10652 "// 四五六七\n"
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010653 "// 八 九\n"
10654 "// 十",
10655 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9)));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010656}
10657
10658TEST_F(FormatTest, SplitsUTF8BlockComments) {
10659 EXPECT_EQ("/* Гляжу,\n"
10660 " * поднимается\n"
10661 " * медленно в\n"
10662 " * гору\n"
10663 " * Лошадка,\n"
10664 " * везущая\n"
10665 " * хворосту\n"
10666 " * воз. */",
10667 format("/* Гляжу, поднимается медленно в гору\n"
10668 " * Лошадка, везущая хворосту воз. */",
10669 getLLVMStyleWithColumns(13)));
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010670 EXPECT_EQ(
10671 "/* 一二三\n"
10672 " * 四五六七\n"
10673 " * 八 九\n"
10674 " * 十 */",
10675 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9)));
Alexander Kornienkoff73c202013-06-05 15:08:20 +000010676 EXPECT_EQ("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯\n"
10677 " * 𝕓𝕪𝕥𝕖\n"
10678 " * 𝖀𝕿𝕱-𝟠 */",
10679 format("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯 𝕓𝕪𝕥𝕖 𝖀𝕿𝕱-𝟠 */", getLLVMStyleWithColumns(12)));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010680}
10681
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010682#endif // _MSC_VER
10683
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010684TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
10685 FormatStyle Style = getLLVMStyle();
10686
10687 Style.ConstructorInitializerIndentWidth = 4;
10688 verifyFormat(
10689 "SomeClass::Constructor()\n"
10690 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
10691 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
10692 Style);
10693
10694 Style.ConstructorInitializerIndentWidth = 2;
10695 verifyFormat(
10696 "SomeClass::Constructor()\n"
10697 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
10698 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
10699 Style);
10700
10701 Style.ConstructorInitializerIndentWidth = 0;
10702 verifyFormat(
10703 "SomeClass::Constructor()\n"
10704 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
10705 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
10706 Style);
Daniel Jasperb618a982016-02-02 10:28:11 +000010707 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
10708 verifyFormat(
10709 "SomeLongTemplateVariableName<\n"
10710 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>",
10711 Style);
10712 verifyFormat(
10713 "bool smaller = 1 < bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
10714 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
10715 Style);
Daniel Jasper00853002014-09-16 16:22:30 +000010716}
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010717
Daniel Jasper00853002014-09-16 16:22:30 +000010718TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
10719 FormatStyle Style = getLLVMStyle();
Francois Ferranda6b6d512017-05-24 11:36:58 +000010720 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010721 Style.ConstructorInitializerIndentWidth = 4;
10722 verifyFormat("SomeClass::Constructor()\n"
10723 " : a(a)\n"
10724 " , b(b)\n"
10725 " , c(c) {}",
10726 Style);
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010727 verifyFormat("SomeClass::Constructor()\n"
10728 " : a(a) {}",
10729 Style);
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010730
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010731 Style.ColumnLimit = 0;
10732 verifyFormat("SomeClass::Constructor()\n"
10733 " : a(a) {}",
10734 Style);
Daniel Jasper56ef6ac2016-03-01 21:41:58 +000010735 verifyFormat("SomeClass::Constructor() noexcept\n"
10736 " : a(a) {}",
10737 Style);
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010738 verifyFormat("SomeClass::Constructor()\n"
10739 " : a(a)\n"
10740 " , b(b)\n"
10741 " , c(c) {}",
10742 Style);
10743 verifyFormat("SomeClass::Constructor()\n"
10744 " : a(a) {\n"
10745 " foo();\n"
10746 " bar();\n"
10747 "}",
10748 Style);
10749
Daniel Jasperd74cf402014-04-08 12:46:38 +000010750 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010751 verifyFormat("SomeClass::Constructor()\n"
10752 " : a(a)\n"
10753 " , b(b)\n"
10754 " , c(c) {\n}",
10755 Style);
10756 verifyFormat("SomeClass::Constructor()\n"
10757 " : a(a) {\n}",
10758 Style);
10759
10760 Style.ColumnLimit = 80;
Daniel Jasperd74cf402014-04-08 12:46:38 +000010761 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010762 Style.ConstructorInitializerIndentWidth = 2;
10763 verifyFormat("SomeClass::Constructor()\n"
10764 " : a(a)\n"
10765 " , b(b)\n"
10766 " , c(c) {}",
10767 Style);
10768
10769 Style.ConstructorInitializerIndentWidth = 0;
10770 verifyFormat("SomeClass::Constructor()\n"
10771 ": a(a)\n"
10772 ", b(b)\n"
10773 ", c(c) {}",
10774 Style);
Daniel Jasperec01cd62013-10-08 05:11:18 +000010775
10776 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
10777 Style.ConstructorInitializerIndentWidth = 4;
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010778 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
10779 verifyFormat(
10780 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
10781 Style);
Daniel Jasperec01cd62013-10-08 05:11:18 +000010782 verifyFormat(
10783 "SomeClass::Constructor()\n"
10784 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
10785 Style);
10786 Style.ConstructorInitializerIndentWidth = 4;
10787 Style.ColumnLimit = 60;
10788 verifyFormat("SomeClass::Constructor()\n"
10789 " : aaaaaaaa(aaaaaaaa)\n"
10790 " , aaaaaaaa(aaaaaaaa)\n"
10791 " , aaaaaaaa(aaaaaaaa) {}",
10792 Style);
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010793}
10794
Daniel Jasper38efc132014-10-21 07:51:54 +000010795TEST_F(FormatTest, Destructors) {
10796 verifyFormat("void F(int &i) { i.~int(); }");
10797 verifyFormat("void F(int &i) { i->~int(); }");
10798}
10799
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010800TEST_F(FormatTest, FormatsWithWebKitStyle) {
10801 FormatStyle Style = getWebKitStyle();
10802
10803 // Don't indent in outer namespaces.
10804 verifyFormat("namespace outer {\n"
10805 "int i;\n"
10806 "namespace inner {\n"
Daniel Jasper65ee3472013-07-31 23:16:02 +000010807 " int i;\n"
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010808 "} // namespace inner\n"
10809 "} // namespace outer\n"
10810 "namespace other_outer {\n"
10811 "int i;\n"
10812 "}",
10813 Style);
10814
10815 // Don't indent case labels.
10816 verifyFormat("switch (variable) {\n"
10817 "case 1:\n"
10818 "case 2:\n"
10819 " doSomething();\n"
10820 " break;\n"
10821 "default:\n"
10822 " ++variable;\n"
10823 "}",
10824 Style);
10825
10826 // Wrap before binary operators.
Daniel Jaspera44991332015-04-29 13:06:49 +000010827 EXPECT_EQ("void f()\n"
10828 "{\n"
10829 " if (aaaaaaaaaaaaaaaa\n"
10830 " && bbbbbbbbbbbbbbbbbbbbbbbb\n"
10831 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
10832 " return;\n"
10833 "}",
10834 format("void f() {\n"
10835 "if (aaaaaaaaaaaaaaaa\n"
10836 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
10837 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
10838 "return;\n"
10839 "}",
10840 Style));
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010841
Daniel Jasper35995672014-04-29 14:05:20 +000010842 // Allow functions on a single line.
10843 verifyFormat("void f() { return; }", Style);
10844
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010845 // Constructor initializers are formatted one per line with the "," on the
10846 // new line.
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010847 verifyFormat("Constructor()\n"
10848 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
10849 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
Daniel Jasper3aa9a6a2014-11-18 23:55:27 +000010850 " aaaaaaaaaaaaaa)\n"
Daniel Jasper234379f2013-12-24 13:31:25 +000010851 " , aaaaaaaaaaaaaaaaaaaaaaa()\n"
10852 "{\n"
10853 "}",
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010854 Style);
10855 verifyFormat("SomeClass::Constructor()\n"
10856 " : a(a)\n"
Daniel Jasper234379f2013-12-24 13:31:25 +000010857 "{\n"
10858 "}",
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010859 Style);
Daniel Jasper234379f2013-12-24 13:31:25 +000010860 EXPECT_EQ("SomeClass::Constructor()\n"
10861 " : a(a)\n"
10862 "{\n"
10863 "}",
10864 format("SomeClass::Constructor():a(a){}", Style));
10865 verifyFormat("SomeClass::Constructor()\n"
10866 " : a(a)\n"
10867 " , b(b)\n"
10868 " , c(c)\n"
10869 "{\n"
Daniel Jaspera44991332015-04-29 13:06:49 +000010870 "}",
10871 Style);
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010872 verifyFormat("SomeClass::Constructor()\n"
10873 " : a(a)\n"
10874 "{\n"
10875 " foo();\n"
10876 " bar();\n"
10877 "}",
10878 Style);
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010879
Daniel Jasper65ee3472013-07-31 23:16:02 +000010880 // Access specifiers should be aligned left.
10881 verifyFormat("class C {\n"
10882 "public:\n"
10883 " int i;\n"
10884 "};",
10885 Style);
10886
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010887 // Do not align comments.
Daniel Jasper552f4a72013-07-31 23:55:15 +000010888 verifyFormat("int a; // Do not\n"
10889 "double b; // align comments.",
10890 Style);
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010891
Daniel Jasper3219e432014-12-02 13:24:51 +000010892 // Do not align operands.
10893 EXPECT_EQ("ASSERT(aaaa\n"
10894 " || bbbb);",
10895 format("ASSERT ( aaaa\n||bbbb);", Style));
10896
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010897 // Accept input's line breaks.
10898 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
10899 " || bbbbbbbbbbbbbbb) {\n"
10900 " i++;\n"
10901 "}",
10902 format("if (aaaaaaaaaaaaaaa\n"
10903 "|| bbbbbbbbbbbbbbb) { i++; }",
10904 Style));
10905 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
10906 " i++;\n"
10907 "}",
10908 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
Daniel Jasper98fb6e12013-11-08 17:33:27 +000010909
10910 // Don't automatically break all macro definitions (llvm.org/PR17842).
10911 verifyFormat("#define aNumber 10", Style);
10912 // However, generally keep the line breaks that the user authored.
10913 EXPECT_EQ("#define aNumber \\\n"
10914 " 10",
10915 format("#define aNumber \\\n"
10916 " 10",
10917 Style));
Daniel Jasperaf4fee22014-04-14 12:05:05 +000010918
10919 // Keep empty and one-element array literals on a single line.
Daniel Jasper7f0c5172014-05-19 08:06:34 +000010920 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
10921 " copyItems:YES];",
10922 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
10923 "copyItems:YES];",
10924 Style));
10925 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
10926 " copyItems:YES];",
10927 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
10928 " copyItems:YES];",
10929 Style));
Daniel Jasper335ff262014-05-28 09:11:53 +000010930 // FIXME: This does not seem right, there should be more indentation before
10931 // the array literal's entries. Nested blocks have the same problem.
Daniel Jasperdb8804b2014-04-14 12:11:07 +000010932 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
Daniel Jasper335ff262014-05-28 09:11:53 +000010933 " @\"a\",\n"
10934 " @\"a\"\n"
10935 "]\n"
Daniel Jasperdb8804b2014-04-14 12:11:07 +000010936 " copyItems:YES];",
10937 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
10938 " @\"a\",\n"
10939 " @\"a\"\n"
10940 " ]\n"
10941 " copyItems:YES];",
10942 Style));
Daniel Jasper7f0c5172014-05-19 08:06:34 +000010943 EXPECT_EQ(
Daniel Jasperdb8804b2014-04-14 12:11:07 +000010944 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
10945 " copyItems:YES];",
Daniel Jasper7f0c5172014-05-19 08:06:34 +000010946 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
10947 " copyItems:YES];",
10948 Style));
10949
10950 verifyFormat("[self.a b:c c:d];", Style);
10951 EXPECT_EQ("[self.a b:c\n"
10952 " c:d];",
10953 format("[self.a b:c\n"
10954 "c:d];",
10955 Style));
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010956}
10957
Manuel Klimekffdeb592013-09-03 15:10:01 +000010958TEST_F(FormatTest, FormatsLambdas) {
Daniel Jasper5f3ea472014-05-22 08:36:53 +000010959 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
10960 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
10961 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
10962 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
10963 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
Chandler Carruthf8b72662014-03-02 12:37:31 +000010964 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
Manuel Klimek9f0a4e52017-09-19 09:59:30 +000010965 verifyFormat("auto c = [a = [b = 42] {}] {};\n");
10966 verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n");
Daniel Jasper3ade3be2016-11-01 06:23:05 +000010967 verifyFormat("int x = f(*+[] {});");
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +000010968 verifyFormat("void f() {\n"
10969 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
10970 "}\n");
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +000010971 verifyFormat("void f() {\n"
10972 " other(x.begin(), //\n"
10973 " x.end(), //\n"
Daniel Jasper9a8d48b2013-09-05 10:04:31 +000010974 " [&](int, int) { return 1; });\n"
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +000010975 "}\n");
Daniel Jasper21397a32014-04-09 12:21:48 +000010976 verifyFormat("SomeFunction([]() { // A cool function...\n"
10977 " return 43;\n"
10978 "});");
Daniel Jasper56346192014-10-27 16:31:46 +000010979 EXPECT_EQ("SomeFunction([]() {\n"
10980 "#define A a\n"
10981 " return 43;\n"
10982 "});",
10983 format("SomeFunction([](){\n"
10984 "#define A a\n"
10985 "return 43;\n"
10986 "});"));
Daniel Jasper0e6c51c2014-05-05 12:36:29 +000010987 verifyFormat("void f() {\n"
10988 " SomeFunction([](decltype(x), A *a) {});\n"
10989 "}");
Daniel Jaspera2fb50f2014-06-24 09:15:49 +000010990 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
10991 " [](const aaaaaaaaaa &a) { return a; });");
Daniel Jaspera5621202014-08-08 12:00:13 +000010992 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
10993 " SomeOtherFunctioooooooooooooooooooooooooon();\n"
10994 "});");
Daniel Jasperd6a1cab2015-01-12 10:23:24 +000010995 verifyFormat("Constructor()\n"
10996 " : Field([] { // comment\n"
10997 " int i;\n"
10998 " }) {}");
Daniel Jasper0ad28142015-05-13 08:47:16 +000010999 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
11000 " return some_parameter.size();\n"
11001 "};");
Daniel Jasper9c8a7742016-01-04 07:29:40 +000011002 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n"
11003 " [](const string &s) { return s; };");
Daniel Jasperc4144ea2015-05-13 16:09:21 +000011004 verifyFormat("int i = aaaaaa ? 1 //\n"
11005 " : [] {\n"
11006 " return 2; //\n"
11007 " }();");
11008 verifyFormat("llvm::errs() << \"number of twos is \"\n"
11009 " << std::count_if(v.begin(), v.end(), [](int x) {\n"
11010 " return x == 2; // force break\n"
11011 " });");
Daniel Jasperd9b319e2017-02-20 12:43:48 +000011012 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
11013 " [=](int iiiiiiiiiiii) {\n"
11014 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n"
11015 " aaaaaaaaaaaaaaaaaaaaaaa;\n"
11016 " });",
Daniel Jasperb9edcfb2015-07-07 13:50:50 +000011017 getLLVMStyleWithColumns(60));
Daniel Jasperea40cee2015-07-14 11:26:14 +000011018 verifyFormat("SomeFunction({[&] {\n"
11019 " // comment\n"
11020 " },\n"
11021 " [&] {\n"
11022 " // comment\n"
11023 " }});");
11024 verifyFormat("SomeFunction({[&] {\n"
11025 " // comment\n"
11026 "}});");
Daniel Jasper100ffc62015-08-21 11:44:57 +000011027 verifyFormat("virtual aaaaaaaaaaaaaaaa(std::function<bool()> bbbbbbbbbbbb =\n"
11028 " [&]() { return true; },\n"
11029 " aaaaa aaaaaaaaa);");
Daniel Jasperbf02b2c12013-09-05 11:49:39 +000011030
Daniel Jaspercb51cf42014-01-16 09:11:55 +000011031 // Lambdas with return types.
Daniel Jasper81a20782014-03-10 10:02:02 +000011032 verifyFormat("int c = []() -> int { return 2; }();\n");
Daniel Jasper60ba32d2015-06-12 09:59:16 +000011033 verifyFormat("int c = []() -> int * { return 2; }();\n");
Daniel Jasper81a20782014-03-10 10:02:02 +000011034 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
11035 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
Daniel Jasperbcb55ee2014-11-21 14:08:38 +000011036 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};");
Daniel Jasper3431b752014-12-08 13:22:37 +000011037 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};");
Daniel Jasperbcb55ee2014-11-21 14:08:38 +000011038 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};");
11039 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};");
Daniel Jasper5eaa0092015-08-13 13:37:08 +000011040 verifyFormat("[a, a]() -> a<1> {};");
Daniel Jasper8f59ae52014-03-11 11:03:26 +000011041 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
11042 " int j) -> int {\n"
Daniel Jaspera2fb50f2014-06-24 09:15:49 +000011043 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n"
Daniel Jasper8f59ae52014-03-11 11:03:26 +000011044 "};");
Daniel Jaspere6623162015-03-02 10:35:13 +000011045 verifyFormat(
11046 "aaaaaaaaaaaaaaaaaaaaaa(\n"
11047 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n"
11048 " return aaaaaaaaaaaaaaaaa;\n"
11049 " });",
11050 getLLVMStyleWithColumns(70));
Daniel Jasper87448c52016-06-13 07:48:45 +000011051 verifyFormat("[]() //\n"
11052 " -> int {\n"
11053 " return 1; //\n"
11054 "};");
Daniel Jaspercb51cf42014-01-16 09:11:55 +000011055
Daniel Jasper3ae6f5a2014-04-09 12:08:39 +000011056 // Multiple lambdas in the same parentheses change indentation rules.
Daniel Jasper4b444492014-11-21 13:38:53 +000011057 verifyFormat("SomeFunction(\n"
11058 " []() {\n"
11059 " int i = 42;\n"
11060 " return i;\n"
11061 " },\n"
11062 " []() {\n"
11063 " int j = 43;\n"
11064 " return j;\n"
11065 " });");
Daniel Jasper3ae6f5a2014-04-09 12:08:39 +000011066
Daniel Jasperda18fd82014-06-10 06:39:03 +000011067 // More complex introducers.
11068 verifyFormat("return [i, args...] {};");
11069
Daniel Jasperbf02b2c12013-09-05 11:49:39 +000011070 // Not lambdas.
Chandler Carruthf8b72662014-03-02 12:37:31 +000011071 verifyFormat("constexpr char hello[]{\"hello\"};");
Daniel Jasperb4b99982013-09-06 21:25:51 +000011072 verifyFormat("double &operator[](int i) { return 0; }\n"
11073 "int i;");
Daniel Jasper6b70ec02014-01-22 17:01:47 +000011074 verifyFormat("std::unique_ptr<int[]> foo() {}");
Daniel Jasperd3c7ab92014-03-11 09:59:36 +000011075 verifyFormat("int i = a[a][a]->f();");
Daniel Jaspera58dd5d2014-03-11 10:03:33 +000011076 verifyFormat("int i = (*b)[a]->f();");
Daniel Jasper84a12e12014-03-10 15:06:25 +000011077
11078 // Other corner cases.
11079 verifyFormat("void f() {\n"
11080 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n"
Martin Probst2c1cdae2017-05-15 11:15:29 +000011081 " );\n"
Daniel Jasper84a12e12014-03-10 15:06:25 +000011082 "}");
Daniel Jasperc580af92014-03-11 09:29:46 +000011083
11084 // Lambdas created through weird macros.
11085 verifyFormat("void f() {\n"
11086 " MACRO((const AA &a) { return 1; });\n"
Daniel Jasper54353da2016-01-07 14:36:11 +000011087 " MACRO((AA &a) { return 1; });\n"
Daniel Jasperc580af92014-03-11 09:29:46 +000011088 "}");
Daniel Jasper11a0ac62014-12-12 09:40:58 +000011089
11090 verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
11091 " doo_dah();\n"
11092 " doo_dah();\n"
11093 " })) {\n"
11094 "}");
Daniel Jasper6a7d5a72017-06-19 07:40:49 +000011095 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n"
11096 " doo_dah();\n"
11097 " doo_dah();\n"
11098 " })) {\n"
11099 "}");
Daniel Jasper29d39d52015-02-08 09:34:49 +000011100 verifyFormat("auto lambda = []() {\n"
11101 " int a = 2\n"
11102 "#if A\n"
11103 " + 2\n"
11104 "#endif\n"
11105 " ;\n"
11106 "};");
Daniel Jasperd9b319e2017-02-20 12:43:48 +000011107
11108 // Lambdas with complex multiline introducers.
11109 verifyFormat(
11110 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
11111 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n"
11112 " -> ::std::unordered_set<\n"
11113 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n"
11114 " //\n"
11115 " });");
Manuel Klimekffdeb592013-09-03 15:10:01 +000011116}
11117
Martin Probsta004b3f2017-11-17 18:06:33 +000011118TEST_F(FormatTest, EmptyLinesInLambdas) {
11119 verifyFormat("auto lambda = []() {\n"
11120 " x(); //\n"
11121 "};",
11122 "auto lambda = []() {\n"
11123 "\n"
11124 " x(); //\n"
11125 "\n"
11126 "};");
11127}
11128
Manuel Klimek516e0542013-09-04 13:25:30 +000011129TEST_F(FormatTest, FormatsBlocks) {
Daniel Jasper76284682014-10-22 09:12:44 +000011130 FormatStyle ShortBlocks = getLLVMStyle();
11131 ShortBlocks.AllowShortBlocksOnASingleLine = true;
11132 verifyFormat("int (^Block)(int, int);", ShortBlocks);
11133 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
11134 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
11135 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
11136 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
11137 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
Daniel Jasper31745732014-01-19 07:46:32 +000011138
Daniel Jasper76284682014-10-22 09:12:44 +000011139 verifyFormat("foo(^{ bar(); });", ShortBlocks);
11140 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
11141 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
Daniel Jasper31745732014-01-19 07:46:32 +000011142
Daniel Jasper76284682014-10-22 09:12:44 +000011143 verifyFormat("[operation setCompletionBlock:^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011144 " [self onOperationDone];\n"
Daniel Jasper76284682014-10-22 09:12:44 +000011145 "}];");
11146 verifyFormat("int i = {[operation setCompletionBlock:^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011147 " [self onOperationDone];\n"
Daniel Jasper76284682014-10-22 09:12:44 +000011148 "}]};");
11149 verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011150 " f();\n"
Daniel Jasper76284682014-10-22 09:12:44 +000011151 "}];");
11152 verifyFormat("int a = [operation block:^int(int *i) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011153 " return 1;\n"
Daniel Jasper76284682014-10-22 09:12:44 +000011154 "}];");
Daniel Jaspera225bce2014-01-16 19:14:34 +000011155 verifyFormat("[myObject doSomethingWith:arg1\n"
Daniel Jasper76284682014-10-22 09:12:44 +000011156 " aaa:^int(int *a) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011157 " return 1;\n"
Daniel Jasper76284682014-10-22 09:12:44 +000011158 " }\n"
Daniel Jasper5f3ea472014-05-22 08:36:53 +000011159 " bbb:f(a * bbbbbbbb)];");
Daniel Jasperb88b25f2013-12-23 07:29:06 +000011160
11161 verifyFormat("[operation setCompletionBlock:^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011162 " [self.delegate newDataAvailable];\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000011163 "}];",
11164 getLLVMStyleWithColumns(60));
11165 verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011166 " NSString *path = [self sessionFilePath];\n"
11167 " if (path) {\n"
11168 " // ...\n"
11169 " }\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000011170 "});");
11171 verifyFormat("[[SessionService sharedService]\n"
11172 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011173 " if (window) {\n"
11174 " [self windowDidLoad:window];\n"
11175 " } else {\n"
11176 " [self errorLoadingWindow];\n"
11177 " }\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000011178 " }];");
11179 verifyFormat("void (^largeBlock)(void) = ^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011180 " // ...\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000011181 "};\n",
11182 getLLVMStyleWithColumns(40));
11183 verifyFormat("[[SessionService sharedService]\n"
11184 " loadWindowWithCompletionBlock: //\n"
11185 " ^(SessionWindow *window) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011186 " if (window) {\n"
11187 " [self windowDidLoad:window];\n"
11188 " } else {\n"
11189 " [self errorLoadingWindow];\n"
11190 " }\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000011191 " }];",
11192 getLLVMStyleWithColumns(60));
11193 verifyFormat("[myObject doSomethingWith:arg1\n"
11194 " firstBlock:^(Foo *a) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011195 " // ...\n"
11196 " int i;\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000011197 " }\n"
11198 " secondBlock:^(Bar *b) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011199 " // ...\n"
11200 " int i;\n"
Daniel Jasperc13ee342014-03-27 09:43:54 +000011201 " }\n"
11202 " thirdBlock:^Foo(Bar *b) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011203 " // ...\n"
11204 " int i;\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000011205 " }];");
Daniel Jasperb77105d2014-04-08 14:04:31 +000011206 verifyFormat("[myObject doSomethingWith:arg1\n"
11207 " firstBlock:-1\n"
11208 " secondBlock:^(Bar *b) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011209 " // ...\n"
11210 " int i;\n"
Daniel Jasperb77105d2014-04-08 14:04:31 +000011211 " }];");
Daniel Jasperac7e34e2014-03-13 10:11:17 +000011212
11213 verifyFormat("f(^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011214 " @autoreleasepool {\n"
11215 " if (a) {\n"
11216 " g();\n"
Daniel Jasperac7e34e2014-03-13 10:11:17 +000011217 " }\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011218 " }\n"
Daniel Jasperac7e34e2014-03-13 10:11:17 +000011219 "});");
Daniel Jasperbb86d842014-11-23 19:15:35 +000011220 verifyFormat("Block b = ^int *(A *a, B *b) {}");
Daniel Jaspere31388a2016-09-26 22:19:08 +000011221 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
11222 "};");
Daniel Jasper50d634b2014-10-28 16:53:38 +000011223
11224 FormatStyle FourIndent = getLLVMStyle();
11225 FourIndent.ObjCBlockIndentWidth = 4;
11226 verifyFormat("[operation setCompletionBlock:^{\n"
11227 " [self onOperationDone];\n"
11228 "}];",
11229 FourIndent);
Manuel Klimek516e0542013-09-04 13:25:30 +000011230}
11231
Daniel Jasper289afc02015-04-23 09:23:17 +000011232TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) {
11233 FormatStyle ZeroColumn = getLLVMStyle();
11234 ZeroColumn.ColumnLimit = 0;
11235
11236 verifyFormat("[[SessionService sharedService] "
11237 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
11238 " if (window) {\n"
11239 " [self windowDidLoad:window];\n"
11240 " } else {\n"
11241 " [self errorLoadingWindow];\n"
11242 " }\n"
11243 "}];",
11244 ZeroColumn);
11245 EXPECT_EQ("[[SessionService sharedService]\n"
11246 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
11247 " if (window) {\n"
11248 " [self windowDidLoad:window];\n"
11249 " } else {\n"
11250 " [self errorLoadingWindow];\n"
11251 " }\n"
11252 " }];",
11253 format("[[SessionService sharedService]\n"
11254 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
11255 " if (window) {\n"
11256 " [self windowDidLoad:window];\n"
11257 " } else {\n"
11258 " [self errorLoadingWindow];\n"
11259 " }\n"
11260 "}];",
11261 ZeroColumn));
11262 verifyFormat("[myObject doSomethingWith:arg1\n"
11263 " firstBlock:^(Foo *a) {\n"
11264 " // ...\n"
11265 " int i;\n"
11266 " }\n"
11267 " secondBlock:^(Bar *b) {\n"
11268 " // ...\n"
11269 " int i;\n"
11270 " }\n"
11271 " thirdBlock:^Foo(Bar *b) {\n"
11272 " // ...\n"
11273 " int i;\n"
11274 " }];",
11275 ZeroColumn);
11276 verifyFormat("f(^{\n"
11277 " @autoreleasepool {\n"
11278 " if (a) {\n"
11279 " g();\n"
11280 " }\n"
11281 " }\n"
11282 "});",
11283 ZeroColumn);
11284 verifyFormat("void (^largeBlock)(void) = ^{\n"
11285 " // ...\n"
11286 "};",
11287 ZeroColumn);
11288
11289 ZeroColumn.AllowShortBlocksOnASingleLine = true;
11290 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +000011291 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn));
Daniel Jasper289afc02015-04-23 09:23:17 +000011292 ZeroColumn.AllowShortBlocksOnASingleLine = false;
11293 EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
11294 " int i;\n"
11295 "};",
11296 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn));
11297}
11298
Alexander Kornienko9e649af2013-09-11 12:25:57 +000011299TEST_F(FormatTest, SupportsCRLF) {
11300 EXPECT_EQ("int a;\r\n"
11301 "int b;\r\n"
11302 "int c;\r\n",
11303 format("int a;\r\n"
11304 " int b;\r\n"
11305 " int c;\r\n",
11306 getLLVMStyle()));
11307 EXPECT_EQ("int a;\r\n"
11308 "int b;\r\n"
11309 "int c;\r\n",
11310 format("int a;\r\n"
11311 " int b;\n"
11312 " int c;\r\n",
11313 getLLVMStyle()));
11314 EXPECT_EQ("int a;\n"
11315 "int b;\n"
11316 "int c;\n",
11317 format("int a;\r\n"
11318 " int b;\n"
11319 " int c;\n",
11320 getLLVMStyle()));
11321 EXPECT_EQ("\"aaaaaaa \"\r\n"
11322 "\"bbbbbbb\";\r\n",
11323 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
11324 EXPECT_EQ("#define A \\\r\n"
11325 " b; \\\r\n"
11326 " c; \\\r\n"
11327 " d;\r\n",
11328 format("#define A \\\r\n"
11329 " b; \\\r\n"
11330 " c; d; \r\n",
11331 getGoogleStyle()));
Daniel Jasper580da272013-10-30 07:36:40 +000011332
11333 EXPECT_EQ("/*\r\n"
11334 "multi line block comments\r\n"
11335 "should not introduce\r\n"
11336 "an extra carriage return\r\n"
11337 "*/\r\n",
11338 format("/*\r\n"
11339 "multi line block comments\r\n"
11340 "should not introduce\r\n"
11341 "an extra carriage return\r\n"
11342 "*/\r\n"));
Alexander Kornienko9e649af2013-09-11 12:25:57 +000011343}
11344
Manuel Klimekb212f3b2013-10-12 22:46:56 +000011345TEST_F(FormatTest, MunchSemicolonAfterBlocks) {
11346 verifyFormat("MY_CLASS(C) {\n"
11347 " int i;\n"
11348 " int j;\n"
11349 "};");
11350}
11351
Daniel Jasper6633ab82013-10-18 10:38:14 +000011352TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {
11353 FormatStyle TwoIndent = getLLVMStyleWithColumns(15);
11354 TwoIndent.ContinuationIndentWidth = 2;
11355
11356 EXPECT_EQ("int i =\n"
11357 " longFunction(\n"
11358 " arg);",
11359 format("int i = longFunction(arg);", TwoIndent));
11360
11361 FormatStyle SixIndent = getLLVMStyleWithColumns(20);
11362 SixIndent.ContinuationIndentWidth = 6;
11363
11364 EXPECT_EQ("int i =\n"
11365 " longFunction(\n"
11366 " arg);",
11367 format("int i = longFunction(arg);", SixIndent));
11368}
11369
Daniel Jasperdd978ae2013-10-29 14:52:02 +000011370TEST_F(FormatTest, SpacesInAngles) {
11371 FormatStyle Spaces = getLLVMStyle();
11372 Spaces.SpacesInAngles = true;
11373
11374 verifyFormat("static_cast< int >(arg);", Spaces);
11375 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
11376 verifyFormat("f< int, float >();", Spaces);
11377 verifyFormat("template <> g() {}", Spaces);
11378 verifyFormat("template < std::vector< int > > f() {}", Spaces);
Daniel Jasper74331d42015-10-26 12:08:47 +000011379 verifyFormat("std::function< void(int, int) > fct;", Spaces);
11380 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }",
11381 Spaces);
Daniel Jasperdd978ae2013-10-29 14:52:02 +000011382
11383 Spaces.Standard = FormatStyle::LS_Cpp03;
11384 Spaces.SpacesInAngles = true;
11385 verifyFormat("A< A< int > >();", Spaces);
11386
11387 Spaces.SpacesInAngles = false;
11388 verifyFormat("A<A<int> >();", Spaces);
11389
11390 Spaces.Standard = FormatStyle::LS_Cpp11;
11391 Spaces.SpacesInAngles = true;
11392 verifyFormat("A< A< int > >();", Spaces);
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000011393
Daniel Jasperdd978ae2013-10-29 14:52:02 +000011394 Spaces.SpacesInAngles = false;
11395 verifyFormat("A<A<int>>();", Spaces);
11396}
11397
Sylvestre Ledru83bbd572016-08-09 14:24:40 +000011398TEST_F(FormatTest, SpaceAfterTemplateKeyword) {
11399 FormatStyle Style = getLLVMStyle();
11400 Style.SpaceAfterTemplateKeyword = false;
11401 verifyFormat("template<int> void foo();", Style);
11402}
11403
Jacques Pienaarfc275112015-02-18 23:48:37 +000011404TEST_F(FormatTest, TripleAngleBrackets) {
11405 verifyFormat("f<<<1, 1>>>();");
11406 verifyFormat("f<<<1, 1, 1, s>>>();");
11407 verifyFormat("f<<<a, b, c, d>>>();");
Daniel Jaspera44991332015-04-29 13:06:49 +000011408 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
Jacques Pienaarfc275112015-02-18 23:48:37 +000011409 verifyFormat("f<param><<<1, 1>>>();");
11410 verifyFormat("f<1><<<1, 1>>>();");
Daniel Jaspera44991332015-04-29 13:06:49 +000011411 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
Jacques Pienaarfc275112015-02-18 23:48:37 +000011412 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
11413 "aaaaaaaaaaa<<<\n 1, 1>>>();");
Daniel Jaspera4322082016-11-05 17:43:16 +000011414 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
11415 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();");
Jacques Pienaarfc275112015-02-18 23:48:37 +000011416}
11417
11418TEST_F(FormatTest, MergeLessLessAtEnd) {
Jacques Pienaar68a7dbf2015-02-20 21:09:01 +000011419 verifyFormat("<<");
Jacques Pienaar411b2512015-02-24 23:23:24 +000011420 EXPECT_EQ("< < <", format("\\\n<<<"));
Jacques Pienaarfc275112015-02-18 23:48:37 +000011421 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
11422 "aaallvm::outs() <<");
11423 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
11424 "aaaallvm::outs()\n <<");
11425}
11426
Manuel Klimek819788d2014-03-18 11:22:45 +000011427TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {
11428 std::string code = "#if A\n"
11429 "#if B\n"
11430 "a.\n"
11431 "#endif\n"
11432 " a = 1;\n"
11433 "#else\n"
11434 "#endif\n"
11435 "#if C\n"
11436 "#else\n"
11437 "#endif\n";
11438 EXPECT_EQ(code, format(code));
11439}
11440
Manuel Klimek68b03042014-04-14 09:14:11 +000011441TEST_F(FormatTest, HandleConflictMarkers) {
11442 // Git/SVN conflict markers.
11443 EXPECT_EQ("int a;\n"
11444 "void f() {\n"
11445 " callme(some(parameter1,\n"
11446 "<<<<<<< text by the vcs\n"
11447 " parameter2),\n"
11448 "||||||| text by the vcs\n"
11449 " parameter2),\n"
11450 " parameter3,\n"
11451 "======= text by the vcs\n"
11452 " parameter2, parameter3),\n"
11453 ">>>>>>> text by the vcs\n"
11454 " otherparameter);\n",
11455 format("int a;\n"
11456 "void f() {\n"
11457 " callme(some(parameter1,\n"
11458 "<<<<<<< text by the vcs\n"
11459 " parameter2),\n"
11460 "||||||| text by the vcs\n"
11461 " parameter2),\n"
11462 " parameter3,\n"
11463 "======= text by the vcs\n"
11464 " parameter2,\n"
11465 " parameter3),\n"
11466 ">>>>>>> text by the vcs\n"
11467 " otherparameter);\n"));
11468
11469 // Perforce markers.
11470 EXPECT_EQ("void f() {\n"
11471 " function(\n"
11472 ">>>> text by the vcs\n"
11473 " parameter,\n"
11474 "==== text by the vcs\n"
11475 " parameter,\n"
11476 "==== text by the vcs\n"
11477 " parameter,\n"
11478 "<<<< text by the vcs\n"
11479 " parameter);\n",
11480 format("void f() {\n"
11481 " function(\n"
11482 ">>>> text by the vcs\n"
11483 " parameter,\n"
11484 "==== text by the vcs\n"
11485 " parameter,\n"
11486 "==== text by the vcs\n"
11487 " parameter,\n"
11488 "<<<< text by the vcs\n"
11489 " parameter);\n"));
11490
11491 EXPECT_EQ("<<<<<<<\n"
11492 "|||||||\n"
11493 "=======\n"
11494 ">>>>>>>",
11495 format("<<<<<<<\n"
11496 "|||||||\n"
11497 "=======\n"
11498 ">>>>>>>"));
11499
11500 EXPECT_EQ("<<<<<<<\n"
11501 "|||||||\n"
11502 "int i;\n"
11503 "=======\n"
11504 ">>>>>>>",
11505 format("<<<<<<<\n"
11506 "|||||||\n"
11507 "int i;\n"
11508 "=======\n"
11509 ">>>>>>>"));
11510
11511 // FIXME: Handle parsing of macros around conflict markers correctly:
11512 EXPECT_EQ("#define Macro \\\n"
11513 "<<<<<<<\n"
11514 "Something \\\n"
11515 "|||||||\n"
11516 "Else \\\n"
11517 "=======\n"
11518 "Other \\\n"
11519 ">>>>>>>\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +000011520 " End int i;\n",
Manuel Klimek68b03042014-04-14 09:14:11 +000011521 format("#define Macro \\\n"
11522 "<<<<<<<\n"
11523 " Something \\\n"
11524 "|||||||\n"
11525 " Else \\\n"
11526 "=======\n"
11527 " Other \\\n"
11528 ">>>>>>>\n"
11529 " End\n"
11530 "int i;\n"));
11531}
11532
Daniel Jasper471894432014-08-06 13:40:26 +000011533TEST_F(FormatTest, DisableRegions) {
11534 EXPECT_EQ("int i;\n"
11535 "// clang-format off\n"
11536 " int j;\n"
11537 "// clang-format on\n"
11538 "int k;",
11539 format(" int i;\n"
11540 " // clang-format off\n"
11541 " int j;\n"
11542 " // clang-format on\n"
11543 " int k;"));
Roman Kashitsyn650ecb52014-09-11 14:47:20 +000011544 EXPECT_EQ("int i;\n"
11545 "/* clang-format off */\n"
11546 " int j;\n"
11547 "/* clang-format on */\n"
11548 "int k;",
11549 format(" int i;\n"
11550 " /* clang-format off */\n"
11551 " int j;\n"
11552 " /* clang-format on */\n"
11553 " int k;"));
Krasimir Georgiev91834222017-01-25 13:58:58 +000011554
11555 // Don't reflow comments within disabled regions.
11556 EXPECT_EQ(
11557 "// clang-format off\n"
11558 "// long long long long long long line\n"
11559 "/* clang-format on */\n"
11560 "/* long long long\n"
11561 " * long long long\n"
11562 " * line */\n"
11563 "int i;\n"
11564 "/* clang-format off */\n"
11565 "/* long long long long long long line */\n",
11566 format("// clang-format off\n"
11567 "// long long long long long long line\n"
11568 "/* clang-format on */\n"
11569 "/* long long long long long long line */\n"
11570 "int i;\n"
11571 "/* clang-format off */\n"
11572 "/* long long long long long long line */\n",
11573 getLLVMStyleWithColumns(20)));
Daniel Jasper471894432014-08-06 13:40:26 +000011574}
11575
Manuel Klimekf0c95b32015-06-11 10:14:13 +000011576TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
11577 format("? ) =");
11578 verifyNoCrash("#define a\\\n /**/}");
11579}
Manuel Klimek5f594f82014-08-13 14:00:41 +000011580
Daniel Jasper498f5582015-12-25 08:53:31 +000011581TEST_F(FormatTest, FormatsTableGenCode) {
11582 FormatStyle Style = getLLVMStyle();
11583 Style.Language = FormatStyle::LK_TableGen;
11584 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);
11585}
11586
Nico Weberb2673a12016-11-10 21:49:25 +000011587TEST_F(FormatTest, ArrayOfTemplates) {
11588 EXPECT_EQ("auto a = new unique_ptr<int>[10];",
11589 format("auto a = new unique_ptr<int > [ 10];"));
11590
11591 FormatStyle Spaces = getLLVMStyle();
11592 Spaces.SpacesInSquareBrackets = true;
11593 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];",
11594 format("auto a = new unique_ptr<int > [10];", Spaces));
11595}
11596
11597TEST_F(FormatTest, ArrayAsTemplateType) {
11598 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;",
11599 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;"));
11600
11601 FormatStyle Spaces = getLLVMStyle();
11602 Spaces.SpacesInSquareBrackets = true;
11603 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",
11604 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces));
11605}
11606
Martin Probstc9c51c42017-03-16 10:21:35 +000011607TEST_F(FormatTest, NoSpaceAfterSuper) {
11608 verifyFormat("__super::FooBar();");
11609}
11610
Eric Liu547d8792016-03-24 13:22:42 +000011611TEST(FormatStyle, GetStyleOfFile) {
11612 vfs::InMemoryFileSystem FS;
11613 // Test 1: format file in the same directory.
11614 ASSERT_TRUE(
11615 FS.addFile("/a/.clang-format", 0,
11616 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
11617 ASSERT_TRUE(
11618 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
Daniel Jasper03a04fe2016-12-12 12:42:29 +000011619 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS);
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +000011620 ASSERT_TRUE((bool)Style1);
11621 ASSERT_EQ(*Style1, getLLVMStyle());
Eric Liu547d8792016-03-24 13:22:42 +000011622
Antonio Maiorano7eb75072017-01-20 01:22:42 +000011623 // Test 2.1: fallback to default.
Eric Liu547d8792016-03-24 13:22:42 +000011624 ASSERT_TRUE(
11625 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
Daniel Jasper03a04fe2016-12-12 12:42:29 +000011626 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS);
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +000011627 ASSERT_TRUE((bool)Style2);
11628 ASSERT_EQ(*Style2, getMozillaStyle());
Eric Liu547d8792016-03-24 13:22:42 +000011629
Antonio Maiorano7eb75072017-01-20 01:22:42 +000011630 // Test 2.2: no format on 'none' fallback style.
11631 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
11632 ASSERT_TRUE((bool)Style2);
11633 ASSERT_EQ(*Style2, getNoStyle());
11634
11635 // Test 2.3: format if config is found with no based style while fallback is
11636 // 'none'.
11637 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
11638 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2")));
11639 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
11640 ASSERT_TRUE((bool)Style2);
11641 ASSERT_EQ(*Style2, getLLVMStyle());
11642
11643 // Test 2.4: format if yaml with no based style, while fallback is 'none'.
11644 Style2 = getStyle("{}", "a.h", "none", "", &FS);
11645 ASSERT_TRUE((bool)Style2);
11646 ASSERT_EQ(*Style2, getLLVMStyle());
11647
Eric Liu547d8792016-03-24 13:22:42 +000011648 // Test 3: format file in parent directory.
11649 ASSERT_TRUE(
11650 FS.addFile("/c/.clang-format", 0,
11651 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
11652 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
11653 llvm::MemoryBuffer::getMemBuffer("int i;")));
Daniel Jasper03a04fe2016-12-12 12:42:29 +000011654 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS);
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +000011655 ASSERT_TRUE((bool)Style3);
11656 ASSERT_EQ(*Style3, getGoogleStyle());
11657
11658 // Test 4: error on invalid fallback style
11659 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS);
11660 ASSERT_FALSE((bool)Style4);
11661 llvm::consumeError(Style4.takeError());
11662
11663 // Test 5: error on invalid yaml on command line
11664 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS);
11665 ASSERT_FALSE((bool)Style5);
11666 llvm::consumeError(Style5.takeError());
11667
11668 // Test 6: error on invalid style
11669 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS);
11670 ASSERT_FALSE((bool)Style6);
11671 llvm::consumeError(Style6.takeError());
11672
11673 // Test 7: found config file, error on parsing it
11674 ASSERT_TRUE(
11675 FS.addFile("/d/.clang-format", 0,
11676 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n"
11677 "InvalidKey: InvalidValue")));
11678 ASSERT_TRUE(
11679 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
11680 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS);
11681 ASSERT_FALSE((bool)Style7);
11682 llvm::consumeError(Style7.takeError());
Eric Liu547d8792016-03-24 13:22:42 +000011683}
11684
Manuel Klimekb12e5a52016-03-01 12:37:30 +000011685TEST_F(ReplacementTest, FormatCodeAfterReplacements) {
11686 // Column limit is 20.
11687 std::string Code = "Type *a =\n"
11688 " new Type();\n"
11689 "g(iiiii, 0, jjjjj,\n"
11690 " 0, kkkkk, 0, mm);\n"
11691 "int bad = format ;";
11692 std::string Expected = "auto a = new Type();\n"
11693 "g(iiiii, nullptr,\n"
11694 " jjjjj, nullptr,\n"
11695 " kkkkk, nullptr,\n"
11696 " mm);\n"
11697 "int bad = format ;";
11698 FileID ID = Context.createInMemoryFile("format.cpp", Code);
Eric Liu40ef2fb2016-08-01 10:16:37 +000011699 tooling::Replacements Replaces = toReplacements(
11700 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6,
11701 "auto "),
11702 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1,
11703 "nullptr"),
11704 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1,
11705 "nullptr"),
11706 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1,
11707 "nullptr")});
Manuel Klimekb12e5a52016-03-01 12:37:30 +000011708
11709 format::FormatStyle Style = format::getLLVMStyle();
11710 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility.
Eric Liu4f8d9942016-07-11 13:53:12 +000011711 auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
11712 EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
11713 << llvm::toString(FormattedReplaces.takeError()) << "\n";
11714 auto Result = applyAllReplacements(Code, *FormattedReplaces);
11715 EXPECT_TRUE(static_cast<bool>(Result));
11716 EXPECT_EQ(Expected, *Result);
Manuel Klimekb12e5a52016-03-01 12:37:30 +000011717}
11718
Eric Liubaf58c22016-05-18 13:43:48 +000011719TEST_F(ReplacementTest, SortIncludesAfterReplacement) {
11720 std::string Code = "#include \"a.h\"\n"
11721 "#include \"c.h\"\n"
11722 "\n"
11723 "int main() {\n"
11724 " return 0;\n"
11725 "}";
11726 std::string Expected = "#include \"a.h\"\n"
11727 "#include \"b.h\"\n"
11728 "#include \"c.h\"\n"
11729 "\n"
11730 "int main() {\n"
11731 " return 0;\n"
11732 "}";
11733 FileID ID = Context.createInMemoryFile("fix.cpp", Code);
Eric Liu40ef2fb2016-08-01 10:16:37 +000011734 tooling::Replacements Replaces = toReplacements(
11735 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0,
11736 "#include \"b.h\"\n")});
Eric Liubaf58c22016-05-18 13:43:48 +000011737
11738 format::FormatStyle Style = format::getLLVMStyle();
11739 Style.SortIncludes = true;
Eric Liu4f8d9942016-07-11 13:53:12 +000011740 auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
11741 EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
11742 << llvm::toString(FormattedReplaces.takeError()) << "\n";
11743 auto Result = applyAllReplacements(Code, *FormattedReplaces);
11744 EXPECT_TRUE(static_cast<bool>(Result));
11745 EXPECT_EQ(Expected, *Result);
Eric Liubaf58c22016-05-18 13:43:48 +000011746}
11747
Krasimir Georgievac16a202017-06-23 11:46:03 +000011748TEST_F(FormatTest, FormatSortsUsingDeclarations) {
11749 EXPECT_EQ("using std::cin;\n"
11750 "using std::cout;",
11751 format("using std::cout;\n"
11752 "using std::cin;", getGoogleStyle()));
11753}
11754
Nico Weberdc065182017-04-05 18:10:42 +000011755TEST_F(FormatTest, UTF8CharacterLiteralCpp03) {
11756 format::FormatStyle Style = format::getLLVMStyle();
11757 Style.Standard = FormatStyle::LS_Cpp03;
11758 // cpp03 recognize this string as identifier u8 and literal character 'a'
11759 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style));
11760}
11761
11762TEST_F(FormatTest, UTF8CharacterLiteralCpp11) {
11763 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers
11764 // all modes, including C++11, C++14 and C++17
11765 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';"));
11766}
11767
Krasimir Georgieva2e7d0d2017-08-29 13:51:38 +000011768TEST_F(FormatTest, DoNotFormatLikelyXml) {
11769 EXPECT_EQ("<!-- ;> -->",
11770 format("<!-- ;> -->", getGoogleStyle()));
11771 EXPECT_EQ(" <!-- >; -->",
11772 format(" <!-- >; -->", getGoogleStyle()));
11773}
11774
Marek Kurdejceeb8b92017-09-07 14:28:32 +000011775TEST_F(FormatTest, StructuredBindings) {
11776 // Structured bindings is a C++17 feature.
11777 // all modes, including C++11, C++14 and C++17
11778 verifyFormat("auto [a, b] = f();");
11779 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();"));
11780 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();"));
11781 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();"));
11782 EXPECT_EQ("auto const volatile [a, b] = f();",
11783 format("auto const volatile[a, b] = f();"));
11784 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();"));
Chih-Hung Hsieh30cd3012017-09-27 00:58:45 +000011785 EXPECT_EQ("auto &[a, b, c] = f();",
Marek Kurdejceeb8b92017-09-07 14:28:32 +000011786 format("auto &[ a , b,c ] = f();"));
Chih-Hung Hsieh30cd3012017-09-27 00:58:45 +000011787 EXPECT_EQ("auto &&[a, b, c] = f();",
Marek Kurdejceeb8b92017-09-07 14:28:32 +000011788 format("auto &&[ a , b,c ] = f();"));
Chih-Hung Hsieh30cd3012017-09-27 00:58:45 +000011789 EXPECT_EQ("auto const &[a, b] = f();", format("auto const&[a, b] = f();"));
11790 EXPECT_EQ("auto const volatile &&[a, b] = f();",
Marek Kurdejceeb8b92017-09-07 14:28:32 +000011791 format("auto const volatile &&[a, b] = f();"));
Chih-Hung Hsieh30cd3012017-09-27 00:58:45 +000011792 EXPECT_EQ("auto const &&[a, b] = f();", format("auto const && [a, b] = f();"));
11793 EXPECT_EQ("const auto &[a, b] = f();", format("const auto & [a, b] = f();"));
11794 EXPECT_EQ("const auto volatile &&[a, b] = f();",
11795 format("const auto volatile &&[a, b] = f();"));
11796 EXPECT_EQ("volatile const auto &&[a, b] = f();",
11797 format("volatile const auto &&[a, b] = f();"));
11798 EXPECT_EQ("const auto &&[a, b] = f();", format("const auto && [a, b] = f();"));
Marek Kurdejceeb8b92017-09-07 14:28:32 +000011799
Manuel Klimeke411aa82017-09-20 09:29:37 +000011800 // Make sure we don't mistake structured bindings for lambdas.
Chih-Hung Hsieh30cd3012017-09-27 00:58:45 +000011801 FormatStyle PointerMiddle = getLLVMStyle();
11802 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
11803 verifyFormat("auto [a1, b]{A * i};", getGoogleStyle());
11804 verifyFormat("auto [a2, b]{A * i};", getLLVMStyle());
11805 verifyFormat("auto [a3, b]{A * i};", PointerMiddle);
11806 verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle());
11807 verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle());
11808 verifyFormat("auto const [a3, b]{A * i};", PointerMiddle);
11809 verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle());
11810 verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle());
11811 verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle);
11812 verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle());
11813 verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle());
11814 verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle);
11815
11816 EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}",
11817 format("for (const auto && [a, b] : some_range) {\n}"));
11818 EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}",
11819 format("for (const auto & [a, b] : some_range) {\n}"));
11820 EXPECT_EQ("for (const auto [a, b] : some_range) {\n}",
11821 format("for (const auto[a, b] : some_range) {\n}"));
11822 EXPECT_EQ("auto [x, y](expr);", format("auto[x,y] (expr);"));
11823 EXPECT_EQ("auto &[x, y](expr);", format("auto & [x,y] (expr);"));
11824 EXPECT_EQ("auto &&[x, y](expr);", format("auto && [x,y] (expr);"));
11825 EXPECT_EQ("auto const &[x, y](expr);", format("auto const & [x,y] (expr);"));
11826 EXPECT_EQ("auto const &&[x, y](expr);", format("auto const && [x,y] (expr);"));
11827 EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y] {expr};"));
11828 EXPECT_EQ("auto const &[x, y]{expr};", format("auto const & [x,y] {expr};"));
11829 EXPECT_EQ("auto const &&[x, y]{expr};", format("auto const && [x,y] {expr};"));
Manuel Klimeke411aa82017-09-20 09:29:37 +000011830
Marek Kurdejceeb8b92017-09-07 14:28:32 +000011831 format::FormatStyle Spaces = format::getLLVMStyle();
11832 Spaces.SpacesInSquareBrackets = true;
11833 verifyFormat("auto [ a, b ] = f();", Spaces);
Chih-Hung Hsieh30cd3012017-09-27 00:58:45 +000011834 verifyFormat("auto &&[ a, b ] = f();", Spaces);
11835 verifyFormat("auto &[ a, b ] = f();", Spaces);
11836 verifyFormat("auto const &&[ a, b ] = f();", Spaces);
11837 verifyFormat("auto const &[ a, b ] = f();", Spaces);
Marek Kurdejceeb8b92017-09-07 14:28:32 +000011838}
11839
Daniel Jasperd246a5a2015-06-15 15:25:11 +000011840} // end namespace
11841} // end namespace format
Daniel Jasper8d1832e2013-01-07 13:26:07 +000011842} // end namespace clang