blob: 6f4bd6d69d0d5f87bcef32e5699915b16fa3531c [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 "}");
Daniel Jasper7ae41cd2013-07-03 10:34:47 +00003075 // Even explicit parentheses stress the precedence enough to make the
3076 // additional break unnecessary.
Daniel Jaspera44991332015-04-29 13:06:49 +00003077 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3078 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
3079 "}");
Daniel Jasper7ae41cd2013-07-03 10:34:47 +00003080 // This cases is borderline, but with the indentation it is still readable.
3081 verifyFormat(
3082 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3083 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3084 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
3085 "}",
3086 getLLVMStyleWithColumns(75));
3087
3088 // If the LHS is a binary expression, we should still use the additional break
3089 // as otherwise the formatting hides the operator precedence.
Daniel Jaspera44991332015-04-29 13:06:49 +00003090 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3091 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
3092 " 5) {\n"
3093 "}");
Daniel Jasper7ae41cd2013-07-03 10:34:47 +00003094
Daniel Jasper571f1af2013-05-14 20:39:56 +00003095 FormatStyle OnePerLine = getLLVMStyle();
3096 OnePerLine.BinPackParameters = false;
3097 verifyFormat(
3098 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3099 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3100 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}",
3101 OnePerLine);
Daniel Jaspere61f9f92017-01-13 23:18:16 +00003102
3103 verifyFormat("int i = someFunction(aaaaaaa, 0)\n"
3104 " .aaa(aaaaaaaaaaaaa) *\n"
3105 " aaaaaaa +\n"
3106 " aaaaaaa;",
3107 getLLVMStyleWithColumns(40));
Daniel Jasperd69fc772013-05-08 14:12:04 +00003108}
3109
Daniel Jasper6bee6822013-04-08 20:33:42 +00003110TEST_F(FormatTest, ExpressionIndentation) {
3111 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3112 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3113 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
3114 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
3115 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
3116 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n"
3117 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
3118 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n"
3119 " ccccccccccccccccccccccccccccccccccccccccc;");
3120 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
3121 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3122 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
3123 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
3124 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3125 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
3126 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
3127 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
3128 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
3129 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
3130 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3131 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
Daniel Jasper6dcecb62013-06-06 09:11:58 +00003132 verifyFormat("if () {\n"
Daniel Jasper21f7dea2017-02-01 09:23:39 +00003133 "} else if (aaaaa && bbbbb > // break\n"
3134 " ccccc) {\n"
3135 "}");
3136 verifyFormat("if () {\n"
Daniel Jasper5c332652014-04-03 12:00:33 +00003137 "} else if (aaaaa &&\n"
3138 " bbbbb > // break\n"
Daniel Jasper21f7dea2017-02-01 09:23:39 +00003139 " ccccc &&\n"
3140 " ddddd) {\n"
Daniel Jasper6dcecb62013-06-06 09:11:58 +00003141 "}");
Alexander Kornienkoafaa8f52013-06-17 13:19:53 +00003142
3143 // Presence of a trailing comment used to change indentation of b.
3144 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
3145 " b;\n"
3146 "return aaaaaaaaaaaaaaaaaaa +\n"
3147 " b; //",
3148 getLLVMStyleWithColumns(30));
Daniel Jasper6bee6822013-04-08 20:33:42 +00003149}
3150
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003151TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) {
3152 // Not sure what the best system is here. Like this, the LHS can be found
3153 // immediately above an operator (everything with the same or a higher
3154 // indent). The RHS is aligned right of the operator and so compasses
3155 // everything until something with the same indent as the operator is found.
3156 // FIXME: Is this a good system?
3157 FormatStyle Style = getLLVMStyle();
Daniel Jasperac043c92014-09-15 11:11:00 +00003158 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003159 verifyFormat(
3160 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00003161 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3162 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3163 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3164 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
3165 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003166 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00003167 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3168 " > ccccccccccccccccccccccccccccccccccccccccc;",
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003169 Style);
3170 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00003171 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3172 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003173 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
3174 Style);
3175 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00003176 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3177 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003178 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
3179 Style);
3180 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3181 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00003182 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3183 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003184 Style);
3185 verifyFormat("if () {\n"
Daniel Jasperc0d606a2014-04-14 11:08:45 +00003186 "} else if (aaaaa\n"
3187 " && bbbbb // break\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00003188 " > ccccc) {\n"
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003189 "}",
3190 Style);
Daniel Jasper119ff532014-11-14 12:31:14 +00003191 verifyFormat("return (a)\n"
3192 " // comment\n"
3193 " + b;",
3194 Style);
Daniel Jaspera44991332015-04-29 13:06:49 +00003195 verifyFormat(
3196 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3197 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
3198 " + cc;",
3199 Style);
Daniel Jasper9e5ede02013-11-08 19:56:28 +00003200
Daniel Jaspere92bf6f2015-05-06 14:23:38 +00003201 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3202 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
3203 Style);
3204
Daniel Jasper9e5ede02013-11-08 19:56:28 +00003205 // Forced by comments.
3206 verifyFormat(
3207 "unsigned ContentSize =\n"
3208 " sizeof(int16_t) // DWARF ARange version number\n"
3209 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
3210 " + sizeof(int8_t) // Pointer Size (in bytes)\n"
3211 " + sizeof(int8_t); // Segment Size (in bytes)");
Daniel Jasper446d1cd2013-11-23 14:45:49 +00003212
3213 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
3214 " == boost::fusion::at_c<1>(iiii).second;",
3215 Style);
Daniel Jasper0a1e5ac2014-05-13 08:01:47 +00003216
3217 Style.ColumnLimit = 60;
3218 verifyFormat("zzzzzzzzzz\n"
3219 " = bbbbbbbbbbbbbbbbb\n"
3220 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
3221 Style);
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003222}
3223
Daniel Jasperb1270392017-02-01 23:27:37 +00003224TEST_F(FormatTest, EnforcedOperatorWraps) {
3225 // Here we'd like to wrap after the || operators, but a comment is forcing an
3226 // earlier wrap.
3227 verifyFormat("bool x = aaaaa //\n"
3228 " || bbbbb\n"
3229 " //\n"
3230 " || cccc;");
3231}
3232
Daniel Jasper3219e432014-12-02 13:24:51 +00003233TEST_F(FormatTest, NoOperandAlignment) {
3234 FormatStyle Style = getLLVMStyle();
3235 Style.AlignOperands = false;
Daniel Jasperc3aa05c2017-02-02 08:30:21 +00003236 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n"
3237 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3238 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
3239 Style);
Daniel Jasper3219e432014-12-02 13:24:51 +00003240 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
Daniel Jaspera44991332015-04-29 13:06:49 +00003241 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3242 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3243 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3244 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3245 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
3246 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
3247 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3248 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3249 " > ccccccccccccccccccccccccccccccccccccccccc;",
3250 Style);
Daniel Jasper3219e432014-12-02 13:24:51 +00003251
3252 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3253 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
3254 " + cc;",
3255 Style);
3256 verifyFormat("int a = aa\n"
3257 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
Daniel Jasper21f7dea2017-02-01 09:23:39 +00003258 " * cccccccccccccccccccccccccccccccccccc;\n",
Daniel Jasper3219e432014-12-02 13:24:51 +00003259 Style);
Daniel Jasperc0956632014-12-03 14:02:59 +00003260
Daniel Jasper6501f7e2015-10-27 12:38:37 +00003261 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
Daniel Jasperc0956632014-12-03 14:02:59 +00003262 verifyFormat("return (a > b\n"
3263 " // comment1\n"
3264 " // comment2\n"
3265 " || c);",
3266 Style);
Daniel Jasper3219e432014-12-02 13:24:51 +00003267}
3268
Daniel Jasperac043c92014-09-15 11:11:00 +00003269TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) {
3270 FormatStyle Style = getLLVMStyle();
3271 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
3272 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
3273 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper3219e432014-12-02 13:24:51 +00003274 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
3275 Style);
Daniel Jasperac043c92014-09-15 11:11:00 +00003276}
3277
Daniel Jasper988e7e42017-05-08 15:07:52 +00003278TEST_F(FormatTest, AllowBinPackingInsideArguments) {
3279 FormatStyle Style = getLLVMStyle();
3280 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
3281 Style.BinPackArguments = false;
3282 Style.ColumnLimit = 40;
3283 verifyFormat("void test() {\n"
3284 " someFunction(\n"
3285 " this + argument + is + quite\n"
3286 " + long + so + it + gets + wrapped\n"
3287 " + but + remains + bin - packed);\n"
3288 "}",
3289 Style);
3290 verifyFormat("void test() {\n"
3291 " someFunction(arg1,\n"
3292 " this + argument + is\n"
3293 " + quite + long + so\n"
3294 " + it + gets + wrapped\n"
3295 " + but + remains + bin\n"
3296 " - packed,\n"
3297 " arg3);\n"
3298 "}",
3299 Style);
3300 verifyFormat("void test() {\n"
3301 " someFunction(\n"
3302 " arg1,\n"
3303 " this + argument + has\n"
3304 " + anotherFunc(nested,\n"
3305 " calls + whose\n"
3306 " + arguments\n"
3307 " + are + also\n"
3308 " + wrapped,\n"
3309 " in + addition)\n"
3310 " + to + being + bin - packed,\n"
3311 " arg3);\n"
3312 "}",
3313 Style);
3314
3315 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
3316 verifyFormat("void test() {\n"
3317 " someFunction(\n"
3318 " arg1,\n"
3319 " this + argument + has +\n"
3320 " anotherFunc(nested,\n"
3321 " calls + whose +\n"
3322 " arguments +\n"
3323 " are + also +\n"
3324 " wrapped,\n"
3325 " in + addition) +\n"
3326 " to + being + bin - packed,\n"
3327 " arg3);\n"
3328 "}",
3329 Style);
3330}
3331
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003332TEST_F(FormatTest, ConstructorInitializers) {
Manuel Klimeke7d10a12013-01-10 13:24:24 +00003333 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
Daniel Jasper2408a8c2013-01-11 11:37:55 +00003334 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
3335 getLLVMStyleWithColumns(45));
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003336 verifyFormat("Constructor()\n"
3337 " : Inttializer(FitsOnTheLine) {}",
Daniel Jasper2408a8c2013-01-11 11:37:55 +00003338 getLLVMStyleWithColumns(44));
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003339 verifyFormat("Constructor()\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003340 " : Inttializer(FitsOnTheLine) {}",
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003341 getLLVMStyleWithColumns(43));
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003342
Daniel Jasper7b259cd2015-08-27 11:59:31 +00003343 verifyFormat("template <typename T>\n"
3344 "Constructor() : Initializer(FitsOnTheLine) {}",
3345 getLLVMStyleWithColumns(45));
3346
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003347 verifyFormat(
3348 "SomeClass::Constructor()\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003349 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003350
3351 verifyFormat(
3352 "SomeClass::Constructor()\n"
Daniel Jasper2408a8c2013-01-11 11:37:55 +00003353 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003354 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}");
Daniel Jasper2408a8c2013-01-11 11:37:55 +00003355 verifyFormat(
3356 "SomeClass::Constructor()\n"
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003357 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003358 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
Daniel Jasper7b259cd2015-08-27 11:59:31 +00003359 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3360 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3361 " : aaaaaaaaaa(aaaaaa) {}");
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003362
3363 verifyFormat("Constructor()\n"
3364 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3365 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3366 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003367 " aaaaaaaaaaaaaaaaaaaaaaa() {}");
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003368
Daniel Jasper65585ed2013-01-28 13:31:35 +00003369 verifyFormat("Constructor()\n"
3370 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003371 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasper65585ed2013-01-28 13:31:35 +00003372
Daniel Jasper62e68172013-02-25 15:59:54 +00003373 verifyFormat("Constructor(int Parameter = 0)\n"
3374 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
3375 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}");
Daniel Jasper87f18f12013-09-06 21:46:41 +00003376 verifyFormat("Constructor()\n"
3377 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
3378 "}",
3379 getLLVMStyleWithColumns(60));
Daniel Jasper4fcc8b92013-11-07 17:52:51 +00003380 verifyFormat("Constructor()\n"
3381 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3382 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}");
Daniel Jasper62e68172013-02-25 15:59:54 +00003383
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003384 // Here a line could be saved by splitting the second initializer onto two
Alp Tokerf6a24ce2013-12-05 16:25:25 +00003385 // lines, but that is not desirable.
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003386 verifyFormat("Constructor()\n"
3387 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
3388 " aaaaaaaaaaa(aaaaaaaaaaa),\n"
3389 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003390
Daniel Jasper23e8e0c2013-02-15 16:49:44 +00003391 FormatStyle OnePerLine = getLLVMStyle();
3392 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
Daniel Jasper7bec87c2016-01-07 18:11:54 +00003393 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false;
Daniel Jasper23e8e0c2013-02-15 16:49:44 +00003394 verifyFormat("SomeClass::Constructor()\n"
3395 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
3396 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003397 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003398 OnePerLine);
Daniel Jasper23e8e0c2013-02-15 16:49:44 +00003399 verifyFormat("SomeClass::Constructor()\n"
3400 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
3401 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003402 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003403 OnePerLine);
Daniel Jasper23e8e0c2013-02-15 16:49:44 +00003404 verifyFormat("MyClass::MyClass(int var)\n"
3405 " : some_var_(var), // 4 space indent\n"
3406 " some_other_var_(var + 1) { // lined up\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003407 "}",
3408 OnePerLine);
Daniel Jasperead41b62013-02-28 09:39:12 +00003409 verifyFormat("Constructor()\n"
3410 " : aaaaa(aaaaaa),\n"
3411 " aaaaa(aaaaaa),\n"
3412 " aaaaa(aaaaaa),\n"
3413 " aaaaa(aaaaaa),\n"
3414 " aaaaa(aaaaaa) {}",
3415 OnePerLine);
Daniel Jaspercc960fa2013-04-22 07:59:53 +00003416 verifyFormat("Constructor()\n"
3417 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
3418 " aaaaaaaaaaaaaaaaaaaaaa) {}",
3419 OnePerLine);
Daniel Jasper7bec87c2016-01-07 18:11:54 +00003420 OnePerLine.BinPackParameters = false;
3421 verifyFormat(
3422 "Constructor()\n"
3423 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n"
3424 " aaaaaaaaaaa().aaa(),\n"
3425 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
3426 OnePerLine);
Daniel Jasperbd73bcf2015-10-27 13:42:08 +00003427 OnePerLine.ColumnLimit = 60;
3428 verifyFormat("Constructor()\n"
3429 " : aaaaaaaaaaaaaaaaaaaa(a),\n"
3430 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
3431 OnePerLine);
Daniel Jasperf6c7c182014-01-13 14:10:04 +00003432
3433 EXPECT_EQ("Constructor()\n"
3434 " : // Comment forcing unwanted break.\n"
3435 " aaaa(aaaa) {}",
3436 format("Constructor() :\n"
3437 " // Comment forcing unwanted break.\n"
3438 " aaaa(aaaa) {}"));
Daniel Jaspere3c0e012013-04-25 13:31:51 +00003439}
3440
Francois Ferranda6b6d512017-05-24 11:36:58 +00003441TEST_F(FormatTest, BreakConstructorInitializersAfterColon) {
3442 FormatStyle Style = getLLVMStyle();
3443 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
3444
3445 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
3446 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}",
3447 getStyleWithColumns(Style, 45));
3448 verifyFormat("Constructor() :\n"
3449 " Initializer(FitsOnTheLine) {}",
3450 getStyleWithColumns(Style, 44));
3451 verifyFormat("Constructor() :\n"
3452 " Initializer(FitsOnTheLine) {}",
3453 getStyleWithColumns(Style, 43));
3454
3455 verifyFormat("template <typename T>\n"
3456 "Constructor() : Initializer(FitsOnTheLine) {}",
3457 getStyleWithColumns(Style, 50));
3458
3459 verifyFormat(
3460 "SomeClass::Constructor() :\n"
3461 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
3462 Style);
3463
3464 verifyFormat(
3465 "SomeClass::Constructor() :\n"
3466 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
3467 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
3468 Style);
3469 verifyFormat(
3470 "SomeClass::Constructor() :\n"
3471 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3472 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
3473 Style);
3474 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3475 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
3476 " aaaaaaaaaa(aaaaaa) {}",
3477 Style);
3478
3479 verifyFormat("Constructor() :\n"
3480 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3481 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3482 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3483 " aaaaaaaaaaaaaaaaaaaaaaa() {}",
3484 Style);
3485
3486 verifyFormat("Constructor() :\n"
3487 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3488 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
3489 Style);
3490
3491 verifyFormat("Constructor(int Parameter = 0) :\n"
3492 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
3493 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}",
3494 Style);
3495 verifyFormat("Constructor() :\n"
3496 " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
3497 "}",
3498 getStyleWithColumns(Style, 60));
3499 verifyFormat("Constructor() :\n"
3500 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3501 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}",
3502 Style);
3503
3504 // Here a line could be saved by splitting the second initializer onto two
3505 // lines, but that is not desirable.
3506 verifyFormat("Constructor() :\n"
3507 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
3508 " aaaaaaaaaaa(aaaaaaaaaaa),\n"
3509 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
3510 Style);
3511
3512 FormatStyle OnePerLine = Style;
3513 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
3514 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false;
3515 verifyFormat("SomeClass::Constructor() :\n"
3516 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
3517 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
3518 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
3519 OnePerLine);
3520 verifyFormat("SomeClass::Constructor() :\n"
3521 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
3522 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
3523 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
3524 OnePerLine);
3525 verifyFormat("MyClass::MyClass(int var) :\n"
3526 " some_var_(var), // 4 space indent\n"
3527 " some_other_var_(var + 1) { // lined up\n"
3528 "}",
3529 OnePerLine);
3530 verifyFormat("Constructor() :\n"
3531 " aaaaa(aaaaaa),\n"
3532 " aaaaa(aaaaaa),\n"
3533 " aaaaa(aaaaaa),\n"
3534 " aaaaa(aaaaaa),\n"
3535 " aaaaa(aaaaaa) {}",
3536 OnePerLine);
3537 verifyFormat("Constructor() :\n"
3538 " aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
3539 " aaaaaaaaaaaaaaaaaaaaaa) {}",
3540 OnePerLine);
3541 OnePerLine.BinPackParameters = false;
3542 verifyFormat(
3543 "Constructor() :\n"
3544 " aaaaaaaaaaaaaaaaaaaaaaaa(\n"
3545 " aaaaaaaaaaa().aaa(),\n"
3546 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
3547 OnePerLine);
3548 OnePerLine.ColumnLimit = 60;
3549 verifyFormat("Constructor() :\n"
3550 " aaaaaaaaaaaaaaaaaaaa(a),\n"
3551 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
3552 OnePerLine);
3553
3554 EXPECT_EQ("Constructor() :\n"
3555 " // Comment forcing unwanted break.\n"
3556 " aaaa(aaaa) {}",
3557 format("Constructor() :\n"
3558 " // Comment forcing unwanted break.\n"
3559 " aaaa(aaaa) {}",
3560 Style));
3561
3562 Style.ColumnLimit = 0;
3563 verifyFormat("SomeClass::Constructor() :\n"
3564 " a(a) {}",
3565 Style);
3566 verifyFormat("SomeClass::Constructor() noexcept :\n"
3567 " a(a) {}",
3568 Style);
3569 verifyFormat("SomeClass::Constructor() :\n"
3570 " a(a), b(b), c(c) {}",
3571 Style);
3572 verifyFormat("SomeClass::Constructor() :\n"
3573 " a(a) {\n"
3574 " foo();\n"
3575 " bar();\n"
3576 "}",
3577 Style);
3578
3579 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
3580 verifyFormat("SomeClass::Constructor() :\n"
3581 " a(a), b(b), c(c) {\n"
3582 "}",
3583 Style);
3584 verifyFormat("SomeClass::Constructor() :\n"
3585 " a(a) {\n"
3586 "}",
3587 Style);
3588
3589 Style.ColumnLimit = 80;
3590 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
3591 Style.ConstructorInitializerIndentWidth = 2;
3592 verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}",
3593 Style);
3594 verifyFormat("SomeClass::Constructor() :\n"
3595 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3596 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}",
3597 Style);
3598}
3599
David Blaikieea95dd72017-08-31 18:49:34 +00003600#ifndef EXPENSIVE_CHECKS
3601// Expensive checks enables libstdc++ checking which includes validating the
3602// state of ranges used in std::priority_queue - this blows out the
3603// runtime/scalability of the function and makes this test unacceptably slow.
Daniel Jaspere3c0e012013-04-25 13:31:51 +00003604TEST_F(FormatTest, MemoizationTests) {
3605 // This breaks if the memoization lookup does not take \c Indent and
3606 // \c LastSpace into account.
3607 verifyFormat(
3608 "extern CFRunLoopTimerRef\n"
3609 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
3610 " CFTimeInterval interval, CFOptionFlags flags,\n"
3611 " CFIndex order, CFRunLoopTimerCallBack callout,\n"
Daniel Jasper8e357692013-05-06 08:27:33 +00003612 " CFRunLoopTimerContext *context) {}");
Daniel Jaspere3c0e012013-04-25 13:31:51 +00003613
3614 // Deep nesting somewhat works around our memoization.
3615 verifyFormat(
3616 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
3617 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
3618 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
3619 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
3620 " aaaaa())))))))))))))))))))))))))))))))))))))));",
3621 getLLVMStyleWithColumns(65));
Daniel Jaspercc3044c2013-05-13 09:19:24 +00003622 verifyFormat(
3623 "aaaaa(\n"
3624 " aaaaa,\n"
3625 " aaaaa(\n"
3626 " aaaaa,\n"
3627 " aaaaa(\n"
3628 " aaaaa,\n"
3629 " aaaaa(\n"
3630 " aaaaa,\n"
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))))))))))));",
3648 getLLVMStyleWithColumns(65));
Daniel Jasperf8114cf2013-05-22 05:27:42 +00003649 verifyFormat(
3650 "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"
3651 " a),\n"
3652 " a),\n"
3653 " a),\n"
3654 " a),\n"
3655 " a),\n"
3656 " a),\n"
3657 " a),\n"
3658 " 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)",
3668 getLLVMStyleWithColumns(65));
Daniel Jasper7b7877a2013-01-12 07:36:22 +00003669
3670 // This test takes VERY long when memoization is broken.
Daniel Jaspere3c0e012013-04-25 13:31:51 +00003671 FormatStyle OnePerLine = getLLVMStyle();
3672 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003673 OnePerLine.BinPackParameters = false;
Daniel Jasper9278eb92013-01-16 14:59:02 +00003674 std::string input = "Constructor()\n"
Daniel Jasper7a31af12013-01-25 15:43:32 +00003675 " : aaaa(a,\n";
Daniel Jasper9278eb92013-01-16 14:59:02 +00003676 for (unsigned i = 0, e = 80; i != e; ++i) {
3677 input += " a,\n";
3678 }
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003679 input += " a) {}";
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003680 verifyFormat(input, OnePerLine);
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003681}
David Blaikieea95dd72017-08-31 18:49:34 +00003682#endif
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003683
Alexander Kornienko578fdd82012-12-06 18:03:27 +00003684TEST_F(FormatTest, BreaksAsHighAsPossible) {
3685 verifyFormat(
Alexander Kornienkoa5151272013-03-12 16:28:18 +00003686 "void f() {\n"
3687 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
3688 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
3689 " f();\n"
3690 "}");
Daniel Jasper70bc8742013-02-26 13:59:14 +00003691 verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00003692 " Intervals[i - 1].getRange().getLast()) {\n}");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00003693}
3694
Daniel Jasper6728fc12013-04-11 14:29:13 +00003695TEST_F(FormatTest, BreaksFunctionDeclarations) {
3696 // Principially, we break function declarations in a certain order:
3697 // 1) break amongst arguments.
3698 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
3699 " Cccccccccccccc cccccccccccccc);");
Daniel Jaspera44991332015-04-29 13:06:49 +00003700 verifyFormat("template <class TemplateIt>\n"
3701 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n"
3702 " TemplateIt *stop) {}");
Daniel Jasper6728fc12013-04-11 14:29:13 +00003703
3704 // 2) break after return type.
Daniel Jasper8e357692013-05-06 08:27:33 +00003705 verifyFormat(
Manuel Klimek836c2862013-06-21 17:25:42 +00003706 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00003707 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);",
Manuel Klimek836c2862013-06-21 17:25:42 +00003708 getGoogleStyle());
Daniel Jasper6728fc12013-04-11 14:29:13 +00003709
3710 // 3) break after (.
3711 verifyFormat(
3712 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
Manuel Klimek836c2862013-06-21 17:25:42 +00003713 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);",
3714 getGoogleStyle());
Daniel Jasper6728fc12013-04-11 14:29:13 +00003715
3716 // 4) break before after nested name specifiers.
3717 verifyFormat(
3718 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00003719 "SomeClasssssssssssssssssssssssssssssssssssssss::\n"
3720 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);",
Manuel Klimek836c2862013-06-21 17:25:42 +00003721 getGoogleStyle());
Daniel Jasper6728fc12013-04-11 14:29:13 +00003722
3723 // However, there are exceptions, if a sufficient amount of lines can be
3724 // saved.
3725 // FIXME: The precise cut-offs wrt. the number of saved lines might need some
3726 // more adjusting.
3727 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
3728 " Cccccccccccccc cccccccccc,\n"
3729 " Cccccccccccccc cccccccccc,\n"
3730 " Cccccccccccccc cccccccccc,\n"
3731 " Cccccccccccccc cccccccccc);");
3732 verifyFormat(
Manuel Klimek836c2862013-06-21 17:25:42 +00003733 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00003734 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3735 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3736 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);",
Manuel Klimek836c2862013-06-21 17:25:42 +00003737 getGoogleStyle());
Daniel Jasper6728fc12013-04-11 14:29:13 +00003738 verifyFormat(
3739 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
3740 " Cccccccccccccc cccccccccc,\n"
3741 " Cccccccccccccc cccccccccc,\n"
3742 " Cccccccccccccc cccccccccc,\n"
3743 " Cccccccccccccc cccccccccc,\n"
3744 " Cccccccccccccc cccccccccc,\n"
3745 " Cccccccccccccc cccccccccc);");
3746 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
3747 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3748 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3749 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3750 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
Daniel Jasper1b8e76f2013-04-15 22:36:37 +00003751
3752 // Break after multi-line parameters.
3753 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3754 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3755 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3756 " bbbb bbbb);");
Daniel Jasper6c0ee172014-11-14 13:14:45 +00003757 verifyFormat("void SomeLoooooooooooongFunction(\n"
3758 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
3759 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3760 " int bbbbbbbbbbbbb);");
Daniel Jasper6331da02013-07-09 07:43:55 +00003761
3762 // Treat overloaded operators like other functions.
3763 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
3764 "operator>(const SomeLoooooooooooooooooooooooooogType &other);");
Daniel Jasperd215b8b2013-08-28 07:27:35 +00003765 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
3766 "operator>>(const SomeLooooooooooooooooooooooooogType &other);");
Alexander Kornienko86b2dfd2014-03-06 15:13:08 +00003767 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
3768 "operator<<(const SomeLooooooooooooooooooooooooogType &other);");
3769 verifyGoogleFormat(
3770 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n"
3771 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
Daniel Jasper6331da02013-07-09 07:43:55 +00003772 verifyGoogleFormat(
3773 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n"
3774 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
Daniel Jasper126153a2013-12-27 06:39:56 +00003775 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3776 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);");
3777 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n"
3778 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);");
Daniel Jasperea79ea12014-08-15 05:00:39 +00003779 verifyGoogleFormat(
3780 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n"
3781 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3782 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}");
Daniel Jasper88db7602016-02-11 06:43:01 +00003783 verifyGoogleFormat(
3784 "template <typename T>\n"
3785 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3786 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n"
3787 " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);");
Daniel Jasper11309812015-03-18 14:20:13 +00003788
3789 FormatStyle Style = getLLVMStyle();
3790 Style.PointerAlignment = FormatStyle::PAS_Left;
3791 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3792 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}",
3793 Style);
Daniel Jaspera44991332015-04-29 13:06:49 +00003794 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
3795 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
3796 Style);
Daniel Jasper6728fc12013-04-11 14:29:13 +00003797}
3798
Daniel Jasper6cdec7c2013-07-09 14:36:48 +00003799TEST_F(FormatTest, TrailingReturnType) {
3800 verifyFormat("auto foo() -> int;\n");
3801 verifyFormat("struct S {\n"
3802 " auto bar() const -> int;\n"
3803 "};");
3804 verifyFormat("template <size_t Order, typename T>\n"
3805 "auto load_img(const std::string &filename)\n"
3806 " -> alias::tensor<Order, T, mem::tag::cpu> {}");
Daniel Jasperda07a722014-10-17 14:37:40 +00003807 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n"
3808 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}");
Daniel Jasperb52c69e2014-10-22 09:01:12 +00003809 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}");
Daniel Jasper6f2b88a2015-06-05 13:18:09 +00003810 verifyFormat("template <typename T>\n"
3811 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n"
3812 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());");
Daniel Jaspera3501d42013-07-11 14:33:06 +00003813
3814 // Not trailing return types.
3815 verifyFormat("void f() { auto a = b->c(); }");
Daniel Jasper6cdec7c2013-07-09 14:36:48 +00003816}
3817
Daniel Jasper5be31f72013-05-21 09:16:31 +00003818TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) {
Daniel Jasperd8c36d02013-10-18 16:34:40 +00003819 // Avoid breaking before trailing 'const' or other trailing annotations, if
3820 // they are not function-like.
Daniel Jasper13c37b32013-05-22 08:28:26 +00003821 FormatStyle Style = getGoogleStyle();
3822 Style.ColumnLimit = 47;
Daniel Jaspere068ac72014-10-27 17:13:59 +00003823 verifyFormat("void someLongFunction(\n"
3824 " int someLoooooooooooooongParameter) const {\n}",
Daniel Jasper13c37b32013-05-22 08:28:26 +00003825 getLLVMStyleWithColumns(47));
Daniel Jasper13c37b32013-05-22 08:28:26 +00003826 verifyFormat("LoooooongReturnType\n"
3827 "someLoooooooongFunction() const {}",
3828 getLLVMStyleWithColumns(47));
3829 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
3830 " const {}",
3831 Style);
Daniel Jasperd8c36d02013-10-18 16:34:40 +00003832 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
3833 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;");
3834 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
3835 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;");
3836 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
3837 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;");
Daniel Jasper43e6a282013-12-16 15:01:54 +00003838 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n"
3839 " aaaaaaaaaaa aaaaa) const override;");
3840 verifyGoogleFormat(
3841 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
3842 " const override;");
Daniel Jasper5be31f72013-05-21 09:16:31 +00003843
Daniel Jasper5550de62014-02-17 07:57:46 +00003844 // Even if the first parameter has to be wrapped.
3845 verifyFormat("void someLongFunction(\n"
3846 " int someLongParameter) const {}",
Daniel Jasperd8c36d02013-10-18 16:34:40 +00003847 getLLVMStyleWithColumns(46));
Daniel Jasper5550de62014-02-17 07:57:46 +00003848 verifyFormat("void someLongFunction(\n"
3849 " int someLongParameter) const {}",
Daniel Jasperd8c36d02013-10-18 16:34:40 +00003850 Style);
Daniel Jasper5550de62014-02-17 07:57:46 +00003851 verifyFormat("void someLongFunction(\n"
3852 " int someLongParameter) override {}",
3853 Style);
3854 verifyFormat("void someLongFunction(\n"
Daniel Jasperb48d3af2014-04-09 10:01:49 +00003855 " int someLongParameter) OVERRIDE {}",
3856 Style);
3857 verifyFormat("void someLongFunction(\n"
Daniel Jasper5550de62014-02-17 07:57:46 +00003858 " int someLongParameter) final {}",
3859 Style);
3860 verifyFormat("void someLongFunction(\n"
Daniel Jasperb48d3af2014-04-09 10:01:49 +00003861 " int someLongParameter) FINAL {}",
3862 Style);
3863 verifyFormat("void someLongFunction(\n"
Daniel Jasper5550de62014-02-17 07:57:46 +00003864 " int parameter) const override {}",
3865 Style);
3866
Daniel Jaspere3f907f2014-06-02 09:52:08 +00003867 Style.BreakBeforeBraces = FormatStyle::BS_Allman;
3868 verifyFormat("void someLongFunction(\n"
3869 " int someLongParameter) const\n"
3870 "{\n"
3871 "}",
3872 Style);
3873
Daniel Jasper5550de62014-02-17 07:57:46 +00003874 // Unless these are unknown annotations.
Daniel Jasperd8c36d02013-10-18 16:34:40 +00003875 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n"
3876 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3877 " LONG_AND_UGLY_ANNOTATION;");
Daniel Jasper718bd362013-07-11 21:02:56 +00003878
3879 // Breaking before function-like trailing annotations is fine to keep them
3880 // close to their arguments.
Daniel Jasper5be31f72013-05-21 09:16:31 +00003881 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3882 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
3883 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
3884 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
3885 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
3886 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}");
Daniel Jasperf9a09062014-04-09 10:29:11 +00003887 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n"
3888 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);");
Daniel Jasper8b76d602014-07-28 12:08:06 +00003889 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});");
Daniel Jasper5be31f72013-05-21 09:16:31 +00003890
3891 verifyFormat(
3892 "void aaaaaaaaaaaaaaaaaa()\n"
3893 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
3894 " aaaaaaaaaaaaaaaaaaaaaaaaa));");
3895 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3896 " __attribute__((unused));");
Daniel Jasper35ec2b22014-04-14 08:15:20 +00003897 verifyGoogleFormat(
Manuel Klimek836c2862013-06-21 17:25:42 +00003898 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper35ec2b22014-04-14 08:15:20 +00003899 " GUARDED_BY(aaaaaaaaaaaa);");
3900 verifyGoogleFormat(
Daniel Jasper40db06a2013-07-11 12:34:23 +00003901 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper35ec2b22014-04-14 08:15:20 +00003902 " GUARDED_BY(aaaaaaaaaaaa);");
3903 verifyGoogleFormat(
3904 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
3905 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper3ca283a2015-05-15 09:58:11 +00003906 verifyGoogleFormat(
3907 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
3908 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper5be31f72013-05-21 09:16:31 +00003909}
3910
Daniel Jasperf090f032015-05-18 09:47:22 +00003911TEST_F(FormatTest, FunctionAnnotations) {
3912 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
Daniel Jasper788ffd72015-08-24 15:10:01 +00003913 "int OldFunction(const string &parameter) {}");
3914 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
Daniel Jasperf090f032015-05-18 09:47:22 +00003915 "string OldFunction(const string &parameter) {}");
3916 verifyFormat("template <typename T>\n"
3917 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
3918 "string OldFunction(const string &parameter) {}");
Daniel Jasper47bbda02015-05-18 13:47:23 +00003919
3920 // Not function annotations.
3921 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3922 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
Daniel Jasper32739302015-05-27 04:55:47 +00003923 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n"
3924 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}");
Daniel Jasper19bc1d02016-04-06 13:58:09 +00003925 verifyFormat("MACRO(abc).function() // wrap\n"
3926 " << abc;");
3927 verifyFormat("MACRO(abc)->function() // wrap\n"
3928 " << abc;");
3929 verifyFormat("MACRO(abc)::function() // wrap\n"
3930 " << abc;");
Daniel Jasperf090f032015-05-18 09:47:22 +00003931}
3932
Daniel Jasperf7935112012-12-03 18:12:45 +00003933TEST_F(FormatTest, BreaksDesireably) {
3934 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
3935 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003936 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
Daniel Jasper39e27382013-01-23 20:41:06 +00003937 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3938 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
3939 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +00003940
3941 verifyFormat(
3942 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003943 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasperf7935112012-12-03 18:12:45 +00003944
3945 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3946 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3947 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jasper9b155472012-12-04 10:50:12 +00003948
3949 verifyFormat(
Daniel Jasper240527c2017-01-16 13:13:15 +00003950 "aaaaaaaa(aaaaaaaaaaaaa,\n"
3951 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3952 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
Daniel Jasper9b155472012-12-04 10:50:12 +00003953 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3954 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));");
Daniel Jasperaa1c9202012-12-05 14:57:28 +00003955
3956 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3957 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
3958
Daniel Jasper3d0c75c2013-01-02 14:40:02 +00003959 verifyFormat(
Alexander Kornienkoa5151272013-03-12 16:28:18 +00003960 "void f() {\n"
3961 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
3962 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
3963 "}");
Daniel Jasper7a31af12013-01-25 15:43:32 +00003964 verifyFormat(
3965 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3966 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
3967 verifyFormat(
Daniel Jasper21f7dea2017-02-01 09:23:39 +00003968 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3969 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
3970 verifyFormat(
Daniel Jasper240527c2017-01-16 13:13:15 +00003971 "aaaaaa(aaa,\n"
3972 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasper21f7dea2017-02-01 09:23:39 +00003973 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3974 " aaaa);");
Daniel Jaspera44991332015-04-29 13:06:49 +00003975 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3976 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3977 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper3d0c75c2013-01-02 14:40:02 +00003978
Daniel Jasper739b85f2015-06-29 10:42:59 +00003979 // Indent consistently independent of call expression and unary operator.
3980 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
3981 " dddddddddddddddddddddddddddddd));");
3982 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
3983 " dddddddddddddddddddddddddddddd));");
Daniel Jasperf79b0b12013-08-30 08:29:25 +00003984 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
Daniel Jasperf79b0b12013-08-30 08:29:25 +00003985 " dddddddddddddddddddddddddddddd));");
3986
Daniel Jasperaa1c9202012-12-05 14:57:28 +00003987 // This test case breaks on an incorrect memoization, i.e. an optimization not
3988 // taking into account the StopAt value.
3989 verifyFormat(
3990 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
Daniel Jasper2eda23e2012-12-24 13:43:52 +00003991 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
3992 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
3993 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper6d822722012-12-24 16:43:00 +00003994
Daniel Jasper8d1832e2013-01-07 13:26:07 +00003995 verifyFormat("{\n {\n {\n"
3996 " Annotation.SpaceRequiredBefore =\n"
3997 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
3998 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
3999 " }\n }\n}");
Alexander Kornienko4d26b6e2013-06-17 12:59:44 +00004000
4001 // Break on an outer level if there was a break on an inner level.
4002 EXPECT_EQ("f(g(h(a, // comment\n"
4003 " b, c),\n"
4004 " d, e),\n"
4005 " x, y);",
4006 format("f(g(h(a, // comment\n"
4007 " b, c), d, e), x, y);"));
Daniel Jasperee7539a2013-07-08 14:25:23 +00004008
4009 // Prefer breaking similar line breaks.
4010 verifyFormat(
4011 "const int kTrackingOptions = NSTrackingMouseMoved |\n"
4012 " NSTrackingMouseEnteredAndExited |\n"
4013 " NSTrackingActiveAlways;");
Daniel Jasperf7935112012-12-03 18:12:45 +00004014}
4015
Daniel Jasper18210d72014-10-09 09:52:05 +00004016TEST_F(FormatTest, FormatsDeclarationsOnePerLine) {
4017 FormatStyle NoBinPacking = getGoogleStyle();
4018 NoBinPacking.BinPackParameters = false;
4019 NoBinPacking.BinPackArguments = true;
4020 verifyFormat("void f() {\n"
4021 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n"
4022 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
4023 "}",
4024 NoBinPacking);
4025 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n"
4026 " int aaaaaaaaaaaaaaaaaaaa,\n"
4027 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4028 NoBinPacking);
Daniel Jasper06ca0fc2016-01-11 11:01:05 +00004029
Daniel Jasper00693b082016-01-09 15:56:47 +00004030 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
4031 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4032 " vector<int> bbbbbbbbbbbbbbb);",
4033 NoBinPacking);
Daniel Jasper06ca0fc2016-01-11 11:01:05 +00004034 // FIXME: This behavior difference is probably not wanted. However, currently
4035 // we cannot distinguish BreakBeforeParameter being set because of the wrapped
4036 // template arguments from BreakBeforeParameter being set because of the
4037 // one-per-line formatting.
4038 verifyFormat(
4039 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n"
4040 " aaaaaaaaaa> aaaaaaaaaa);",
4041 NoBinPacking);
4042 verifyFormat(
4043 "void fffffffffff(\n"
4044 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n"
4045 " aaaaaaaaaa);");
Daniel Jasper18210d72014-10-09 09:52:05 +00004046}
4047
Daniel Jasper9278eb92013-01-16 14:59:02 +00004048TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
Daniel Jaspera628c982013-04-03 13:36:17 +00004049 FormatStyle NoBinPacking = getGoogleStyle();
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004050 NoBinPacking.BinPackParameters = false;
Daniel Jasper18210d72014-10-09 09:52:05 +00004051 NoBinPacking.BinPackArguments = false;
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004052 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
4053 " aaaaaaaaaaaaaaaaaaaa,\n"
4054 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);",
4055 NoBinPacking);
4056 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
4057 " aaaaaaaaaaaaa,\n"
4058 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));",
4059 NoBinPacking);
4060 verifyFormat(
Daniel Jasper9278eb92013-01-16 14:59:02 +00004061 "aaaaaaaa(aaaaaaaaaaaaa,\n"
4062 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4063 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
4064 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004065 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));",
4066 NoBinPacking);
4067 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
4068 " .aaaaaaaaaaaaaaaaaa();",
4069 NoBinPacking);
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00004070 verifyFormat("void f() {\n"
4071 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4072 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n"
4073 "}",
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004074 NoBinPacking);
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00004075
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004076 verifyFormat(
Daniel Jaspere941b162013-01-23 10:08:28 +00004077 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4078 " aaaaaaaaaaaa,\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004079 " aaaaaaaaaaaa);",
4080 NoBinPacking);
4081 verifyFormat(
Daniel Jasper9278eb92013-01-16 14:59:02 +00004082 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
4083 " ddddddddddddddddddddddddddddd),\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004084 " test);",
4085 NoBinPacking);
Daniel Jasper9278eb92013-01-16 14:59:02 +00004086
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004087 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
4088 " aaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper253dad232015-11-23 15:55:45 +00004089 " aaaaaaaaaaaaaaaaaaaaaaa>\n"
4090 " aaaaaaaaaaaaaaaaaa;",
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004091 NoBinPacking);
4092 verifyFormat("a(\"a\"\n"
4093 " \"a\",\n"
4094 " a);");
Daniel Jaspere941b162013-01-23 10:08:28 +00004095
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004096 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
Daniel Jasperf7db4332013-01-29 16:03:49 +00004097 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
Daniel Jaspere941b162013-01-23 10:08:28 +00004098 " aaaaaaaaa,\n"
Daniel Jasperf7db4332013-01-29 16:03:49 +00004099 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004100 NoBinPacking);
Daniel Jasper687af3b2013-02-14 14:26:07 +00004101 verifyFormat(
4102 "void f() {\n"
4103 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
4104 " .aaaaaaa();\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00004105 "}",
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004106 NoBinPacking);
Daniel Jasper53e8d852013-05-22 08:55:55 +00004107 verifyFormat(
4108 "template <class SomeType, class SomeOtherType>\n"
4109 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
4110 NoBinPacking);
Daniel Jasper9278eb92013-01-16 14:59:02 +00004111}
4112
Daniel Jasperb10cbc42013-07-10 14:02:49 +00004113TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
4114 FormatStyle Style = getLLVMStyleWithColumns(15);
4115 Style.ExperimentalAutoDetectBinPacking = true;
4116 EXPECT_EQ("aaa(aaaa,\n"
4117 " aaaa,\n"
4118 " aaaa);\n"
4119 "aaa(aaaa,\n"
4120 " aaaa,\n"
4121 " aaaa);",
4122 format("aaa(aaaa,\n" // one-per-line
4123 " aaaa,\n"
4124 " aaaa );\n"
4125 "aaa(aaaa, aaaa, aaaa);", // inconclusive
4126 Style));
4127 EXPECT_EQ("aaa(aaaa, aaaa,\n"
4128 " aaaa);\n"
4129 "aaa(aaaa, aaaa,\n"
4130 " aaaa);",
4131 format("aaa(aaaa, aaaa,\n" // bin-packed
4132 " aaaa );\n"
4133 "aaa(aaaa, aaaa, aaaa);", // inconclusive
4134 Style));
4135}
4136
Daniel Jasper04468962013-01-18 10:56:38 +00004137TEST_F(FormatTest, FormatsBuilderPattern) {
Daniel Jaspera44991332015-04-29 13:06:49 +00004138 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n"
4139 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
4140 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
4141 " .StartsWith(\".init\", ORDER_INIT)\n"
4142 " .StartsWith(\".fini\", ORDER_FINI)\n"
4143 " .StartsWith(\".hash\", ORDER_HASH)\n"
4144 " .Default(ORDER_TEXT);\n");
Daniel Jasperc6fbc212013-05-15 09:35:08 +00004145
Daniel Jaspereb50c672013-02-15 20:33:06 +00004146 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00004147 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
Daniel Jasper9ed9ade2013-02-18 13:24:21 +00004148 verifyFormat(
Daniel Jasper801cdb22016-01-05 13:03:59 +00004149 "aaaaaaa->aaaaaaa\n"
4150 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4151 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
Daniel Jasper9ed9ade2013-02-18 13:24:21 +00004152 " ->aaaaaaaa(aaaaaaaaaaaaaaa);");
Daniel Jaspere53beb22013-02-18 13:52:06 +00004153 verifyFormat(
Daniel Jasperf901a572015-12-07 19:50:48 +00004154 "aaaaaaa->aaaaaaa\n"
4155 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4156 " ->aaaaaaaa(aaaaaaaaaaaaaaa);");
4157 verifyFormat(
Daniel Jaspere53beb22013-02-18 13:52:06 +00004158 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
Daniel Jasperf9a84b52013-03-01 16:48:32 +00004159 " aaaaaaaaaaaaaa);");
Daniel Jaspere53beb22013-02-18 13:52:06 +00004160 verifyFormat(
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004161 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n"
4162 " aaaaaa->aaaaaaaaaaaa()\n"
4163 " ->aaaaaaaaaaaaaaaa(\n"
Daniel Jasper9dedc7752015-04-07 06:41:24 +00004164 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004165 " ->aaaaaaaaaaaaaaaaa();");
Daniel Jasper33b909c2013-10-25 14:29:37 +00004166 verifyGoogleFormat(
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00004167 "void f() {\n"
4168 " someo->Add((new util::filetools::Handler(dir))\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004169 " ->OnEvent1(NewPermanentCallback(\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00004170 " this, &HandlerHolderClass::EventHandlerCBA))\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004171 " ->OnEvent2(NewPermanentCallback(\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00004172 " this, &HandlerHolderClass::EventHandlerCBB))\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004173 " ->OnEvent3(NewPermanentCallback(\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00004174 " this, &HandlerHolderClass::EventHandlerCBC))\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004175 " ->OnEvent5(NewPermanentCallback(\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00004176 " this, &HandlerHolderClass::EventHandlerCBD))\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004177 " ->OnEvent6(NewPermanentCallback(\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00004178 " this, &HandlerHolderClass::EventHandlerCBE)));\n"
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00004179 "}");
Daniel Jasper4c6e0052013-08-27 14:24:43 +00004180
4181 verifyFormat(
4182 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();");
4183 verifyFormat("aaaaaaaaaaaaaaa()\n"
4184 " .aaaaaaaaaaaaaaa()\n"
4185 " .aaaaaaaaaaaaaaa()\n"
4186 " .aaaaaaaaaaaaaaa()\n"
4187 " .aaaaaaaaaaaaaaa();");
4188 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
4189 " .aaaaaaaaaaaaaaa()\n"
4190 " .aaaaaaaaaaaaaaa()\n"
4191 " .aaaaaaaaaaaaaaa();");
4192 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
4193 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
4194 " .aaaaaaaaaaaaaaa();");
Daniel Jasperf8151e92013-08-30 07:12:40 +00004195 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
4196 " ->aaaaaaaaaaaaaae(0)\n"
4197 " ->aaaaaaaaaaaaaaa();");
Daniel Jasper36c28ce2013-09-06 08:54:24 +00004198
Daniel Jasper775954b2015-04-24 10:08:09 +00004199 // Don't linewrap after very short segments.
4200 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4201 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4202 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
4203 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4204 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4205 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
4206 verifyFormat("aaa()\n"
4207 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4208 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4209 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
4210
Daniel Jaspercc3114d2013-10-18 15:23:06 +00004211 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
4212 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4213 " .has<bbbbbbbbbbbbbbbbbbbbb>();");
4214 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
4215 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00004216 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();");
Daniel Jaspercc3114d2013-10-18 15:23:06 +00004217
Daniel Jaspera41aa532014-09-19 08:01:25 +00004218 // Prefer not to break after empty parentheses.
Daniel Jasper36c28ce2013-09-06 08:54:24 +00004219 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
4220 " First->LastNewlineOffset);");
Daniel Jasperf901a572015-12-07 19:50:48 +00004221
4222 // Prefer not to create "hanging" indents.
4223 verifyFormat(
4224 "return !soooooooooooooome_map\n"
4225 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4226 " .second;");
Daniel Jasper00492f92016-01-05 13:03:50 +00004227 verifyFormat(
4228 "return aaaaaaaaaaaaaaaa\n"
4229 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n"
4230 " .aaaa(aaaaaaaaaaaaaa);");
4231 // No hanging indent here.
4232 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n"
4233 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
4234 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n"
4235 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper801cdb22016-01-05 13:03:59 +00004236 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
4237 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4238 getLLVMStyleWithColumns(60));
4239 verifyFormat("aaaaaaaaaaaaaaaaaa\n"
4240 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
4241 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4242 getLLVMStyleWithColumns(59));
Daniel Jasper411af722016-01-05 16:10:39 +00004243 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4244 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4245 " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper04468962013-01-18 10:56:38 +00004246}
4247
Daniel Jasperde5c2072012-12-24 00:13:23 +00004248TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) {
4249 verifyFormat(
4250 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004251 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00004252 verifyFormat(
4253 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n"
4254 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}");
4255
Daniel Jasper8d1832e2013-01-07 13:26:07 +00004256 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004257 " ccccccccccccccccccccccccc) {\n}");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00004258 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n"
4259 " ccccccccccccccccccccccccc) {\n}");
4260
Daniel Jasper8d1832e2013-01-07 13:26:07 +00004261 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004262 " ccccccccccccccccccccccccc) {\n}");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00004263 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n"
4264 " ccccccccccccccccccccccccc) {\n}");
4265
Daniel Jasperde5c2072012-12-24 00:13:23 +00004266 verifyFormat(
4267 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004268 " ccccccccccccccccccccccccc) {\n}");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00004269 verifyFormat(
4270 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n"
4271 " ccccccccccccccccccccccccc) {\n}");
4272
Daniel Jasper400adc62013-02-08 15:28:42 +00004273 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
4274 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
4275 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
4276 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00004277 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n"
4278 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n"
4279 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n"
4280 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
4281
Daniel Jasper400adc62013-02-08 15:28:42 +00004282 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
4283 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
4284 " aaaaaaaaaaaaaaa != aa) {\n}");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00004285 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n"
4286 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n"
4287 " aaaaaaaaaaaaaaa != aa) {\n}");
Daniel Jasperde5c2072012-12-24 00:13:23 +00004288}
4289
Daniel Jasper43b65482013-01-23 12:27:43 +00004290TEST_F(FormatTest, BreaksAfterAssignments) {
Daniel Jasper206df732013-01-07 13:08:40 +00004291 verifyFormat(
Daniel Jasper43b65482013-01-23 12:27:43 +00004292 "unsigned Cost =\n"
4293 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
4294 " SI->getPointerAddressSpaceee());\n");
Daniel Jasper206df732013-01-07 13:08:40 +00004295 verifyFormat(
Daniel Jasper1565eb32013-01-23 15:55:19 +00004296 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
4297 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
Daniel Jaspera836b902013-01-23 16:58:21 +00004298
4299 verifyFormat(
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004300 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
4301 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper7b27a102013-05-27 12:45:09 +00004302 verifyFormat("unsigned OriginalStartColumn =\n"
4303 " SourceMgr.getSpellingColumnNumber(\n"
4304 " Current.FormatTok.getStartOfNonWhitespace()) -\n"
4305 " 1;");
Daniel Jasper206df732013-01-07 13:08:40 +00004306}
4307
Francois Ferrand9976efa2017-05-22 08:28:17 +00004308TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) {
4309 FormatStyle Style = getLLVMStyle();
4310 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
4311 " bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;",
4312 Style);
4313
4314 Style.PenaltyBreakAssignment = 20;
4315 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
4316 " cccccccccccccccccccccccccc;",
4317 Style);
4318}
4319
Daniel Jasper2eda23e2012-12-24 13:43:52 +00004320TEST_F(FormatTest, AlignsAfterAssignments) {
4321 verifyFormat(
4322 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper206df732013-01-07 13:08:40 +00004323 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00004324 verifyFormat(
4325 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper206df732013-01-07 13:08:40 +00004326 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00004327 verifyFormat(
4328 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper206df732013-01-07 13:08:40 +00004329 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00004330 verifyFormat(
4331 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper206df732013-01-07 13:08:40 +00004332 " aaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperee7539a2013-07-08 14:25:23 +00004333 verifyFormat(
4334 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n"
4335 " aaaaaaaaaaaaaaaaaaaaaaaa +\n"
4336 " aaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00004337}
4338
4339TEST_F(FormatTest, AlignsAfterReturn) {
4340 verifyFormat(
4341 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4342 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
4343 verifyFormat(
4344 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4345 " aaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperc238c872013-04-02 14:33:13 +00004346 verifyFormat(
4347 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00004348 " aaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasperc238c872013-04-02 14:33:13 +00004349 verifyFormat(
4350 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00004351 " aaaaaaaaaaaaaaaaaaaaaa());");
4352 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4353 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
4354 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4355 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
4356 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jaspereabede62013-09-30 08:29:03 +00004357 verifyFormat("return\n"
4358 " // true if code is one of a or b.\n"
4359 " code == a || code == b;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00004360}
4361
Daniel Jasper3aa9a6a2014-11-18 23:55:27 +00004362TEST_F(FormatTest, AlignsAfterOpenBracket) {
4363 verifyFormat(
4364 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
4365 " aaaaaaaaa aaaaaaa) {}");
4366 verifyFormat(
4367 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
4368 " aaaaaaaaaaa aaaaaaaaa);");
4369 verifyFormat(
4370 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
4371 " aaaaaaaaaaaaaaaaaaaaa));");
4372 FormatStyle Style = getLLVMStyle();
Daniel Jasper6501f7e2015-10-27 12:38:37 +00004373 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
Daniel Jaspera44991332015-04-29 13:06:49 +00004374 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4375 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}",
4376 Style);
4377 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
4378 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);",
4379 Style);
4380 verifyFormat("SomeLongVariableName->someFunction(\n"
4381 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));",
4382 Style);
Daniel Jasper3aa9a6a2014-11-18 23:55:27 +00004383 verifyFormat(
4384 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
4385 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4386 Style);
4387 verifyFormat(
4388 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
4389 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4390 Style);
4391 verifyFormat(
4392 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
4393 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
4394 Style);
Daniel Jasper870d1bc2015-12-14 08:41:18 +00004395
Daniel Jasper2a9f7202016-02-08 09:52:54 +00004396 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n"
4397 " ccccccc(aaaaaaaaaaaaaaaaa, //\n"
4398 " b));",
4399 Style);
4400
Daniel Jasper870d1bc2015-12-14 08:41:18 +00004401 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
4402 Style.BinPackArguments = false;
4403 Style.BinPackParameters = false;
4404 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4405 " aaaaaaaaaaa aaaaaaaa,\n"
4406 " aaaaaaaaa aaaaaaa,\n"
4407 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4408 Style);
4409 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
4410 " aaaaaaaaaaa aaaaaaaaa,\n"
4411 " aaaaaaaaaaa aaaaaaaaa,\n"
4412 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4413 Style);
Daniel Jasper710f8492016-03-17 12:00:22 +00004414 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n"
4415 " aaaaaaaaaaaaaaa,\n"
4416 " aaaaaaaaaaaaaaaaaaaaa,\n"
4417 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
Daniel Jasper870d1bc2015-12-14 08:41:18 +00004418 Style);
Daniel Jasper710f8492016-03-17 12:00:22 +00004419 verifyFormat(
4420 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n"
4421 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
4422 Style);
4423 verifyFormat(
4424 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n"
4425 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
4426 Style);
4427 verifyFormat(
4428 "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4429 " aaaaaaaaaaaaaaaaaaaaa(\n"
4430 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n"
4431 " aaaaaaaaaaaaaaaa);",
4432 Style);
4433 verifyFormat(
4434 "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4435 " aaaaaaaaaaaaaaaaaaaaa(\n"
4436 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n"
4437 " aaaaaaaaaaaaaaaa);",
4438 Style);
Daniel Jasper3aa9a6a2014-11-18 23:55:27 +00004439}
4440
Daniel Jasper3219e432014-12-02 13:24:51 +00004441TEST_F(FormatTest, ParenthesesAndOperandAlignment) {
4442 FormatStyle Style = getLLVMStyleWithColumns(40);
4443 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
4444 " bbbbbbbbbbbbbbbbbbbbbb);",
4445 Style);
Daniel Jasper6501f7e2015-10-27 12:38:37 +00004446 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
Daniel Jasper3219e432014-12-02 13:24:51 +00004447 Style.AlignOperands = false;
4448 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
4449 " bbbbbbbbbbbbbbbbbbbbbb);",
4450 Style);
Daniel Jasper6501f7e2015-10-27 12:38:37 +00004451 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
Daniel Jasper3219e432014-12-02 13:24:51 +00004452 Style.AlignOperands = true;
4453 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
4454 " bbbbbbbbbbbbbbbbbbbbbb);",
4455 Style);
Daniel Jasper6501f7e2015-10-27 12:38:37 +00004456 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
Daniel Jasper3219e432014-12-02 13:24:51 +00004457 Style.AlignOperands = false;
4458 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
4459 " bbbbbbbbbbbbbbbbbbbbbb);",
4460 Style);
4461}
4462
Daniel Jasper399d24b2013-01-09 07:06:56 +00004463TEST_F(FormatTest, BreaksConditionalExpressions) {
4464 verifyFormat(
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004465 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4466 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4467 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
4468 verifyFormat(
4469 "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
Daniel Jasper22ed2622016-11-29 09:40:32 +00004470 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4471 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper8c5fba92013-01-16 16:23:19 +00004472 verifyFormat(
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004473 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4474 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
4475 verifyFormat(
4476 "aaaa(aaaaaaaaa, aaaaaaaaa,\n"
Daniel Jasper22ed2622016-11-29 09:40:32 +00004477 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4478 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperca6623b2013-01-28 12:45:14 +00004479 verifyFormat(
4480 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
4481 " : aaaaaaaaaaaaa);");
4482 verifyFormat(
4483 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasperaab220f2013-03-20 13:53:11 +00004484 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasperca6623b2013-01-28 12:45:14 +00004485 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4486 " aaaaaaaaaaaaa);");
Daniel Jasperb1ae7342013-08-01 22:05:00 +00004487 verifyFormat(
4488 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4489 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4490 " aaaaaaaaaaaaa);");
Daniel Jasperca6623b2013-01-28 12:45:14 +00004491 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4492 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4493 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4494 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4495 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
4496 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4497 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4498 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4499 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4500 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4501 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4502 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperb1ae7342013-08-01 22:05:00 +00004503 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4504 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4505 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4506 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4507 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper54a86022013-02-15 11:07:25 +00004508 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4509 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4510 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasperc238c872013-04-02 14:33:13 +00004511 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
4512 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4513 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4514 " : aaaaaaaaaaaaaaaa;");
Daniel Jaspercd8599e2013-02-23 21:01:55 +00004515 verifyFormat(
4516 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4517 " ? aaaaaaaaaaaaaaa\n"
4518 " : aaaaaaaaaaaaaaa;");
4519 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00004520 " aaaaaaaaa\n"
Daniel Jaspere7de2a32013-04-08 10:45:44 +00004521 " ? b\n"
4522 " : c);");
Daniel Jasper119ff532014-11-14 12:31:14 +00004523 verifyFormat("return aaaa == bbbb\n"
4524 " // comment\n"
4525 " ? aaaa\n"
4526 " : bbbb;");
Daniel Jaspera44991332015-04-29 13:06:49 +00004527 verifyFormat("unsigned Indent =\n"
Daniel Jasper22ed2622016-11-29 09:40:32 +00004528 " format(TheLine.First,\n"
4529 " IndentForLevel[TheLine.Level] >= 0\n"
4530 " ? IndentForLevel[TheLine.Level]\n"
4531 " : TheLine * 2,\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004532 " TheLine.InPPDirective, PreviousEndOfLineColumn);",
Daniel Jasper22ed2622016-11-29 09:40:32 +00004533 getLLVMStyleWithColumns(60));
Daniel Jasper2c611c02013-05-31 14:56:12 +00004534 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
4535 " ? aaaaaaaaaaaaaaa\n"
4536 " : bbbbbbbbbbbbbbb //\n"
4537 " ? ccccccccccccccc\n"
4538 " : ddddddddddddddd;");
4539 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
4540 " ? aaaaaaaaaaaaaaa\n"
4541 " : (bbbbbbbbbbbbbbb //\n"
4542 " ? ccccccccccccccc\n"
4543 " : ddddddddddddddd);");
Daniel Jasperc0d606a2014-04-14 11:08:45 +00004544 verifyFormat(
4545 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4546 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4547 " aaaaaaaaaaaaaaaaaaaaa +\n"
4548 " aaaaaaaaaaaaaaaaaaaaa\n"
4549 " : aaaaaaaaaa;");
Daniel Jasperfc3861a2014-07-17 12:22:04 +00004550 verifyFormat(
Daniel Jasper240527c2017-01-16 13:13:15 +00004551 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4552 " : aaaaaaaaaaaaaaaaaaaaaa\n"
4553 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper54a86022013-02-15 11:07:25 +00004554
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004555 FormatStyle NoBinPacking = getLLVMStyle();
Daniel Jasper18210d72014-10-09 09:52:05 +00004556 NoBinPacking.BinPackArguments = false;
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004557 verifyFormat(
Daniel Jaspercd8599e2013-02-23 21:01:55 +00004558 "void f() {\n"
4559 " g(aaa,\n"
4560 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
4561 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4562 " ? aaaaaaaaaaaaaaa\n"
4563 " : aaaaaaaaaaaaaaa);\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004564 "}",
4565 NoBinPacking);
Daniel Jasperb1ae7342013-08-01 22:05:00 +00004566 verifyFormat(
4567 "void f() {\n"
4568 " g(aaa,\n"
4569 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
4570 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4571 " ?: aaaaaaaaaaaaaaa);\n"
4572 "}",
4573 NoBinPacking);
Daniel Jasper1a31bab2014-10-16 09:10:11 +00004574
4575 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n"
4576 " // comment.\n"
4577 " ccccccccccccccccccccccccccccccccccccccc\n"
4578 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4579 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);");
Daniel Jasper6c22c442014-11-14 13:03:40 +00004580
4581 // Assignments in conditional expressions. Apparently not uncommon :-(.
4582 verifyFormat("return a != b\n"
4583 " // comment\n"
4584 " ? a = b\n"
4585 " : a = b;");
4586 verifyFormat("return a != b\n"
4587 " // comment\n"
4588 " ? a = a != b\n"
4589 " // comment\n"
4590 " ? a = b\n"
4591 " : a\n"
4592 " : a;\n");
4593 verifyFormat("return a != b\n"
4594 " // comment\n"
4595 " ? a\n"
4596 " : a = a != b\n"
4597 " // comment\n"
4598 " ? a = b\n"
4599 " : a;");
Daniel Jasper399d24b2013-01-09 07:06:56 +00004600}
4601
Daniel Jasper165b29e2013-11-08 00:57:11 +00004602TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) {
4603 FormatStyle Style = getLLVMStyle();
4604 Style.BreakBeforeTernaryOperators = false;
4605 Style.ColumnLimit = 70;
4606 verifyFormat(
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004607 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4608 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4609 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4610 Style);
4611 verifyFormat(
4612 "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
Daniel Jasper22ed2622016-11-29 09:40:32 +00004613 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4614 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
Daniel Jasper165b29e2013-11-08 00:57:11 +00004615 Style);
4616 verifyFormat(
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004617 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4618 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4619 Style);
4620 verifyFormat(
4621 "aaaa(aaaaaaaa, aaaaaaaaaa,\n"
Daniel Jasper22ed2622016-11-29 09:40:32 +00004622 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4623 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
Daniel Jasper165b29e2013-11-08 00:57:11 +00004624 Style);
4625 verifyFormat(
4626 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n"
4627 " aaaaaaaaaaaaa);",
4628 Style);
4629 verifyFormat(
4630 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4631 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4632 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4633 " aaaaaaaaaaaaa);",
4634 Style);
4635 verifyFormat(
4636 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4637 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4638 " aaaaaaaaaaaaa);",
4639 Style);
4640 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4641 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4642 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
4643 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4644 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4645 Style);
4646 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4647 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4648 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4649 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
4650 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4651 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4652 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4653 Style);
4654 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4655 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n"
4656 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4657 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4658 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4659 Style);
4660 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4661 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4662 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4663 Style);
4664 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +00004665 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
Daniel Jasper165b29e2013-11-08 00:57:11 +00004666 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4667 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4668 Style);
4669 verifyFormat(
4670 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4671 " aaaaaaaaaaaaaaa :\n"
4672 " aaaaaaaaaaaaaaa;",
4673 Style);
4674 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
4675 " aaaaaaaaa ?\n"
4676 " b :\n"
4677 " c);",
4678 Style);
Daniel Jasper22ed2622016-11-29 09:40:32 +00004679 verifyFormat("unsigned Indent =\n"
4680 " format(TheLine.First,\n"
4681 " IndentForLevel[TheLine.Level] >= 0 ?\n"
4682 " IndentForLevel[TheLine.Level] :\n"
4683 " TheLine * 2,\n"
4684 " TheLine.InPPDirective, PreviousEndOfLineColumn);",
4685 Style);
Daniel Jasper165b29e2013-11-08 00:57:11 +00004686 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
4687 " aaaaaaaaaaaaaaa :\n"
4688 " bbbbbbbbbbbbbbb ? //\n"
4689 " ccccccccccccccc :\n"
4690 " ddddddddddddddd;",
4691 Style);
4692 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
4693 " aaaaaaaaaaaaaaa :\n"
4694 " (bbbbbbbbbbbbbbb ? //\n"
4695 " ccccccccccccccc :\n"
4696 " ddddddddddddddd);",
4697 Style);
Daniel Jasper45860fa2016-02-03 17:27:10 +00004698 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4699 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n"
4700 " ccccccccccccccccccccccccccc;",
4701 Style);
Daniel Jasper04b4e102016-03-01 04:19:59 +00004702 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4703 " aaaaa :\n"
4704 " bbbbbbbbbbbbbbb + cccccccccccccccc;",
4705 Style);
Daniel Jasper165b29e2013-11-08 00:57:11 +00004706}
4707
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004708TEST_F(FormatTest, DeclarationsOfMultipleVariables) {
4709 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
4710 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();");
4711 verifyFormat("bool a = true, b = false;");
4712
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004713 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Daniel Jaspera628c982013-04-03 13:36:17 +00004714 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004715 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
Daniel Jasperc238c872013-04-02 14:33:13 +00004716 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);");
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004717 verifyFormat(
Daniel Jasper37905f72013-02-21 15:00:29 +00004718 "bool aaaaaaaaaaaaaaaaaaaaa =\n"
Daniel Jaspera628c982013-04-03 13:36:17 +00004719 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
Daniel Jasper37905f72013-02-21 15:00:29 +00004720 " d = e && f;");
Daniel Jasper31c96b92013-04-05 09:38:50 +00004721 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
4722 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;");
4723 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
4724 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;");
4725 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
4726 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;");
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004727
Daniel Jasperbea1ab42015-03-01 18:55:26 +00004728 FormatStyle Style = getGoogleStyle();
4729 Style.PointerAlignment = FormatStyle::PAS_Left;
4730 Style.DerivePointerAlignment = false;
4731 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4732 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
4733 " *b = bbbbbbbbbbbbbbbbbbb;",
4734 Style);
Daniel Jaspera44991332015-04-29 13:06:49 +00004735 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
4736 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;",
4737 Style);
Daniel Jasper3f2cde92016-09-26 15:14:24 +00004738 verifyFormat("vector<int*> a, b;", Style);
Daniel Jasper85d1f0b2016-10-04 20:18:25 +00004739 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style);
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004740}
4741
Nico Weber4a5030c2013-01-12 01:28:06 +00004742TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
4743 verifyFormat("arr[foo ? bar : baz];");
4744 verifyFormat("f()[foo ? bar : baz];");
4745 verifyFormat("(a + b)[foo ? bar : baz];");
4746 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
4747}
4748
Daniel Jasperf7935112012-12-03 18:12:45 +00004749TEST_F(FormatTest, AlignsStringLiterals) {
4750 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
4751 " \"short literal\");");
4752 verifyFormat(
4753 "looooooooooooooooooooooooongFunction(\n"
4754 " \"short literal\"\n"
4755 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00004756 verifyFormat("someFunction(\"Always break between multi-line\"\n"
4757 " \" string literals\",\n"
4758 " and, other, parameters);");
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004759 EXPECT_EQ("fun + \"1243\" /* comment */\n"
4760 " \"5678\";",
Manuel Klimek02f640a2013-02-20 15:25:48 +00004761 format("fun + \"1243\" /* comment */\n"
Daniel Jasper240527c2017-01-16 13:13:15 +00004762 " \"5678\";",
Manuel Klimek02f640a2013-02-20 15:25:48 +00004763 getLLVMStyleWithColumns(28)));
4764 EXPECT_EQ(
4765 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
4766 " \"aaaaaaaaaaaaaaaaaaaaa\"\n"
4767 " \"aaaaaaaaaaaaaaaa\";",
4768 format("aaaaaa ="
4769 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
4770 "aaaaaaaaaaaaaaaaaaaaa\" "
4771 "\"aaaaaaaaaaaaaaaa\";"));
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004772 verifyFormat("a = a + \"a\"\n"
4773 " \"a\"\n"
4774 " \"a\";");
4775 verifyFormat("f(\"a\", \"b\"\n"
4776 " \"c\");");
Daniel Jasperaf5ba0e2013-02-23 07:46:38 +00004777
4778 verifyFormat(
4779 "#define LL_FORMAT \"ll\"\n"
4780 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
4781 " \"d, ddddddddd: %\" LL_FORMAT \"d\");");
Daniel Jasper47a04442013-05-13 20:50:15 +00004782
4783 verifyFormat("#define A(X) \\\n"
4784 " \"aaaaa\" #X \"bbbbbb\" \\\n"
4785 " \"ccccc\"",
4786 getLLVMStyleWithColumns(23));
4787 verifyFormat("#define A \"def\"\n"
4788 "f(\"abc\" A \"ghi\"\n"
4789 " \"jkl\");");
Daniel Jasper04b6a082013-12-20 06:22:01 +00004790
4791 verifyFormat("f(L\"a\"\n"
Daniel Jasper015c7a92015-05-11 15:15:48 +00004792 " L\"b\");");
Daniel Jasper04b6a082013-12-20 06:22:01 +00004793 verifyFormat("#define A(X) \\\n"
4794 " L\"aaaaa\" #X L\"bbbbbb\" \\\n"
4795 " L\"ccccc\"",
4796 getLLVMStyleWithColumns(25));
Daniel Jasper015c7a92015-05-11 15:15:48 +00004797
4798 verifyFormat("f(@\"a\"\n"
4799 " @\"b\");");
4800 verifyFormat("NSString s = @\"a\"\n"
Daniel Jasper09285532015-05-17 08:13:23 +00004801 " @\"b\"\n"
4802 " @\"c\";");
4803 verifyFormat("NSString s = @\"a\"\n"
4804 " \"b\"\n"
4805 " \"c\";");
Daniel Jasperf7935112012-12-03 18:12:45 +00004806}
4807
Zachary Turner448592e2015-12-18 22:20:15 +00004808TEST_F(FormatTest, ReturnTypeBreakingStyle) {
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004809 FormatStyle Style = getLLVMStyle();
Zachary Turner448592e2015-12-18 22:20:15 +00004810 // No declarations or definitions should be moved to own line.
4811 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
4812 verifyFormat("class A {\n"
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004813 " int f() { return 1; }\n"
Zachary Turner448592e2015-12-18 22:20:15 +00004814 " int g();\n"
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004815 "};\n"
Zachary Turner448592e2015-12-18 22:20:15 +00004816 "int f() { return 1; }\n"
4817 "int g();\n",
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004818 Style);
Zachary Turner448592e2015-12-18 22:20:15 +00004819
4820 // All declarations and definitions should have the return type moved to its
4821 // own
4822 // line.
4823 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
4824 verifyFormat("class E {\n"
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004825 " int\n"
4826 " f() {\n"
4827 " return 1;\n"
4828 " }\n"
Zachary Turner448592e2015-12-18 22:20:15 +00004829 " int\n"
4830 " g();\n"
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004831 "};\n"
4832 "int\n"
4833 "f() {\n"
4834 " return 1;\n"
Zachary Turner448592e2015-12-18 22:20:15 +00004835 "}\n"
4836 "int\n"
4837 "g();\n",
4838 Style);
4839
4840 // Top-level definitions, and no kinds of declarations should have the
4841 // return type moved to its own line.
4842 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions;
4843 verifyFormat("class B {\n"
4844 " int f() { return 1; }\n"
4845 " int g();\n"
4846 "};\n"
4847 "int\n"
4848 "f() {\n"
4849 " return 1;\n"
4850 "}\n"
4851 "int g();\n",
4852 Style);
4853
4854 // Top-level definitions and declarations should have the return type moved
4855 // to its own line.
4856 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel;
4857 verifyFormat("class C {\n"
4858 " int f() { return 1; }\n"
4859 " int g();\n"
4860 "};\n"
4861 "int\n"
4862 "f() {\n"
4863 " return 1;\n"
4864 "}\n"
4865 "int\n"
4866 "g();\n",
4867 Style);
4868
4869 // All definitions should have the return type moved to its own line, but no
4870 // kinds of declarations.
4871 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
4872 verifyFormat("class D {\n"
4873 " int\n"
4874 " f() {\n"
4875 " return 1;\n"
4876 " }\n"
4877 " int g();\n"
4878 "};\n"
4879 "int\n"
4880 "f() {\n"
4881 " return 1;\n"
4882 "}\n"
4883 "int g();\n",
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004884 Style);
Daniel Jasperca4ea1c2014-08-05 12:16:31 +00004885 verifyFormat("const char *\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004886 "f(void) {\n" // Break here.
Daniel Jasperca4ea1c2014-08-05 12:16:31 +00004887 " return \"\";\n"
4888 "}\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004889 "const char *bar(void);\n", // No break here.
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004890 Style);
Daniel Jasperdb764792014-08-14 11:36:03 +00004891 verifyFormat("template <class T>\n"
4892 "T *\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004893 "f(T &c) {\n" // Break here.
Daniel Jasperdb764792014-08-14 11:36:03 +00004894 " return NULL;\n"
4895 "}\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004896 "template <class T> T *f(T &c);\n", // No break here.
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004897 Style);
Birunthan Mohanathas525579d2015-07-15 19:11:58 +00004898 verifyFormat("class C {\n"
4899 " int\n"
4900 " operator+() {\n"
4901 " return 1;\n"
4902 " }\n"
4903 " int\n"
4904 " operator()() {\n"
4905 " return 1;\n"
4906 " }\n"
4907 "};\n",
4908 Style);
4909 verifyFormat("void\n"
4910 "A::operator()() {}\n"
4911 "void\n"
4912 "A::operator>>() {}\n"
4913 "void\n"
4914 "A::operator+() {}\n",
4915 Style);
4916 verifyFormat("void *operator new(std::size_t s);", // No break here.
4917 Style);
4918 verifyFormat("void *\n"
4919 "operator new(std::size_t s) {}",
4920 Style);
4921 verifyFormat("void *\n"
4922 "operator delete[](void *ptr) {}",
4923 Style);
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004924 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
Daniel Jasperdb764792014-08-14 11:36:03 +00004925 verifyFormat("const char *\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004926 "f(void)\n" // Break here.
Daniel Jasperdb764792014-08-14 11:36:03 +00004927 "{\n"
4928 " return \"\";\n"
4929 "}\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004930 "const char *bar(void);\n", // No break here.
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004931 Style);
Daniel Jasperdb764792014-08-14 11:36:03 +00004932 verifyFormat("template <class T>\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004933 "T *\n" // Problem here: no line break
4934 "f(T &c)\n" // Break here.
Daniel Jasperdb764792014-08-14 11:36:03 +00004935 "{\n"
4936 " return NULL;\n"
4937 "}\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004938 "template <class T> T *f(T &c);\n", // No break here.
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +00004939 Style);
Daniel Jasperca4ea1c2014-08-05 12:16:31 +00004940}
4941
Alexander Kornienko58611712013-07-04 12:02:44 +00004942TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) {
4943 FormatStyle NoBreak = getLLVMStyle();
4944 NoBreak.AlwaysBreakBeforeMultilineStrings = false;
4945 FormatStyle Break = getLLVMStyle();
4946 Break.AlwaysBreakBeforeMultilineStrings = true;
Daniel Jasperc834c702013-07-17 15:38:19 +00004947 verifyFormat("aaaa = \"bbbb\"\n"
4948 " \"cccc\";",
4949 NoBreak);
4950 verifyFormat("aaaa =\n"
4951 " \"bbbb\"\n"
4952 " \"cccc\";",
4953 Break);
4954 verifyFormat("aaaa(\"bbbb\"\n"
4955 " \"cccc\");",
4956 NoBreak);
4957 verifyFormat("aaaa(\n"
4958 " \"bbbb\"\n"
4959 " \"cccc\");",
4960 Break);
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004961 verifyFormat("aaaa(qqq, \"bbbb\"\n"
4962 " \"cccc\");",
Daniel Jasperc834c702013-07-17 15:38:19 +00004963 NoBreak);
Daniel Jasper1bf729c2015-06-18 16:05:17 +00004964 verifyFormat("aaaa(qqq,\n"
4965 " \"bbbb\"\n"
4966 " \"cccc\");",
Daniel Jasperc834c702013-07-17 15:38:19 +00004967 Break);
Daniel Jasper1bf729c2015-06-18 16:05:17 +00004968 verifyFormat("aaaa(qqq,\n"
4969 " L\"bbbb\"\n"
4970 " L\"cccc\");",
4971 Break);
Daniel Jasper21f7dea2017-02-01 09:23:39 +00004972 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n"
4973 " \"bbbb\"));",
Daniel Jasper04b6a082013-12-20 06:22:01 +00004974 Break);
Daniel Jasper9fb676a2015-06-19 10:32:28 +00004975 verifyFormat("string s = someFunction(\n"
4976 " \"abc\"\n"
4977 " \"abc\");",
4978 Break);
Daniel Jasperc834c702013-07-17 15:38:19 +00004979
Daniel Jasper3251fff2014-06-10 06:27:23 +00004980 // As we break before unary operators, breaking right after them is bad.
4981 verifyFormat("string foo = abc ? \"x\"\n"
4982 " \"blah blah blah blah blah blah\"\n"
4983 " : \"y\";",
4984 Break);
4985
Daniel Jasperc834c702013-07-17 15:38:19 +00004986 // Don't break if there is no column gain.
4987 verifyFormat("f(\"aaaa\"\n"
4988 " \"bbbb\");",
4989 Break);
4990
4991 // Treat literals with escaped newlines like multi-line string literals.
Alexander Kornienko657c67b2013-07-16 21:06:13 +00004992 EXPECT_EQ("x = \"a\\\n"
4993 "b\\\n"
4994 "c\";",
4995 format("x = \"a\\\n"
4996 "b\\\n"
4997 "c\";",
4998 NoBreak));
Daniel Jasper2aaedd32015-06-18 09:12:47 +00004999 EXPECT_EQ("xxxx =\n"
Alexander Kornienko657c67b2013-07-16 21:06:13 +00005000 " \"a\\\n"
5001 "b\\\n"
5002 "c\";",
Daniel Jasper2aaedd32015-06-18 09:12:47 +00005003 format("xxxx = \"a\\\n"
Alexander Kornienko657c67b2013-07-16 21:06:13 +00005004 "b\\\n"
5005 "c\";",
5006 Break));
Daniel Jasper27943052013-11-09 03:08:25 +00005007
Alexander Kornienkod4fa2e62017-04-11 09:55:00 +00005008 EXPECT_EQ("NSString *const kString =\n"
5009 " @\"aaaa\"\n"
5010 " @\"bbbb\";",
Daniel Jasper27943052013-11-09 03:08:25 +00005011 format("NSString *const kString = @\"aaaa\"\n"
Daniel Jasper015c7a92015-05-11 15:15:48 +00005012 "@\"bbbb\";",
Daniel Jasper27943052013-11-09 03:08:25 +00005013 Break));
Daniel Jasper6fd5d642015-01-20 12:59:20 +00005014
5015 Break.ColumnLimit = 0;
5016 verifyFormat("const char *hello = \"hello llvm\";", Break);
Alexander Kornienko58611712013-07-04 12:02:44 +00005017}
5018
Alexander Kornienko578fdd82012-12-06 18:03:27 +00005019TEST_F(FormatTest, AlignsPipes) {
5020 verifyFormat(
5021 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5022 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5023 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5024 verifyFormat(
5025 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
5026 " << aaaaaaaaaaaaaaaaaaaa;");
5027 verifyFormat(
5028 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5029 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5030 verifyFormat(
Daniel Jasper7aacf462016-12-19 11:14:23 +00005031 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5032 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5033 verifyFormat(
Alexander Kornienko578fdd82012-12-06 18:03:27 +00005034 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
5035 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
5036 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";");
5037 verifyFormat(
5038 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5039 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5040 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jaspera44991332015-04-29 13:06:49 +00005041 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5042 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5043 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5044 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
Daniel Jasper2fd16632015-05-17 07:27:09 +00005045 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n"
5046 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);");
Daniel Jasper0e617842014-04-16 12:26:54 +00005047 verifyFormat(
5048 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5049 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper04bbda92017-03-16 07:54:11 +00005050 verifyFormat(
5051 "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n"
5052 " aaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper2603ee02013-02-04 07:34:48 +00005053
Daniel Jasperc0d606a2014-04-14 11:08:45 +00005054 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n"
5055 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();");
Daniel Jasper173504e2015-05-10 21:15:07 +00005056 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5057 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5058 " aaaaaaaaaaaaaaaaaaaaa)\n"
5059 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper5962fa82015-06-03 09:26:03 +00005060 verifyFormat("LOG_IF(aaa == //\n"
5061 " bbb)\n"
5062 " << a << b;");
Daniel Jasperc238c872013-04-02 14:33:13 +00005063
Daniel Jasper467ddb12013-08-12 12:58:05 +00005064 // But sometimes, breaking before the first "<<" is desirable.
Daniel Jasper004177e2013-12-19 16:06:40 +00005065 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
5066 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);");
Daniel Jasper77d5d312013-07-12 15:14:05 +00005067 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
5068 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5069 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper467ddb12013-08-12 12:58:05 +00005070 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
5071 " << BEF << IsTemplate << Description << E->getType();");
Daniel Jasper602a7272016-02-11 13:15:14 +00005072 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
5073 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5074 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5075 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
5076 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5077 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5078 " << aaa;");
Daniel Jasper77d5d312013-07-12 15:14:05 +00005079
Daniel Jasperc238c872013-04-02 14:33:13 +00005080 verifyFormat(
5081 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5082 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper0b1f76b2013-09-29 12:02:57 +00005083
5084 // Incomplete string literal.
5085 EXPECT_EQ("llvm::errs() << \"\n"
5086 " << a;",
5087 format("llvm::errs() << \"\n<<a;"));
Manuel Klimek06c84f22013-11-20 11:20:32 +00005088
5089 verifyFormat("void f() {\n"
5090 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n"
5091 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n"
5092 "}");
Daniel Jasperd05d3a82015-01-08 13:56:57 +00005093
5094 // Handle 'endl'.
Daniel Jasper69963122015-02-17 10:05:15 +00005095 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n"
5096 " << bbbbbbbbbbbbbbbbbbbbbb << endl;");
5097 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;");
Daniel Jasper0a589412016-01-05 13:06:27 +00005098
5099 // Handle '\n'.
5100 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n"
5101 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
5102 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n"
5103 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';");
5104 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n"
5105 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";");
5106 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00005107}
5108
Daniel Jasper7209bb92016-12-13 11:16:42 +00005109TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) {
5110 verifyFormat("return out << \"somepacket = {\\n\"\n"
5111 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
5112 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
5113 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
5114 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
5115 " << \"}\";");
5116
5117 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
5118 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
5119 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;");
5120 verifyFormat(
5121 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
5122 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
5123 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
5124 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
5125 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;");
5126 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
5127 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
5128 verifyFormat(
5129 "void f() {\n"
5130 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n"
5131 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5132 "}");
5133
5134 // Breaking before the first "<<" is generally not desirable.
5135 verifyFormat(
5136 "llvm::errs()\n"
5137 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5138 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5139 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5140 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
5141 getLLVMStyleWithColumns(70));
5142 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
5143 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5144 " << \"aaaaaaaaaaaaaaaaaaa: \"\n"
5145 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5146 " << \"aaaaaaaaaaaaaaaaaaa: \"\n"
5147 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
5148 getLLVMStyleWithColumns(70));
5149
5150 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
5151 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
5152 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;");
5153 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
5154 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
5155 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);");
Daniel Jasperf789f052016-12-20 15:27:46 +00005156 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n"
5157 " (aaaa + aaaa);",
5158 getLLVMStyleWithColumns(40));
5159 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n"
5160 " (aaaaaaa + aaaaa));",
5161 getLLVMStyleWithColumns(40));
Daniel Jasper23888612016-12-22 12:37:06 +00005162 verifyFormat(
5163 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n"
5164 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n"
5165 " bbbbbbbbbbbbbbbbbbbbbbb);");
Daniel Jasper7209bb92016-12-13 11:16:42 +00005166}
5167
Daniel Jasperf7935112012-12-03 18:12:45 +00005168TEST_F(FormatTest, UnderstandsEquals) {
5169 verifyFormat(
5170 "aaaaaaaaaaaaaaaaa =\n"
5171 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5172 verifyFormat(
5173 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00005174 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasperf7935112012-12-03 18:12:45 +00005175 verifyFormat(
5176 "if (a) {\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005177 " f();\n"
Daniel Jasperf7935112012-12-03 18:12:45 +00005178 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00005179 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
5180 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +00005181
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005182 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5183 " 100000000 + 10000000) {\n}");
Daniel Jasperf7935112012-12-03 18:12:45 +00005184}
5185
Daniel Jasper5485d0c2012-12-17 14:34:14 +00005186TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00005187 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
5188 " .looooooooooooooooooooooooooooooooooooooongFunction();");
Daniel Jasper5485d0c2012-12-17 14:34:14 +00005189
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00005190 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
5191 " ->looooooooooooooooooooooooooooooooooooooongFunction();");
Daniel Jasper5485d0c2012-12-17 14:34:14 +00005192
5193 verifyFormat(
5194 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
5195 " Parameter2);");
5196
5197 verifyFormat(
5198 "ShortObject->shortFunction(\n"
5199 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
5200 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);");
5201
5202 verifyFormat("loooooooooooooongFunction(\n"
5203 " LoooooooooooooongObject->looooooooooooooooongFunction());");
5204
5205 verifyFormat(
5206 "function(LoooooooooooooooooooooooooooooooooooongObject\n"
5207 " ->loooooooooooooooooooooooooooooooooooooooongFunction());");
5208
Daniel Jasper687af3b2013-02-14 14:26:07 +00005209 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
5210 " .WillRepeatedly(Return(SomeValue));");
Daniel Jasperd6f17d82014-09-12 16:35:28 +00005211 verifyFormat("void f() {\n"
5212 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
5213 " .Times(2)\n"
5214 " .WillRepeatedly(Return(SomeValue));\n"
5215 "}");
Daniel Jasper4d7a97a2014-01-10 08:40:17 +00005216 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n"
5217 " ccccccccccccccccccccccc);");
Daniel Jasper32a796b2013-05-27 11:50:16 +00005218 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper05cd9292015-03-26 18:46:28 +00005219 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5220 " .aaaaa(aaaaa),\n"
Daniel Jasper32a796b2013-05-27 11:50:16 +00005221 " aaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00005222 verifyFormat("void f() {\n"
5223 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5224 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n"
5225 "}");
Daniel Jaspera44991332015-04-29 13:06:49 +00005226 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5227 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5228 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5229 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5230 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jasperc238c872013-04-02 14:33:13 +00005231 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5232 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5233 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5234 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
5235 "}");
Daniel Jasper687af3b2013-02-14 14:26:07 +00005236
Daniel Jasperc7345cc2013-01-07 07:13:20 +00005237 // Here, it is not necessary to wrap at "." or "->".
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00005238 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00005239 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasperc7345cc2013-01-07 07:13:20 +00005240 verifyFormat(
5241 "aaaaaaaaaaa->aaaaaaaaa(\n"
5242 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5243 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
Daniel Jaspere11095a2013-02-14 15:01:34 +00005244
5245 verifyFormat(
5246 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5247 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
Daniel Jasper8f6ae192013-03-13 15:37:48 +00005248 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
5249 " aaaaaaaaa()->aaaaaa()->aaaaa());");
5250 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
5251 " aaaaaaaaa()->aaaaaa()->aaaaa());");
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00005252
Daniel Jasper9b334242013-03-15 14:57:30 +00005253 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper05cd9292015-03-26 18:46:28 +00005254 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5255 " .a();");
Daniel Jasper9b334242013-03-15 14:57:30 +00005256
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00005257 FormatStyle NoBinPacking = getLLVMStyle();
5258 NoBinPacking.BinPackParameters = false;
5259 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
5260 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
5261 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
5262 " aaaaaaaaaaaaaaaaaaa,\n"
5263 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5264 NoBinPacking);
Daniel Jasperbd058882013-07-09 11:57:27 +00005265
5266 // If there is a subsequent call, change to hanging indentation.
5267 verifyFormat(
5268 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5269 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n"
5270 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5271 verifyFormat(
5272 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5273 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));");
Daniel Jasper96964352013-12-18 10:44:36 +00005274 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5275 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5276 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5277 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5278 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5279 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
Daniel Jasper5485d0c2012-12-17 14:34:14 +00005280}
5281
Daniel Jasperac5c1c22013-01-02 15:08:56 +00005282TEST_F(FormatTest, WrapsTemplateDeclarations) {
5283 verifyFormat("template <typename T>\n"
5284 "virtual void loooooooooooongFunction(int Param1, int Param2);");
Daniel Jasper69bd8fb2013-09-27 07:49:08 +00005285 verifyFormat("template <typename T>\n"
5286 "// T should be one of {A, B}.\n"
5287 "virtual void loooooooooooongFunction(int Param1, int Param2);");
Daniel Jasperac5c1c22013-01-02 15:08:56 +00005288 verifyFormat(
Daniel Jasper04468962013-01-18 10:56:38 +00005289 "template <typename T>\n"
Daniel Jasper400adc62013-02-08 15:28:42 +00005290 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;");
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005291 verifyFormat("template <typename T>\n"
5292 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
5293 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);");
Daniel Jasperac5c1c22013-01-02 15:08:56 +00005294 verifyFormat(
5295 "template <typename T>\n"
5296 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
5297 " int Paaaaaaaaaaaaaaaaaaaaram2);");
Daniel Jasper90e51fd2013-01-02 18:30:06 +00005298 verifyFormat(
5299 "template <typename T>\n"
5300 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
5301 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
5302 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper89058942013-01-09 09:50:48 +00005303 verifyFormat("template <typename T>\n"
5304 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jaspera628c982013-04-03 13:36:17 +00005305 " int aaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperbcab4302013-01-09 10:40:23 +00005306 verifyFormat(
5307 "template <typename T1, typename T2 = char, typename T3 = char,\n"
5308 " typename T4 = char>\n"
5309 "void f();");
Daniel Jasper298c3402013-11-22 07:48:15 +00005310 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n"
5311 " template <typename> class cccccccccccccccccccccc,\n"
5312 " typename ddddddddddddd>\n"
5313 "class C {};");
Daniel Jasper7a31af12013-01-25 15:43:32 +00005314 verifyFormat(
5315 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
5316 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper3a9370c2013-02-04 07:21:18 +00005317
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00005318 verifyFormat("void f() {\n"
5319 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
5320 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n"
5321 "}");
Daniel Jasper61e6bbf2013-05-29 12:07:31 +00005322
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00005323 verifyFormat("template <typename T> class C {};");
Daniel Jasper61e6bbf2013-05-29 12:07:31 +00005324 verifyFormat("template <typename T> void f();");
5325 verifyFormat("template <typename T> void f() {}");
Daniel Jasper0e90c3d2013-07-05 09:14:35 +00005326 verifyFormat(
5327 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
5328 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5329 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
5330 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
5331 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5332 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
5333 " bbbbbbbbbbbbbbbbbbbbbbbb);",
5334 getLLVMStyleWithColumns(72));
Daniel Jasperfcfac102014-07-15 09:00:34 +00005335 EXPECT_EQ("static_cast<A< //\n"
5336 " B> *>(\n"
5337 "\n"
Martin Probst2c1cdae2017-05-15 11:15:29 +00005338 ");",
Daniel Jasperfcfac102014-07-15 09:00:34 +00005339 format("static_cast<A<//\n"
5340 " B>*>(\n"
5341 "\n"
5342 " );"));
Daniel Jasper598dd332014-08-12 13:22:26 +00005343 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5344 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);");
Daniel Jasper5c9e3cd2013-09-14 08:13:22 +00005345
5346 FormatStyle AlwaysBreak = getLLVMStyle();
5347 AlwaysBreak.AlwaysBreakTemplateDeclarations = true;
5348 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
5349 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
5350 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
5351 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5352 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
5353 " ccccccccccccccccccccccccccccccccccccccccccccccc);");
5354 verifyFormat("template <template <typename> class Fooooooo,\n"
5355 " template <typename> class Baaaaaaar>\n"
5356 "struct C {};",
5357 AlwaysBreak);
Daniel Jasperd3e014d2013-10-09 15:06:17 +00005358 verifyFormat("template <typename T> // T can be A, B or C.\n"
5359 "struct C {};",
5360 AlwaysBreak);
Daniel Jaspera7900ad2016-05-08 18:12:22 +00005361 verifyFormat("template <enum E> class A {\n"
5362 "public:\n"
5363 " E *f();\n"
5364 "};");
Daniel Jasperac5c1c22013-01-02 15:08:56 +00005365}
5366
Daniel Jasper2db1b4a2017-02-06 10:55:49 +00005367TEST_F(FormatTest, WrapsTemplateParameters) {
5368 FormatStyle Style = getLLVMStyle();
5369 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5370 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
5371 verifyFormat(
5372 "template <typename... a> struct q {};\n"
5373 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
5374 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
5375 " y;",
5376 Style);
5377 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5378 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
5379 verifyFormat(
5380 "template <typename... a> struct r {};\n"
5381 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
5382 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
5383 " y;",
5384 Style);
5385 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
5386 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
5387 verifyFormat(
5388 "template <typename... a> struct s {};\n"
5389 "extern s<\n"
5390 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
5391 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n"
5392 " y;",
5393 Style);
5394 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
5395 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
5396 verifyFormat(
5397 "template <typename... a> struct t {};\n"
5398 "extern t<\n"
5399 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
5400 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n"
5401 " y;",
5402 Style);
5403}
5404
Daniel Jasper45797022013-01-25 10:57:27 +00005405TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
5406 verifyFormat(
5407 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
5408 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5409 verifyFormat(
5410 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
5411 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5412 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
5413
Daniel Jasper0f0234e2013-05-08 10:00:18 +00005414 // FIXME: Should we have the extra indent after the second break?
Daniel Jasper45797022013-01-25 10:57:27 +00005415 verifyFormat(
5416 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
5417 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
Daniel Jasper0f0234e2013-05-08 10:00:18 +00005418 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper45797022013-01-25 10:57:27 +00005419
Daniel Jasper45797022013-01-25 10:57:27 +00005420 verifyFormat(
5421 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
Daniel Jasper4ad42352013-01-28 07:43:15 +00005422 " cccccccccccccccccccccccccccccccccccccccccccccc());");
Daniel Jasper45797022013-01-25 10:57:27 +00005423
5424 // Breaking at nested name specifiers is generally not desirable.
5425 verifyFormat(
5426 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5427 " aaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperca6623b2013-01-28 12:45:14 +00005428
5429 verifyFormat(
Daniel Jasper240527c2017-01-16 13:13:15 +00005430 "aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n"
5431 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
5432 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasperca6623b2013-01-28 12:45:14 +00005433 " aaaaaaaaaaaaaaaaaaaaa);",
5434 getLLVMStyleWithColumns(74));
Daniel Jasperc238c872013-04-02 14:33:13 +00005435
5436 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
5437 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5438 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper45797022013-01-25 10:57:27 +00005439}
5440
Daniel Jasperf7935112012-12-03 18:12:45 +00005441TEST_F(FormatTest, UnderstandsTemplateParameters) {
5442 verifyFormat("A<int> a;");
Chandler Carruthf8b72662014-03-02 12:37:31 +00005443 verifyFormat("A<A<A<int>>> a;");
Daniel Jasperf7935112012-12-03 18:12:45 +00005444 verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
5445 verifyFormat("bool x = a < 1 || 2 > a;");
5446 verifyFormat("bool x = 5 < f<int>();");
5447 verifyFormat("bool x = f<int>() > 5;");
5448 verifyFormat("bool x = 5 < a<int>::x;");
5449 verifyFormat("bool x = a < 4 ? a > 2 : false;");
5450 verifyFormat("bool x = f() ? a < 2 : a > 2;");
5451
5452 verifyGoogleFormat("A<A<int>> a;");
5453 verifyGoogleFormat("A<A<A<int>>> a;");
5454 verifyGoogleFormat("A<A<A<A<int>>>> a;");
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005455 verifyGoogleFormat("A<A<int> > a;");
5456 verifyGoogleFormat("A<A<A<int> > > a;");
5457 verifyGoogleFormat("A<A<A<A<int> > > > a;");
Daniel Jasperfba84ff2013-10-12 05:16:06 +00005458 verifyGoogleFormat("A<::A<int>> a;");
5459 verifyGoogleFormat("A<::A> a;");
5460 verifyGoogleFormat("A< ::A> a;");
5461 verifyGoogleFormat("A< ::A<int> > a;");
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005462 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
5463 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
Daniel Jasperfba84ff2013-10-12 05:16:06 +00005464 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle()));
5465 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle()));
Daniel Jasper352f0df2015-07-18 16:35:30 +00005466 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };",
5467 format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle()));
Daniel Jasperf7935112012-12-03 18:12:45 +00005468
Nico Weber7533b4d2014-09-24 17:17:32 +00005469 verifyFormat("A<A>> a;", getChromiumStyle(FormatStyle::LK_Cpp));
5470
Daniel Jasperf7935112012-12-03 18:12:45 +00005471 verifyFormat("test >> a >> b;");
5472 verifyFormat("test << a >> b;");
5473
5474 verifyFormat("f<int>();");
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005475 verifyFormat("template <typename T> void f() {}");
Daniel Jasperb13135b2015-01-08 08:48:21 +00005476 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;");
Daniel Jasper112b50e2015-05-06 14:53:50 +00005477 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : "
5478 "sizeof(char)>::type>;");
Daniel Jasperadba2aa2015-05-18 12:52:00 +00005479 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};");
Daniel Jasper0c9772e2016-02-05 14:17:16 +00005480 verifyFormat("f(a.operator()<A>());");
5481 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5482 " .template operator()<A>());",
5483 getLLVMStyleWithColumns(35));
Daniel Jasperd5893912013-06-01 18:56:00 +00005484
5485 // Not template parameters.
5486 verifyFormat("return a < b && c > d;");
5487 verifyFormat("void f() {\n"
5488 " while (a < b && c > d) {\n"
5489 " }\n"
5490 "}");
Daniel Jasper62c0ac02013-07-30 22:37:19 +00005491 verifyFormat("template <typename... Types>\n"
5492 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}");
Daniel Jasper0de8efa2013-09-17 08:15:46 +00005493
5494 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5495 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);",
5496 getLLVMStyleWithColumns(60));
Daniel Jasper6ba16382014-07-28 13:19:58 +00005497 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");");
Daniel Jasper65df5aa2014-08-04 14:51:02 +00005498 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}");
Daniel Jasper4d9ec172015-05-06 08:38:24 +00005499 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <");
Daniel Jasperf7935112012-12-03 18:12:45 +00005500}
5501
Malcolm Parsons6af3f142016-11-03 16:57:30 +00005502TEST_F(FormatTest, BitshiftOperatorWidth) {
5503 EXPECT_EQ("int a = 1 << 2; /* foo\n"
5504 " bar */",
5505 format("int a=1<<2; /* foo\n"
5506 " bar */"));
5507
5508 EXPECT_EQ("int b = 256 >> 1; /* foo\n"
5509 " bar */",
5510 format("int b =256>>1 ; /* foo\n"
5511 " bar */"));
5512}
5513
Daniel Jasperd8ffcfa2013-02-28 09:21:10 +00005514TEST_F(FormatTest, UnderstandsBinaryOperators) {
5515 verifyFormat("COMPARE(a, ==, b);");
Daniel Jasper594be2f2016-06-13 07:49:09 +00005516 verifyFormat("auto s = sizeof...(Ts) - 1;");
Alexander Kornienko674be0a2013-03-20 16:41:56 +00005517}
5518
5519TEST_F(FormatTest, UnderstandsPointersToMembers) {
5520 verifyFormat("int A::*x;");
Daniel Jaspercfda5172013-05-08 14:58:20 +00005521 verifyFormat("int (S::*func)(void *);");
Daniel Jasper37194282013-05-28 08:33:00 +00005522 verifyFormat("void f() { int (S::*func)(void *); }");
Daniel Jasper2f34cac2013-05-08 15:06:58 +00005523 verifyFormat("typedef bool *(Class::*Member)() const;");
Daniel Jaspercfda5172013-05-08 14:58:20 +00005524 verifyFormat("void f() {\n"
5525 " (a->*f)();\n"
5526 " a->*x;\n"
5527 " (a.*f)();\n"
5528 " ((*a).*f)();\n"
5529 " a.*x;\n"
5530 "}");
Daniel Jasper998cabc2013-07-18 14:46:07 +00005531 verifyFormat("void f() {\n"
5532 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
5533 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n"
5534 "}");
Daniel Jasper85bcadc2014-07-09 13:07:57 +00005535 verifyFormat(
5536 "(aaaaaaaaaa->*bbbbbbb)(\n"
5537 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jasper2f34cac2013-05-08 15:06:58 +00005538 FormatStyle Style = getLLVMStyle();
Daniel Jasper553d4872014-06-17 12:40:34 +00005539 Style.PointerAlignment = FormatStyle::PAS_Left;
Daniel Jasper2f34cac2013-05-08 15:06:58 +00005540 verifyFormat("typedef bool* (Class::*Member)() const;", Style);
Daniel Jasperd8ffcfa2013-02-28 09:21:10 +00005541}
5542
Daniel Jasper8dd40472012-12-21 09:41:31 +00005543TEST_F(FormatTest, UnderstandsUnaryOperators) {
Daniel Jasperf7935112012-12-03 18:12:45 +00005544 verifyFormat("int a = -2;");
Daniel Jasper8b529712012-12-04 13:02:32 +00005545 verifyFormat("f(-1, -2, -3);");
5546 verifyFormat("a[-1] = 5;");
5547 verifyFormat("int a = 5 + -2;");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00005548 verifyFormat("if (i == -1) {\n}");
5549 verifyFormat("if (i != -1) {\n}");
5550 verifyFormat("if (i > -1) {\n}");
5551 verifyFormat("if (i < -1) {\n}");
Daniel Jasper26333c32012-12-06 13:16:39 +00005552 verifyFormat("++(a->f());");
5553 verifyFormat("--(a->f());");
Daniel Jasper13f23e12013-01-14 12:18:19 +00005554 verifyFormat("(a->f())++;");
5555 verifyFormat("a[42]++;");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00005556 verifyFormat("if (!(a->f())) {\n}");
Daniel Jasper8dd40472012-12-21 09:41:31 +00005557
5558 verifyFormat("a-- > b;");
5559 verifyFormat("b ? -a : c;");
5560 verifyFormat("n * sizeof char16;");
Alexander Kornienko1e808872013-06-28 12:51:24 +00005561 verifyFormat("n * alignof char16;", getGoogleStyle());
Daniel Jasper8dd40472012-12-21 09:41:31 +00005562 verifyFormat("sizeof(char);");
Alexander Kornienko1e808872013-06-28 12:51:24 +00005563 verifyFormat("alignof(char);", getGoogleStyle());
Daniel Jasperda1c68a2013-01-02 15:26:16 +00005564
5565 verifyFormat("return -1;");
5566 verifyFormat("switch (a) {\n"
5567 "case -1:\n"
5568 " break;\n"
5569 "}");
Daniel Jasper399d1ee2013-03-22 10:44:43 +00005570 verifyFormat("#define X -1");
5571 verifyFormat("#define X -kConstant");
Nico Weber63a54eb2013-01-12 05:41:23 +00005572
Chandler Carruthf8b72662014-03-02 12:37:31 +00005573 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};");
5574 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};");
Daniel Jasper71945272013-01-15 14:27:39 +00005575
5576 verifyFormat("int a = /* confusing comment */ -1;");
5577 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case.
5578 verifyFormat("int a = i /* confusing comment */++;");
Daniel Jasperf7935112012-12-03 18:12:45 +00005579}
5580
Daniel Jasper0c214fa2014-02-05 13:43:04 +00005581TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) {
Daniel Jasperf110e202013-08-21 08:39:01 +00005582 verifyFormat("if (!aaaaaaaaaa( // break\n"
Daniel Jasper0c214fa2014-02-05 13:43:04 +00005583 " aaaaa)) {\n"
Daniel Jasperf110e202013-08-21 08:39:01 +00005584 "}");
5585 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
Daniel Jasper739b85f2015-06-29 10:42:59 +00005586 " aaaaa));");
Daniel Jasper0649d362013-08-23 15:14:03 +00005587 verifyFormat("*aaa = aaaaaaa( // break\n"
5588 " bbbbbb);");
Daniel Jasperf110e202013-08-21 08:39:01 +00005589}
5590
Daniel Jasper8863ada2013-08-26 08:10:17 +00005591TEST_F(FormatTest, UnderstandsOverloadedOperators) {
Daniel Jasper537a2962012-12-24 10:56:04 +00005592 verifyFormat("bool operator<();");
5593 verifyFormat("bool operator>();");
5594 verifyFormat("bool operator=();");
5595 verifyFormat("bool operator==();");
5596 verifyFormat("bool operator!=();");
5597 verifyFormat("int operator+();");
5598 verifyFormat("int operator++();");
Daniel Jasperbbf5f4e2017-11-06 12:11:51 +00005599 verifyFormat("int operator++(int) volatile noexcept;");
Daniel Jasper804a2762016-01-09 15:56:40 +00005600 verifyFormat("bool operator,();");
Daniel Jasper537a2962012-12-24 10:56:04 +00005601 verifyFormat("bool operator();");
5602 verifyFormat("bool operator()();");
5603 verifyFormat("bool operator[]();");
5604 verifyFormat("operator bool();");
Daniel Jasper35d2dc72013-02-11 08:01:18 +00005605 verifyFormat("operator int();");
5606 verifyFormat("operator void *();");
Daniel Jasper537a2962012-12-24 10:56:04 +00005607 verifyFormat("operator SomeType<int>();");
Daniel Jasper35d2dc72013-02-11 08:01:18 +00005608 verifyFormat("operator SomeType<int, int>();");
Chandler Carruthf8b72662014-03-02 12:37:31 +00005609 verifyFormat("operator SomeType<SomeType<int>>();");
Daniel Jasper537a2962012-12-24 10:56:04 +00005610 verifyFormat("void *operator new(std::size_t size);");
5611 verifyFormat("void *operator new[](std::size_t size);");
5612 verifyFormat("void operator delete(void *ptr);");
5613 verifyFormat("void operator delete[](void *ptr);");
Daniel Jasper8f9624b2013-05-10 07:59:58 +00005614 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
5615 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);");
Daniel Jasper804a2762016-01-09 15:56:40 +00005616 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n"
Daniel Jasperdf51f2e62016-01-11 12:55:33 +00005617 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;");
Daniel Jasper35d2dc72013-02-11 08:01:18 +00005618
Daniel Jasper0af92eb2013-02-15 19:24:08 +00005619 verifyFormat(
5620 "ostream &operator<<(ostream &OutputStream,\n"
5621 " SomeReallyLongType WithSomeReallyLongValue);");
Daniel Jasper54ac8202013-04-05 17:21:59 +00005622 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
5623 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
5624 " return left.group < right.group;\n"
5625 "}");
Daniel Jasper6e8f4ed2013-04-11 08:48:20 +00005626 verifyFormat("SomeType &operator=(const SomeType &S);");
Daniel Jasper8835a322014-10-20 13:56:30 +00005627 verifyFormat("f.template operator()<int>();");
Daniel Jasper0af92eb2013-02-15 19:24:08 +00005628
Daniel Jasper35d2dc72013-02-11 08:01:18 +00005629 verifyGoogleFormat("operator void*();");
5630 verifyGoogleFormat("operator SomeType<SomeType<int>>();");
Daniel Jasperedc5f092013-10-29 12:24:23 +00005631 verifyGoogleFormat("operator ::A();");
Daniel Jasper42401c82013-09-02 09:20:39 +00005632
5633 verifyFormat("using A::operator+;");
Daniel Jasper5af04a42015-10-07 03:43:10 +00005634 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n"
5635 "int i;");
Daniel Jasperf7935112012-12-03 18:12:45 +00005636}
5637
Daniel Jasper1c220482015-02-25 10:30:06 +00005638TEST_F(FormatTest, UnderstandsFunctionRefQualification) {
Daniel Jasperaf642c62015-08-25 13:40:51 +00005639 verifyFormat("Deleted &operator=(const Deleted &) & = default;");
5640 verifyFormat("Deleted &operator=(const Deleted &) && = delete;");
5641 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;");
5642 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;");
5643 verifyFormat("Deleted &operator=(const Deleted &) &;");
5644 verifyFormat("Deleted &operator=(const Deleted &) &&;");
5645 verifyFormat("SomeType MemberFunction(const Deleted &) &;");
5646 verifyFormat("SomeType MemberFunction(const Deleted &) &&;");
5647 verifyFormat("SomeType MemberFunction(const Deleted &) && {}");
5648 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}");
5649 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}");
Jacob Bandes-Storch58933c52017-08-10 01:30:22 +00005650 verifyFormat("void Fn(T const &) const &;");
5651 verifyFormat("void Fn(T const volatile &&) const volatile &&;");
Daniel Jasper28b4d512016-11-01 06:23:19 +00005652 verifyFormat("template <typename T>\n"
5653 "void F(T) && = delete;",
5654 getGoogleStyle());
Daniel Jasper1c220482015-02-25 10:30:06 +00005655
Daniel Jasperaf642c62015-08-25 13:40:51 +00005656 FormatStyle AlignLeft = getLLVMStyle();
5657 AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
Daniel Jasper2b4d6ea2016-06-08 08:23:46 +00005658 verifyFormat("void A::b() && {}", AlignLeft);
Daniel Jasperaf642c62015-08-25 13:40:51 +00005659 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft);
5660 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;",
5661 AlignLeft);
5662 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft);
5663 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft);
Daniel Jasperc3ff0cd2016-04-18 11:31:21 +00005664 verifyFormat("auto Function(T t) & -> void {}", AlignLeft);
5665 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft);
5666 verifyFormat("auto Function(T) & -> void {}", AlignLeft);
5667 verifyFormat("auto Function(T) & -> void;", AlignLeft);
Jacob Bandes-Storch58933c52017-08-10 01:30:22 +00005668 verifyFormat("void Fn(T const&) const&;", AlignLeft);
5669 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft);
Daniel Jasper1c220482015-02-25 10:30:06 +00005670
5671 FormatStyle Spaces = getLLVMStyle();
5672 Spaces.SpacesInCStyleCastParentheses = true;
Daniel Jasperaf642c62015-08-25 13:40:51 +00005673 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces);
5674 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces);
5675 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces);
5676 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces);
Daniel Jasper1c220482015-02-25 10:30:06 +00005677
5678 Spaces.SpacesInCStyleCastParentheses = false;
5679 Spaces.SpacesInParentheses = true;
Daniel Jasperaf642c62015-08-25 13:40:51 +00005680 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces);
5681 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", Spaces);
5682 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces);
5683 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces);
Daniel Jasper1c220482015-02-25 10:30:06 +00005684}
5685
Daniel Jasperd6a947f2013-01-11 16:09:04 +00005686TEST_F(FormatTest, UnderstandsNewAndDelete) {
Daniel Jasperba0bda92013-02-23 08:07:18 +00005687 verifyFormat("void f() {\n"
5688 " A *a = new A;\n"
5689 " A *a = new (placement) A;\n"
5690 " delete a;\n"
5691 " delete (A *)a;\n"
5692 "}");
Daniel Jasper71646ec2014-07-30 12:14:10 +00005693 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
5694 " typename aaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper316ab382014-08-06 13:14:58 +00005695 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5696 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
5697 " typename aaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper80222262014-11-02 22:46:42 +00005698 verifyFormat("delete[] h->p;");
Daniel Jasperd6a947f2013-01-11 16:09:04 +00005699}
5700
Daniel Jasper22bcf8a2013-01-02 08:57:10 +00005701TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005702 verifyFormat("int *f(int *a) {}");
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005703 verifyFormat("int main(int argc, char **argv) {}");
Daniel Jasper5065bc42013-02-18 12:44:35 +00005704 verifyFormat("Test::Test(int b) : a(b * b) {}");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005705 verifyIndependentOfContext("f(a, *a);");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005706 verifyFormat("void g() { f(*a); }");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005707 verifyIndependentOfContext("int a = b * 10;");
5708 verifyIndependentOfContext("int a = 10 * b;");
5709 verifyIndependentOfContext("int a = b * c;");
5710 verifyIndependentOfContext("int a += b * c;");
5711 verifyIndependentOfContext("int a -= b * c;");
5712 verifyIndependentOfContext("int a *= b * c;");
5713 verifyIndependentOfContext("int a /= b * c;");
5714 verifyIndependentOfContext("int a = *b;");
5715 verifyIndependentOfContext("int a = *b * c;");
5716 verifyIndependentOfContext("int a = b * *c;");
Daniel Jasper93101662015-05-19 12:29:27 +00005717 verifyIndependentOfContext("int a = b * (10);");
5718 verifyIndependentOfContext("S << b * (10);");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005719 verifyIndependentOfContext("return 10 * b;");
5720 verifyIndependentOfContext("return *b * *c;");
5721 verifyIndependentOfContext("return a & ~b;");
5722 verifyIndependentOfContext("f(b ? *c : *d);");
5723 verifyIndependentOfContext("int a = b ? *c : *d;");
5724 verifyIndependentOfContext("*b = a;");
5725 verifyIndependentOfContext("a * ~b;");
5726 verifyIndependentOfContext("a * !b;");
5727 verifyIndependentOfContext("a * +b;");
5728 verifyIndependentOfContext("a * -b;");
5729 verifyIndependentOfContext("a * ++b;");
5730 verifyIndependentOfContext("a * --b;");
5731 verifyIndependentOfContext("a[4] * b;");
Daniel Jasper8e559272013-02-27 11:43:50 +00005732 verifyIndependentOfContext("a[a * a] = 1;");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005733 verifyIndependentOfContext("f() * b;");
5734 verifyIndependentOfContext("a * [self dostuff];");
Daniel Jasper6e42b1e2013-04-01 17:13:26 +00005735 verifyIndependentOfContext("int x = a * (a + b);");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005736 verifyIndependentOfContext("(a *)(a + b);");
Daniel Jasper942d9712014-04-28 09:19:28 +00005737 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005738 verifyIndependentOfContext("int *pa = (int *)&a;");
Nico Weber44449172013-02-12 16:17:07 +00005739 verifyIndependentOfContext("return sizeof(int **);");
5740 verifyIndependentOfContext("return sizeof(int ******);");
5741 verifyIndependentOfContext("return (int **&)a;");
Daniel Jasper4d03d3b2013-05-28 15:27:10 +00005742 verifyIndependentOfContext("f((*PointerToArray)[10]);");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005743 verifyFormat("void f(Type (*parameter)[10]) {}");
Daniel Jasper4bc013e2015-10-07 01:41:22 +00005744 verifyFormat("void f(Type (&parameter)[10]) {}");
Nico Weber44449172013-02-12 16:17:07 +00005745 verifyGoogleFormat("return sizeof(int**);");
5746 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);");
5747 verifyGoogleFormat("Type** A = static_cast<Type**>(P);");
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00005748 verifyFormat("auto a = [](int **&, int ***) {};");
Daniel Jasperd46e07e2013-10-20 18:15:30 +00005749 verifyFormat("auto PointerBinding = [](const char *S) {};");
Daniel Jasper71665cd2013-09-10 10:26:38 +00005750 verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
Daniel Jasper4ac7de72014-06-11 07:35:16 +00005751 verifyFormat("[](const decltype(*a) &value) {}");
Daniel Jasper033181b2015-08-13 13:43:51 +00005752 verifyFormat("decltype(a * b) F();");
Daniel Jasper99b5a462015-05-12 10:20:32 +00005753 verifyFormat("#define MACRO() [](A *a) { return 1; }");
Daniel Jasperd27df3d2016-02-01 11:21:07 +00005754 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}");
Daniel Jasper3682fcd2013-12-16 08:36:18 +00005755 verifyIndependentOfContext("typedef void (*f)(int *a);");
Daniel Jasper39485162014-05-22 09:00:33 +00005756 verifyIndependentOfContext("int i{a * b};");
Daniel Jasper7d028292014-06-02 11:54:20 +00005757 verifyIndependentOfContext("aaa && aaa->f();");
Daniel Jasper2ac3fdf2014-07-28 12:08:16 +00005758 verifyIndependentOfContext("int x = ~*p;");
Daniel Jasperd127e3b2014-11-14 17:26:49 +00005759 verifyFormat("Constructor() : a(a), area(width * height) {}");
Daniel Jaspere1e348b2014-11-17 18:42:22 +00005760 verifyFormat("Constructor() : a(a), area(a, width * height) {}");
Daniel Jaspere4ab49e2015-04-20 12:54:29 +00005761 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}");
Daniel Jasper6a3fd832014-11-17 13:55:04 +00005762 verifyFormat("void f() { f(a, c * d); }");
Daniel Jasper3a26a8d2015-05-13 12:54:30 +00005763 verifyFormat("void f() { f(new a(), c * d); }");
Daniel Jasperc941e7d2017-01-09 11:04:07 +00005764 verifyFormat("void f(const MyOverride &override);");
5765 verifyFormat("void f(const MyFinal &final);");
5766 verifyIndependentOfContext("bool a = f() && override.f();");
5767 verifyIndependentOfContext("bool a = f() && final.f();");
Daniel Jasper27234032012-12-07 09:52:15 +00005768
Daniel Jasper5b49f472013-01-23 12:10:53 +00005769 verifyIndependentOfContext("InvalidRegions[*R] = 0;");
Daniel Jasper3c2557d2013-01-04 20:46:38 +00005770
Daniel Jasper5b49f472013-01-23 12:10:53 +00005771 verifyIndependentOfContext("A<int *> a;");
5772 verifyIndependentOfContext("A<int **> a;");
5773 verifyIndependentOfContext("A<int *, int *> a;");
Daniel Jasper139d4a32014-04-08 13:07:41 +00005774 verifyIndependentOfContext("A<int *[]> a;");
Daniel Jasperc697ad22013-02-06 10:05:46 +00005775 verifyIndependentOfContext(
5776 "const char *const p = reinterpret_cast<const char *const>(q);");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005777 verifyIndependentOfContext("A<int **, int **> a;");
Daniel Jasper8035b0a2013-02-06 10:57:42 +00005778 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);");
Daniel Jasperae907642013-03-14 10:50:25 +00005779 verifyFormat("for (char **a = b; *a; ++a) {\n}");
Daniel Jasperc37de302013-05-03 14:41:24 +00005780 verifyFormat("for (; a && b;) {\n}");
Daniel Jasperea2d0422014-05-08 08:50:10 +00005781 verifyFormat("bool foo = true && [] { return false; }();");
Daniel Jaspera4396862012-12-10 18:59:13 +00005782
Daniel Jasper66dcb1c2013-01-08 20:03:18 +00005783 verifyFormat(
5784 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5785 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5786
Daniel Jasper1f5d6372016-06-13 14:45:12 +00005787 verifyGoogleFormat("int const* a = &b;");
Daniel Jasper6a968202015-01-07 12:19:53 +00005788 verifyGoogleFormat("**outparam = 1;");
Daniel Jasper75092162015-01-23 19:04:49 +00005789 verifyGoogleFormat("*outparam = a * b;");
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005790 verifyGoogleFormat("int main(int argc, char** argv) {}");
Daniel Jaspera4396862012-12-10 18:59:13 +00005791 verifyGoogleFormat("A<int*> a;");
5792 verifyGoogleFormat("A<int**> a;");
5793 verifyGoogleFormat("A<int*, int*> a;");
5794 verifyGoogleFormat("A<int**, int**> a;");
Daniel Jasper22bcf8a2013-01-02 08:57:10 +00005795 verifyGoogleFormat("f(b ? *c : *d);");
5796 verifyGoogleFormat("int a = b ? *c : *d;");
Daniel Jaspera1dc93a2013-01-16 16:04:06 +00005797 verifyGoogleFormat("Type* t = **x;");
5798 verifyGoogleFormat("Type* t = *++*x;");
5799 verifyGoogleFormat("*++*x;");
5800 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);");
5801 verifyGoogleFormat("Type* t = x++ * y;");
Daniel Jasperc697ad22013-02-06 10:05:46 +00005802 verifyGoogleFormat(
5803 "const char* const p = reinterpret_cast<const char* const>(q);");
Daniel Jasper8184d662014-07-28 12:24:21 +00005804 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);");
Daniel Jasper0bd9a192014-11-10 16:57:30 +00005805 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);");
5806 verifyGoogleFormat("template <typename T>\n"
5807 "void f(int i = 0, SomeType** temps = NULL);");
Manuel Klimek557811f2013-01-14 10:58:01 +00005808
Daniel Jasper1904e9b2014-08-14 10:53:19 +00005809 FormatStyle Left = getLLVMStyle();
5810 Left.PointerAlignment = FormatStyle::PAS_Left;
5811 verifyFormat("x = *a(x) = *a(y);", Left);
Daniel Jasper28b4d512016-11-01 06:23:19 +00005812 verifyFormat("for (;; *a = b) {\n}", Left);
Daniel Jasper95516cd2015-12-23 18:01:29 +00005813 verifyFormat("return *this += 1;", Left);
Manuel Klimek06b575c2017-07-17 15:27:53 +00005814 verifyFormat("throw *x;", Left);
Krasimir Georgiev9b5a89b2017-08-14 11:06:07 +00005815 verifyFormat("delete *x;", Left);
5816 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left);
5817 verifyFormat("[](const decltype(*a)* ptr) {}", Left);
5818 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left);
Daniel Jasper1904e9b2014-08-14 10:53:19 +00005819
Daniel Jasper5b49f472013-01-23 12:10:53 +00005820 verifyIndependentOfContext("a = *(x + y);");
5821 verifyIndependentOfContext("a = &(x + y);");
5822 verifyIndependentOfContext("*(x + y).call();");
5823 verifyIndependentOfContext("&(x + y)->call();");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005824 verifyFormat("void f() { &(*I).first; }");
Daniel Jasper71945272013-01-15 14:27:39 +00005825
Daniel Jasper5b49f472013-01-23 12:10:53 +00005826 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
Daniel Jasper71945272013-01-15 14:27:39 +00005827 verifyFormat(
Daniel Jasperf9fc2152014-04-09 13:18:49 +00005828 "int *MyValues = {\n"
5829 " *A, // Operator detection might be confused by the '{'\n"
5830 " *BB // Operator detection might be confused by previous comment\n"
Daniel Jasper71945272013-01-15 14:27:39 +00005831 "};");
Nico Weber80a82762013-01-17 17:17:19 +00005832
Daniel Jasper5b49f472013-01-23 12:10:53 +00005833 verifyIndependentOfContext("if (int *a = &b)");
5834 verifyIndependentOfContext("if (int &a = *b)");
5835 verifyIndependentOfContext("if (a & b[i])");
5836 verifyIndependentOfContext("if (a::b::c::d & b[i])");
5837 verifyIndependentOfContext("if (*b[i])");
5838 verifyIndependentOfContext("if (int *a = (&b))");
5839 verifyIndependentOfContext("while (int *a = &b)");
Daniel Jasperdf620b22013-09-21 17:31:51 +00005840 verifyIndependentOfContext("size = sizeof *a;");
Daniel Jasperdc4f7252015-03-11 12:59:49 +00005841 verifyIndependentOfContext("if (a && (b = c))");
Daniel Jasper420d7d32013-01-23 12:58:14 +00005842 verifyFormat("void f() {\n"
5843 " for (const int &v : Values) {\n"
5844 " }\n"
5845 "}");
Daniel Jasper5065bc42013-02-18 12:44:35 +00005846 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
5847 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
Daniel Jasper5ca9b712013-09-11 20:37:10 +00005848 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}");
Daniel Jasper0b820602013-01-22 11:46:26 +00005849
Daniel Jaspera98da3d2013-11-07 19:56:07 +00005850 verifyFormat("#define A (!a * b)");
Daniel Jasperb910bbb2013-05-13 07:14:40 +00005851 verifyFormat("#define MACRO \\\n"
5852 " int *i = a * b; \\\n"
5853 " void f(a *b);",
5854 getLLVMStyleWithColumns(19));
5855
Daniel Jasper97b89482013-03-13 07:49:51 +00005856 verifyIndependentOfContext("A = new SomeType *[Length];");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005857 verifyIndependentOfContext("A = new SomeType *[Length]();");
Daniel Jasper6f9c8d22013-07-05 13:30:40 +00005858 verifyIndependentOfContext("T **t = new T *;");
5859 verifyIndependentOfContext("T **t = new T *();");
Daniel Jasper532a0312015-04-23 10:23:53 +00005860 verifyGoogleFormat("A = new SomeType*[Length]();");
5861 verifyGoogleFormat("A = new SomeType*[Length];");
Daniel Jasper6f9c8d22013-07-05 13:30:40 +00005862 verifyGoogleFormat("T** t = new T*;");
5863 verifyGoogleFormat("T** t = new T*();");
Daniel Jasperb910bbb2013-05-13 07:14:40 +00005864
Daniel Jaspera65e8872014-03-25 10:52:45 +00005865 verifyFormat("STATIC_ASSERT((a & b) == 0);");
5866 verifyFormat("STATIC_ASSERT(0 == (a & b));");
Manuel Klimekf81e5c02014-03-27 11:17:36 +00005867 verifyFormat("template <bool a, bool b> "
Daniel Jasper4afc6b32014-06-02 10:57:55 +00005868 "typename t::if<x && y>::type f() {}");
5869 verifyFormat("template <int *y> f() {}");
Manuel Klimekf81e5c02014-03-27 11:17:36 +00005870 verifyFormat("vector<int *> v;");
5871 verifyFormat("vector<int *const> v;");
5872 verifyFormat("vector<int *const **const *> v;");
5873 verifyFormat("vector<int *volatile> v;");
5874 verifyFormat("vector<a * b> v;");
Manuel Klimek1f9d80a2014-03-27 19:00:52 +00005875 verifyFormat("foo<b && false>();");
5876 verifyFormat("foo<b & 1>();");
Daniel Jasper73e171f2014-08-29 12:54:38 +00005877 verifyFormat("decltype(*::std::declval<const T &>()) void F();");
Daniel Jasper13a7f462014-10-28 18:11:52 +00005878 verifyFormat(
Daniel Jasper21f7dea2017-02-01 09:23:39 +00005879 "template <class T, class = typename std::enable_if<\n"
5880 " std::is_integral<T>::value &&\n"
5881 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n"
5882 "void F();",
5883 getLLVMStyleWithColumns(70));
5884 verifyFormat(
Daniel Jasper22ed2622016-11-29 09:40:32 +00005885 "template <class T,\n"
5886 " class = typename std::enable_if<\n"
5887 " std::is_integral<T>::value &&\n"
Daniel Jasper21f7dea2017-02-01 09:23:39 +00005888 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n"
5889 " class U>\n"
Daniel Jasperf0c809a2014-10-28 18:28:22 +00005890 "void F();",
Daniel Jasper22ed2622016-11-29 09:40:32 +00005891 getLLVMStyleWithColumns(70));
Daniel Jasperf0c809a2014-10-28 18:28:22 +00005892 verifyFormat(
5893 "template <class T,\n"
5894 " class = typename ::std::enable_if<\n"
5895 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n"
5896 "void F();",
5897 getGoogleStyleWithColumns(68));
Manuel Klimek1f9d80a2014-03-27 19:00:52 +00005898
Daniel Jaspercc7bf7f2014-04-03 09:00:49 +00005899 verifyIndependentOfContext("MACRO(int *i);");
5900 verifyIndependentOfContext("MACRO(auto *a);");
5901 verifyIndependentOfContext("MACRO(const A *a);");
Daniel Jasper628dd852017-03-08 09:49:12 +00005902 verifyIndependentOfContext("MACRO(A *const a);");
Daniel Jasper91beebd2014-06-30 13:44:47 +00005903 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');");
Daniel Jasperd0d27aa2016-11-01 06:23:14 +00005904 verifyFormat("void f() { f(float{1}, a * a); }");
Daniel Jaspercc7bf7f2014-04-03 09:00:49 +00005905 // FIXME: Is there a way to make this work?
5906 // verifyIndependentOfContext("MACRO(A *a);");
5907
Daniel Jasper32ccb032014-06-23 07:36:18 +00005908 verifyFormat("DatumHandle const *operator->() const { return input_; }");
Daniel Jasper0ea4d792015-10-07 01:41:14 +00005909 verifyFormat("return options != nullptr && operator==(*options);");
Daniel Jasper32ccb032014-06-23 07:36:18 +00005910
Daniel Jasper866468a2014-04-14 13:15:29 +00005911 EXPECT_EQ("#define OP(x) \\\n"
5912 " ostream &operator<<(ostream &s, const A &a) { \\\n"
5913 " return s << a.DebugString(); \\\n"
5914 " }",
5915 format("#define OP(x) \\\n"
5916 " ostream &operator<<(ostream &s, const A &a) { \\\n"
5917 " return s << a.DebugString(); \\\n"
5918 " }",
5919 getLLVMStyleWithColumns(50)));
5920
Manuel Klimek1f9d80a2014-03-27 19:00:52 +00005921 // FIXME: We cannot handle this case yet; we might be able to figure out that
5922 // foo<x> d > v; doesn't make sense.
Daniel Jasper6ba16382014-07-28 13:19:58 +00005923 verifyFormat("foo<a<b && c> d> v;");
Daniel Jasper553d4872014-06-17 12:40:34 +00005924
5925 FormatStyle PointerMiddle = getLLVMStyle();
5926 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
5927 verifyFormat("delete *x;", PointerMiddle);
5928 verifyFormat("int * x;", PointerMiddle);
5929 verifyFormat("template <int * y> f() {}", PointerMiddle);
5930 verifyFormat("int * f(int * a) {}", PointerMiddle);
5931 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle);
5932 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle);
5933 verifyFormat("A<int *> a;", PointerMiddle);
5934 verifyFormat("A<int **> a;", PointerMiddle);
5935 verifyFormat("A<int *, int *> a;", PointerMiddle);
5936 verifyFormat("A<int * []> a;", PointerMiddle);
Daniel Jasper532a0312015-04-23 10:23:53 +00005937 verifyFormat("A = new SomeType *[Length]();", PointerMiddle);
5938 verifyFormat("A = new SomeType *[Length];", PointerMiddle);
Daniel Jasper553d4872014-06-17 12:40:34 +00005939 verifyFormat("T ** t = new T *;", PointerMiddle);
Daniel Jasper3992e2c2015-07-01 21:02:24 +00005940
5941 // Member function reference qualifiers aren't binary operators.
5942 verifyFormat("string // break\n"
Daniel Jasperaf642c62015-08-25 13:40:51 +00005943 "operator()() & {}");
Daniel Jasper3992e2c2015-07-01 21:02:24 +00005944 verifyFormat("string // break\n"
Daniel Jasperaf642c62015-08-25 13:40:51 +00005945 "operator()() && {}");
Daniel Jasper3992e2c2015-07-01 21:02:24 +00005946 verifyGoogleFormat("template <typename T>\n"
Daniel Jasperaf642c62015-08-25 13:40:51 +00005947 "auto x() & -> int {}");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005948}
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005949
Daniel Jasperee6d6502013-07-17 20:25:02 +00005950TEST_F(FormatTest, UnderstandsAttributes) {
5951 verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
Daniel Jasper559b63c2014-01-28 20:13:43 +00005952 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
5953 "aaaaaaaaaaaaaaaaaaaaaaa(int i);");
Daniel Jaspera5fa4d12015-07-06 11:30:34 +00005954 FormatStyle AfterType = getLLVMStyle();
Zachary Turner448592e2015-12-18 22:20:15 +00005955 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
Daniel Jaspera5fa4d12015-07-06 11:30:34 +00005956 verifyFormat("__attribute__((nodebug)) void\n"
5957 "foo() {}\n",
5958 AfterType);
Daniel Jasperee6d6502013-07-17 20:25:02 +00005959}
5960
Daniel Jasper10cd5812013-05-06 06:35:44 +00005961TEST_F(FormatTest, UnderstandsEllipsis) {
5962 verifyFormat("int printf(const char *fmt, ...);");
5963 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
Daniel Jasperbafa6b72013-07-01 09:47:25 +00005964 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}");
5965
5966 FormatStyle PointersLeft = getLLVMStyle();
Daniel Jasper553d4872014-06-17 12:40:34 +00005967 PointersLeft.PointerAlignment = FormatStyle::PAS_Left;
Daniel Jasperbafa6b72013-07-01 09:47:25 +00005968 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft);
Daniel Jasper10cd5812013-05-06 06:35:44 +00005969}
5970
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005971TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005972 EXPECT_EQ("int *a;\n"
5973 "int *a;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005974 "int *a;",
5975 format("int *a;\n"
5976 "int* a;\n"
5977 "int *a;",
5978 getGoogleStyle()));
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005979 EXPECT_EQ("int* a;\n"
5980 "int* a;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005981 "int* a;",
5982 format("int* a;\n"
5983 "int* a;\n"
5984 "int *a;",
5985 getGoogleStyle()));
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005986 EXPECT_EQ("int *a;\n"
5987 "int *a;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005988 "int *a;",
5989 format("int *a;\n"
5990 "int * a;\n"
5991 "int * a;",
5992 getGoogleStyle()));
Daniel Jasper352f0df2015-07-18 16:35:30 +00005993 EXPECT_EQ("auto x = [] {\n"
5994 " int *a;\n"
5995 " int *a;\n"
5996 " int *a;\n"
5997 "};",
5998 format("auto x=[]{int *a;\n"
5999 "int * a;\n"
6000 "int * a;};",
6001 getGoogleStyle()));
Daniel Jasperf7935112012-12-03 18:12:45 +00006002}
6003
Alexander Kornienkoa5151272013-03-12 16:28:18 +00006004TEST_F(FormatTest, UnderstandsRvalueReferences) {
6005 verifyFormat("int f(int &&a) {}");
6006 verifyFormat("int f(int a, char &&b) {}");
6007 verifyFormat("void f() { int &&a = b; }");
6008 verifyGoogleFormat("int f(int a, char&& b) {}");
6009 verifyGoogleFormat("void f() { int&& a = b; }");
6010
Daniel Jasper1eff9082013-05-27 16:36:33 +00006011 verifyIndependentOfContext("A<int &&> a;");
6012 verifyIndependentOfContext("A<int &&, int &&> a;");
6013 verifyGoogleFormat("A<int&&> a;");
6014 verifyGoogleFormat("A<int&&, int&&> a;");
Daniel Jasper8b1c6352013-08-01 17:58:23 +00006015
6016 // Not rvalue references:
6017 verifyFormat("template <bool B, bool C> class A {\n"
6018 " static_assert(B && C, \"Something is wrong\");\n"
6019 "};");
Daniel Jasper29a98cf2013-08-13 09:09:09 +00006020 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))");
6021 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))");
Daniel Jasper72ab43b2014-04-14 12:50:02 +00006022 verifyFormat("#define A(a, b) (a && b)");
Alexander Kornienkoa5151272013-03-12 16:28:18 +00006023}
6024
Manuel Klimekc1237a82013-01-23 14:08:21 +00006025TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
6026 verifyFormat("void f() {\n"
6027 " x[aaaaaaaaa -\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00006028 " b] = 23;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006029 "}",
6030 getLLVMStyleWithColumns(15));
Manuel Klimekc1237a82013-01-23 14:08:21 +00006031}
6032
Daniel Jasperef906a92013-01-13 08:01:36 +00006033TEST_F(FormatTest, FormatsCasts) {
6034 verifyFormat("Type *A = static_cast<Type *>(P);");
6035 verifyFormat("Type *A = (Type *)P;");
6036 verifyFormat("Type *A = (vector<Type *, int *>)P;");
6037 verifyFormat("int a = (int)(2.0f);");
Daniel Jasperda6f2252013-05-31 16:14:28 +00006038 verifyFormat("int a = (int)2.0f;");
6039 verifyFormat("x[(int32)y];");
6040 verifyFormat("x = (int32)y;");
6041 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
6042 verifyFormat("int a = (int)*b;");
6043 verifyFormat("int a = (int)2.0f;");
6044 verifyFormat("int a = (int)~0;");
6045 verifyFormat("int a = (int)++a;");
6046 verifyFormat("int a = (int)sizeof(int);");
6047 verifyFormat("int a = (int)+2;");
6048 verifyFormat("my_int a = (my_int)2.0f;");
6049 verifyFormat("my_int a = (my_int)sizeof(int);");
Daniel Jasper05866372013-06-06 08:20:20 +00006050 verifyFormat("return (my_int)aaa;");
Daniel Jasper49a94482013-07-15 15:04:42 +00006051 verifyFormat("#define x ((int)-1)");
Daniel Jaspera45eb4c2014-10-06 13:16:43 +00006052 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1");
Daniel Jasper49a94482013-07-15 15:04:42 +00006053 verifyFormat("#define p(q) ((int *)&q)");
Daniel Jasper30646202014-07-14 12:38:38 +00006054 verifyFormat("fn(a)(b) + 1;");
Daniel Jasperef906a92013-01-13 08:01:36 +00006055
Dinesh Dwivedi76f98f82014-05-05 13:14:35 +00006056 verifyFormat("void f() { my_int a = (my_int)*b; }");
6057 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }");
6058 verifyFormat("my_int a = (my_int)~0;");
6059 verifyFormat("my_int a = (my_int)++a;");
Daniel Jaspera45eb4c2014-10-06 13:16:43 +00006060 verifyFormat("my_int a = (my_int)-2;");
Dinesh Dwivedi76f98f82014-05-05 13:14:35 +00006061 verifyFormat("my_int a = (my_int)1;");
6062 verifyFormat("my_int a = (my_int *)1;");
6063 verifyFormat("my_int a = (const my_int)-1;");
6064 verifyFormat("my_int a = (const my_int *)-1;");
Daniel Jasper4b3ba212014-08-25 09:36:07 +00006065 verifyFormat("my_int a = (my_int)(my_int)-1;");
Daniel Jasperf5e5ee62015-05-19 11:18:39 +00006066 verifyFormat("my_int a = (ns::my_int)-2;");
Daniel Jasper554e49f2015-06-12 07:15:33 +00006067 verifyFormat("case (my_int)ONE:");
Daniel Jasper94b1bdf2016-04-05 11:46:06 +00006068 verifyFormat("auto x = (X)this;");
Dinesh Dwivedi76f98f82014-05-05 13:14:35 +00006069
6070 // FIXME: single value wrapped with paren will be treated as cast.
6071 verifyFormat("void f(int i = (kValue)*kMask) {}");
Daniel Jasperef906a92013-01-13 08:01:36 +00006072
Dinesh Dwivedi2e92e662014-05-06 11:46:49 +00006073 verifyFormat("{ (void)F; }");
6074
Daniel Jasper998cabc2013-07-18 14:46:07 +00006075 // Don't break after a cast's
6076 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
6077 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
6078 " bbbbbbbbbbbbbbbbbbbbbb);");
6079
Daniel Jasperef906a92013-01-13 08:01:36 +00006080 // These are not casts.
6081 verifyFormat("void f(int *) {}");
Nico Weber4401b2a2013-02-13 04:32:57 +00006082 verifyFormat("f(foo)->b;");
6083 verifyFormat("f(foo).b;");
6084 verifyFormat("f(foo)(b);");
6085 verifyFormat("f(foo)[b];");
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00006086 verifyFormat("[](foo) { return 4; }(bar);");
Nico Weber4401b2a2013-02-13 04:32:57 +00006087 verifyFormat("(*funptr)(foo)[4];");
6088 verifyFormat("funptrs[4](foo)[4];");
Daniel Jasperef906a92013-01-13 08:01:36 +00006089 verifyFormat("void f(int *);");
6090 verifyFormat("void f(int *) = 0;");
6091 verifyFormat("void f(SmallVector<int>) {}");
6092 verifyFormat("void f(SmallVector<int>);");
6093 verifyFormat("void f(SmallVector<int>) = 0;");
Nico Weber06fcec12013-02-09 18:02:07 +00006094 verifyFormat("void f(int i = (kA * kB) & kMask) {}");
Nico Weber4401b2a2013-02-13 04:32:57 +00006095 verifyFormat("int a = sizeof(int) * b;");
Alexander Kornienko1e808872013-06-28 12:51:24 +00006096 verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
Daniel Jasper05866372013-06-06 08:20:20 +00006097 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
6098 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
Aaron Ballman61005bc2015-02-16 14:14:01 +00006099 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00006100
Daniel Jasperba0bda92013-02-23 08:07:18 +00006101 // These are not casts, but at some point were confused with casts.
6102 verifyFormat("virtual void foo(int *) override;");
6103 verifyFormat("virtual void foo(char &) const;");
6104 verifyFormat("virtual void foo(int *a, char *) const;");
Daniel Jasper8a68b952013-03-13 17:13:53 +00006105 verifyFormat("int a = sizeof(int *) + b;");
Alexander Kornienko1e808872013-06-28 12:51:24 +00006106 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
Daniel Jasper9bb30012015-11-23 15:55:50 +00006107 verifyFormat("bool b = f(g<int>) && c;");
Daniel Jasper8e8b4fb2015-11-23 19:11:45 +00006108 verifyFormat("typedef void (*f)(int i) func;");
Daniel Jasper1bc1b502013-07-05 07:58:34 +00006109
6110 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
6111 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
Daniel Jasperaea3bde2013-07-12 11:19:37 +00006112 // FIXME: The indentation here is not ideal.
Daniel Jasper0e90c3d2013-07-05 09:14:35 +00006113 verifyFormat(
Daniel Jasperaea3bde2013-07-12 11:19:37 +00006114 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6115 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
6116 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];");
Daniel Jasperef906a92013-01-13 08:01:36 +00006117}
6118
Daniel Jasperc1fa2812013-01-10 13:08:12 +00006119TEST_F(FormatTest, FormatsFunctionTypes) {
Daniel Jasperc1fa2812013-01-10 13:08:12 +00006120 verifyFormat("A<bool()> a;");
6121 verifyFormat("A<SomeType()> a;");
Daniel Jasper37194282013-05-28 08:33:00 +00006122 verifyFormat("A<void (*)(int, std::string)> a;");
Daniel Jasperb8914dd2013-03-20 09:53:18 +00006123 verifyFormat("A<void *(int)>;");
Daniel Jasper6e42b1e2013-04-01 17:13:26 +00006124 verifyFormat("void *(*a)(int *, SomeType *);");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00006125 verifyFormat("int (*func)(void *);");
Daniel Jasper37194282013-05-28 08:33:00 +00006126 verifyFormat("void f() { int (*func)(void *); }");
Daniel Jasper59036852013-08-12 12:16:34 +00006127 verifyFormat("template <class CallbackClass>\n"
6128 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);");
Daniel Jasperb8914dd2013-03-20 09:53:18 +00006129
Daniel Jasper6e42b1e2013-04-01 17:13:26 +00006130 verifyGoogleFormat("A<void*(int*, SomeType*)>;");
6131 verifyGoogleFormat("void* (*a)(int);");
Daniel Jasper59036852013-08-12 12:16:34 +00006132 verifyGoogleFormat(
6133 "template <class CallbackClass>\n"
6134 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);");
Daniel Jasperabc34212013-05-14 08:34:47 +00006135
Daniel Jasper5dad58e2013-05-15 07:51:51 +00006136 // Other constructs can look somewhat like function types:
Daniel Jasperabc34212013-05-14 08:34:47 +00006137 verifyFormat("A<sizeof(*x)> a;");
Daniel Jasper5dad58e2013-05-15 07:51:51 +00006138 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
Daniel Jasper655d96a2013-07-16 11:37:21 +00006139 verifyFormat("some_var = function(*some_pointer_var)[0];");
6140 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
Daniel Jaspera85c3312015-12-28 07:44:25 +00006141 verifyFormat("int x = f(&h)();");
Daniel Jasper21561662016-06-13 07:49:35 +00006142 verifyFormat("returnsFunction(&param1, &param2)(param);");
Daniel Jaspercab46172017-04-24 14:28:49 +00006143 verifyFormat("std::function<\n"
6144 " LooooooooooongTemplatedType<\n"
6145 " SomeType>*(\n"
6146 " LooooooooooooooooongType type)>\n"
6147 " function;",
6148 getGoogleStyleWithColumns(40));
Daniel Jasperc1fa2812013-01-10 13:08:12 +00006149}
6150
Daniel Jasperbeaa3222015-02-26 11:30:50 +00006151TEST_F(FormatTest, FormatsPointersToArrayTypes) {
6152 verifyFormat("A (*foo_)[6];");
6153 verifyFormat("vector<int> (*foo_)[6];");
6154}
6155
Daniel Jasper4355e7f2014-07-09 07:50:33 +00006156TEST_F(FormatTest, BreaksLongVariableDeclarations) {
6157 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
6158 " LoooooooooooooooooooooooooooooooooooooooongVariable;");
6159 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
6160 " LoooooooooooooooooooooooooooooooooooooooongVariable;");
Daniel Jasperb754a742015-03-12 15:04:53 +00006161 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
6162 " *LoooooooooooooooooooooooooooooooooooooooongVariable;");
Daniel Jasper4355e7f2014-07-09 07:50:33 +00006163
6164 // Different ways of ()-initializiation.
6165 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
6166 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);");
6167 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
6168 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);");
6169 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
6170 " LoooooooooooooooooooooooooooooooooooooooongVariable({});");
Daniel Jasper0faa9132015-04-23 13:58:40 +00006171 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
6172 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);");
Daniel Jasper697a8ec2017-02-07 21:38:16 +00006173
6174 // Lambdas should not confuse the variable declaration heuristic.
6175 verifyFormat("LooooooooooooooooongType\n"
6176 " variable(nullptr, [](A *a) {});",
6177 getLLVMStyleWithColumns(40));
Daniel Jasper4355e7f2014-07-09 07:50:33 +00006178}
6179
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00006180TEST_F(FormatTest, BreaksLongDeclarations) {
Daniel Jasper8e357692013-05-06 08:27:33 +00006181 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00006182 " AnotherNameForTheLongType;");
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00006183 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00006184 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper8e357692013-05-06 08:27:33 +00006185 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00006186 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
Daniel Jasperb754a742015-03-12 15:04:53 +00006187 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n"
6188 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
Daniel Jasper8e357692013-05-06 08:27:33 +00006189 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
6190 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasper2ad0aba2014-10-28 17:06:04 +00006191 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n"
6192 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasperdba1c552013-07-02 09:47:29 +00006193 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
6194 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasperf10a28d2014-05-05 13:48:09 +00006195 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
6196 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasperc3ff0cd2016-04-18 11:31:21 +00006197 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
6198 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);");
6199 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
6200 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}");
Daniel Jasperc75e1ef2014-07-09 08:42:42 +00006201 FormatStyle Indented = getLLVMStyle();
6202 Indented.IndentWrappedFunctionNames = true;
6203 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
6204 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();",
6205 Indented);
6206 verifyFormat(
6207 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
6208 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
6209 Indented);
6210 verifyFormat(
6211 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
6212 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
6213 Indented);
6214 verifyFormat(
6215 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
6216 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
6217 Indented);
Daniel Jasper8e357692013-05-06 08:27:33 +00006218
6219 // FIXME: Without the comment, this breaks after "(".
Manuel Klimek836c2862013-06-21 17:25:42 +00006220 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n"
6221 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();",
6222 getGoogleStyle());
Daniel Jasper8e357692013-05-06 08:27:33 +00006223
Daniel Jasperd2639ef2013-01-28 15:16:31 +00006224 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00006225 " int LoooooooooooooooooooongParam2) {}");
Daniel Jasperd1926a32013-01-02 08:44:14 +00006226 verifyFormat(
Daniel Jasper6728fc12013-04-11 14:29:13 +00006227 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
6228 " SourceLocation L, IdentifierIn *II,\n"
6229 " Type *T) {}");
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00006230 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
Daniel Jasperb754a742015-03-12 15:04:53 +00006231 "ReallyReaaallyLongFunctionName(\n"
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00006232 " const std::string &SomeParameter,\n"
Daniel Jasperb754a742015-03-12 15:04:53 +00006233 " const SomeType<string, SomeOtherTemplateParameter>\n"
6234 " &ReallyReallyLongParameterName,\n"
6235 " const SomeType<string, SomeOtherTemplateParameter>\n"
6236 " &AnotherLongParameterName) {}");
Daniel Jasperc6fbc212013-05-15 09:35:08 +00006237 verifyFormat("template <typename A>\n"
6238 "SomeLoooooooooooooooooooooongType<\n"
6239 " typename some_namespace::SomeOtherType<A>::Type>\n"
6240 "Function() {}");
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00006241
Daniel Jasperd36ef5e2013-01-28 15:40:20 +00006242 verifyGoogleFormat(
Daniel Jasper53643062013-08-19 10:16:18 +00006243 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
6244 " aaaaaaaaaaaaaaaaaaaaaaa;");
6245 verifyGoogleFormat(
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00006246 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
6247 " SourceLocation L) {}");
Daniel Jasperb9caeac2013-02-13 20:33:44 +00006248 verifyGoogleFormat(
6249 "some_namespace::LongReturnType\n"
6250 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00006251 " int first_long_parameter, int second_parameter) {}");
Daniel Jasperb9caeac2013-02-13 20:33:44 +00006252
6253 verifyGoogleFormat("template <typename T>\n"
6254 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00006255 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
Daniel Jasper57d4a582013-02-28 10:06:05 +00006256 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6257 " int aaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper78b45332014-08-14 10:52:56 +00006258
6259 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
Daniel Jasperb754a742015-03-12 15:04:53 +00006260 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6261 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperde7ca752015-05-04 07:39:00 +00006262 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6263 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
6264 " aaaaaaaaaaaaaaaaaaaaaaaa);");
6265 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6266 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
6267 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n"
6268 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Andi-Bogdan Postelnicu67329892017-03-07 14:48:02 +00006269
Andi-Bogdan Postelnicu4743e2d2017-03-07 15:20:31 +00006270 verifyFormat("template <typename T> // Templates on own line.\n"
6271 "static int // Some comment.\n"
Andi-Bogdan Postelnicu67329892017-03-07 14:48:02 +00006272 "MyFunction(int a);",
6273 getLLVMStyle());
Daniel Jasperd1926a32013-01-02 08:44:14 +00006274}
6275
Daniel Jasperaea3bde2013-07-12 11:19:37 +00006276TEST_F(FormatTest, FormatsArrays) {
6277 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
6278 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
Daniel Jasper362a1bf2015-12-23 18:01:43 +00006279 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n"
6280 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;");
Daniel Jaspere1afb9b2015-12-30 12:23:00 +00006281 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n"
6282 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}");
Daniel Jasperaea3bde2013-07-12 11:19:37 +00006283 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6284 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
6285 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6286 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
6287 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6288 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
6289 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
6290 verifyFormat(
6291 "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
6292 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
6293 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
Daniel Jasperf9168de2016-03-01 04:19:55 +00006294 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n"
6295 " .aaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jaspere0ab9e72013-12-06 15:19:50 +00006296
6297 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n"
6298 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];");
Daniel Jasperecaba172014-06-10 13:27:57 +00006299 verifyFormat(
6300 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n"
6301 " .aaaaaaa[0]\n"
6302 " .aaaaaaaaaaaaaaaaaaaaaa();");
Manuel Klimek27f278182016-01-19 14:05:32 +00006303 verifyFormat("a[::b::c];");
Daniel Jasper675b4f82015-01-19 10:51:23 +00006304
6305 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10));
Daniel Jaspera3cd21642016-01-14 13:36:46 +00006306
6307 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0);
6308 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit);
Daniel Jasperaea3bde2013-07-12 11:19:37 +00006309}
6310
Daniel Jaspere9de2602012-12-06 09:56:08 +00006311TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
6312 verifyFormat("(a)->b();");
6313 verifyFormat("--a;");
6314}
6315
Daniel Jasper8b529712012-12-04 13:02:32 +00006316TEST_F(FormatTest, HandlesIncludeDirectives) {
Daniel Jasper2ab0d012013-01-14 15:52:06 +00006317 verifyFormat("#include <string>\n"
6318 "#include <a/b/c.h>\n"
6319 "#include \"a/b/string\"\n"
6320 "#include \"string.h\"\n"
6321 "#include \"string.h\"\n"
Manuel Klimek99c7baa2013-01-15 15:50:27 +00006322 "#include <a-a>\n"
Daniel Jasperaf5ba0e2013-02-23 07:46:38 +00006323 "#include < path with space >\n"
Daniel Jasperfa3f8fb2015-05-19 11:22:29 +00006324 "#include_next <test.h>"
Daniel Jasper4a4be012013-05-06 10:24:51 +00006325 "#include \"abc.h\" // this is included for ABC\n"
Daniel Jasper8bb99e82013-05-16 12:59:13 +00006326 "#include \"some long include\" // with a comment\n"
Manuel Klimek45ab5592017-11-14 09:19:53 +00006327 "#include \"some very long include path\"\n"
6328 "#include <some/very/long/include/path>\n",
Daniel Jasperaf5ba0e2013-02-23 07:46:38 +00006329 getLLVMStyleWithColumns(35));
Daniel Jasper98857842013-10-30 13:54:53 +00006330 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\""));
6331 EXPECT_EQ("#include <a>", format("#include<a>"));
Nico Weber8f83ee42012-12-21 18:21:56 +00006332
Daniel Jasper5ef433f2013-01-13 08:12:18 +00006333 verifyFormat("#import <string>");
6334 verifyFormat("#import <a/b/c.h>");
6335 verifyFormat("#import \"a/b/string\"");
6336 verifyFormat("#import \"string.h\"");
6337 verifyFormat("#import \"string.h\"");
Daniel Jaspered8f1c62013-08-28 08:24:04 +00006338 verifyFormat("#if __has_include(<strstream>)\n"
6339 "#include <strstream>\n"
6340 "#endif");
Daniel Jasper47ef6dd2014-01-17 16:21:39 +00006341
Daniel Jasper343643b2014-08-13 08:29:18 +00006342 verifyFormat("#define MY_IMPORT <a/b>");
6343
Nico Weber21088802017-02-10 19:36:52 +00006344 verifyFormat("#if __has_include(<a/b>)");
6345 verifyFormat("#if __has_include_next(<a/b>)");
6346 verifyFormat("#define F __has_include(<a/b>)");
6347 verifyFormat("#define F __has_include_next(<a/b>)");
6348
Daniel Jasper47ef6dd2014-01-17 16:21:39 +00006349 // Protocol buffer definition or missing "#".
6350 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";",
6351 getLLVMStyleWithColumns(30));
Daniel Jasper9509f182014-05-05 08:08:07 +00006352
6353 FormatStyle Style = getLLVMStyle();
6354 Style.AlwaysBreakBeforeMultilineStrings = true;
6355 Style.ColumnLimit = 0;
6356 verifyFormat("#import \"abc.h\"", Style);
Daniel Jasper86ee0b62014-12-04 08:57:27 +00006357
6358 // But 'import' might also be a regular C++ namespace.
6359 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6360 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper8b529712012-12-04 13:02:32 +00006361}
6362
Alexander Kornienko578fdd82012-12-06 18:03:27 +00006363//===----------------------------------------------------------------------===//
6364// Error recovery tests.
6365//===----------------------------------------------------------------------===//
6366
Daniel Jasper66e9dee2013-02-14 09:19:04 +00006367TEST_F(FormatTest, IncompleteParameterLists) {
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00006368 FormatStyle NoBinPacking = getLLVMStyle();
6369 NoBinPacking.BinPackParameters = false;
6370 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
6371 " double *min_x,\n"
6372 " double *max_x,\n"
6373 " double *min_y,\n"
6374 " double *max_y,\n"
6375 " double *min_z,\n"
6376 " double *max_z, ) {}",
6377 NoBinPacking);
Daniel Jasper66e9dee2013-02-14 09:19:04 +00006378}
6379
Daniel Jasper83a54d22013-01-10 09:26:47 +00006380TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
Alexander Kornienkoae6e53c2013-01-16 11:45:16 +00006381 verifyFormat("void f() { return; }\n42");
6382 verifyFormat("void f() {\n"
6383 " if (0)\n"
6384 " return;\n"
6385 "}\n"
6386 "42");
Alexander Kornienko1231e062013-01-16 11:43:46 +00006387 verifyFormat("void f() { return }\n42");
6388 verifyFormat("void f() {\n"
6389 " if (0)\n"
6390 " return\n"
6391 "}\n"
6392 "42");
6393}
6394
6395TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
6396 EXPECT_EQ("void f() { return }", format("void f ( ) { return }"));
6397 EXPECT_EQ("void f() {\n"
6398 " if (a)\n"
6399 " return\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006400 "}",
6401 format("void f ( ) { if ( a ) return }"));
Daniel Jasperabca58c2013-05-15 14:09:55 +00006402 EXPECT_EQ("namespace N {\n"
6403 "void f()\n"
6404 "}",
6405 format("namespace N { void f() }"));
Alexander Kornienko1231e062013-01-16 11:43:46 +00006406 EXPECT_EQ("namespace N {\n"
6407 "void f() {}\n"
6408 "void g()\n"
Krasimir Georgiev9163fe22017-03-02 09:54:44 +00006409 "} // namespace N",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006410 format("namespace N { void f( ) { } void g( ) }"));
Daniel Jasper83a54d22013-01-10 09:26:47 +00006411}
6412
Daniel Jasper2df93312013-01-09 10:16:05 +00006413TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
6414 verifyFormat("int aaaaaaaa =\n"
Alexander Kornienkoffd6d042013-03-27 11:52:18 +00006415 " // Overlylongcomment\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006416 " b;",
6417 getLLVMStyleWithColumns(20));
Daniel Jasper2df93312013-01-09 10:16:05 +00006418 verifyFormat("function(\n"
6419 " ShortArgument,\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006420 " LoooooooooooongArgument);\n",
6421 getLLVMStyleWithColumns(20));
Daniel Jasper2df93312013-01-09 10:16:05 +00006422}
6423
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00006424TEST_F(FormatTest, IncorrectAccessSpecifier) {
6425 verifyFormat("public:");
6426 verifyFormat("class A {\n"
6427 "public\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00006428 " void f() {}\n"
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00006429 "};");
6430 verifyFormat("public\n"
6431 "int qwerty;");
6432 verifyFormat("public\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00006433 "B {}");
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00006434 verifyFormat("public\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00006435 "{}");
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00006436 verifyFormat("public\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00006437 "B { int x; }");
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00006438}
Daniel Jasperf7935112012-12-03 18:12:45 +00006439
Daniel Jasper291f9362013-03-20 15:58:10 +00006440TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
6441 verifyFormat("{");
6442 verifyFormat("#})");
Daniel Jasperd97d5d52015-02-17 09:58:03 +00006443 verifyNoCrash("(/**/[:!] ?[).");
Daniel Jasper291f9362013-03-20 15:58:10 +00006444}
Alexander Kornienko0ea8e102012-12-04 15:40:36 +00006445
6446TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00006447 verifyFormat("do {\n}");
6448 verifyFormat("do {\n}\n"
Alexander Kornienko0ea8e102012-12-04 15:40:36 +00006449 "f();");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00006450 verifyFormat("do {\n}\n"
Alexander Kornienko0ea8e102012-12-04 15:40:36 +00006451 "wheeee(fun);");
6452 verifyFormat("do {\n"
6453 " f();\n"
Manuel Klimek28cacc72013-01-07 18:10:23 +00006454 "}");
Alexander Kornienko0ea8e102012-12-04 15:40:36 +00006455}
6456
Manuel Klimek9fa8d552013-01-11 19:23:05 +00006457TEST_F(FormatTest, IncorrectCodeMissingParens) {
Manuel Klimekadededf2013-01-11 18:28:36 +00006458 verifyFormat("if {\n foo;\n foo();\n}");
Manuel Klimek9fa8d552013-01-11 19:23:05 +00006459 verifyFormat("switch {\n foo;\n foo();\n}");
Manuel Klimekec5c3db2015-05-07 12:26:30 +00006460 verifyIncompleteFormat("for {\n foo;\n foo();\n}");
Manuel Klimek9fa8d552013-01-11 19:23:05 +00006461 verifyFormat("while {\n foo;\n foo();\n}");
6462 verifyFormat("do {\n foo;\n foo();\n} while;");
Manuel Klimekadededf2013-01-11 18:28:36 +00006463}
6464
Daniel Jasperc0880a92013-01-04 18:52:56 +00006465TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
Manuel Klimekec5c3db2015-05-07 12:26:30 +00006466 verifyIncompleteFormat("namespace {\n"
6467 "class Foo { Foo (\n"
6468 "};\n"
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00006469 "} // namespace");
Daniel Jasperc0880a92013-01-04 18:52:56 +00006470}
6471
Alexander Kornienko870f9eb2012-12-04 17:27:50 +00006472TEST_F(FormatTest, IncorrectCodeErrorDetection) {
Daniel Jasperfbc057e2013-10-18 17:20:57 +00006473 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n"));
Manuel Klimeke7d10a12013-01-10 13:24:24 +00006474 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n"));
6475 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n"));
Daniel Jasperfbc057e2013-10-18 17:20:57 +00006476 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n"));
Alexander Kornienko870f9eb2012-12-04 17:27:50 +00006477
Alexander Kornienko870f9eb2012-12-04 17:27:50 +00006478 EXPECT_EQ("{\n"
Daniel Jasperfbc057e2013-10-18 17:20:57 +00006479 " {\n"
6480 " breakme(\n"
6481 " qwe);\n"
6482 " }\n",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006483 format("{\n"
6484 " {\n"
6485 " breakme(qwe);\n"
6486 "}\n",
6487 getLLVMStyleWithColumns(10)));
Alexander Kornienko870f9eb2012-12-04 17:27:50 +00006488}
6489
Manuel Klimek73a2fdf2013-01-10 14:36:46 +00006490TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006491 verifyFormat("int x = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006492 " avariable,\n"
6493 " b(alongervariable)};",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006494 getLLVMStyleWithColumns(25));
Manuel Klimek73a2fdf2013-01-10 14:36:46 +00006495}
6496
Manuel Klimek762dd182013-01-21 10:07:49 +00006497TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
Daniel Jasper4afc6b32014-06-02 10:57:55 +00006498 verifyFormat("return (a)(b){1, 2, 3};");
Manuel Klimek762dd182013-01-21 10:07:49 +00006499}
6500
Daniel Jasperae8e0d82014-04-17 11:32:02 +00006501TEST_F(FormatTest, LayoutCxx11BraceInitializers) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00006502 verifyFormat("vector<int> x{1, 2, 3, 4};");
Daniel Jaspera125d532014-03-21 12:38:57 +00006503 verifyFormat("vector<int> x{\n"
Francois Ferrandd2130f52017-06-30 20:00:02 +00006504 " 1,\n"
6505 " 2,\n"
6506 " 3,\n"
6507 " 4,\n"
Daniel Jaspera125d532014-03-21 12:38:57 +00006508 "};");
Chandler Carruthf8b72662014-03-02 12:37:31 +00006509 verifyFormat("vector<T> x{{}, {}, {}, {}};");
6510 verifyFormat("f({1, 2});");
6511 verifyFormat("auto v = Foo{-1};");
6512 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});");
6513 verifyFormat("Class::Class : member{1, 2, 3} {}");
6514 verifyFormat("new vector<int>{1, 2, 3};");
6515 verifyFormat("new int[3]{1, 2, 3};");
Daniel Jasper7a2d60e2014-05-07 07:59:03 +00006516 verifyFormat("new int{1};");
Chandler Carruthf8b72662014-03-02 12:37:31 +00006517 verifyFormat("return {arg1, arg2};");
6518 verifyFormat("return {arg1, SomeType{parameter}};");
6519 verifyFormat("int count = set<int>{f(), g(), h()}.size();");
6520 verifyFormat("new T{arg1, arg2};");
6521 verifyFormat("f(MyMap[{composite, key}]);");
6522 verifyFormat("class Class {\n"
6523 " T member = {arg1, arg2};\n"
6524 "};");
6525 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};");
Francois Ferrand5f07f442017-06-19 14:41:21 +00006526 verifyFormat("const struct A a = {.a = 1, .b = 2};");
6527 verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
Daniel Jasper91b032a2014-05-22 12:46:38 +00006528 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");");
6529 verifyFormat("int a = std::is_integral<int>{} + 0;");
Daniel Jaspere5777d22013-05-23 10:15:45 +00006530
Daniel Jasper438059e2014-05-22 12:11:13 +00006531 verifyFormat("int foo(int i) { return fo1{}(i); }");
6532 verifyFormat("int foo(int i) { return fo1{}(i); }");
Daniel Jasper4afc6b32014-06-02 10:57:55 +00006533 verifyFormat("auto i = decltype(x){};");
Daniel Jasper610381f2014-08-26 09:37:52 +00006534 verifyFormat("std::vector<int> v = {1, 0 /* comment */};");
Daniel Jasper168c8aa2014-08-27 11:53:26 +00006535 verifyFormat("Node n{1, Node{1000}, //\n"
6536 " 2};");
Daniel Jasperb812e322015-02-26 11:46:29 +00006537 verifyFormat("Aaaa aaaaaaa{\n"
6538 " {\n"
6539 " aaaa,\n"
6540 " },\n"
6541 "};");
Daniel Jaspercec9ffd2015-05-18 14:12:24 +00006542 verifyFormat("class C : public D {\n"
6543 " SomeClass SC{2};\n"
6544 "};");
Daniel Jasper3c883d12015-05-18 14:49:19 +00006545 verifyFormat("class C : public A {\n"
6546 " class D : public B {\n"
6547 " void f() { int i{2}; }\n"
6548 " };\n"
6549 "};");
Daniel Jasperb86e2722015-08-24 13:23:37 +00006550 verifyFormat("#define A {a, a},");
Daniel Jasper438059e2014-05-22 12:11:13 +00006551
Francois Ferrandd2130f52017-06-30 20:00:02 +00006552 // Binpacking only if there is no trailing comma
6553 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n"
6554 " cccccccccc, dddddddddd};",
6555 getLLVMStyleWithColumns(50));
6556 verifyFormat("const Aaaaaa aaaaa = {\n"
6557 " aaaaaaaaaaa,\n"
6558 " bbbbbbbbbbb,\n"
6559 " ccccccccccc,\n"
6560 " ddddddddddd,\n"
6561 "};", getLLVMStyleWithColumns(50));
6562
Daniel Jaspere4ada022016-12-13 10:05:03 +00006563 // Cases where distinguising braced lists and blocks is hard.
6564 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);");
6565 verifyFormat("void f() {\n"
6566 " return; // comment\n"
6567 "}\n"
6568 "SomeType t;");
6569 verifyFormat("void f() {\n"
6570 " if (a) {\n"
6571 " f();\n"
6572 " }\n"
6573 "}\n"
6574 "SomeType t;");
6575
Daniel Jasper08434342015-05-26 07:26:26 +00006576 // In combination with BinPackArguments = false.
Daniel Jasperae8e0d82014-04-17 11:32:02 +00006577 FormatStyle NoBinPacking = getLLVMStyle();
Daniel Jasper08434342015-05-26 07:26:26 +00006578 NoBinPacking.BinPackArguments = false;
Daniel Jasperae8e0d82014-04-17 11:32:02 +00006579 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n"
6580 " bbbbb,\n"
6581 " ccccc,\n"
6582 " ddddd,\n"
6583 " eeeee,\n"
6584 " ffffff,\n"
6585 " ggggg,\n"
6586 " hhhhhh,\n"
6587 " iiiiii,\n"
6588 " jjjjjj,\n"
6589 " kkkkkk};",
6590 NoBinPacking);
6591 verifyFormat("const Aaaaaa aaaaa = {\n"
6592 " aaaaa,\n"
6593 " bbbbb,\n"
6594 " ccccc,\n"
6595 " ddddd,\n"
6596 " eeeee,\n"
6597 " ffffff,\n"
6598 " ggggg,\n"
6599 " hhhhhh,\n"
6600 " iiiiii,\n"
6601 " jjjjjj,\n"
6602 " kkkkkk,\n"
6603 "};",
6604 NoBinPacking);
Daniel Jasper839922e2014-08-13 08:46:21 +00006605 verifyFormat(
6606 "const Aaaaaa aaaaa = {\n"
6607 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n"
6608 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n"
6609 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n"
6610 "};",
6611 NoBinPacking);
Daniel Jasperae8e0d82014-04-17 11:32:02 +00006612
Chandler Carruthf8b72662014-03-02 12:37:31 +00006613 // FIXME: The alignment of these trailing comments might be bad. Then again,
6614 // this might be utterly useless in real code.
6615 verifyFormat("Constructor::Constructor()\n"
Daniel Jasper64a328e2014-11-11 19:34:57 +00006616 " : some_value{ //\n"
6617 " aaaaaaa, //\n"
6618 " bbbbbbb} {}");
Daniel Jasper5a611392013-12-19 21:41:37 +00006619
Chandler Carruthf8b72662014-03-02 12:37:31 +00006620 // In braced lists, the first comment is always assumed to belong to the
6621 // first element. Thus, it can be moved to the next or previous line as
6622 // appropriate.
6623 EXPECT_EQ("function({// First element:\n"
6624 " 1,\n"
6625 " // Second element:\n"
6626 " 2});",
6627 format("function({\n"
6628 " // First element:\n"
6629 " 1,\n"
6630 " // Second element:\n"
6631 " 2});"));
6632 EXPECT_EQ("std::vector<int> MyNumbers{\n"
6633 " // First element:\n"
6634 " 1,\n"
6635 " // Second element:\n"
6636 " 2};",
6637 format("std::vector<int> MyNumbers{// First element:\n"
6638 " 1,\n"
6639 " // Second element:\n"
6640 " 2};",
6641 getLLVMStyleWithColumns(30)));
Francois Ferrandd2130f52017-06-30 20:00:02 +00006642 // A trailing comma should still lead to an enforced line break and no
6643 // binpacking.
Daniel Jasper64a328e2014-11-11 19:34:57 +00006644 EXPECT_EQ("vector<int> SomeVector = {\n"
6645 " // aaa\n"
Francois Ferrandd2130f52017-06-30 20:00:02 +00006646 " 1,\n"
6647 " 2,\n"
Daniel Jasper64a328e2014-11-11 19:34:57 +00006648 "};",
6649 format("vector<int> SomeVector = { // aaa\n"
6650 " 1, 2, };"));
Daniel Jasper5a611392013-12-19 21:41:37 +00006651
Chandler Carruthf8b72662014-03-02 12:37:31 +00006652 FormatStyle ExtraSpaces = getLLVMStyle();
6653 ExtraSpaces.Cpp11BracedListStyle = false;
6654 ExtraSpaces.ColumnLimit = 75;
6655 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces);
6656 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces);
6657 verifyFormat("f({ 1, 2 });", ExtraSpaces);
6658 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces);
6659 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces);
6660 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces);
6661 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces);
6662 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces);
6663 verifyFormat("return { arg1, arg2 };", ExtraSpaces);
6664 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces);
6665 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces);
6666 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces);
6667 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces);
6668 verifyFormat("class Class {\n"
6669 " T member = { arg1, arg2 };\n"
6670 "};",
6671 ExtraSpaces);
6672 verifyFormat(
6673 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6674 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
6675 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
6676 " bbbbbbbbbbbbbbbbbbbb, bbbbb };",
6677 ExtraSpaces);
6678 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces);
Daniel Jasper610381f2014-08-26 09:37:52 +00006679 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });",
Chandler Carruthf8b72662014-03-02 12:37:31 +00006680 ExtraSpaces);
6681 verifyFormat(
6682 "someFunction(OtherParam,\n"
6683 " BracedList{ // comment 1 (Forcing interesting break)\n"
6684 " param1, param2,\n"
6685 " // comment 2\n"
Daniel Jasper11a0ac62014-12-12 09:40:58 +00006686 " param3, param4 });",
Chandler Carruthf8b72662014-03-02 12:37:31 +00006687 ExtraSpaces);
6688 verifyFormat(
6689 "std::this_thread::sleep_for(\n"
6690 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);",
6691 ExtraSpaces);
Daniel Jasperff8d61362016-12-19 08:40:56 +00006692 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n"
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00006693 " aaaaaaa,\n"
6694 " aaaaaaaaaa,\n"
6695 " aaaaa,\n"
6696 " aaaaaaaaaaaaaaa,\n"
6697 " aaa,\n"
6698 " aaaaaaaaaa,\n"
6699 " a,\n"
6700 " aaaaaaaaaaaaaaaaaaaaa,\n"
6701 " aaaaaaaaaaaa,\n"
6702 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n"
6703 " aaaaaaa,\n"
6704 " a};");
Chandler Carruthf8b72662014-03-02 12:37:31 +00006705 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces);
Francois Ferrand5f07f442017-06-19 14:41:21 +00006706 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces);
6707 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces);
Manuel Klimekab419912013-05-23 09:41:43 +00006708}
6709
Daniel Jasper33b909c2013-10-25 14:29:37 +00006710TEST_F(FormatTest, FormatsBracedListsInColumnLayout) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00006711 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6712 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6713 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6714 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6715 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6716 " 1, 22, 333, 4444, 55555, 666666, 7777777};");
Daniel Jasper731dde92015-05-15 09:41:59 +00006717 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006718 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
Daniel Jasper731dde92015-05-15 09:41:59 +00006719 " 1, 22, 333, 4444, 55555, //\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006720 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6721 " 1, 22, 333, 4444, 55555, 666666, 7777777};");
Daniel Jasper8de9ed02013-08-22 15:00:41 +00006722 verifyFormat(
Chandler Carruthf8b72662014-03-02 12:37:31 +00006723 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6724 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6725 " 1, 22, 333, 4444, 55555, 666666, // comment\n"
6726 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
6727 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
6728 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
6729 " 7777777};");
Daniel Jasper8de9ed02013-08-22 15:00:41 +00006730 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006731 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
6732 " X86::R8, X86::R9, X86::R10, X86::R11, 0};");
Daniel Jasper731dde92015-05-15 09:41:59 +00006733 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
6734 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
6735 " // Separating comment.\n"
6736 " X86::R8, X86::R9, X86::R10, X86::R11, 0};");
6737 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
6738 " // Leading comment\n"
6739 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
6740 " X86::R8, X86::R9, X86::R10, X86::R11, 0};");
Chandler Carruthf8b72662014-03-02 12:37:31 +00006741 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
6742 " 1, 1, 1, 1};",
Daniel Jasper8de9ed02013-08-22 15:00:41 +00006743 getLLVMStyleWithColumns(39));
Chandler Carruthf8b72662014-03-02 12:37:31 +00006744 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
6745 " 1, 1, 1, 1};",
Daniel Jasper8de9ed02013-08-22 15:00:41 +00006746 getLLVMStyleWithColumns(38));
6747 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006748 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};",
6749 getLLVMStyleWithColumns(43));
Daniel Jaspere4c16c72015-05-08 13:51:14 +00006750 verifyFormat(
6751 "static unsigned SomeValues[10][3] = {\n"
6752 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n"
6753 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};");
6754 verifyFormat("static auto fields = new vector<string>{\n"
6755 " \"aaaaaaaaaaaaa\",\n"
6756 " \"aaaaaaaaaaaaa\",\n"
6757 " \"aaaaaaaaaaaa\",\n"
6758 " \"aaaaaaaaaaaaaa\",\n"
6759 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
6760 " \"aaaaaaaaaaaa\",\n"
6761 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
6762 "};");
Daniel Jasperd57843d2015-05-11 13:35:40 +00006763 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};");
6764 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n"
6765 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n"
6766 " 3, cccccccccccccccccccccc};",
6767 getLLVMStyleWithColumns(60));
Daniel Jasperf93551c2013-08-23 10:05:49 +00006768
6769 // Trailing commas.
Daniel Jaspera125d532014-03-21 12:38:57 +00006770 verifyFormat("vector<int> x = {\n"
6771 " 1, 1, 1, 1, 1, 1, 1, 1,\n"
6772 "};",
Daniel Jasperf93551c2013-08-23 10:05:49 +00006773 getLLVMStyleWithColumns(39));
Daniel Jasperb175d572014-04-09 09:53:23 +00006774 verifyFormat("vector<int> x = {\n"
6775 " 1, 1, 1, 1, 1, 1, 1, 1, //\n"
Daniel Jasperf93551c2013-08-23 10:05:49 +00006776 "};",
6777 getLLVMStyleWithColumns(39));
Daniel Jasper610381f2014-08-26 09:37:52 +00006778 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
6779 " 1, 1, 1, 1,\n"
6780 " /**/ /**/};",
Daniel Jasper8863ada2013-08-26 08:10:17 +00006781 getLLVMStyleWithColumns(39));
Daniel Jaspere4c16c72015-05-08 13:51:14 +00006782
Daniel Jasper60c27072015-05-13 08:16:00 +00006783 // Trailing comment in the first line.
6784 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n"
6785 " 1111111111, 2222222222, 33333333333, 4444444444, //\n"
6786 " 111111111, 222222222, 3333333333, 444444444, //\n"
6787 " 11111111, 22222222, 333333333, 44444444};");
Daniel Jasper00fb2a12015-07-15 16:26:47 +00006788 // Trailing comment in the last line.
6789 verifyFormat("int aaaaa[] = {\n"
6790 " 1, 2, 3, // comment\n"
6791 " 4, 5, 6 // comment\n"
6792 "};");
Daniel Jasper60c27072015-05-13 08:16:00 +00006793
Daniel Jaspere4c16c72015-05-08 13:51:14 +00006794 // With nested lists, we should either format one item per line or all nested
6795 // lists one on line.
6796 // FIXME: For some nested lists, we can do better.
Chandler Carruthf8b72662014-03-02 12:37:31 +00006797 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
6798 " {aaaaaaaaaaaaaaaaaaa},\n"
6799 " {aaaaaaaaaaaaaaaaaaaaa},\n"
6800 " {aaaaaaaaaaaaaaaaa}};",
Daniel Jaspercb3f0ed2013-08-27 08:43:47 +00006801 getLLVMStyleWithColumns(60));
Daniel Jasper63af7c42013-12-09 14:40:19 +00006802 verifyFormat(
6803 "SomeStruct my_struct_array = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006804 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n"
6805 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n"
6806 " {aaa, aaa},\n"
6807 " {aaa, aaa},\n"
6808 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n"
6809 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n"
6810 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};");
Daniel Jasper01603472014-01-09 13:42:56 +00006811
6812 // No column layout should be used here.
Francois Ferrandd2130f52017-06-30 20:00:02 +00006813 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006814 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};");
Daniel Jasper20e8c3b2015-01-19 10:51:42 +00006815
6816 verifyNoCrash("a<,");
Daniel Jasperabd1f572016-03-02 22:44:03 +00006817
Daniel Jaspereb65e912015-12-21 18:31:15 +00006818 // No braced initializer here.
6819 verifyFormat("void f() {\n"
6820 " struct Dummy {};\n"
6821 " f(v);\n"
6822 "}");
Daniel Jasper55582072016-01-04 07:30:44 +00006823
6824 // Long lists should be formatted in columns even if they are nested.
6825 verifyFormat(
6826 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6827 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6828 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6829 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6830 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6831 " 1, 22, 333, 4444, 55555, 666666, 7777777});");
Daniel Jaspere6169662016-12-19 07:26:11 +00006832
6833 // Allow "single-column" layout even if that violates the column limit. There
6834 // isn't going to be a better way.
6835 verifyFormat("std::vector<int> a = {\n"
6836 " aaaaaaaa,\n"
6837 " aaaaaaaa,\n"
6838 " aaaaaaaa,\n"
6839 " aaaaaaaa,\n"
6840 " aaaaaaaaaa,\n"
6841 " aaaaaaaa,\n"
6842 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};",
6843 getLLVMStyleWithColumns(30));
Daniel Jasper083d1702016-12-21 17:02:06 +00006844 verifyFormat("vector<int> aaaa = {\n"
6845 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6846 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6847 " aaaaaa.aaaaaaa,\n"
6848 " aaaaaa.aaaaaaa,\n"
6849 " aaaaaa.aaaaaaa,\n"
6850 " aaaaaa.aaaaaaa,\n"
6851 "};");
Daniel Jasperd1a9d8acd2017-01-12 19:35:26 +00006852
6853 // Don't create hanging lists.
Daniel Jasper21f7dea2017-02-01 09:23:39 +00006854 verifyFormat("someFunction(Param, {List1, List2,\n"
6855 " List3});",
6856 getLLVMStyleWithColumns(35));
6857 verifyFormat("someFunction(Param, Param,\n"
Daniel Jasperd1a9d8acd2017-01-12 19:35:26 +00006858 " {List1, List2,\n"
6859 " List3});",
6860 getLLVMStyleWithColumns(35));
Daniel Jaspere3710102017-01-12 20:06:28 +00006861 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n"
6862 " aaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper8de9ed02013-08-22 15:00:41 +00006863}
6864
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00006865TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00006866 FormatStyle DoNotMerge = getLLVMStyle();
Daniel Jasperd74cf402014-04-08 12:46:38 +00006867 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00006868
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00006869 verifyFormat("void f() { return 42; }");
6870 verifyFormat("void f() {\n"
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00006871 " return 42;\n"
6872 "}",
6873 DoNotMerge);
6874 verifyFormat("void f() {\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00006875 " // Comment\n"
6876 "}");
6877 verifyFormat("{\n"
6878 "#error {\n"
6879 " int a;\n"
6880 "}");
6881 verifyFormat("{\n"
6882 " int a;\n"
6883 "#error {\n"
6884 "}");
Daniel Jasperf9eb9b12013-05-16 10:17:39 +00006885 verifyFormat("void f() {} // comment");
6886 verifyFormat("void f() { int a; } // comment");
Daniel Jasper92716502013-05-16 16:54:34 +00006887 verifyFormat("void f() {\n"
6888 "} // comment",
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00006889 DoNotMerge);
6890 verifyFormat("void f() {\n"
6891 " int a;\n"
6892 "} // comment",
6893 DoNotMerge);
6894 verifyFormat("void f() {\n"
6895 "} // comment",
Daniel Jasper92716502013-05-16 16:54:34 +00006896 getLLVMStyleWithColumns(15));
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00006897
6898 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
6899 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22));
6900
6901 verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
6902 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
Alexander Kornienko06dd15a2013-12-04 13:58:27 +00006903 verifyFormat("class C {\n"
6904 " C()\n"
6905 " : iiiiiiii(nullptr),\n"
6906 " kkkkkkk(nullptr),\n"
6907 " mmmmmmm(nullptr),\n"
6908 " nnnnnnn(nullptr) {}\n"
6909 "};",
6910 getGoogleStyle());
Alexander Kornienko31e95542013-12-04 12:21:08 +00006911
6912 FormatStyle NoColumnLimit = getLLVMStyle();
6913 NoColumnLimit.ColumnLimit = 0;
6914 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));
6915 EXPECT_EQ("class C {\n"
6916 " A() : b(0) {}\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00006917 "};",
6918 format("class C{A():b(0){}};", NoColumnLimit));
Alexander Kornienko31e95542013-12-04 12:21:08 +00006919 EXPECT_EQ("A()\n"
6920 " : b(0) {\n"
6921 "}",
6922 format("A()\n:b(0)\n{\n}", NoColumnLimit));
6923
6924 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit;
Daniel Jasperd74cf402014-04-08 12:46:38 +00006925 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine =
6926 FormatStyle::SFS_None;
Alexander Kornienko31e95542013-12-04 12:21:08 +00006927 EXPECT_EQ("A()\n"
6928 " : b(0) {\n"
6929 "}",
6930 format("A():b(0){}", DoNotMergeNoColumnLimit));
6931 EXPECT_EQ("A()\n"
6932 " : b(0) {\n"
6933 "}",
6934 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit));
Daniel Jasper64989962014-02-07 13:45:27 +00006935
6936 verifyFormat("#define A \\\n"
6937 " void f() { \\\n"
6938 " int i; \\\n"
6939 " }",
6940 getLLVMStyleWithColumns(20));
6941 verifyFormat("#define A \\\n"
6942 " void f() { int i; }",
6943 getLLVMStyleWithColumns(21));
6944 verifyFormat("#define A \\\n"
6945 " void f() { \\\n"
6946 " int i; \\\n"
6947 " } \\\n"
6948 " int j;",
6949 getLLVMStyleWithColumns(22));
6950 verifyFormat("#define A \\\n"
6951 " void f() { int i; } \\\n"
6952 " int j;",
6953 getLLVMStyleWithColumns(23));
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00006954}
6955
Francois Ferrand2a81ca82017-06-13 07:02:43 +00006956TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) {
6957 FormatStyle MergeEmptyOnly = getLLVMStyle();
6958 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
6959 verifyFormat("class C {\n"
6960 " int f() {}\n"
6961 "};",
6962 MergeEmptyOnly);
6963 verifyFormat("class C {\n"
6964 " int f() {\n"
6965 " return 42;\n"
6966 " }\n"
6967 "};",
6968 MergeEmptyOnly);
6969 verifyFormat("int f() {}", MergeEmptyOnly);
6970 verifyFormat("int f() {\n"
6971 " return 42;\n"
6972 "}",
6973 MergeEmptyOnly);
6974
6975 // Also verify behavior when BraceWrapping.AfterFunction = true
6976 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
6977 MergeEmptyOnly.BraceWrapping.AfterFunction = true;
6978 verifyFormat("int f() {}", MergeEmptyOnly);
6979 verifyFormat("class C {\n"
6980 " int f() {}\n"
6981 "};",
6982 MergeEmptyOnly);
6983}
6984
Daniel Jasperd74cf402014-04-08 12:46:38 +00006985TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) {
6986 FormatStyle MergeInlineOnly = getLLVMStyle();
6987 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
6988 verifyFormat("class C {\n"
6989 " int f() { return 42; }\n"
6990 "};",
6991 MergeInlineOnly);
6992 verifyFormat("int f() {\n"
6993 " return 42;\n"
6994 "}",
6995 MergeInlineOnly);
Francois Ferrand2a81ca82017-06-13 07:02:43 +00006996
6997 // SFS_Inline implies SFS_Empty
6998 verifyFormat("class C {\n"
6999 " int f() {}\n"
7000 "};",
7001 MergeInlineOnly);
7002 verifyFormat("int f() {}", MergeInlineOnly);
7003
7004 // Also verify behavior when BraceWrapping.AfterFunction = true
7005 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
7006 MergeInlineOnly.BraceWrapping.AfterFunction = true;
7007 verifyFormat("class C {\n"
7008 " int f() { return 42; }\n"
7009 "};",
7010 MergeInlineOnly);
7011 verifyFormat("int f()\n"
7012 "{\n"
7013 " return 42;\n"
7014 "}",
7015 MergeInlineOnly);
7016
7017 // SFS_Inline implies SFS_Empty
7018 verifyFormat("int f() {}", MergeInlineOnly);
7019 verifyFormat("class C {\n"
7020 " int f() {}\n"
7021 "};",
7022 MergeInlineOnly);
7023}
7024
Francois Ferrandd3f0e3d2017-06-21 13:56:02 +00007025TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) {
7026 FormatStyle MergeInlineOnly = getLLVMStyle();
7027 MergeInlineOnly.AllowShortFunctionsOnASingleLine =
7028 FormatStyle::SFS_InlineOnly;
7029 verifyFormat("class C {\n"
7030 " int f() { return 42; }\n"
7031 "};",
7032 MergeInlineOnly);
7033 verifyFormat("int f() {\n"
7034 " return 42;\n"
7035 "}",
7036 MergeInlineOnly);
7037
7038 // SFS_InlineOnly does not imply SFS_Empty
7039 verifyFormat("class C {\n"
7040 " int f() {}\n"
7041 "};",
7042 MergeInlineOnly);
7043 verifyFormat("int f() {\n"
7044 "}",
7045 MergeInlineOnly);
7046
7047 // Also verify behavior when BraceWrapping.AfterFunction = true
7048 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
7049 MergeInlineOnly.BraceWrapping.AfterFunction = true;
7050 verifyFormat("class C {\n"
7051 " int f() { return 42; }\n"
7052 "};",
7053 MergeInlineOnly);
7054 verifyFormat("int f()\n"
7055 "{\n"
7056 " return 42;\n"
7057 "}",
7058 MergeInlineOnly);
7059
7060 // SFS_InlineOnly does not imply SFS_Empty
7061 verifyFormat("int f()\n"
7062 "{\n"
7063 "}",
7064 MergeInlineOnly);
7065 verifyFormat("class C {\n"
7066 " int f() {}\n"
7067 "};",
7068 MergeInlineOnly);
7069}
7070
Francois Ferrandad722562017-06-30 20:25:55 +00007071TEST_F(FormatTest, SplitEmptyFunction) {
Francois Ferrand2a81ca82017-06-13 07:02:43 +00007072 FormatStyle Style = getLLVMStyle();
7073 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
7074 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
7075 Style.BraceWrapping.AfterFunction = true;
Francois Ferrandad722562017-06-30 20:25:55 +00007076 Style.BraceWrapping.SplitEmptyFunction = false;
Francois Ferrand2a81ca82017-06-13 07:02:43 +00007077 Style.ColumnLimit = 40;
7078
7079 verifyFormat("int f()\n"
7080 "{}",
7081 Style);
7082 verifyFormat("int f()\n"
7083 "{\n"
7084 " return 42;\n"
7085 "}",
7086 Style);
7087 verifyFormat("int f()\n"
7088 "{\n"
7089 " // some comment\n"
7090 "}",
7091 Style);
7092
7093 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
7094 verifyFormat("int f() {}", Style);
7095 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
7096 "{}",
7097 Style);
7098 verifyFormat("int f()\n"
7099 "{\n"
7100 " return 0;\n"
7101 "}",
7102 Style);
7103
7104 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
7105 verifyFormat("class Foo {\n"
7106 " int f() {}\n"
7107 "};\n",
7108 Style);
7109 verifyFormat("class Foo {\n"
7110 " int f() { return 0; }\n"
7111 "};\n",
7112 Style);
7113 verifyFormat("class Foo {\n"
7114 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
7115 " {}\n"
7116 "};\n",
7117 Style);
7118 verifyFormat("class Foo {\n"
7119 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
7120 " {\n"
7121 " return 0;\n"
7122 " }\n"
7123 "};\n",
7124 Style);
7125
7126 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
7127 verifyFormat("int f() {}", Style);
7128 verifyFormat("int f() { return 0; }", Style);
7129 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
7130 "{}",
7131 Style);
7132 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
7133 "{\n"
7134 " return 0;\n"
7135 "}",
7136 Style);
Daniel Jasperd74cf402014-04-08 12:46:38 +00007137}
Krasimir Georgiev6a1c9d52017-10-02 15:53:37 +00007138TEST_F(FormatTest, KeepShortFunctionAfterPPElse) {
7139 FormatStyle Style = getLLVMStyle();
7140 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
7141 verifyFormat("#ifdef A\n"
7142 "int f() {}\n"
7143 "#else\n"
7144 "int g() {}\n"
7145 "#endif",
7146 Style);
7147}
Daniel Jasperd74cf402014-04-08 12:46:38 +00007148
Francois Ferrandad722562017-06-30 20:25:55 +00007149TEST_F(FormatTest, SplitEmptyClass) {
7150 FormatStyle Style = getLLVMStyle();
7151 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
7152 Style.BraceWrapping.AfterClass = true;
7153 Style.BraceWrapping.SplitEmptyRecord = false;
7154
7155 verifyFormat("class Foo\n"
7156 "{};",
7157 Style);
7158 verifyFormat("/* something */ class Foo\n"
7159 "{};",
7160 Style);
7161 verifyFormat("template <typename X> class Foo\n"
7162 "{};",
7163 Style);
7164 verifyFormat("class Foo\n"
7165 "{\n"
7166 " Foo();\n"
7167 "};",
7168 Style);
7169 verifyFormat("typedef class Foo\n"
7170 "{\n"
7171 "} Foo_t;",
7172 Style);
7173}
7174
7175TEST_F(FormatTest, SplitEmptyStruct) {
7176 FormatStyle Style = getLLVMStyle();
7177 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
7178 Style.BraceWrapping.AfterStruct = true;
7179 Style.BraceWrapping.SplitEmptyRecord = false;
7180
7181 verifyFormat("struct Foo\n"
7182 "{};",
7183 Style);
7184 verifyFormat("/* something */ struct Foo\n"
7185 "{};",
7186 Style);
7187 verifyFormat("template <typename X> struct Foo\n"
7188 "{};",
7189 Style);
7190 verifyFormat("struct Foo\n"
7191 "{\n"
7192 " Foo();\n"
7193 "};",
7194 Style);
7195 verifyFormat("typedef struct Foo\n"
7196 "{\n"
7197 "} Foo_t;",
7198 Style);
7199 //typedef struct Bar {} Bar_t;
7200}
7201
7202TEST_F(FormatTest, SplitEmptyUnion) {
7203 FormatStyle Style = getLLVMStyle();
7204 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
7205 Style.BraceWrapping.AfterUnion = true;
7206 Style.BraceWrapping.SplitEmptyRecord = false;
7207
7208 verifyFormat("union Foo\n"
7209 "{};",
7210 Style);
7211 verifyFormat("/* something */ union Foo\n"
7212 "{};",
7213 Style);
7214 verifyFormat("union Foo\n"
7215 "{\n"
7216 " A,\n"
7217 "};",
7218 Style);
7219 verifyFormat("typedef union Foo\n"
7220 "{\n"
7221 "} Foo_t;",
7222 Style);
7223}
7224
7225TEST_F(FormatTest, SplitEmptyNamespace) {
7226 FormatStyle Style = getLLVMStyle();
7227 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
7228 Style.BraceWrapping.AfterNamespace = true;
7229 Style.BraceWrapping.SplitEmptyNamespace = false;
7230
7231 verifyFormat("namespace Foo\n"
7232 "{};",
7233 Style);
7234 verifyFormat("/* something */ namespace Foo\n"
7235 "{};",
7236 Style);
7237 verifyFormat("inline namespace Foo\n"
7238 "{};",
7239 Style);
7240 verifyFormat("namespace Foo\n"
7241 "{\n"
7242 "void Bar();\n"
7243 "};",
7244 Style);
7245}
7246
7247TEST_F(FormatTest, NeverMergeShortRecords) {
7248 FormatStyle Style = getLLVMStyle();
7249
7250 verifyFormat("class Foo {\n"
7251 " Foo();\n"
7252 "};",
7253 Style);
7254 verifyFormat("typedef class Foo {\n"
7255 " Foo();\n"
7256 "} Foo_t;",
7257 Style);
7258 verifyFormat("struct Foo {\n"
7259 " Foo();\n"
7260 "};",
7261 Style);
7262 verifyFormat("typedef struct Foo {\n"
7263 " Foo();\n"
7264 "} Foo_t;",
7265 Style);
7266 verifyFormat("union Foo {\n"
7267 " A,\n"
7268 "};",
7269 Style);
7270 verifyFormat("typedef union Foo {\n"
7271 " A,\n"
7272 "} Foo_t;",
7273 Style);
7274 verifyFormat("namespace Foo {\n"
7275 "void Bar();\n"
7276 "};",
7277 Style);
7278
7279 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
7280 Style.BraceWrapping.AfterClass = true;
7281 Style.BraceWrapping.AfterStruct = true;
7282 Style.BraceWrapping.AfterUnion = true;
7283 Style.BraceWrapping.AfterNamespace = true;
7284 verifyFormat("class Foo\n"
7285 "{\n"
7286 " Foo();\n"
7287 "};",
7288 Style);
7289 verifyFormat("typedef class Foo\n"
7290 "{\n"
7291 " Foo();\n"
7292 "} Foo_t;",
7293 Style);
7294 verifyFormat("struct Foo\n"
7295 "{\n"
7296 " Foo();\n"
7297 "};",
7298 Style);
7299 verifyFormat("typedef struct Foo\n"
7300 "{\n"
7301 " Foo();\n"
7302 "} Foo_t;",
7303 Style);
7304 verifyFormat("union Foo\n"
7305 "{\n"
7306 " A,\n"
7307 "};",
7308 Style);
7309 verifyFormat("typedef union Foo\n"
7310 "{\n"
7311 " A,\n"
7312 "} Foo_t;",
7313 Style);
7314 verifyFormat("namespace Foo\n"
7315 "{\n"
7316 "void Bar();\n"
7317 "};",
7318 Style);
7319}
7320
Manuel Klimeke01bab52013-01-15 13:38:33 +00007321TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
7322 // Elaborate type variable declarations.
Chandler Carruthf8b72662014-03-02 12:37:31 +00007323 verifyFormat("struct foo a = {bar};\nint n;");
7324 verifyFormat("class foo a = {bar};\nint n;");
7325 verifyFormat("union foo a = {bar};\nint n;");
Manuel Klimeke01bab52013-01-15 13:38:33 +00007326
7327 // Elaborate types inside function definitions.
7328 verifyFormat("struct foo f() {}\nint n;");
7329 verifyFormat("class foo f() {}\nint n;");
7330 verifyFormat("union foo f() {}\nint n;");
7331
7332 // Templates.
7333 verifyFormat("template <class X> void f() {}\nint n;");
7334 verifyFormat("template <struct X> void f() {}\nint n;");
7335 verifyFormat("template <union X> void f() {}\nint n;");
7336
7337 // Actual definitions...
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00007338 verifyFormat("struct {\n} n;");
7339 verifyFormat(
7340 "template <template <class T, class Y>, class Z> class X {\n} n;");
Manuel Klimeke01bab52013-01-15 13:38:33 +00007341 verifyFormat("union Z {\n int n;\n} x;");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00007342 verifyFormat("class MACRO Z {\n} n;");
7343 verifyFormat("class MACRO(X) Z {\n} n;");
7344 verifyFormat("class __attribute__(X) Z {\n} n;");
7345 verifyFormat("class __declspec(X) Z {\n} n;");
Manuel Klimekd2650902013-02-06 15:57:54 +00007346 verifyFormat("class A##B##C {\n} n;");
Manuel Klimek91e48582013-10-07 09:15:41 +00007347 verifyFormat("class alignas(16) Z {\n} n;");
Daniel Jasper04785d02015-05-06 14:03:02 +00007348 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;");
7349 verifyFormat("class MACROA MACRO(X) Z {\n} n;");
Manuel Klimeke01bab52013-01-15 13:38:33 +00007350
Manuel Klimek3c6b7c72013-01-21 10:17:14 +00007351 // Redefinition from nested context:
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00007352 verifyFormat("class A::B::C {\n} n;");
Manuel Klimek3c6b7c72013-01-21 10:17:14 +00007353
Manuel Klimekcdee74d2013-01-21 13:58:54 +00007354 // Template definitions.
Daniel Jasper6f05e592013-05-15 13:46:48 +00007355 verifyFormat(
7356 "template <typename F>\n"
7357 "Matcher(const Matcher<F> &Other,\n"
7358 " typename enable_if_c<is_base_of<F, T>::value &&\n"
7359 " !is_same<F, T>::value>::type * = 0)\n"
7360 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
7361
Manuel Klimekcdee74d2013-01-21 13:58:54 +00007362 // FIXME: This is still incorrectly handled at the formatter side.
Daniel Jasper62c0ac02013-07-30 22:37:19 +00007363 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
Daniel Jasper6f2b88a2015-06-05 13:18:09 +00007364 verifyFormat("int i = SomeFunction(a<b, a> b);");
Manuel Klimekcdee74d2013-01-21 13:58:54 +00007365
7366 // FIXME:
7367 // This now gets parsed incorrectly as class definition.
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00007368 // verifyFormat("class A<int> f() {\n}\nint n;");
Manuel Klimekcdee74d2013-01-21 13:58:54 +00007369
Manuel Klimeke01bab52013-01-15 13:38:33 +00007370 // Elaborate types where incorrectly parsing the structural element would
7371 // break the indent.
7372 verifyFormat("if (true)\n"
7373 " class X x;\n"
7374 "else\n"
7375 " f();\n");
Daniel Jasper1a32a612013-03-20 15:12:38 +00007376
7377 // This is simply incomplete. Formatting is not important, but must not crash.
Daniel Jaspercdaffa42013-08-13 10:58:30 +00007378 verifyFormat("class A:");
Manuel Klimekd5e5f8f2013-01-11 18:13:04 +00007379}
7380
Manuel Klimek99c7baa2013-01-15 15:50:27 +00007381TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
Manuel Klimek71814b42013-10-11 21:25:45 +00007382 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n",
7383 format("#error Leave all white!!!!! space* alone!\n"));
7384 EXPECT_EQ(
7385 "#warning Leave all white!!!!! space* alone!\n",
7386 format("#warning Leave all white!!!!! space* alone!\n"));
Manuel Klimek99c7baa2013-01-15 15:50:27 +00007387 EXPECT_EQ("#error 1", format(" # error 1"));
7388 EXPECT_EQ("#warning 1", format(" # warning 1"));
7389}
7390
Daniel Jasper4431aa92013-04-23 13:54:04 +00007391TEST_F(FormatTest, FormatHashIfExpressions) {
Daniel Jasper7cfde412014-01-21 08:56:09 +00007392 verifyFormat("#if AAAA && BBBB");
Daniel Jasperd7884572015-08-14 12:44:06 +00007393 verifyFormat("#if (AAAA && BBBB)");
7394 verifyFormat("#elif (AAAA && BBBB)");
Daniel Jasper4431aa92013-04-23 13:54:04 +00007395 // FIXME: Come up with a better indentation for #elif.
7396 verifyFormat(
7397 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n"
7398 " defined(BBBBBBBB)\n"
7399 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n"
7400 " defined(BBBBBBBB)\n"
7401 "#endif",
7402 getLLVMStyleWithColumns(65));
7403}
7404
Manuel Klimekd3b92fa2013-01-18 14:04:34 +00007405TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
7406 FormatStyle AllowsMergedIf = getGoogleStyle();
7407 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true;
7408 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
7409 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
Manuel Klimekda087612013-01-18 14:46:43 +00007410 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf);
7411 EXPECT_EQ("if (true) return 42;",
7412 format("if (true)\nreturn 42;", AllowsMergedIf));
7413 FormatStyle ShortMergedIf = AllowsMergedIf;
7414 ShortMergedIf.ColumnLimit = 25;
Daniel Jasper6fe2f002013-04-25 08:56:26 +00007415 verifyFormat("#define A \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00007416 " if (true) return 42;",
7417 ShortMergedIf);
Daniel Jasper6fe2f002013-04-25 08:56:26 +00007418 verifyFormat("#define A \\\n"
7419 " f(); \\\n"
Manuel Klimekda087612013-01-18 14:46:43 +00007420 " if (true)\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00007421 "#define B",
7422 ShortMergedIf);
Daniel Jasper6fe2f002013-04-25 08:56:26 +00007423 verifyFormat("#define A \\\n"
7424 " f(); \\\n"
Manuel Klimekda087612013-01-18 14:46:43 +00007425 " if (true)\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00007426 "g();",
7427 ShortMergedIf);
Manuel Klimekd5e782b2013-01-21 14:16:56 +00007428 verifyFormat("{\n"
7429 "#ifdef A\n"
7430 " // Comment\n"
7431 " if (true) continue;\n"
7432 "#endif\n"
7433 " // Comment\n"
Manuel Klimek71814b42013-10-11 21:25:45 +00007434 " if (true) continue;\n"
7435 "}",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00007436 ShortMergedIf);
Daniel Jasper6a7d5a72017-06-19 07:40:49 +00007437 ShortMergedIf.ColumnLimit = 33;
7438 verifyFormat("#define A \\\n"
7439 " if constexpr (true) return 42;",
7440 ShortMergedIf);
Daniel Jasper64989962014-02-07 13:45:27 +00007441 ShortMergedIf.ColumnLimit = 29;
7442 verifyFormat("#define A \\\n"
7443 " if (aaaaaaaaaa) return 1; \\\n"
7444 " return 2;",
7445 ShortMergedIf);
7446 ShortMergedIf.ColumnLimit = 28;
7447 verifyFormat("#define A \\\n"
7448 " if (aaaaaaaaaa) \\\n"
7449 " return 1; \\\n"
7450 " return 2;",
7451 ShortMergedIf);
Daniel Jasper6a7d5a72017-06-19 07:40:49 +00007452 verifyFormat("#define A \\\n"
7453 " if constexpr (aaaaaaa) \\\n"
7454 " return 1; \\\n"
7455 " return 2;",
7456 ShortMergedIf);
Manuel Klimekd3b92fa2013-01-18 14:04:34 +00007457}
7458
Manuel Klimekd33516e2013-01-23 10:09:28 +00007459TEST_F(FormatTest, FormatStarDependingOnContext) {
Manuel Klimek0a3a3c92013-01-23 09:32:48 +00007460 verifyFormat("void f(int *a);");
7461 verifyFormat("void f() { f(fint * b); }");
Manuel Klimek39080572013-01-23 11:03:04 +00007462 verifyFormat("class A {\n void f(int *a);\n};");
7463 verifyFormat("class A {\n int *a;\n};");
7464 verifyFormat("namespace a {\n"
7465 "namespace b {\n"
7466 "class A {\n"
7467 " void f() {}\n"
7468 " int *a;\n"
7469 "};\n"
Krasimir Georgiev9163fe22017-03-02 09:54:44 +00007470 "} // namespace b\n"
7471 "} // namespace a");
Manuel Klimek0a3a3c92013-01-23 09:32:48 +00007472}
7473
Manuel Klimekd33516e2013-01-23 10:09:28 +00007474TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
7475 verifyFormat("while");
7476 verifyFormat("operator");
7477}
7478
Daniel Jasperfda47cd2016-10-31 13:23:00 +00007479TEST_F(FormatTest, SkipsDeeplyNestedLines) {
7480 // This code would be painfully slow to format if we didn't skip it.
7481 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
7482 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
7483 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
7484 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
7485 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
7486 "A(1, 1)\n"
7487 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x
7488 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7489 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7490 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7491 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7492 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7493 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7494 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7495 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
7496 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n");
7497 // Deeply nested part is untouched, rest is formatted.
7498 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n",
7499 format(std::string("int i;\n") + Code + "int j;\n",
Krasimir Georgievbcda54b2017-04-21 14:35:20 +00007500 getLLVMStyle(), SC_ExpectIncomplete));
Daniel Jasperfda47cd2016-10-31 13:23:00 +00007501}
7502
Nico Weber7e6a7a12013-01-08 17:56:31 +00007503//===----------------------------------------------------------------------===//
7504// Objective-C tests.
7505//===----------------------------------------------------------------------===//
7506
Fariborz Jahanian68a542a2012-12-20 19:54:13 +00007507TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
7508 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
7509 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
7510 format("-(NSUInteger)indexOfObject:(id)anObject;"));
Daniel Jasper8d1832e2013-01-07 13:26:07 +00007511 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
Fariborz Jahanian68a542a2012-12-20 19:54:13 +00007512 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
7513 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
7514 format("-(NSInteger)Method3:(id)anObject;"));
7515 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
7516 format("-(NSInteger)Method4:(id)anObject;"));
7517 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
7518 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
7519 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
7520 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
Daniel Jaspera44991332015-04-29 13:06:49 +00007521 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "
7522 "forAllCells:(BOOL)flag;",
7523 format("- (void)sendAction:(SEL)aSelector to:(id)anObject "
7524 "forAllCells:(BOOL)flag;"));
Fariborz Jahanian9017ec32012-12-21 22:51:18 +00007525
7526 // Very long objectiveC method declaration.
Daniel Jasper55ca6082015-03-12 22:13:45 +00007527 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
7528 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;");
Daniel Jasper1ac3e052013-02-05 10:07:47 +00007529 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
7530 " inRange:(NSRange)range\n"
7531 " outRange:(NSRange)out_range\n"
7532 " outRange1:(NSRange)out_range1\n"
7533 " outRange2:(NSRange)out_range2\n"
7534 " outRange3:(NSRange)out_range3\n"
7535 " outRange4:(NSRange)out_range4\n"
7536 " outRange5:(NSRange)out_range5\n"
7537 " outRange6:(NSRange)out_range6\n"
7538 " outRange7:(NSRange)out_range7\n"
7539 " outRange8:(NSRange)out_range8\n"
7540 " outRange9:(NSRange)out_range9;");
Nico Weberd6f962f2013-01-10 20:18:33 +00007541
Daniel Jaspera2a4d9c2015-05-13 09:38:25 +00007542 // When the function name has to be wrapped.
7543 FormatStyle Style = getLLVMStyle();
7544 Style.IndentWrappedFunctionNames = false;
7545 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
7546 "veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
7547 " anotherName:(NSString)bbbbbbbbbbbbbb {\n"
7548 "}",
7549 Style);
7550 Style.IndentWrappedFunctionNames = true;
7551 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
7552 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
7553 " anotherName:(NSString)bbbbbbbbbbbbbb {\n"
7554 "}",
7555 Style);
7556
Nico Weberd6f962f2013-01-10 20:18:33 +00007557 verifyFormat("- (int)sum:(vector<int>)numbers;");
Nico Weber772fbfd2013-01-17 06:14:50 +00007558 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
Nico Weberd6f962f2013-01-10 20:18:33 +00007559 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
7560 // protocol lists (but not for template classes):
Daniel Jaspera44991332015-04-29 13:06:49 +00007561 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
Nico Weber9efe2912013-01-10 23:11:41 +00007562
Daniel Jasper37194282013-05-28 08:33:00 +00007563 verifyFormat("- (int (*)())foo:(int (*)())f;");
7564 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
Nico Weber9efe2912013-01-10 23:11:41 +00007565
7566 // If there's no return type (very rare in practice!), LLVM and Google style
7567 // agree.
Daniel Jasperdd9276e2013-03-22 16:55:40 +00007568 verifyFormat("- foo;");
Nico Weber9efe2912013-01-10 23:11:41 +00007569 verifyFormat("- foo:(int)f;");
7570 verifyGoogleFormat("- foo:(int)foo;");
Fariborz Jahanian68a542a2012-12-20 19:54:13 +00007571}
7572
Nico Weber0588b502013-02-07 00:19:29 +00007573
Alexander Kornienko64a42b82014-04-15 14:52:43 +00007574TEST_F(FormatTest, BreaksStringLiterals) {
Manuel Klimek1998ea22013-02-20 10:15:13 +00007575 EXPECT_EQ("\"some text \"\n"
7576 "\"other\";",
7577 format("\"some text other\";", getLLVMStyleWithColumns(12)));
Alexander Kornienko9e90b622013-04-17 17:34:05 +00007578 EXPECT_EQ("\"some text \"\n"
7579 "\"other\";",
7580 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
Manuel Klimek1998ea22013-02-20 10:15:13 +00007581 EXPECT_EQ(
7582 "#define A \\\n"
7583 " \"some \" \\\n"
7584 " \"text \" \\\n"
7585 " \"other\";",
7586 format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
7587 EXPECT_EQ(
7588 "#define A \\\n"
7589 " \"so \" \\\n"
7590 " \"text \" \\\n"
7591 " \"other\";",
7592 format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
7593
7594 EXPECT_EQ("\"some text\"",
7595 format("\"some text\"", getLLVMStyleWithColumns(1)));
7596 EXPECT_EQ("\"some text\"",
7597 format("\"some text\"", getLLVMStyleWithColumns(11)));
7598 EXPECT_EQ("\"some \"\n"
7599 "\"text\"",
7600 format("\"some text\"", getLLVMStyleWithColumns(10)));
7601 EXPECT_EQ("\"some \"\n"
7602 "\"text\"",
7603 format("\"some text\"", getLLVMStyleWithColumns(7)));
Manuel Klimekb176cff2013-03-01 13:14:08 +00007604 EXPECT_EQ("\"some\"\n"
Alexander Kornienkocb45bc12013-04-15 14:28:00 +00007605 "\" tex\"\n"
7606 "\"t\"",
Manuel Klimek1998ea22013-02-20 10:15:13 +00007607 format("\"some text\"", getLLVMStyleWithColumns(6)));
Manuel Klimekabf6e032013-03-04 20:03:38 +00007608 EXPECT_EQ("\"some\"\n"
7609 "\" tex\"\n"
7610 "\" and\"",
7611 format("\"some tex and\"", getLLVMStyleWithColumns(6)));
7612 EXPECT_EQ("\"some\"\n"
7613 "\"/tex\"\n"
7614 "\"/and\"",
7615 format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
Manuel Klimek1998ea22013-02-20 10:15:13 +00007616
7617 EXPECT_EQ("variable =\n"
7618 " \"long string \"\n"
7619 " \"literal\";",
7620 format("variable = \"long string literal\";",
7621 getLLVMStyleWithColumns(20)));
7622
7623 EXPECT_EQ("variable = f(\n"
7624 " \"long string \"\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00007625 " \"literal\",\n"
7626 " short,\n"
Manuel Klimek1998ea22013-02-20 10:15:13 +00007627 " loooooooooooooooooooong);",
7628 format("variable = f(\"long string literal\", short, "
7629 "loooooooooooooooooooong);",
7630 getLLVMStyleWithColumns(20)));
Alexander Kornienko4d26b6e2013-06-17 12:59:44 +00007631
Daniel Jaspera44991332015-04-29 13:06:49 +00007632 EXPECT_EQ(
7633 "f(g(\"long string \"\n"
7634 " \"literal\"),\n"
7635 " b);",
7636 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20)));
Alexander Kornienko4d26b6e2013-06-17 12:59:44 +00007637 EXPECT_EQ("f(g(\"long string \"\n"
7638 " \"literal\",\n"
7639 " a),\n"
7640 " b);",
7641 format("f(g(\"long string literal\", a), b);",
7642 getLLVMStyleWithColumns(20)));
Manuel Klimek1998ea22013-02-20 10:15:13 +00007643 EXPECT_EQ(
7644 "f(\"one two\".split(\n"
Daniel Jasperf79b0b12013-08-30 08:29:25 +00007645 " variable));",
Manuel Klimek1998ea22013-02-20 10:15:13 +00007646 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
7647 EXPECT_EQ("f(\"one two three four five six \"\n"
7648 " \"seven\".split(\n"
7649 " really_looooong_variable));",
7650 format("f(\"one two three four five six seven\"."
7651 "split(really_looooong_variable));",
7652 getLLVMStyleWithColumns(33)));
7653
7654 EXPECT_EQ("f(\"some \"\n"
7655 " \"text\",\n"
7656 " other);",
7657 format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
Daniel Jasper5497fce2013-02-26 12:52:34 +00007658
7659 // Only break as a last resort.
7660 verifyFormat(
7661 "aaaaaaaaaaaaaaaaaaaa(\n"
7662 " aaaaaaaaaaaaaaaaaaaa,\n"
7663 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
Manuel Klimekb176cff2013-03-01 13:14:08 +00007664
Daniel Jaspera44991332015-04-29 13:06:49 +00007665 EXPECT_EQ("\"splitmea\"\n"
7666 "\"trandomp\"\n"
7667 "\"oint\"",
7668 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
Manuel Klimeke317d1b2013-03-01 13:29:19 +00007669
Daniel Jaspera44991332015-04-29 13:06:49 +00007670 EXPECT_EQ("\"split/\"\n"
7671 "\"pathat/\"\n"
7672 "\"slashes\"",
7673 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
Daniel Jasper6fe2f002013-04-25 08:56:26 +00007674
Daniel Jaspera44991332015-04-29 13:06:49 +00007675 EXPECT_EQ("\"split/\"\n"
7676 "\"pathat/\"\n"
7677 "\"slashes\"",
7678 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
Alexander Kornienko72852072013-06-19 14:22:47 +00007679 EXPECT_EQ("\"split at \"\n"
7680 "\"spaces/at/\"\n"
7681 "\"slashes.at.any$\"\n"
7682 "\"non-alphanumeric%\"\n"
7683 "\"1111111111characte\"\n"
7684 "\"rs\"",
7685 format("\"split at "
7686 "spaces/at/"
7687 "slashes.at."
7688 "any$non-"
7689 "alphanumeric%"
7690 "1111111111characte"
7691 "rs\"",
7692 getLLVMStyleWithColumns(20)));
7693
Daniel Jasper5aad4e52013-07-12 11:37:05 +00007694 // Verify that splitting the strings understands
7695 // Style::AlwaysBreakBeforeMultilineStrings.
Daniel Jasper2aaedd32015-06-18 09:12:47 +00007696 EXPECT_EQ(
7697 "aaaaaaaaaaaa(\n"
7698 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
7699 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
7700 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
7701 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
7702 "aaaaaaaaaaaaaaaaaaaaaa\");",
7703 getGoogleStyle()));
Daniel Jasper2436fe92013-10-18 16:47:55 +00007704 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
7705 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",
7706 format("return \"aaaaaaaaaaaaaaaaaaaaaa "
7707 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
7708 "aaaaaaaaaaaaaaaaaaaaaa\";",
7709 getGoogleStyle()));
Daniel Jasper3dcd7ec2013-08-02 11:01:15 +00007710 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
7711 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
7712 format("llvm::outs() << "
7713 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
7714 "aaaaaaaaaaaaaaaaaaa\";"));
Daniel Jasperf438cb72013-08-23 11:57:34 +00007715 EXPECT_EQ("ffff(\n"
7716 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
7717 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
7718 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
7719 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
7720 getGoogleStyle()));
Daniel Jasper5aad4e52013-07-12 11:37:05 +00007721
Daniel Jaspere1a7b762016-02-01 11:21:02 +00007722 FormatStyle Style = getLLVMStyleWithColumns(12);
7723 Style.BreakStringLiterals = false;
7724 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style));
7725
Daniel Jasper6fe2f002013-04-25 08:56:26 +00007726 FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +00007727 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
Daniel Jaspera44991332015-04-29 13:06:49 +00007728 EXPECT_EQ("#define A \\\n"
7729 " \"some \" \\\n"
7730 " \"text \" \\\n"
7731 " \"other\";",
7732 format("#define A \"some text other\";", AlignLeft));
Manuel Klimek1998ea22013-02-20 10:15:13 +00007733}
7734
Manuel Klimek93699f42017-11-29 14:29:43 +00007735TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) {
7736 EXPECT_EQ("C a = \"some more \"\n"
7737 " \"text\";",
7738 format("C a = \"some more text\";", getLLVMStyleWithColumns(18)));
7739}
7740
Manuel Klimek9e321992015-07-28 15:50:24 +00007741TEST_F(FormatTest, FullyRemoveEmptyLines) {
7742 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80);
7743 NoEmptyLines.MaxEmptyLinesToKeep = 0;
7744 EXPECT_EQ("int i = a(b());",
7745 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines));
7746}
7747
Alexander Kornienko64a42b82014-04-15 14:52:43 +00007748TEST_F(FormatTest, BreaksStringLiteralsWithTabs) {
7749 EXPECT_EQ(
7750 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
7751 "(\n"
7752 " \"x\t\");",
7753 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
7754 "aaaaaaa("
7755 "\"x\t\");"));
7756}
7757
Daniel Jasper174b0122014-01-09 14:18:12 +00007758TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {
Alexander Kornienko81e32942013-09-16 20:20:49 +00007759 EXPECT_EQ(
7760 "u8\"utf8 string \"\n"
7761 "u8\"literal\";",
7762 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
7763 EXPECT_EQ(
7764 "u\"utf16 string \"\n"
7765 "u\"literal\";",
7766 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
7767 EXPECT_EQ(
7768 "U\"utf32 string \"\n"
7769 "U\"literal\";",
7770 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
7771 EXPECT_EQ("L\"wide string \"\n"
7772 "L\"literal\";",
7773 format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
Daniel Jasper174b0122014-01-09 14:18:12 +00007774 EXPECT_EQ("@\"NSString \"\n"
7775 "@\"literal\";",
Daniel Jasperd07c2ee2014-01-14 09:53:07 +00007776 format("@\"NSString literal\";", getGoogleStyleWithColumns(19)));
Alexander Kornienkod4fa2e62017-04-11 09:55:00 +00007777 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26));
Daniel Jaspere4b48c62015-01-21 19:50:35 +00007778
7779 // This input makes clang-format try to split the incomplete unicode escape
7780 // sequence, which used to lead to a crasher.
7781 verifyNoCrash(
7782 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
7783 getLLVMStyleWithColumns(60));
Alexander Kornienko81e32942013-09-16 20:20:49 +00007784}
7785
Alexander Kornienko732b6bd2014-12-14 20:47:11 +00007786TEST_F(FormatTest, DoesNotBreakRawStringLiterals) {
7787 FormatStyle Style = getGoogleStyleWithColumns(15);
7788 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style));
7789 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style));
7790 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style));
7791 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style));
7792 EXPECT_EQ("u8R\"x(raw literal)x\";",
7793 format("u8R\"x(raw literal)x\";", Style));
Alexander Kornienko81e32942013-09-16 20:20:49 +00007794}
7795
7796TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
7797 FormatStyle Style = getLLVMStyleWithColumns(20);
7798 EXPECT_EQ(
7799 "_T(\"aaaaaaaaaaaaaa\")\n"
7800 "_T(\"aaaaaaaaaaaaaa\")\n"
7801 "_T(\"aaaaaaaaaaaa\")",
7802 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
Krasimir Georgievbc05eba2017-03-08 12:54:50 +00007803 EXPECT_EQ("f(x,\n"
7804 " _T(\"aaaaaaaaaaaa\")\n"
7805 " _T(\"aaa\"),\n"
Alexander Kornienko81e32942013-09-16 20:20:49 +00007806 " z);",
7807 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
7808
7809 // FIXME: Handle embedded spaces in one iteration.
7810 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
7811 // "_T(\"aaaaaaaaaaaaa\")\n"
7812 // "_T(\"aaaaaaaaaaaaa\")\n"
7813 // "_T(\"a\")",
7814 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
7815 // getLLVMStyleWithColumns(20)));
7816 EXPECT_EQ(
7817 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
7818 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
Daniel Jaspere99c72f2015-03-26 14:47:35 +00007819 EXPECT_EQ("f(\n"
7820 "#if !TEST\n"
7821 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
7822 "#endif\n"
Martin Probst2c1cdae2017-05-15 11:15:29 +00007823 ");",
Daniel Jaspere99c72f2015-03-26 14:47:35 +00007824 format("f(\n"
7825 "#if !TEST\n"
7826 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
7827 "#endif\n"
7828 ");"));
7829 EXPECT_EQ("f(\n"
7830 "\n"
7831 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));",
7832 format("f(\n"
7833 "\n"
7834 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));"));
Alexander Kornienko81e32942013-09-16 20:20:49 +00007835}
7836
Krasimir Georgievbc05eba2017-03-08 12:54:50 +00007837TEST_F(FormatTest, BreaksStringLiteralOperands) {
7838 // In a function call with two operands, the second can be broken with no line
7839 // break before it.
7840 EXPECT_EQ("func(a, \"long long \"\n"
7841 " \"long long\");",
7842 format("func(a, \"long long long long\");",
7843 getLLVMStyleWithColumns(24)));
7844 // In a function call with three operands, the second must be broken with a
7845 // line break before it.
7846 EXPECT_EQ("func(a,\n"
7847 " \"long long long \"\n"
7848 " \"long\",\n"
7849 " c);",
7850 format("func(a, \"long long long long\", c);",
7851 getLLVMStyleWithColumns(24)));
7852 // In a function call with three operands, the third must be broken with a
7853 // line break before it.
7854 EXPECT_EQ("func(a, b,\n"
7855 " \"long long long \"\n"
7856 " \"long\");",
7857 format("func(a, b, \"long long long long\");",
7858 getLLVMStyleWithColumns(24)));
7859 // In a function call with three operands, both the second and the third must
7860 // be broken with a line break before them.
7861 EXPECT_EQ("func(a,\n"
7862 " \"long long long \"\n"
7863 " \"long\",\n"
7864 " \"long long long \"\n"
7865 " \"long\");",
7866 format("func(a, \"long long long long\", \"long long long long\");",
7867 getLLVMStyleWithColumns(24)));
7868 // In a chain of << with two operands, the second can be broken with no line
7869 // break before it.
7870 EXPECT_EQ("a << \"line line \"\n"
7871 " \"line\";",
7872 format("a << \"line line line\";",
7873 getLLVMStyleWithColumns(20)));
7874 // In a chain of << with three operands, the second can be broken with no line
7875 // break before it.
7876 EXPECT_EQ("abcde << \"line \"\n"
7877 " \"line line\"\n"
7878 " << c;",
7879 format("abcde << \"line line line\" << c;",
7880 getLLVMStyleWithColumns(20)));
7881 // In a chain of << with three operands, the third must be broken with a line
7882 // break before it.
7883 EXPECT_EQ("a << b\n"
7884 " << \"line line \"\n"
7885 " \"line\";",
7886 format("a << b << \"line line line\";",
7887 getLLVMStyleWithColumns(20)));
7888 // In a chain of << with three operands, the second can be broken with no line
7889 // break before it and the third must be broken with a line break before it.
7890 EXPECT_EQ("abcd << \"line line \"\n"
7891 " \"line\"\n"
7892 " << \"line line \"\n"
7893 " \"line\";",
7894 format("abcd << \"line line line\" << \"line line line\";",
7895 getLLVMStyleWithColumns(20)));
7896 // In a chain of binary operators with two operands, the second can be broken
7897 // with no line break before it.
7898 EXPECT_EQ("abcd + \"line line \"\n"
7899 " \"line line\";",
7900 format("abcd + \"line line line line\";",
7901 getLLVMStyleWithColumns(20)));
7902 // In a chain of binary operators with three operands, the second must be
7903 // broken with a line break before it.
7904 EXPECT_EQ("abcd +\n"
7905 " \"line line \"\n"
7906 " \"line line\" +\n"
7907 " e;",
7908 format("abcd + \"line line line line\" + e;",
7909 getLLVMStyleWithColumns(20)));
7910 // In a function call with two operands, with AlignAfterOpenBracket enabled,
7911 // the first must be broken with a line break before it.
7912 FormatStyle Style = getLLVMStyleWithColumns(25);
7913 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7914 EXPECT_EQ("someFunction(\n"
7915 " \"long long long \"\n"
7916 " \"long\",\n"
7917 " a);",
7918 format("someFunction(\"long long long long\", a);", Style));
7919}
7920
Alexander Kornienko657c67b2013-07-16 21:06:13 +00007921TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
Alexander Kornienkod7b837e2013-08-29 17:32:57 +00007922 EXPECT_EQ(
7923 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
7924 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
7925 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
7926 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
7927 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
7928 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
7929}
7930
7931TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
7932 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
Daniel Jasperc39b56f2013-12-16 07:23:08 +00007933 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle()));
Alexander Kornienkod7b837e2013-08-29 17:32:57 +00007934 EXPECT_EQ("fffffffffff(g(R\"x(\n"
7935 "multiline raw string literal xxxxxxxxxxxxxx\n"
7936 ")x\",\n"
7937 " a),\n"
7938 " b);",
7939 format("fffffffffff(g(R\"x(\n"
7940 "multiline raw string literal xxxxxxxxxxxxxx\n"
7941 ")x\", a), b);",
7942 getGoogleStyleWithColumns(20)));
7943 EXPECT_EQ("fffffffffff(\n"
7944 " g(R\"x(qqq\n"
7945 "multiline raw string literal xxxxxxxxxxxxxx\n"
7946 ")x\",\n"
7947 " a),\n"
7948 " b);",
7949 format("fffffffffff(g(R\"x(qqq\n"
7950 "multiline raw string literal xxxxxxxxxxxxxx\n"
7951 ")x\", a), b);",
7952 getGoogleStyleWithColumns(20)));
7953
7954 EXPECT_EQ("fffffffffff(R\"x(\n"
7955 "multiline raw string literal xxxxxxxxxxxxxx\n"
7956 ")x\");",
7957 format("fffffffffff(R\"x(\n"
7958 "multiline raw string literal xxxxxxxxxxxxxx\n"
7959 ")x\");",
7960 getGoogleStyleWithColumns(20)));
7961 EXPECT_EQ("fffffffffff(R\"x(\n"
7962 "multiline raw string literal xxxxxxxxxxxxxx\n"
Daniel Jasper5d2587d2014-03-27 16:14:13 +00007963 ")x\" + bbbbbb);",
Alexander Kornienkod7b837e2013-08-29 17:32:57 +00007964 format("fffffffffff(R\"x(\n"
7965 "multiline raw string literal xxxxxxxxxxxxxx\n"
Daniel Jasper5d2587d2014-03-27 16:14:13 +00007966 ")x\" + bbbbbb);",
Alexander Kornienkod7b837e2013-08-29 17:32:57 +00007967 getGoogleStyleWithColumns(20)));
Daniel Jasperc39b56f2013-12-16 07:23:08 +00007968 EXPECT_EQ("fffffffffff(\n"
7969 " R\"x(\n"
7970 "multiline raw string literal xxxxxxxxxxxxxx\n"
7971 ")x\" +\n"
7972 " bbbbbb);",
7973 format("fffffffffff(\n"
7974 " R\"x(\n"
7975 "multiline raw string literal xxxxxxxxxxxxxx\n"
7976 ")x\" + bbbbbb);",
7977 getGoogleStyleWithColumns(20)));
Alexander Kornienko657c67b2013-07-16 21:06:13 +00007978}
7979
Alexander Kornienkobe633902013-06-14 11:46:10 +00007980TEST_F(FormatTest, SkipsUnknownStringLiterals) {
Daniel Jasper8369aa52013-07-16 20:28:33 +00007981 verifyFormat("string a = \"unterminated;");
7982 EXPECT_EQ("function(\"unterminated,\n"
7983 " OtherParameter);",
7984 format("function( \"unterminated,\n"
7985 " OtherParameter);"));
Alexander Kornienko1e808872013-06-28 12:51:24 +00007986}
7987
7988TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00007989 FormatStyle Style = getLLVMStyle();
7990 Style.Standard = FormatStyle::LS_Cpp03;
Alexander Kornienko1e808872013-06-28 12:51:24 +00007991 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
Chandler Carruthf8b72662014-03-02 12:37:31 +00007992 format("#define x(_a) printf(\"foo\"_a);", Style));
Alexander Kornienkobe633902013-06-14 11:46:10 +00007993}
7994
Daniel Jaspera44991332015-04-29 13:06:49 +00007995TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }
Daniel Jasper20fd3c62014-04-15 08:49:21 +00007996
Manuel Klimek5ecb5fd2013-05-14 09:04:24 +00007997TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
7998 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
7999 " \"ddeeefff\");",
8000 format("someFunction(\"aaabbbcccdddeeefff\");",
8001 getLLVMStyleWithColumns(25)));
8002 EXPECT_EQ("someFunction1234567890(\n"
8003 " \"aaabbbcccdddeeefff\");",
8004 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
8005 getLLVMStyleWithColumns(26)));
8006 EXPECT_EQ("someFunction1234567890(\n"
8007 " \"aaabbbcccdddeeeff\"\n"
8008 " \"f\");",
8009 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
8010 getLLVMStyleWithColumns(25)));
8011 EXPECT_EQ("someFunction1234567890(\n"
8012 " \"aaabbbcccdddeeeff\"\n"
8013 " \"f\");",
8014 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
8015 getLLVMStyleWithColumns(24)));
Manuel Klimek77866142017-11-17 11:17:15 +00008016 EXPECT_EQ("someFunction(\n"
8017 " \"aaabbbcc ddde \"\n"
8018 " \"efff\");",
Daniel Jasper2739af32013-08-28 10:03:58 +00008019 format("someFunction(\"aaabbbcc ddde efff\");",
Manuel Klimek5ecb5fd2013-05-14 09:04:24 +00008020 getLLVMStyleWithColumns(25)));
8021 EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
8022 " \"ddeeefff\");",
8023 format("someFunction(\"aaabbbccc ddeeefff\");",
8024 getLLVMStyleWithColumns(25)));
8025 EXPECT_EQ("someFunction1234567890(\n"
8026 " \"aaabb \"\n"
8027 " \"cccdddeeefff\");",
8028 format("someFunction1234567890(\"aaabb cccdddeeefff\");",
8029 getLLVMStyleWithColumns(25)));
8030 EXPECT_EQ("#define A \\\n"
8031 " string s = \\\n"
8032 " \"123456789\" \\\n"
8033 " \"0\"; \\\n"
8034 " int i;",
8035 format("#define A string s = \"1234567890\"; int i;",
8036 getLLVMStyleWithColumns(20)));
Manuel Klimek77866142017-11-17 11:17:15 +00008037 EXPECT_EQ("someFunction(\n"
8038 " \"aaabbbcc \"\n"
8039 " \"dddeeefff\");",
Daniel Jasper2739af32013-08-28 10:03:58 +00008040 format("someFunction(\"aaabbbcc dddeeefff\");",
8041 getLLVMStyleWithColumns(25)));
Manuel Klimek5ecb5fd2013-05-14 09:04:24 +00008042}
8043
Manuel Klimek5085d9b2013-03-08 18:59:48 +00008044TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
Daniel Jaspera44991332015-04-29 13:06:49 +00008045 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3)));
8046 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2)));
Manuel Klimek5085d9b2013-03-08 18:59:48 +00008047 EXPECT_EQ("\"test\"\n"
8048 "\"\\n\"",
8049 format("\"test\\n\"", getLLVMStyleWithColumns(7)));
8050 EXPECT_EQ("\"tes\\\\\"\n"
8051 "\"n\"",
8052 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
8053 EXPECT_EQ("\"\\\\\\\\\"\n"
8054 "\"\\n\"",
8055 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
Daniel Jaspera44991332015-04-29 13:06:49 +00008056 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
Manuel Klimek5085d9b2013-03-08 18:59:48 +00008057 EXPECT_EQ("\"\\uff01\"\n"
8058 "\"test\"",
8059 format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
8060 EXPECT_EQ("\"\\Uff01ff02\"",
8061 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
8062 EXPECT_EQ("\"\\x000000000001\"\n"
8063 "\"next\"",
8064 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
8065 EXPECT_EQ("\"\\x000000000001next\"",
8066 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
8067 EXPECT_EQ("\"\\x000000000001\"",
8068 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
8069 EXPECT_EQ("\"test\"\n"
8070 "\"\\000000\"\n"
8071 "\"000001\"",
8072 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
8073 EXPECT_EQ("\"test\\000\"\n"
Alexander Kornienkocb45bc12013-04-15 14:28:00 +00008074 "\"00000000\"\n"
8075 "\"1\"",
Manuel Klimek5085d9b2013-03-08 18:59:48 +00008076 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
Manuel Klimek5085d9b2013-03-08 18:59:48 +00008077}
8078
Manuel Klimeka3ff45e2013-04-10 09:52:05 +00008079TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
8080 verifyFormat("void f() {\n"
8081 " return g() {}\n"
8082 " void h() {}");
Daniel Jasper4afc6b32014-06-02 10:57:55 +00008083 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
Daniel Jasper1ec31062013-05-28 18:50:02 +00008084 "g();\n"
Manuel Klimeka3ff45e2013-04-10 09:52:05 +00008085 "}");
8086}
8087
Manuel Klimek421147e2014-01-24 09:25:23 +00008088TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) {
8089 verifyFormat(
Daniel Jasper39485162014-05-22 09:00:33 +00008090 "void f() { return C{param1, param2}.SomeCall(param1, param2); }");
Manuel Klimek421147e2014-01-24 09:25:23 +00008091}
8092
Manuel Klimek13b97d82013-05-13 08:42:42 +00008093TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
8094 verifyFormat("class X {\n"
8095 " void f() {\n"
8096 " }\n"
8097 "};",
8098 getLLVMStyleWithColumns(12));
8099}
8100
8101TEST_F(FormatTest, ConfigurableIndentWidth) {
8102 FormatStyle EightIndent = getLLVMStyleWithColumns(18);
8103 EightIndent.IndentWidth = 8;
Chandler Carruthf8b72662014-03-02 12:37:31 +00008104 EightIndent.ContinuationIndentWidth = 8;
Manuel Klimek13b97d82013-05-13 08:42:42 +00008105 verifyFormat("void f() {\n"
8106 " someFunction();\n"
8107 " if (true) {\n"
8108 " f();\n"
8109 " }\n"
8110 "}",
8111 EightIndent);
8112 verifyFormat("class X {\n"
8113 " void f() {\n"
8114 " }\n"
8115 "};",
8116 EightIndent);
8117 verifyFormat("int x[] = {\n"
8118 " call(),\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00008119 " call()};",
Manuel Klimek13b97d82013-05-13 08:42:42 +00008120 EightIndent);
8121}
8122
Alexander Kornienko34a87e82013-06-22 01:35:36 +00008123TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
Daniel Jaspere068ac72014-10-27 17:13:59 +00008124 verifyFormat("double\n"
Manuel Klimek836c2862013-06-21 17:25:42 +00008125 "f();",
8126 getLLVMStyleWithColumns(8));
8127}
8128
Manuel Klimekb9eae4c2013-05-13 09:22:11 +00008129TEST_F(FormatTest, ConfigurableUseOfTab) {
8130 FormatStyle Tab = getLLVMStyleWithColumns(42);
8131 Tab.IndentWidth = 8;
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00008132 Tab.UseTab = FormatStyle::UT_Always;
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +00008133 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left;
Alexander Kornienkodb4c21f2013-09-27 09:45:40 +00008134
8135 EXPECT_EQ("if (aaaaaaaa && // q\n"
8136 " bb)\t\t// w\n"
8137 "\t;",
8138 format("if (aaaaaaaa &&// q\n"
8139 "bb)// w\n"
8140 ";",
8141 Tab));
8142 EXPECT_EQ("if (aaa && bbb) // w\n"
8143 "\t;",
8144 format("if(aaa&&bbb)// w\n"
8145 ";",
8146 Tab));
8147
Manuel Klimekb9eae4c2013-05-13 09:22:11 +00008148 verifyFormat("class X {\n"
8149 "\tvoid f() {\n"
8150 "\t\tsomeFunction(parameter1,\n"
8151 "\t\t\t parameter2);\n"
8152 "\t}\n"
8153 "};",
8154 Tab);
8155 verifyFormat("#define A \\\n"
8156 "\tvoid f() { \\\n"
8157 "\t\tsomeFunction( \\\n"
8158 "\t\t parameter1, \\\n"
8159 "\t\t parameter2); \\\n"
8160 "\t}",
8161 Tab);
Manuel Klimek34d15152013-05-28 10:01:59 +00008162
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +00008163 Tab.TabWidth = 4;
8164 Tab.IndentWidth = 8;
8165 verifyFormat("class TabWidth4Indent8 {\n"
8166 "\t\tvoid f() {\n"
8167 "\t\t\t\tsomeFunction(parameter1,\n"
8168 "\t\t\t\t\t\t\t parameter2);\n"
8169 "\t\t}\n"
8170 "};",
8171 Tab);
8172
8173 Tab.TabWidth = 4;
8174 Tab.IndentWidth = 4;
8175 verifyFormat("class TabWidth4Indent4 {\n"
8176 "\tvoid f() {\n"
8177 "\t\tsomeFunction(parameter1,\n"
8178 "\t\t\t\t\t parameter2);\n"
8179 "\t}\n"
8180 "};",
8181 Tab);
8182
8183 Tab.TabWidth = 8;
8184 Tab.IndentWidth = 4;
8185 verifyFormat("class TabWidth8Indent4 {\n"
8186 " void f() {\n"
8187 "\tsomeFunction(parameter1,\n"
8188 "\t\t parameter2);\n"
8189 " }\n"
8190 "};",
8191 Tab);
8192
Alexander Kornienko39856b72013-09-10 09:38:25 +00008193 Tab.TabWidth = 8;
8194 Tab.IndentWidth = 8;
8195 EXPECT_EQ("/*\n"
8196 "\t a\t\tcomment\n"
8197 "\t in multiple lines\n"
8198 " */",
8199 format(" /*\t \t \n"
8200 " \t \t a\t\tcomment\t \t\n"
8201 " \t \t in multiple lines\t\n"
8202 " \t */",
8203 Tab));
Alexander Kornienkodb4c21f2013-09-27 09:45:40 +00008204
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00008205 Tab.UseTab = FormatStyle::UT_ForIndentation;
Chandler Carruthf8b72662014-03-02 12:37:31 +00008206 verifyFormat("{\n"
8207 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8208 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8209 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8210 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8211 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8212 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
Alexander Kornienkoe2e03872013-10-14 00:46:35 +00008213 "};",
8214 Tab);
Daniel Jasper411af722016-01-05 16:10:39 +00008215 verifyFormat("enum AA {\n"
Daniel Jasper96972812014-01-05 12:38:10 +00008216 "\ta1, // Force multiple lines\n"
Alexander Kornienkoe2e03872013-10-14 00:46:35 +00008217 "\ta2,\n"
8218 "\ta3\n"
8219 "};",
8220 Tab);
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00008221 EXPECT_EQ("if (aaaaaaaa && // q\n"
8222 " bb) // w\n"
8223 "\t;",
8224 format("if (aaaaaaaa &&// q\n"
8225 "bb)// w\n"
8226 ";",
8227 Tab));
8228 verifyFormat("class X {\n"
8229 "\tvoid f() {\n"
8230 "\t\tsomeFunction(parameter1,\n"
8231 "\t\t parameter2);\n"
8232 "\t}\n"
8233 "};",
8234 Tab);
8235 verifyFormat("{\n"
Daniel Jasper100ffc62015-08-21 11:44:57 +00008236 "\tQ(\n"
8237 "\t {\n"
8238 "\t\t int a;\n"
8239 "\t\t someFunction(aaaaaaaa,\n"
8240 "\t\t bbbbbbb);\n"
8241 "\t },\n"
8242 "\t p);\n"
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00008243 "}",
8244 Tab);
8245 EXPECT_EQ("{\n"
8246 "\t/* aaaa\n"
8247 "\t bbbb */\n"
8248 "}",
8249 format("{\n"
8250 "/* aaaa\n"
8251 " bbbb */\n"
8252 "}",
8253 Tab));
8254 EXPECT_EQ("{\n"
8255 "\t/*\n"
8256 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8257 "\t bbbbbbbbbbbbb\n"
8258 "\t*/\n"
8259 "}",
8260 format("{\n"
8261 "/*\n"
8262 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
8263 "*/\n"
8264 "}",
8265 Tab));
8266 EXPECT_EQ("{\n"
8267 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8268 "\t// bbbbbbbbbbbbb\n"
8269 "}",
8270 format("{\n"
8271 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
8272 "}",
8273 Tab));
8274 EXPECT_EQ("{\n"
8275 "\t/*\n"
8276 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8277 "\t bbbbbbbbbbbbb\n"
8278 "\t*/\n"
8279 "}",
8280 format("{\n"
8281 "\t/*\n"
8282 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
8283 "\t*/\n"
8284 "}",
8285 Tab));
8286 EXPECT_EQ("{\n"
8287 "\t/*\n"
8288 "\n"
8289 "\t*/\n"
8290 "}",
8291 format("{\n"
8292 "\t/*\n"
8293 "\n"
8294 "\t*/\n"
Alexander Kornienko45dc1b22013-09-27 16:40:11 +00008295 "}",
8296 Tab));
8297 EXPECT_EQ("{\n"
8298 "\t/*\n"
8299 " asdf\n"
8300 "\t*/\n"
8301 "}",
8302 format("{\n"
8303 "\t/*\n"
8304 " asdf\n"
8305 "\t*/\n"
8306 "}",
8307 Tab));
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00008308
8309 Tab.UseTab = FormatStyle::UT_Never;
Alexander Kornienko39856b72013-09-10 09:38:25 +00008310 EXPECT_EQ("/*\n"
8311 " a\t\tcomment\n"
8312 " in multiple lines\n"
8313 " */",
8314 format(" /*\t \t \n"
8315 " \t \t a\t\tcomment\t \t\n"
8316 " \t \t in multiple lines\t\n"
8317 " \t */",
8318 Tab));
8319 EXPECT_EQ("/* some\n"
8320 " comment */",
Daniel Jaspera44991332015-04-29 13:06:49 +00008321 format(" \t \t /* some\n"
8322 " \t \t comment */",
8323 Tab));
Alexander Kornienko39856b72013-09-10 09:38:25 +00008324 EXPECT_EQ("int a; /* some\n"
8325 " comment */",
Daniel Jaspera44991332015-04-29 13:06:49 +00008326 format(" \t \t int a; /* some\n"
8327 " \t \t comment */",
8328 Tab));
Manuel Klimek34d15152013-05-28 10:01:59 +00008329
Alexander Kornienko39856b72013-09-10 09:38:25 +00008330 EXPECT_EQ("int a; /* some\n"
8331 "comment */",
Daniel Jaspera44991332015-04-29 13:06:49 +00008332 format(" \t \t int\ta; /* some\n"
8333 " \t \t comment */",
8334 Tab));
Alexander Kornienko39856b72013-09-10 09:38:25 +00008335 EXPECT_EQ("f(\"\t\t\"); /* some\n"
8336 " comment */",
Daniel Jaspera44991332015-04-29 13:06:49 +00008337 format(" \t \t f(\"\t\t\"); /* some\n"
8338 " \t \t comment */",
8339 Tab));
Manuel Klimek34d15152013-05-28 10:01:59 +00008340 EXPECT_EQ("{\n"
8341 " /*\n"
8342 " * Comment\n"
8343 " */\n"
8344 " int i;\n"
8345 "}",
8346 format("{\n"
8347 "\t/*\n"
8348 "\t * Comment\n"
8349 "\t */\n"
8350 "\t int i;\n"
8351 "}"));
Marianne Mailhot-Sarrasin51fe2792016-04-14 14:52:26 +00008352
8353 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
8354 Tab.TabWidth = 8;
8355 Tab.IndentWidth = 8;
8356 EXPECT_EQ("if (aaaaaaaa && // q\n"
8357 " bb) // w\n"
8358 "\t;",
8359 format("if (aaaaaaaa &&// q\n"
8360 "bb)// w\n"
8361 ";",
8362 Tab));
8363 EXPECT_EQ("if (aaa && bbb) // w\n"
8364 "\t;",
8365 format("if(aaa&&bbb)// w\n"
8366 ";",
8367 Tab));
8368 verifyFormat("class X {\n"
8369 "\tvoid f() {\n"
8370 "\t\tsomeFunction(parameter1,\n"
8371 "\t\t\t parameter2);\n"
8372 "\t}\n"
8373 "};",
8374 Tab);
8375 verifyFormat("#define A \\\n"
8376 "\tvoid f() { \\\n"
8377 "\t\tsomeFunction( \\\n"
8378 "\t\t parameter1, \\\n"
8379 "\t\t parameter2); \\\n"
8380 "\t}",
8381 Tab);
8382 Tab.TabWidth = 4;
8383 Tab.IndentWidth = 8;
8384 verifyFormat("class TabWidth4Indent8 {\n"
8385 "\t\tvoid f() {\n"
8386 "\t\t\t\tsomeFunction(parameter1,\n"
8387 "\t\t\t\t\t\t\t parameter2);\n"
8388 "\t\t}\n"
8389 "};",
8390 Tab);
8391 Tab.TabWidth = 4;
8392 Tab.IndentWidth = 4;
8393 verifyFormat("class TabWidth4Indent4 {\n"
8394 "\tvoid f() {\n"
8395 "\t\tsomeFunction(parameter1,\n"
8396 "\t\t\t\t\t parameter2);\n"
8397 "\t}\n"
8398 "};",
8399 Tab);
8400 Tab.TabWidth = 8;
8401 Tab.IndentWidth = 4;
8402 verifyFormat("class TabWidth8Indent4 {\n"
8403 " void f() {\n"
8404 "\tsomeFunction(parameter1,\n"
8405 "\t\t parameter2);\n"
8406 " }\n"
8407 "};",
8408 Tab);
8409 Tab.TabWidth = 8;
8410 Tab.IndentWidth = 8;
8411 EXPECT_EQ("/*\n"
8412 "\t a\t\tcomment\n"
8413 "\t in multiple lines\n"
8414 " */",
8415 format(" /*\t \t \n"
8416 " \t \t a\t\tcomment\t \t\n"
8417 " \t \t in multiple lines\t\n"
8418 " \t */",
8419 Tab));
8420 verifyFormat("{\n"
8421 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8422 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8423 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8424 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8425 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8426 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
8427 "};",
8428 Tab);
8429 verifyFormat("enum AA {\n"
8430 "\ta1, // Force multiple lines\n"
8431 "\ta2,\n"
8432 "\ta3\n"
8433 "};",
8434 Tab);
8435 EXPECT_EQ("if (aaaaaaaa && // q\n"
8436 " bb) // w\n"
8437 "\t;",
8438 format("if (aaaaaaaa &&// q\n"
8439 "bb)// w\n"
8440 ";",
8441 Tab));
8442 verifyFormat("class X {\n"
8443 "\tvoid f() {\n"
8444 "\t\tsomeFunction(parameter1,\n"
8445 "\t\t\t parameter2);\n"
8446 "\t}\n"
8447 "};",
8448 Tab);
8449 verifyFormat("{\n"
8450 "\tQ(\n"
8451 "\t {\n"
8452 "\t\t int a;\n"
8453 "\t\t someFunction(aaaaaaaa,\n"
8454 "\t\t\t\t bbbbbbb);\n"
8455 "\t },\n"
8456 "\t p);\n"
8457 "}",
8458 Tab);
8459 EXPECT_EQ("{\n"
8460 "\t/* aaaa\n"
8461 "\t bbbb */\n"
8462 "}",
8463 format("{\n"
8464 "/* aaaa\n"
8465 " bbbb */\n"
8466 "}",
8467 Tab));
8468 EXPECT_EQ("{\n"
8469 "\t/*\n"
8470 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8471 "\t bbbbbbbbbbbbb\n"
8472 "\t*/\n"
8473 "}",
8474 format("{\n"
8475 "/*\n"
8476 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
8477 "*/\n"
8478 "}",
8479 Tab));
8480 EXPECT_EQ("{\n"
8481 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8482 "\t// bbbbbbbbbbbbb\n"
8483 "}",
8484 format("{\n"
8485 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
8486 "}",
8487 Tab));
8488 EXPECT_EQ("{\n"
8489 "\t/*\n"
8490 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8491 "\t bbbbbbbbbbbbb\n"
8492 "\t*/\n"
8493 "}",
8494 format("{\n"
8495 "\t/*\n"
8496 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
8497 "\t*/\n"
8498 "}",
8499 Tab));
8500 EXPECT_EQ("{\n"
8501 "\t/*\n"
8502 "\n"
8503 "\t*/\n"
8504 "}",
8505 format("{\n"
8506 "\t/*\n"
8507 "\n"
8508 "\t*/\n"
8509 "}",
8510 Tab));
8511 EXPECT_EQ("{\n"
8512 "\t/*\n"
8513 " asdf\n"
8514 "\t*/\n"
8515 "}",
8516 format("{\n"
8517 "\t/*\n"
8518 " asdf\n"
8519 "\t*/\n"
8520 "}",
8521 Tab));
8522 EXPECT_EQ("/*\n"
8523 "\t a\t\tcomment\n"
8524 "\t in multiple lines\n"
8525 " */",
8526 format(" /*\t \t \n"
8527 " \t \t a\t\tcomment\t \t\n"
8528 " \t \t in multiple lines\t\n"
8529 " \t */",
8530 Tab));
8531 EXPECT_EQ("/* some\n"
8532 " comment */",
8533 format(" \t \t /* some\n"
8534 " \t \t comment */",
8535 Tab));
8536 EXPECT_EQ("int a; /* some\n"
8537 " comment */",
8538 format(" \t \t int a; /* some\n"
8539 " \t \t comment */",
8540 Tab));
8541 EXPECT_EQ("int a; /* some\n"
8542 "comment */",
8543 format(" \t \t int\ta; /* some\n"
8544 " \t \t comment */",
8545 Tab));
8546 EXPECT_EQ("f(\"\t\t\"); /* some\n"
8547 " comment */",
8548 format(" \t \t f(\"\t\t\"); /* some\n"
8549 " \t \t comment */",
8550 Tab));
8551 EXPECT_EQ("{\n"
8552 " /*\n"
8553 " * Comment\n"
8554 " */\n"
8555 " int i;\n"
8556 "}",
8557 format("{\n"
8558 "\t/*\n"
8559 "\t * Comment\n"
8560 "\t */\n"
8561 "\t int i;\n"
8562 "}"));
8563 Tab.AlignConsecutiveAssignments = true;
8564 Tab.AlignConsecutiveDeclarations = true;
8565 Tab.TabWidth = 4;
8566 Tab.IndentWidth = 4;
8567 verifyFormat("class Assign {\n"
8568 "\tvoid f() {\n"
8569 "\t\tint x = 123;\n"
8570 "\t\tint random = 4;\n"
8571 "\t\tstd::string alphabet =\n"
8572 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
8573 "\t}\n"
8574 "};",
8575 Tab);
Manuel Klimekb9eae4c2013-05-13 09:22:11 +00008576}
8577
Alexander Kornienko917f9e02013-09-10 12:29:48 +00008578TEST_F(FormatTest, CalculatesOriginalColumn) {
8579 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8580 "q\"; /* some\n"
8581 " comment */",
8582 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8583 "q\"; /* some\n"
8584 " comment */",
8585 getLLVMStyle()));
8586 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
8587 "/* some\n"
8588 " comment */",
8589 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
8590 " /* some\n"
8591 " comment */",
8592 getLLVMStyle()));
8593 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8594 "qqq\n"
8595 "/* some\n"
8596 " comment */",
8597 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8598 "qqq\n"
8599 " /* some\n"
8600 " comment */",
8601 getLLVMStyle()));
8602 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8603 "wwww; /* some\n"
8604 " comment */",
8605 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8606 "wwww; /* some\n"
8607 " comment */",
8608 getLLVMStyle()));
8609}
8610
Alexander Kornienkofdca83d2013-12-10 10:18:34 +00008611TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
Daniel Jasperb55acad2013-08-20 12:36:34 +00008612 FormatStyle NoSpace = getLLVMStyle();
Alexander Kornienkofdca83d2013-12-10 10:18:34 +00008613 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never;
Daniel Jasperb55acad2013-08-20 12:36:34 +00008614
8615 verifyFormat("while(true)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008616 " continue;",
8617 NoSpace);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008618 verifyFormat("for(;;)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008619 " continue;",
8620 NoSpace);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008621 verifyFormat("if(true)\n"
8622 " f();\n"
8623 "else if(true)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008624 " f();",
8625 NoSpace);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008626 verifyFormat("do {\n"
8627 " do_something();\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008628 "} while(something());",
8629 NoSpace);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008630 verifyFormat("switch(x) {\n"
8631 "default:\n"
8632 " break;\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008633 "}",
8634 NoSpace);
Chad Rosier0a84f172014-08-05 17:58:54 +00008635 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace);
Daniel Jasper78b194992014-08-06 14:15:41 +00008636 verifyFormat("size_t x = sizeof(x);", NoSpace);
8637 verifyFormat("auto f(int x) -> decltype(x);", NoSpace);
8638 verifyFormat("int f(T x) noexcept(x.create());", NoSpace);
8639 verifyFormat("alignas(128) char a[128];", NoSpace);
8640 verifyFormat("size_t x = alignof(MyType);", NoSpace);
8641 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace);
8642 verifyFormat("int f() throw(Deprecated);", NoSpace);
Anders Waldenborgb09075a2015-05-19 16:54:26 +00008643 verifyFormat("typedef void (*cb)(int);", NoSpace);
Daniel Jaspera804d1e2015-08-11 20:32:24 +00008644 verifyFormat("T A::operator()();", NoSpace);
8645 verifyFormat("X A::operator++(T);", NoSpace);
Alexander Kornienkofdca83d2013-12-10 10:18:34 +00008646
8647 FormatStyle Space = getLLVMStyle();
8648 Space.SpaceBeforeParens = FormatStyle::SBPO_Always;
8649
8650 verifyFormat("int f ();", Space);
8651 verifyFormat("void f (int a, T b) {\n"
8652 " while (true)\n"
8653 " continue;\n"
8654 "}",
8655 Space);
8656 verifyFormat("if (true)\n"
8657 " f ();\n"
8658 "else if (true)\n"
8659 " f ();",
8660 Space);
8661 verifyFormat("do {\n"
8662 " do_something ();\n"
8663 "} while (something ());",
8664 Space);
8665 verifyFormat("switch (x) {\n"
8666 "default:\n"
8667 " break;\n"
8668 "}",
8669 Space);
8670 verifyFormat("A::A () : a (1) {}", Space);
8671 verifyFormat("void f () __attribute__ ((asdf));", Space);
8672 verifyFormat("*(&a + 1);\n"
8673 "&((&a)[1]);\n"
8674 "a[(b + c) * d];\n"
8675 "(((a + 1) * 2) + 3) * 4;",
8676 Space);
8677 verifyFormat("#define A(x) x", Space);
8678 verifyFormat("#define A (x) x", Space);
8679 verifyFormat("#if defined(x)\n"
8680 "#endif",
8681 Space);
Chad Rosier0a84f172014-08-05 17:58:54 +00008682 verifyFormat("auto i = std::make_unique<int> (5);", Space);
Daniel Jasper78b194992014-08-06 14:15:41 +00008683 verifyFormat("size_t x = sizeof (x);", Space);
8684 verifyFormat("auto f (int x) -> decltype (x);", Space);
8685 verifyFormat("int f (T x) noexcept (x.create ());", Space);
8686 verifyFormat("alignas (128) char a[128];", Space);
8687 verifyFormat("size_t x = alignof (MyType);", Space);
8688 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space);
8689 verifyFormat("int f () throw (Deprecated);", Space);
Anders Waldenborgb09075a2015-05-19 16:54:26 +00008690 verifyFormat("typedef void (*cb) (int);", Space);
Daniel Jaspera804d1e2015-08-11 20:32:24 +00008691 verifyFormat("T A::operator() ();", Space);
8692 verifyFormat("X A::operator++ (T);", Space);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008693}
8694
8695TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
8696 FormatStyle Spaces = getLLVMStyle();
8697
8698 Spaces.SpacesInParentheses = true;
8699 verifyFormat("call( x, y, z );", Spaces);
Daniel Jasper92e09822015-03-18 12:59:19 +00008700 verifyFormat("call();", Spaces);
8701 verifyFormat("std::function<void( int, int )> callback;", Spaces);
Daniel Jasper74331d42015-10-26 12:08:47 +00008702 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }",
8703 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008704 verifyFormat("while ( (bool)1 )\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008705 " continue;",
8706 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008707 verifyFormat("for ( ;; )\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008708 " continue;",
8709 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008710 verifyFormat("if ( true )\n"
8711 " f();\n"
8712 "else if ( true )\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008713 " f();",
8714 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008715 verifyFormat("do {\n"
8716 " do_something( (int)i );\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008717 "} while ( something() );",
8718 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008719 verifyFormat("switch ( x ) {\n"
8720 "default:\n"
8721 " break;\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008722 "}",
8723 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008724
8725 Spaces.SpacesInParentheses = false;
8726 Spaces.SpacesInCStyleCastParentheses = true;
8727 verifyFormat("Type *A = ( Type * )P;", Spaces);
8728 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
8729 verifyFormat("x = ( int32 )y;", Spaces);
8730 verifyFormat("int a = ( int )(2.0f);", Spaces);
8731 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
8732 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
8733 verifyFormat("#define x (( int )-1)", Spaces);
8734
Daniel Jasper92e09822015-03-18 12:59:19 +00008735 // Run the first set of tests again with:
Richard Trieucc3949d2016-02-18 22:34:54 +00008736 Spaces.SpacesInParentheses = false;
8737 Spaces.SpaceInEmptyParentheses = true;
Daniel Jasperb55acad2013-08-20 12:36:34 +00008738 Spaces.SpacesInCStyleCastParentheses = true;
8739 verifyFormat("call(x, y, z);", Spaces);
Daniel Jasper92e09822015-03-18 12:59:19 +00008740 verifyFormat("call( );", Spaces);
8741 verifyFormat("std::function<void(int, int)> callback;", Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008742 verifyFormat("while (( bool )1)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008743 " continue;",
8744 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008745 verifyFormat("for (;;)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008746 " continue;",
8747 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008748 verifyFormat("if (true)\n"
8749 " f( );\n"
8750 "else if (true)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008751 " f( );",
8752 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008753 verifyFormat("do {\n"
8754 " do_something(( int )i);\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008755 "} while (something( ));",
8756 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008757 verifyFormat("switch (x) {\n"
8758 "default:\n"
8759 " break;\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008760 "}",
8761 Spaces);
Daniel Jasperdb986eb2014-09-03 07:37:29 +00008762
Daniel Jasper92e09822015-03-18 12:59:19 +00008763 // Run the first set of tests again with:
Daniel Jasperdb986eb2014-09-03 07:37:29 +00008764 Spaces.SpaceAfterCStyleCast = true;
8765 verifyFormat("call(x, y, z);", Spaces);
Daniel Jasper92e09822015-03-18 12:59:19 +00008766 verifyFormat("call( );", Spaces);
8767 verifyFormat("std::function<void(int, int)> callback;", Spaces);
Daniel Jasperdb986eb2014-09-03 07:37:29 +00008768 verifyFormat("while (( bool ) 1)\n"
8769 " continue;",
8770 Spaces);
8771 verifyFormat("for (;;)\n"
8772 " continue;",
8773 Spaces);
8774 verifyFormat("if (true)\n"
8775 " f( );\n"
8776 "else if (true)\n"
8777 " f( );",
8778 Spaces);
8779 verifyFormat("do {\n"
8780 " do_something(( int ) i);\n"
8781 "} while (something( ));",
8782 Spaces);
8783 verifyFormat("switch (x) {\n"
8784 "default:\n"
8785 " break;\n"
8786 "}",
8787 Spaces);
Daniel Jasper92e09822015-03-18 12:59:19 +00008788
8789 // Run subset of tests again with:
Daniel Jasperdb986eb2014-09-03 07:37:29 +00008790 Spaces.SpacesInCStyleCastParentheses = false;
8791 Spaces.SpaceAfterCStyleCast = true;
8792 verifyFormat("while ((bool) 1)\n"
8793 " continue;",
8794 Spaces);
8795 verifyFormat("do {\n"
8796 " do_something((int) i);\n"
8797 "} while (something( ));",
8798 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008799}
8800
Daniel Jasperad981f82014-08-26 11:41:14 +00008801TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) {
8802 verifyFormat("int a[5];");
8803 verifyFormat("a[3] += 42;");
8804
8805 FormatStyle Spaces = getLLVMStyle();
8806 Spaces.SpacesInSquareBrackets = true;
8807 // Lambdas unchanged.
8808 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces);
8809 verifyFormat("return [i, args...] {};", Spaces);
8810
8811 // Not lambdas.
8812 verifyFormat("int a[ 5 ];", Spaces);
8813 verifyFormat("a[ 3 ] += 42;", Spaces);
8814 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces);
8815 verifyFormat("double &operator[](int i) { return 0; }\n"
8816 "int i;",
8817 Spaces);
8818 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces);
8819 verifyFormat("int i = a[ a ][ a ]->f();", Spaces);
8820 verifyFormat("int i = (*b)[ a ]->f();", Spaces);
8821}
8822
Daniel Jasperd94bff32013-09-25 15:15:02 +00008823TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
8824 verifyFormat("int a = 5;");
8825 verifyFormat("a += 42;");
8826 verifyFormat("a or_eq 8;");
8827
8828 FormatStyle Spaces = getLLVMStyle();
8829 Spaces.SpaceBeforeAssignmentOperators = false;
8830 verifyFormat("int a= 5;", Spaces);
8831 verifyFormat("a+= 42;", Spaces);
8832 verifyFormat("a or_eq 8;", Spaces);
8833}
8834
Daniel Jaspera44991332015-04-29 13:06:49 +00008835TEST_F(FormatTest, AlignConsecutiveAssignments) {
8836 FormatStyle Alignment = getLLVMStyle();
8837 Alignment.AlignConsecutiveAssignments = false;
8838 verifyFormat("int a = 5;\n"
8839 "int oneTwoThree = 123;",
8840 Alignment);
8841 verifyFormat("int a = 5;\n"
8842 "int oneTwoThree = 123;",
8843 Alignment);
8844
8845 Alignment.AlignConsecutiveAssignments = true;
8846 verifyFormat("int a = 5;\n"
8847 "int oneTwoThree = 123;",
8848 Alignment);
8849 verifyFormat("int a = method();\n"
8850 "int oneTwoThree = 133;",
8851 Alignment);
8852 verifyFormat("a &= 5;\n"
8853 "bcd *= 5;\n"
8854 "ghtyf += 5;\n"
8855 "dvfvdb -= 5;\n"
8856 "a /= 5;\n"
8857 "vdsvsv %= 5;\n"
8858 "sfdbddfbdfbb ^= 5;\n"
8859 "dvsdsv |= 5;\n"
8860 "int dsvvdvsdvvv = 123;",
8861 Alignment);
8862 verifyFormat("int i = 1, j = 10;\n"
8863 "something = 2000;",
8864 Alignment);
8865 verifyFormat("something = 2000;\n"
8866 "int i = 1, j = 10;\n",
8867 Alignment);
8868 verifyFormat("something = 2000;\n"
8869 "another = 911;\n"
8870 "int i = 1, j = 10;\n"
8871 "oneMore = 1;\n"
8872 "i = 2;",
8873 Alignment);
8874 verifyFormat("int a = 5;\n"
8875 "int one = 1;\n"
8876 "method();\n"
8877 "int oneTwoThree = 123;\n"
8878 "int oneTwo = 12;",
8879 Alignment);
Daniel Jasperbbfd20d2015-09-22 09:32:00 +00008880 verifyFormat("int oneTwoThree = 123;\n"
8881 "int oneTwo = 12;\n"
8882 "method();\n",
8883 Alignment);
Daniel Jaspera44991332015-04-29 13:06:49 +00008884 verifyFormat("int oneTwoThree = 123; // comment\n"
8885 "int oneTwo = 12; // comment",
8886 Alignment);
8887 EXPECT_EQ("int a = 5;\n"
8888 "\n"
8889 "int oneTwoThree = 123;",
8890 format("int a = 5;\n"
8891 "\n"
8892 "int oneTwoThree= 123;",
8893 Alignment));
8894 EXPECT_EQ("int a = 5;\n"
8895 "int one = 1;\n"
8896 "\n"
8897 "int oneTwoThree = 123;",
8898 format("int a = 5;\n"
8899 "int one = 1;\n"
8900 "\n"
8901 "int oneTwoThree = 123;",
8902 Alignment));
8903 EXPECT_EQ("int a = 5;\n"
8904 "int one = 1;\n"
8905 "\n"
8906 "int oneTwoThree = 123;\n"
8907 "int oneTwo = 12;",
8908 format("int a = 5;\n"
8909 "int one = 1;\n"
8910 "\n"
8911 "int oneTwoThree = 123;\n"
8912 "int oneTwo = 12;",
8913 Alignment));
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +00008914 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
8915 verifyFormat("#define A \\\n"
8916 " int aaaa = 12; \\\n"
8917 " int b = 23; \\\n"
8918 " int ccc = 234; \\\n"
8919 " int dddddddddd = 2345;",
8920 Alignment);
8921 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
Daniel Jaspera44991332015-04-29 13:06:49 +00008922 verifyFormat("#define A \\\n"
8923 " int aaaa = 12; \\\n"
8924 " int b = 23; \\\n"
8925 " int ccc = 234; \\\n"
8926 " int dddddddddd = 2345;",
8927 Alignment);
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +00008928 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
Daniel Jaspera44991332015-04-29 13:06:49 +00008929 verifyFormat("#define A "
8930 " \\\n"
8931 " int aaaa = 12; "
8932 " \\\n"
8933 " int b = 23; "
8934 " \\\n"
8935 " int ccc = 234; "
8936 " \\\n"
8937 " int dddddddddd = 2345;",
8938 Alignment);
8939 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
8940 "k = 4, int l = 5,\n"
8941 " int m = 6) {\n"
8942 " int j = 10;\n"
8943 " otherThing = 1;\n"
8944 "}",
8945 Alignment);
8946 verifyFormat("void SomeFunction(int parameter = 0) {\n"
8947 " int i = 1;\n"
8948 " int j = 2;\n"
8949 " int big = 10000;\n"
8950 "}",
8951 Alignment);
8952 verifyFormat("class C {\n"
8953 "public:\n"
Daniel Jasperec90e512015-12-01 12:00:43 +00008954 " int i = 1;\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008955 " virtual void f() = 0;\n"
8956 "};",
8957 Alignment);
8958 verifyFormat("int i = 1;\n"
8959 "if (SomeType t = getSomething()) {\n"
8960 "}\n"
8961 "int j = 2;\n"
8962 "int big = 10000;",
8963 Alignment);
8964 verifyFormat("int j = 7;\n"
8965 "for (int k = 0; k < N; ++k) {\n"
8966 "}\n"
8967 "int j = 2;\n"
8968 "int big = 10000;\n"
8969 "}",
8970 Alignment);
8971 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
8972 verifyFormat("int i = 1;\n"
8973 "LooooooooooongType loooooooooooooooooooooongVariable\n"
8974 " = someLooooooooooooooooongFunction();\n"
8975 "int j = 2;",
8976 Alignment);
8977 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
8978 verifyFormat("int i = 1;\n"
8979 "LooooooooooongType loooooooooooooooooooooongVariable =\n"
8980 " someLooooooooooooooooongFunction();\n"
8981 "int j = 2;",
8982 Alignment);
Daniel Jasper39828252015-10-07 15:03:26 +00008983
8984 verifyFormat("auto lambda = []() {\n"
8985 " auto i = 0;\n"
8986 " return 0;\n"
8987 "};\n"
8988 "int i = 0;\n"
8989 "auto v = type{\n"
8990 " i = 1, //\n"
8991 " (i = 2), //\n"
8992 " i = 3 //\n"
8993 "};",
8994 Alignment);
8995
Daniel Jaspera44991332015-04-29 13:06:49 +00008996 verifyFormat(
8997 "int i = 1;\n"
8998 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
8999 " loooooooooooooooooooooongParameterB);\n"
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00009000 "int j = 2;",
Daniel Jaspera44991332015-04-29 13:06:49 +00009001 Alignment);
Daniel Jasperec90e512015-12-01 12:00:43 +00009002
9003 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
9004 " typename B = very_long_type_name_1,\n"
9005 " typename T_2 = very_long_type_name_2>\n"
9006 "auto foo() {}\n",
9007 Alignment);
9008 verifyFormat("int a, b = 1;\n"
9009 "int c = 2;\n"
9010 "int dd = 3;\n",
9011 Alignment);
9012 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n"
9013 "float b[1][] = {{3.f}};\n",
9014 Alignment);
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00009015 verifyFormat("for (int i = 0; i < 1; i++)\n"
9016 " int x = 1;\n",
9017 Alignment);
9018 verifyFormat("for (i = 0; i < 1; i++)\n"
9019 " x = 1;\n"
9020 "y = 1;\n",
9021 Alignment);
Daniel Jaspera44991332015-04-29 13:06:49 +00009022}
9023
Daniel Jaspere12597c2015-10-01 10:06:54 +00009024TEST_F(FormatTest, AlignConsecutiveDeclarations) {
9025 FormatStyle Alignment = getLLVMStyle();
9026 Alignment.AlignConsecutiveDeclarations = false;
9027 verifyFormat("float const a = 5;\n"
9028 "int oneTwoThree = 123;",
9029 Alignment);
9030 verifyFormat("int a = 5;\n"
9031 "float const oneTwoThree = 123;",
9032 Alignment);
9033
9034 Alignment.AlignConsecutiveDeclarations = true;
9035 verifyFormat("float const a = 5;\n"
9036 "int oneTwoThree = 123;",
9037 Alignment);
9038 verifyFormat("int a = method();\n"
9039 "float const oneTwoThree = 133;",
9040 Alignment);
9041 verifyFormat("int i = 1, j = 10;\n"
9042 "something = 2000;",
9043 Alignment);
9044 verifyFormat("something = 2000;\n"
9045 "int i = 1, j = 10;\n",
9046 Alignment);
9047 verifyFormat("float something = 2000;\n"
9048 "double another = 911;\n"
9049 "int i = 1, j = 10;\n"
9050 "const int *oneMore = 1;\n"
9051 "unsigned i = 2;",
9052 Alignment);
9053 verifyFormat("float a = 5;\n"
9054 "int one = 1;\n"
9055 "method();\n"
9056 "const double oneTwoThree = 123;\n"
9057 "const unsigned int oneTwo = 12;",
9058 Alignment);
9059 verifyFormat("int oneTwoThree{0}; // comment\n"
9060 "unsigned oneTwo; // comment",
9061 Alignment);
9062 EXPECT_EQ("float const a = 5;\n"
9063 "\n"
9064 "int oneTwoThree = 123;",
9065 format("float const a = 5;\n"
9066 "\n"
9067 "int oneTwoThree= 123;",
9068 Alignment));
9069 EXPECT_EQ("float a = 5;\n"
9070 "int one = 1;\n"
9071 "\n"
9072 "unsigned oneTwoThree = 123;",
9073 format("float a = 5;\n"
9074 "int one = 1;\n"
9075 "\n"
9076 "unsigned oneTwoThree = 123;",
9077 Alignment));
9078 EXPECT_EQ("float a = 5;\n"
9079 "int one = 1;\n"
9080 "\n"
9081 "unsigned oneTwoThree = 123;\n"
9082 "int oneTwo = 12;",
9083 format("float a = 5;\n"
9084 "int one = 1;\n"
9085 "\n"
9086 "unsigned oneTwoThree = 123;\n"
9087 "int oneTwo = 12;",
9088 Alignment));
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00009089 // Function prototype alignment
9090 verifyFormat("int a();\n"
9091 "double b();",
9092 Alignment);
9093 verifyFormat("int a(int x);\n"
9094 "double b();",
9095 Alignment);
9096 unsigned OldColumnLimit = Alignment.ColumnLimit;
9097 // We need to set ColumnLimit to zero, in order to stress nested alignments,
9098 // otherwise the function parameters will be re-flowed onto a single line.
9099 Alignment.ColumnLimit = 0;
9100 EXPECT_EQ("int a(int x,\n"
9101 " float y);\n"
9102 "double b(int x,\n"
9103 " double y);",
9104 format("int a(int x,\n"
9105 " float y);\n"
9106 "double b(int x,\n"
9107 " double y);",
9108 Alignment));
9109 // This ensures that function parameters of function declarations are
9110 // correctly indented when their owning functions are indented.
9111 // The failure case here is for 'double y' to not be indented enough.
9112 EXPECT_EQ("double a(int x);\n"
9113 "int b(int y,\n"
9114 " double z);",
9115 format("double a(int x);\n"
9116 "int b(int y,\n"
9117 " double z);",
9118 Alignment));
9119 // Set ColumnLimit low so that we induce wrapping immediately after
9120 // the function name and opening paren.
9121 Alignment.ColumnLimit = 13;
9122 verifyFormat("int function(\n"
9123 " int x,\n"
9124 " bool y);",
9125 Alignment);
9126 Alignment.ColumnLimit = OldColumnLimit;
9127 // Ensure function pointers don't screw up recursive alignment
9128 verifyFormat("int a(int x, void (*fp)(int y));\n"
9129 "double b();",
9130 Alignment);
Daniel Jaspere12597c2015-10-01 10:06:54 +00009131 Alignment.AlignConsecutiveAssignments = true;
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00009132 // Ensure recursive alignment is broken by function braces, so that the
9133 // "a = 1" does not align with subsequent assignments inside the function
9134 // body.
9135 verifyFormat("int func(int a = 1) {\n"
9136 " int b = 2;\n"
9137 " int cc = 3;\n"
9138 "}",
9139 Alignment);
Daniel Jaspere12597c2015-10-01 10:06:54 +00009140 verifyFormat("float something = 2000;\n"
9141 "double another = 911;\n"
9142 "int i = 1, j = 10;\n"
9143 "const int *oneMore = 1;\n"
9144 "unsigned i = 2;",
9145 Alignment);
9146 verifyFormat("int oneTwoThree = {0}; // comment\n"
9147 "unsigned oneTwo = 0; // comment",
9148 Alignment);
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00009149 // Make sure that scope is correctly tracked, in the absence of braces
9150 verifyFormat("for (int i = 0; i < n; i++)\n"
9151 " j = i;\n"
9152 "double x = 1;\n",
9153 Alignment);
9154 verifyFormat("if (int i = 0)\n"
9155 " j = i;\n"
9156 "double x = 1;\n",
9157 Alignment);
9158 // Ensure operator[] and operator() are comprehended
9159 verifyFormat("struct test {\n"
9160 " long long int foo();\n"
9161 " int operator[](int a);\n"
9162 " double bar();\n"
9163 "};\n",
9164 Alignment);
9165 verifyFormat("struct test {\n"
9166 " long long int foo();\n"
9167 " int operator()(int a);\n"
9168 " double bar();\n"
9169 "};\n",
9170 Alignment);
Daniel Jaspere12597c2015-10-01 10:06:54 +00009171 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
9172 " int const i = 1;\n"
9173 " int * j = 2;\n"
9174 " int big = 10000;\n"
9175 "\n"
9176 " unsigned oneTwoThree = 123;\n"
9177 " int oneTwo = 12;\n"
9178 " method();\n"
9179 " float k = 2;\n"
9180 " int ll = 10000;\n"
9181 "}",
9182 format("void SomeFunction(int parameter= 0) {\n"
9183 " int const i= 1;\n"
9184 " int *j=2;\n"
9185 " int big = 10000;\n"
9186 "\n"
9187 "unsigned oneTwoThree =123;\n"
9188 "int oneTwo = 12;\n"
9189 " method();\n"
9190 "float k= 2;\n"
9191 "int ll=10000;\n"
9192 "}",
9193 Alignment));
9194 Alignment.AlignConsecutiveAssignments = false;
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +00009195 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
9196 verifyFormat("#define A \\\n"
9197 " int aaaa = 12; \\\n"
9198 " float b = 23; \\\n"
9199 " const int ccc = 234; \\\n"
9200 " unsigned dddddddddd = 2345;",
9201 Alignment);
9202 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
Daniel Jaspere12597c2015-10-01 10:06:54 +00009203 verifyFormat("#define A \\\n"
9204 " int aaaa = 12; \\\n"
9205 " float b = 23; \\\n"
9206 " const int ccc = 234; \\\n"
9207 " unsigned dddddddddd = 2345;",
9208 Alignment);
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +00009209 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
Daniel Jaspere12597c2015-10-01 10:06:54 +00009210 Alignment.ColumnLimit = 30;
9211 verifyFormat("#define A \\\n"
9212 " int aaaa = 12; \\\n"
9213 " float b = 23; \\\n"
9214 " const int ccc = 234; \\\n"
9215 " int dddddddddd = 2345;",
9216 Alignment);
9217 Alignment.ColumnLimit = 80;
9218 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
9219 "k = 4, int l = 5,\n"
9220 " int m = 6) {\n"
9221 " const int j = 10;\n"
9222 " otherThing = 1;\n"
9223 "}",
9224 Alignment);
9225 verifyFormat("void SomeFunction(int parameter = 0) {\n"
9226 " int const i = 1;\n"
9227 " int * j = 2;\n"
9228 " int big = 10000;\n"
9229 "}",
9230 Alignment);
9231 verifyFormat("class C {\n"
9232 "public:\n"
9233 " int i = 1;\n"
9234 " virtual void f() = 0;\n"
9235 "};",
9236 Alignment);
9237 verifyFormat("float i = 1;\n"
9238 "if (SomeType t = getSomething()) {\n"
9239 "}\n"
9240 "const unsigned j = 2;\n"
9241 "int big = 10000;",
9242 Alignment);
9243 verifyFormat("float j = 7;\n"
9244 "for (int k = 0; k < N; ++k) {\n"
9245 "}\n"
9246 "unsigned j = 2;\n"
9247 "int big = 10000;\n"
9248 "}",
9249 Alignment);
9250 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
9251 verifyFormat("float i = 1;\n"
9252 "LooooooooooongType loooooooooooooooooooooongVariable\n"
9253 " = someLooooooooooooooooongFunction();\n"
9254 "int j = 2;",
9255 Alignment);
9256 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
9257 verifyFormat("int i = 1;\n"
9258 "LooooooooooongType loooooooooooooooooooooongVariable =\n"
9259 " someLooooooooooooooooongFunction();\n"
9260 "int j = 2;",
9261 Alignment);
Daniel Jasper39828252015-10-07 15:03:26 +00009262
9263 Alignment.AlignConsecutiveAssignments = true;
9264 verifyFormat("auto lambda = []() {\n"
9265 " auto ii = 0;\n"
9266 " float j = 0;\n"
9267 " return 0;\n"
9268 "};\n"
9269 "int i = 0;\n"
9270 "float i2 = 0;\n"
9271 "auto v = type{\n"
9272 " i = 1, //\n"
9273 " (i = 2), //\n"
9274 " i = 3 //\n"
9275 "};",
9276 Alignment);
9277 Alignment.AlignConsecutiveAssignments = false;
9278
Daniel Jaspere12597c2015-10-01 10:06:54 +00009279 verifyFormat(
9280 "int i = 1;\n"
9281 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
9282 " loooooooooooooooooooooongParameterB);\n"
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00009283 "int j = 2;",
Daniel Jaspere12597c2015-10-01 10:06:54 +00009284 Alignment);
9285
9286 // Test interactions with ColumnLimit and AlignConsecutiveAssignments:
9287 // We expect declarations and assignments to align, as long as it doesn't
Nikola Smiljanic92b397f2017-03-23 02:51:25 +00009288 // exceed the column limit, starting a new alignment sequence whenever it
Daniel Jaspere12597c2015-10-01 10:06:54 +00009289 // happens.
9290 Alignment.AlignConsecutiveAssignments = true;
9291 Alignment.ColumnLimit = 30;
9292 verifyFormat("float ii = 1;\n"
9293 "unsigned j = 2;\n"
9294 "int someVerylongVariable = 1;\n"
9295 "AnotherLongType ll = 123456;\n"
9296 "VeryVeryLongType k = 2;\n"
9297 "int myvar = 1;",
9298 Alignment);
9299 Alignment.ColumnLimit = 80;
Daniel Jasperec90e512015-12-01 12:00:43 +00009300 Alignment.AlignConsecutiveAssignments = false;
9301
9302 verifyFormat(
9303 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n"
9304 " typename LongType, typename B>\n"
9305 "auto foo() {}\n",
9306 Alignment);
9307 verifyFormat("float a, b = 1;\n"
9308 "int c = 2;\n"
9309 "int dd = 3;\n",
9310 Alignment);
9311 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n"
9312 "float b[1][] = {{3.f}};\n",
9313 Alignment);
9314 Alignment.AlignConsecutiveAssignments = true;
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 = false;
9323
9324 Alignment.ColumnLimit = 30;
9325 Alignment.BinPackParameters = false;
9326 verifyFormat("void foo(float a,\n"
9327 " float b,\n"
9328 " int c,\n"
9329 " uint32_t *d) {\n"
9330 " int * e = 0;\n"
9331 " float f = 0;\n"
9332 " double g = 0;\n"
9333 "}\n"
9334 "void bar(ino_t a,\n"
9335 " int b,\n"
9336 " uint32_t *c,\n"
9337 " bool d) {}\n",
9338 Alignment);
9339 Alignment.BinPackParameters = true;
9340 Alignment.ColumnLimit = 80;
Daniel Jasper4917af62017-08-25 19:14:53 +00009341
9342 // Bug 33507
9343 Alignment.PointerAlignment = FormatStyle::PAS_Middle;
9344 verifyFormat(
9345 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n"
9346 " static const Version verVs2017;\n"
9347 " return true;\n"
9348 "});\n",
9349 Alignment);
9350 Alignment.PointerAlignment = FormatStyle::PAS_Right;
Daniel Jaspere12597c2015-10-01 10:06:54 +00009351}
9352
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009353TEST_F(FormatTest, LinuxBraceBreaking) {
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009354 FormatStyle LinuxBraceStyle = getLLVMStyle();
9355 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009356 verifyFormat("namespace a\n"
9357 "{\n"
9358 "class A\n"
9359 "{\n"
9360 " void f()\n"
9361 " {\n"
9362 " if (true) {\n"
9363 " a();\n"
9364 " b();\n"
Daniel Jasper96cbb502015-12-14 08:33:07 +00009365 " } else {\n"
9366 " a();\n"
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009367 " }\n"
9368 " }\n"
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00009369 " void g() { return; }\n"
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009370 "};\n"
9371 "struct B {\n"
9372 " int x;\n"
9373 "};\n"
Marek Kurdejcaf6fd52017-09-27 07:51:51 +00009374 "} // namespace a\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009375 LinuxBraceStyle);
9376 verifyFormat("enum X {\n"
9377 " Y = 0,\n"
9378 "}\n",
9379 LinuxBraceStyle);
9380 verifyFormat("struct S {\n"
9381 " int Type;\n"
9382 " union {\n"
9383 " int x;\n"
9384 " double y;\n"
9385 " } Value;\n"
9386 " class C\n"
9387 " {\n"
9388 " MyFavoriteType Value;\n"
9389 " } Class;\n"
9390 "}\n",
9391 LinuxBraceStyle);
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009392}
9393
Birunthan Mohanathas305fa9c2015-07-12 03:13:54 +00009394TEST_F(FormatTest, MozillaBraceBreaking) {
9395 FormatStyle MozillaBraceStyle = getLLVMStyle();
9396 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00009397 MozillaBraceStyle.FixNamespaceComments = false;
Birunthan Mohanathas305fa9c2015-07-12 03:13:54 +00009398 verifyFormat("namespace a {\n"
9399 "class A\n"
9400 "{\n"
9401 " void f()\n"
9402 " {\n"
9403 " if (true) {\n"
9404 " a();\n"
9405 " b();\n"
9406 " }\n"
9407 " }\n"
9408 " void g() { return; }\n"
9409 "};\n"
9410 "enum E\n"
9411 "{\n"
9412 " A,\n"
9413 " // foo\n"
9414 " B,\n"
9415 " C\n"
9416 "};\n"
9417 "struct B\n"
9418 "{\n"
9419 " int x;\n"
9420 "};\n"
9421 "}\n",
9422 MozillaBraceStyle);
9423 verifyFormat("struct S\n"
9424 "{\n"
9425 " int Type;\n"
9426 " union\n"
9427 " {\n"
9428 " int x;\n"
9429 " double y;\n"
9430 " } Value;\n"
9431 " class C\n"
9432 " {\n"
9433 " MyFavoriteType Value;\n"
9434 " } Class;\n"
9435 "}\n",
9436 MozillaBraceStyle);
9437}
9438
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009439TEST_F(FormatTest, StroustrupBraceBreaking) {
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009440 FormatStyle StroustrupBraceStyle = getLLVMStyle();
9441 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009442 verifyFormat("namespace a {\n"
9443 "class A {\n"
9444 " void f()\n"
9445 " {\n"
9446 " if (true) {\n"
9447 " a();\n"
9448 " b();\n"
9449 " }\n"
9450 " }\n"
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00009451 " void g() { return; }\n"
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009452 "};\n"
9453 "struct B {\n"
9454 " int x;\n"
9455 "};\n"
Krasimir Georgiev9163fe22017-03-02 09:54:44 +00009456 "} // namespace a\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009457 StroustrupBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009458
Daniel Jasperd9670872014-08-05 12:06:20 +00009459 verifyFormat("void foo()\n"
9460 "{\n"
9461 " if (a) {\n"
9462 " a();\n"
9463 " }\n"
9464 " else {\n"
9465 " b();\n"
9466 " }\n"
9467 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009468 StroustrupBraceStyle);
Daniel Jasperd9670872014-08-05 12:06:20 +00009469
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009470 verifyFormat("#ifdef _DEBUG\n"
9471 "int foo(int i = 0)\n"
9472 "#else\n"
9473 "int foo(int i = 5)\n"
9474 "#endif\n"
9475 "{\n"
9476 " return i;\n"
9477 "}",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009478 StroustrupBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009479
9480 verifyFormat("void foo() {}\n"
9481 "void bar()\n"
9482 "#ifdef _DEBUG\n"
9483 "{\n"
9484 " foo();\n"
9485 "}\n"
9486 "#else\n"
9487 "{\n"
9488 "}\n"
9489 "#endif",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009490 StroustrupBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009491
9492 verifyFormat("void foobar() { int i = 5; }\n"
9493 "#ifdef _DEBUG\n"
9494 "void bar() {}\n"
9495 "#else\n"
9496 "void bar() { foobar(); }\n"
9497 "#endif",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009498 StroustrupBraceStyle);
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009499}
9500
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00009501TEST_F(FormatTest, AllmanBraceBreaking) {
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009502 FormatStyle AllmanBraceStyle = getLLVMStyle();
9503 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;
Marek Kurdejcaf6fd52017-09-27 07:51:51 +00009504
9505 EXPECT_EQ("namespace a\n"
9506 "{\n"
9507 "void f();\n"
9508 "void g();\n"
9509 "} // namespace a\n",
9510 format("namespace a\n"
9511 "{\n"
9512 "void f();\n"
9513 "void g();\n"
9514 "}\n",
9515 AllmanBraceStyle));
9516
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00009517 verifyFormat("namespace a\n"
9518 "{\n"
9519 "class A\n"
9520 "{\n"
9521 " void f()\n"
9522 " {\n"
9523 " if (true)\n"
9524 " {\n"
9525 " a();\n"
9526 " b();\n"
9527 " }\n"
9528 " }\n"
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00009529 " void g() { return; }\n"
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009530 "};\n"
9531 "struct B\n"
9532 "{\n"
9533 " int x;\n"
9534 "};\n"
Marek Kurdejcaf6fd52017-09-27 07:51:51 +00009535 "} // namespace a",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009536 AllmanBraceStyle);
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00009537
9538 verifyFormat("void f()\n"
9539 "{\n"
9540 " if (true)\n"
9541 " {\n"
9542 " a();\n"
9543 " }\n"
9544 " else if (false)\n"
9545 " {\n"
9546 " b();\n"
9547 " }\n"
9548 " else\n"
9549 " {\n"
9550 " c();\n"
9551 " }\n"
9552 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009553 AllmanBraceStyle);
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00009554
9555 verifyFormat("void f()\n"
9556 "{\n"
9557 " for (int i = 0; i < 10; ++i)\n"
9558 " {\n"
9559 " a();\n"
9560 " }\n"
9561 " while (false)\n"
9562 " {\n"
9563 " b();\n"
9564 " }\n"
9565 " do\n"
9566 " {\n"
9567 " c();\n"
9568 " } while (false)\n"
9569 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009570 AllmanBraceStyle);
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00009571
9572 verifyFormat("void f(int a)\n"
9573 "{\n"
9574 " switch (a)\n"
9575 " {\n"
9576 " case 0:\n"
9577 " break;\n"
9578 " case 1:\n"
9579 " {\n"
9580 " break;\n"
9581 " }\n"
9582 " case 2:\n"
9583 " {\n"
9584 " }\n"
9585 " break;\n"
9586 " default:\n"
9587 " break;\n"
9588 " }\n"
9589 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009590 AllmanBraceStyle);
Manuel Klimeka027f302013-08-07 19:20:45 +00009591
9592 verifyFormat("enum X\n"
9593 "{\n"
9594 " Y = 0,\n"
9595 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009596 AllmanBraceStyle);
Daniel Jaspere18ff372014-06-02 10:17:32 +00009597 verifyFormat("enum X\n"
9598 "{\n"
9599 " Y = 0\n"
9600 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009601 AllmanBraceStyle);
Manuel Klimeka027f302013-08-07 19:20:45 +00009602
Dinesh Dwivediea3aca82014-05-02 17:01:46 +00009603 verifyFormat("@interface BSApplicationController ()\n"
9604 "{\n"
9605 "@private\n"
9606 " id _extraIvar;\n"
9607 "}\n"
9608 "@end\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009609 AllmanBraceStyle);
Dinesh Dwivediea3aca82014-05-02 17:01:46 +00009610
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009611 verifyFormat("#ifdef _DEBUG\n"
9612 "int foo(int i = 0)\n"
9613 "#else\n"
9614 "int foo(int i = 5)\n"
9615 "#endif\n"
9616 "{\n"
9617 " return i;\n"
9618 "}",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009619 AllmanBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009620
9621 verifyFormat("void foo() {}\n"
9622 "void bar()\n"
9623 "#ifdef _DEBUG\n"
9624 "{\n"
9625 " foo();\n"
9626 "}\n"
9627 "#else\n"
9628 "{\n"
9629 "}\n"
9630 "#endif",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009631 AllmanBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009632
9633 verifyFormat("void foobar() { int i = 5; }\n"
9634 "#ifdef _DEBUG\n"
9635 "void bar() {}\n"
9636 "#else\n"
9637 "void bar() { foobar(); }\n"
9638 "#endif",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009639 AllmanBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009640
Daniel Jasperba1b6bb2014-05-26 07:24:34 +00009641 // This shouldn't affect ObjC blocks..
Daniel Jasper565ed5e2014-05-22 13:53:55 +00009642 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +00009643 " // ...\n"
9644 " int i;\n"
Daniel Jasperba1b6bb2014-05-26 07:24:34 +00009645 "}];",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009646 AllmanBraceStyle);
Daniel Jasper565ed5e2014-05-22 13:53:55 +00009647 verifyFormat("void (^block)(void) = ^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +00009648 " // ...\n"
9649 " int i;\n"
Daniel Jasperba1b6bb2014-05-26 07:24:34 +00009650 "};",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009651 AllmanBraceStyle);
Daniel Jasperba1b6bb2014-05-26 07:24:34 +00009652 // .. or dict literals.
9653 verifyFormat("void f()\n"
9654 "{\n"
Alexander Kornienkod4fa2e62017-04-11 09:55:00 +00009655 " // ...\n"
9656 " [object someMethod:@{@\"a\" : @\"b\"}];\n"
9657 "}",
9658 AllmanBraceStyle);
9659 verifyFormat("void f()\n"
9660 "{\n"
9661 " // ...\n"
9662 " [object someMethod:@{a : @\"b\"}];\n"
Daniel Jasperba1b6bb2014-05-26 07:24:34 +00009663 "}",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009664 AllmanBraceStyle);
Daniel Jasper55aed672014-12-07 16:44:49 +00009665 verifyFormat("int f()\n"
9666 "{ // comment\n"
9667 " return 42;\n"
9668 "}",
9669 AllmanBraceStyle);
Daniel Jasper565ed5e2014-05-22 13:53:55 +00009670
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009671 AllmanBraceStyle.ColumnLimit = 19;
9672 verifyFormat("void f() { int i; }", AllmanBraceStyle);
9673 AllmanBraceStyle.ColumnLimit = 18;
Daniel Jasper234379f2013-12-24 13:31:25 +00009674 verifyFormat("void f()\n"
9675 "{\n"
9676 " int i;\n"
9677 "}",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009678 AllmanBraceStyle);
9679 AllmanBraceStyle.ColumnLimit = 80;
Daniel Jasper234379f2013-12-24 13:31:25 +00009680
Roman Kashitsyna043ced2014-08-11 12:18:01 +00009681 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle;
Manuel Klimeka027f302013-08-07 19:20:45 +00009682 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = true;
9683 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
9684 verifyFormat("void f(bool b)\n"
9685 "{\n"
9686 " if (b)\n"
9687 " {\n"
9688 " return;\n"
9689 " }\n"
9690 "}\n",
9691 BreakBeforeBraceShortIfs);
9692 verifyFormat("void f(bool b)\n"
9693 "{\n"
Daniel Jasper6a7d5a72017-06-19 07:40:49 +00009694 " if constexpr (b)\n"
9695 " {\n"
9696 " return;\n"
9697 " }\n"
9698 "}\n",
9699 BreakBeforeBraceShortIfs);
9700 verifyFormat("void f(bool b)\n"
9701 "{\n"
Manuel Klimeka027f302013-08-07 19:20:45 +00009702 " if (b) return;\n"
9703 "}\n",
9704 BreakBeforeBraceShortIfs);
9705 verifyFormat("void f(bool b)\n"
9706 "{\n"
Daniel Jasper6a7d5a72017-06-19 07:40:49 +00009707 " if constexpr (b) return;\n"
9708 "}\n",
9709 BreakBeforeBraceShortIfs);
9710 verifyFormat("void f(bool b)\n"
9711 "{\n"
Manuel Klimeka027f302013-08-07 19:20:45 +00009712 " while (b)\n"
9713 " {\n"
9714 " return;\n"
9715 " }\n"
9716 "}\n",
9717 BreakBeforeBraceShortIfs);
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00009718}
9719
Alexander Kornienko3a33f022013-12-12 09:49:52 +00009720TEST_F(FormatTest, GNUBraceBreaking) {
9721 FormatStyle GNUBraceStyle = getLLVMStyle();
9722 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU;
9723 verifyFormat("namespace a\n"
9724 "{\n"
9725 "class A\n"
9726 "{\n"
9727 " void f()\n"
9728 " {\n"
9729 " int a;\n"
9730 " {\n"
9731 " int b;\n"
9732 " }\n"
9733 " if (true)\n"
9734 " {\n"
9735 " a();\n"
9736 " b();\n"
9737 " }\n"
9738 " }\n"
9739 " void g() { return; }\n"
9740 "}\n"
Marek Kurdejcaf6fd52017-09-27 07:51:51 +00009741 "} // namespace a",
Alexander Kornienko3a33f022013-12-12 09:49:52 +00009742 GNUBraceStyle);
9743
9744 verifyFormat("void f()\n"
9745 "{\n"
9746 " if (true)\n"
9747 " {\n"
9748 " a();\n"
9749 " }\n"
9750 " else if (false)\n"
9751 " {\n"
9752 " b();\n"
9753 " }\n"
9754 " else\n"
9755 " {\n"
9756 " c();\n"
9757 " }\n"
9758 "}\n",
9759 GNUBraceStyle);
9760
9761 verifyFormat("void f()\n"
9762 "{\n"
9763 " for (int i = 0; i < 10; ++i)\n"
9764 " {\n"
9765 " a();\n"
9766 " }\n"
9767 " while (false)\n"
9768 " {\n"
9769 " b();\n"
9770 " }\n"
9771 " do\n"
9772 " {\n"
9773 " c();\n"
9774 " }\n"
9775 " while (false);\n"
9776 "}\n",
9777 GNUBraceStyle);
9778
9779 verifyFormat("void f(int a)\n"
9780 "{\n"
9781 " switch (a)\n"
9782 " {\n"
9783 " case 0:\n"
9784 " break;\n"
9785 " case 1:\n"
9786 " {\n"
9787 " break;\n"
9788 " }\n"
9789 " case 2:\n"
9790 " {\n"
9791 " }\n"
9792 " break;\n"
9793 " default:\n"
9794 " break;\n"
9795 " }\n"
9796 "}\n",
9797 GNUBraceStyle);
9798
9799 verifyFormat("enum X\n"
9800 "{\n"
9801 " Y = 0,\n"
9802 "}\n",
9803 GNUBraceStyle);
Dinesh Dwivediea3aca82014-05-02 17:01:46 +00009804
9805 verifyFormat("@interface BSApplicationController ()\n"
9806 "{\n"
9807 "@private\n"
9808 " id _extraIvar;\n"
9809 "}\n"
9810 "@end\n",
9811 GNUBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00009812
9813 verifyFormat("#ifdef _DEBUG\n"
9814 "int foo(int i = 0)\n"
9815 "#else\n"
9816 "int foo(int i = 5)\n"
9817 "#endif\n"
9818 "{\n"
9819 " return i;\n"
9820 "}",
9821 GNUBraceStyle);
9822
9823 verifyFormat("void foo() {}\n"
9824 "void bar()\n"
9825 "#ifdef _DEBUG\n"
9826 "{\n"
9827 " foo();\n"
9828 "}\n"
9829 "#else\n"
9830 "{\n"
9831 "}\n"
9832 "#endif",
9833 GNUBraceStyle);
9834
9835 verifyFormat("void foobar() { int i = 5; }\n"
9836 "#ifdef _DEBUG\n"
9837 "void bar() {}\n"
9838 "#else\n"
9839 "void bar() { foobar(); }\n"
9840 "#endif",
9841 GNUBraceStyle);
Alexander Kornienko3a33f022013-12-12 09:49:52 +00009842}
Roman Kashitsyn291f64f2015-08-10 13:43:19 +00009843
9844TEST_F(FormatTest, WebKitBraceBreaking) {
9845 FormatStyle WebKitBraceStyle = getLLVMStyle();
9846 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit;
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00009847 WebKitBraceStyle.FixNamespaceComments = false;
Roman Kashitsyn291f64f2015-08-10 13:43:19 +00009848 verifyFormat("namespace a {\n"
9849 "class A {\n"
9850 " void f()\n"
9851 " {\n"
9852 " if (true) {\n"
9853 " a();\n"
9854 " b();\n"
9855 " }\n"
9856 " }\n"
9857 " void g() { return; }\n"
9858 "};\n"
9859 "enum E {\n"
9860 " A,\n"
9861 " // foo\n"
9862 " B,\n"
9863 " C\n"
9864 "};\n"
9865 "struct B {\n"
9866 " int x;\n"
9867 "};\n"
9868 "}\n",
9869 WebKitBraceStyle);
9870 verifyFormat("struct S {\n"
9871 " int Type;\n"
9872 " union {\n"
9873 " int x;\n"
9874 " double y;\n"
9875 " } Value;\n"
9876 " class C {\n"
9877 " MyFavoriteType Value;\n"
9878 " } Class;\n"
9879 "};\n",
9880 WebKitBraceStyle);
9881}
9882
Manuel Klimekd5735502013-08-12 03:51:17 +00009883TEST_F(FormatTest, CatchExceptionReferenceBinding) {
9884 verifyFormat("void f() {\n"
9885 " try {\n"
Daniel Jasper04a71a42014-05-08 11:58:24 +00009886 " } catch (const Exception &e) {\n"
Manuel Klimekd5735502013-08-12 03:51:17 +00009887 " }\n"
9888 "}\n",
9889 getLLVMStyle());
9890}
9891
Daniel Jasper9613c812013-08-07 16:29:23 +00009892TEST_F(FormatTest, UnderstandsPragmas) {
9893 verifyFormat("#pragma omp reduction(| : var)");
9894 verifyFormat("#pragma omp reduction(+ : var)");
Daniel Jasperdc32c1b2014-01-09 13:56:49 +00009895
9896 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
9897 "(including parentheses).",
9898 format("#pragma mark Any non-hyphenated or hyphenated string "
9899 "(including parentheses)."));
Daniel Jasper9613c812013-08-07 16:29:23 +00009900}
9901
Daniel Jasperee4a8a12015-04-22 09:45:42 +00009902TEST_F(FormatTest, UnderstandPragmaOption) {
9903 verifyFormat("#pragma option -C -A");
9904
9905 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A"));
9906}
9907
Manuel Klimek77866142017-11-17 11:17:15 +00009908TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) {
9909 FormatStyle Style = getLLVMStyle();
9910 Style.ColumnLimit = 20;
9911
9912 verifyFormat("int a; // the\n"
9913 " // comment", Style);
9914 EXPECT_EQ("int a; /* first line\n"
9915 " * second\n"
9916 " * line third\n"
9917 " * line\n"
9918 " */",
9919 format("int a; /* first line\n"
9920 " * second\n"
9921 " * line third\n"
9922 " * line\n"
9923 " */",
9924 Style));
9925 EXPECT_EQ("int a; // first line\n"
9926 " // second\n"
9927 " // line third\n"
9928 " // line",
9929 format("int a; // first line\n"
9930 " // second line\n"
9931 " // third line",
9932 Style));
9933
9934 Style.PenaltyExcessCharacter = 90;
9935 verifyFormat("int a; // the comment", Style);
Manuel Klimek93699f42017-11-29 14:29:43 +00009936 EXPECT_EQ("int a; // the comment\n"
Manuel Klimek0b58c322017-12-01 13:28:08 +00009937 " // aaa",
9938 format("int a; // the comment aaa", Style));
Manuel Klimek77866142017-11-17 11:17:15 +00009939 EXPECT_EQ("int a; /* first line\n"
9940 " * second line\n"
9941 " * third line\n"
9942 " */",
9943 format("int a; /* first line\n"
9944 " * second line\n"
9945 " * third line\n"
9946 " */",
9947 Style));
Manuel Klimek93699f42017-11-29 14:29:43 +00009948 EXPECT_EQ("int a; // first line\n"
9949 " // second line\n"
9950 " // third line",
9951 format("int a; // first line\n"
9952 " // second line\n"
9953 " // third line",
9954 Style));
Manuel Klimek77866142017-11-17 11:17:15 +00009955 // FIXME: Investigate why this is not getting the same layout as the test
9956 // above.
9957 EXPECT_EQ("int a; /* first line\n"
Manuel Klimek93699f42017-11-29 14:29:43 +00009958 " * second line\n"
9959 " * third line\n"
Manuel Klimek77866142017-11-17 11:17:15 +00009960 " */",
9961 format("int a; /* first line second line third line"
9962 "\n*/",
9963 Style));
9964
9965 EXPECT_EQ("// foo bar baz bazfoo\n"
Manuel Klimek0b58c322017-12-01 13:28:08 +00009966 "// foo bar foo bar\n",
Manuel Klimek77866142017-11-17 11:17:15 +00009967 format("// foo bar baz bazfoo\n"
Manuel Klimek0b58c322017-12-01 13:28:08 +00009968 "// foo bar foo bar\n",
Manuel Klimek77866142017-11-17 11:17:15 +00009969 Style));
9970 EXPECT_EQ("// foo bar baz bazfoo\n"
Manuel Klimek0b58c322017-12-01 13:28:08 +00009971 "// foo bar foo bar\n",
Manuel Klimek77866142017-11-17 11:17:15 +00009972 format("// foo bar baz bazfoo\n"
Manuel Klimek0b58c322017-12-01 13:28:08 +00009973 "// foo bar foo bar\n",
Manuel Klimek77866142017-11-17 11:17:15 +00009974 Style));
9975
9976 // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the
9977 // next one.
Manuel Klimek93699f42017-11-29 14:29:43 +00009978 EXPECT_EQ("// foo bar baz bazfoo\n"
9979 "// bar foo bar\n",
Manuel Klimek77866142017-11-17 11:17:15 +00009980 format("// foo bar baz bazfoo bar\n"
9981 "// foo bar\n",
9982 Style));
9983
9984 EXPECT_EQ("// foo bar baz bazfoo\n"
Manuel Klimek93699f42017-11-29 14:29:43 +00009985 "// foo bar baz bazfoo\n"
9986 "// bar foo bar\n",
Manuel Klimek77866142017-11-17 11:17:15 +00009987 format("// foo bar baz bazfoo\n"
9988 "// foo bar baz bazfoo bar\n"
9989 "// foo bar\n",
9990 Style));
9991
Manuel Klimek77866142017-11-17 11:17:15 +00009992 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));
Manuel Klimek0b58c322017-12-01 13:28:08 +00009999
10000 // Make sure we do not keep protruding characters if strict mode reflow is
10001 // cheaper than keeping protruding characters.
10002 Style.ColumnLimit = 21;
10003 EXPECT_EQ("// foo foo foo foo\n"
10004 "// foo foo foo foo\n"
10005 "// foo foo foo foo\n",
10006 format("// foo foo foo foo foo foo foo foo foo foo foo foo\n",
10007 Style));
10008
10009 EXPECT_EQ("int a = /* long block\n"
10010 " comment */\n"
10011 " 42;",
10012 format("int a = /* long block comment */ 42;", Style));
Manuel Klimek77866142017-11-17 11:17:15 +000010013}
10014
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010015#define EXPECT_ALL_STYLES_EQUAL(Styles) \
10016 for (size_t i = 1; i < Styles.size(); ++i) \
Daniel Jaspera44991332015-04-29 13:06:49 +000010017 EXPECT_EQ(Styles[0], Styles[i]) << "Style #" << i << " of " << Styles.size() \
10018 << " differs from Style #0"
Alexander Kornienkod6538332013-05-07 15:32:14 +000010019
10020TEST_F(FormatTest, GetsPredefinedStyleByName) {
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010021 SmallVector<FormatStyle, 3> Styles;
10022 Styles.resize(3);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010023
Alexander Kornienko006b5c82013-05-19 00:53:30 +000010024 Styles[0] = getLLVMStyle();
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010025 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
10026 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
10027 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010028
Alexander Kornienko006b5c82013-05-19 00:53:30 +000010029 Styles[0] = getGoogleStyle();
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010030 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
10031 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
10032 EXPECT_ALL_STYLES_EQUAL(Styles);
10033
Nico Weber514ecc82014-02-02 20:50:45 +000010034 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010035 EXPECT_TRUE(
10036 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
10037 EXPECT_TRUE(
10038 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
10039 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010040
Nico Weber514ecc82014-02-02 20:50:45 +000010041 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010042 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
10043 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
10044 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienko006b5c82013-05-19 00:53:30 +000010045
10046 Styles[0] = getMozillaStyle();
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010047 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
10048 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
10049 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienko006b5c82013-05-19 00:53:30 +000010050
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010051 Styles[0] = getWebKitStyle();
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010052 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
10053 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
10054 EXPECT_ALL_STYLES_EQUAL(Styles);
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010055
Alexander Kornienkofe7a57f2013-12-10 15:42:15 +000010056 Styles[0] = getGNUStyle();
10057 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
10058 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
10059 EXPECT_ALL_STYLES_EQUAL(Styles);
10060
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010061 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
10062}
10063
10064TEST_F(FormatTest, GetsCorrectBasedOnStyle) {
10065 SmallVector<FormatStyle, 8> Styles;
10066 Styles.resize(2);
10067
10068 Styles[0] = getGoogleStyle();
10069 Styles[1] = getLLVMStyle();
10070 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
10071 EXPECT_ALL_STYLES_EQUAL(Styles);
10072
10073 Styles.resize(5);
Nico Weber514ecc82014-02-02 20:50:45 +000010074 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010075 Styles[1] = getLLVMStyle();
10076 Styles[1].Language = FormatStyle::LK_JavaScript;
10077 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
10078
10079 Styles[2] = getLLVMStyle();
10080 Styles[2].Language = FormatStyle::LK_JavaScript;
10081 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
10082 "BasedOnStyle: Google",
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +000010083 &Styles[2])
10084 .value());
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010085
10086 Styles[3] = getLLVMStyle();
10087 Styles[3].Language = FormatStyle::LK_JavaScript;
10088 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
10089 "Language: JavaScript",
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +000010090 &Styles[3])
10091 .value());
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010092
10093 Styles[4] = getLLVMStyle();
10094 Styles[4].Language = FormatStyle::LK_JavaScript;
10095 EXPECT_EQ(0, parseConfiguration("---\n"
10096 "BasedOnStyle: LLVM\n"
10097 "IndentWidth: 123\n"
10098 "---\n"
10099 "BasedOnStyle: Google\n"
10100 "Language: JavaScript",
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +000010101 &Styles[4])
10102 .value());
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010103 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010104}
10105
Daniel Jasper91881d92014-09-29 08:07:46 +000010106#define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \
Alexander Kornienkod6538332013-05-07 15:32:14 +000010107 Style.FIELD = false; \
Daniel Jasper91881d92014-09-29 08:07:46 +000010108 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \
Alexander Kornienko006b5c82013-05-19 00:53:30 +000010109 EXPECT_TRUE(Style.FIELD); \
Daniel Jasper91881d92014-09-29 08:07:46 +000010110 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \
Patrik Hagglund76aca642013-05-14 07:53:53 +000010111 EXPECT_FALSE(Style.FIELD);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010112
Daniel Jasper91881d92014-09-29 08:07:46 +000010113#define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
10114
Daniel Jasperc1bc38e2015-09-29 14:57:55 +000010115#define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \
10116 Style.STRUCT.FIELD = false; \
10117 EXPECT_EQ(0, \
10118 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \
10119 .value()); \
10120 EXPECT_TRUE(Style.STRUCT.FIELD); \
10121 EXPECT_EQ(0, \
10122 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \
10123 .value()); \
10124 EXPECT_FALSE(Style.STRUCT.FIELD);
10125
10126#define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \
10127 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD)
10128
Daniel Jasper00853002014-09-16 16:22:30 +000010129#define CHECK_PARSE(TEXT, FIELD, VALUE) \
10130 EXPECT_NE(VALUE, Style.FIELD); \
10131 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \
10132 EXPECT_EQ(VALUE, Style.FIELD)
10133
Alexander Kornienkoc6221a52014-08-14 13:07:35 +000010134TEST_F(FormatTest, ParsesConfigurationBools) {
Alexander Kornienkocabdd732013-11-29 15:19:43 +000010135 FormatStyle Style = {};
10136 Style.Language = FormatStyle::LK_Cpp;
Daniel Jasper3219e432014-12-02 13:24:51 +000010137 CHECK_PARSE_BOOL(AlignOperands);
Daniel Jasper552f4a72013-07-31 23:55:15 +000010138 CHECK_PARSE_BOOL(AlignTrailingComments);
Daniel Jaspera44991332015-04-29 13:06:49 +000010139 CHECK_PARSE_BOOL(AlignConsecutiveAssignments);
Daniel Jaspere12597c2015-10-01 10:06:54 +000010140 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010141 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
Daniel Jasper17605d32014-05-14 09:33:35 +000010142 CHECK_PARSE_BOOL(AllowShortBlocksOnASingleLine);
Daniel Jasperb87899b2014-09-10 13:11:45 +000010143 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010144 CHECK_PARSE_BOOL(AllowShortIfStatementsOnASingleLine);
Daniel Jasper997af662013-05-16 12:16:23 +000010145 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
Daniel Jasper61e6bbf2013-05-29 12:07:31 +000010146 CHECK_PARSE_BOOL(AlwaysBreakTemplateDeclarations);
Daniel Jasper18210d72014-10-09 09:52:05 +000010147 CHECK_PARSE_BOOL(BinPackArguments);
Daniel Jasper6501f7e2015-10-27 12:38:37 +000010148 CHECK_PARSE_BOOL(BinPackParameters);
Daniel Jaspere1a7b762016-02-01 11:21:02 +000010149 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
Daniel Jasper165b29e2013-11-08 00:57:11 +000010150 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
Daniel Jaspere1a7b762016-02-01 11:21:02 +000010151 CHECK_PARSE_BOOL(BreakStringLiterals);
Andi-Bogdan Postelnicu0ef8ee12017-03-10 15:10:37 +000010152 CHECK_PARSE_BOOL(BreakBeforeInheritanceComma)
Francois Ferrande56a8292017-06-14 12:29:47 +000010153 CHECK_PARSE_BOOL(CompactNamespaces);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010154 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
Daniel Jasper553d4872014-06-17 12:40:34 +000010155 CHECK_PARSE_BOOL(DerivePointerAlignment);
Daniel Jasper91881d92014-09-29 08:07:46 +000010156 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
Daniel Jasperda446772015-11-16 12:38:56 +000010157 CHECK_PARSE_BOOL(DisableFormat);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010158 CHECK_PARSE_BOOL(IndentCaseLabels);
Daniel Jasperc75e1ef2014-07-09 08:42:42 +000010159 CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
Daniel Jaspera26fc5c2014-03-21 13:43:14 +000010160 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
Daniel Jaspere9beea22014-01-28 15:20:33 +000010161 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010162 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
Daniel Jasper6ab54682013-07-16 18:22:10 +000010163 CHECK_PARSE_BOOL(Cpp11BracedListStyle);
Daniel Jaspera0a50392015-12-01 13:28:53 +000010164 CHECK_PARSE_BOOL(ReflowComments);
Daniel Jasperda446772015-11-16 12:38:56 +000010165 CHECK_PARSE_BOOL(SortIncludes);
Krasimir Georgievac16a202017-06-23 11:46:03 +000010166 CHECK_PARSE_BOOL(SortUsingDeclarations);
Daniel Jasperb55acad2013-08-20 12:36:34 +000010167 CHECK_PARSE_BOOL(SpacesInParentheses);
Daniel Jasperad981f82014-08-26 11:41:14 +000010168 CHECK_PARSE_BOOL(SpacesInSquareBrackets);
Daniel Jasperdd978ae2013-10-29 14:52:02 +000010169 CHECK_PARSE_BOOL(SpacesInAngles);
Daniel Jasperb55acad2013-08-20 12:36:34 +000010170 CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
Daniel Jasperb2e10a52014-01-15 15:09:08 +000010171 CHECK_PARSE_BOOL(SpacesInContainerLiterals);
Daniel Jasperb55acad2013-08-20 12:36:34 +000010172 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
Daniel Jasperdb986eb2014-09-03 07:37:29 +000010173 CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
Sylvestre Ledru83bbd572016-08-09 14:24:40 +000010174 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
Daniel Jasperd94bff32013-09-25 15:15:02 +000010175 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
Daniel Jasperc1bc38e2015-09-29 14:57:55 +000010176
10177 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass);
10178 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterControlStatement);
10179 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum);
10180 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction);
10181 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace);
10182 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration);
10183 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct);
10184 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion);
Krasimir Georgievd6ce9372017-09-15 11:23:50 +000010185 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock);
Daniel Jasperc1bc38e2015-09-29 14:57:55 +000010186 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch);
10187 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse);
10188 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces);
Francois Ferrandad722562017-06-30 20:25:55 +000010189 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction);
10190 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord);
10191 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace);
Alexander Kornienkoc6221a52014-08-14 13:07:35 +000010192}
Alexander Kornienkod6538332013-05-07 15:32:14 +000010193
Alexander Kornienkoc6221a52014-08-14 13:07:35 +000010194#undef CHECK_PARSE_BOOL
10195
Alexander Kornienkoc6221a52014-08-14 13:07:35 +000010196TEST_F(FormatTest, ParsesConfiguration) {
10197 FormatStyle Style = {};
10198 Style.Language = FormatStyle::LK_Cpp;
Alexander Kornienkod6538332013-05-07 15:32:14 +000010199 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010200 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
10201 ConstructorInitializerIndentWidth, 1234u);
Daniel Jasper50d634b2014-10-28 16:53:38 +000010202 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010203 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
10204 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
Francois Ferrand9976efa2017-05-22 08:28:17 +000010205 CHECK_PARSE("PenaltyBreakAssignment: 1234",
10206 PenaltyBreakAssignment, 1234u);
Daniel Jasper33b909c2013-10-25 14:29:37 +000010207 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
10208 PenaltyBreakBeforeFirstCallParameter, 1234u);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010209 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
10210 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
10211 PenaltyReturnTypeOnItsOwnLine, 1234u);
10212 CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
10213 SpacesBeforeTrailingComments, 1234u);
Manuel Klimek13b97d82013-05-13 08:42:42 +000010214 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
Daniel Jasper6633ab82013-10-18 10:38:14 +000010215 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
Daniel Jasper9c8ff352016-03-21 14:11:27 +000010216 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
Alexander Kornienkod6538332013-05-07 15:32:14 +000010217
Daniel Jasper553d4872014-06-17 12:40:34 +000010218 Style.PointerAlignment = FormatStyle::PAS_Middle;
Daniel Jasperac043c92014-09-15 11:11:00 +000010219 CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
10220 FormatStyle::PAS_Left);
10221 CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
10222 FormatStyle::PAS_Right);
10223 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
10224 FormatStyle::PAS_Middle);
Daniel Jasper00853002014-09-16 16:22:30 +000010225 // For backward compatibility:
10226 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
10227 FormatStyle::PAS_Left);
10228 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
10229 FormatStyle::PAS_Right);
10230 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
10231 FormatStyle::PAS_Middle);
Daniel Jasper553d4872014-06-17 12:40:34 +000010232
Alexander Kornienkod6538332013-05-07 15:32:14 +000010233 Style.Standard = FormatStyle::LS_Auto;
Alexander Kornienkob40cfe42013-09-04 14:09:13 +000010234 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
10235 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Cpp11);
Alexander Kornienkod6538332013-05-07 15:32:14 +000010236 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
10237 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
10238 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
10239
Daniel Jasperac043c92014-09-15 11:11:00 +000010240 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
Daniel Jasperac043c92014-09-15 11:11:00 +000010241 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
10242 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
Daniel Jasperac043c92014-09-15 11:11:00 +000010243 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
10244 FormatStyle::BOS_None);
10245 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
10246 FormatStyle::BOS_All);
Daniel Jasper00853002014-09-16 16:22:30 +000010247 // For backward compatibility:
10248 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
10249 FormatStyle::BOS_None);
10250 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
10251 FormatStyle::BOS_All);
Daniel Jasperac043c92014-09-15 11:11:00 +000010252
Francois Ferranda6b6d512017-05-24 11:36:58 +000010253 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
10254 CHECK_PARSE("BreakConstructorInitializers: BeforeComma",
10255 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
10256 CHECK_PARSE("BreakConstructorInitializers: AfterColon",
10257 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon);
10258 CHECK_PARSE("BreakConstructorInitializers: BeforeColon",
10259 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon);
10260 // For backward compatibility:
10261 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true",
10262 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
10263
Daniel Jasper6501f7e2015-10-27 12:38:37 +000010264 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
10265 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
10266 FormatStyle::BAS_Align);
10267 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket,
10268 FormatStyle::BAS_DontAlign);
10269 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket,
10270 FormatStyle::BAS_AlwaysBreak);
10271 // For backward compatibility:
10272 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
10273 FormatStyle::BAS_DontAlign);
10274 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
10275 FormatStyle::BAS_Align);
10276
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +000010277 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10278 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines,
10279 FormatStyle::ENAS_DontAlign);
10280 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines,
10281 FormatStyle::ENAS_Left);
10282 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines,
10283 FormatStyle::ENAS_Right);
10284 // For backward compatibility:
10285 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines,
10286 FormatStyle::ENAS_Left);
10287 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines,
10288 FormatStyle::ENAS_Right);
10289
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +000010290 Style.UseTab = FormatStyle::UT_ForIndentation;
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +000010291 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
10292 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
10293 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
Marianne Mailhot-Sarrasin51fe2792016-04-14 14:52:26 +000010294 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
10295 FormatStyle::UT_ForContinuationAndIndentation);
Daniel Jasper00853002014-09-16 16:22:30 +000010296 // For backward compatibility:
10297 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
10298 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +000010299
Daniel Jasperd74cf402014-04-08 12:46:38 +000010300 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
Daniel Jasperd74cf402014-04-08 12:46:38 +000010301 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
10302 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
10303 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
10304 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
Daniel Jasper9e709352014-11-26 10:43:58 +000010305 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
10306 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
Daniel Jasperd74cf402014-04-08 12:46:38 +000010307 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
10308 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
Daniel Jasper00853002014-09-16 16:22:30 +000010309 // For backward compatibility:
10310 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
10311 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
10312 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
10313 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
Daniel Jasperd74cf402014-04-08 12:46:38 +000010314
Alexander Kornienkofdca83d2013-12-10 10:18:34 +000010315 Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
10316 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
10317 FormatStyle::SBPO_Never);
10318 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
10319 FormatStyle::SBPO_Always);
10320 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
10321 FormatStyle::SBPO_ControlStatements);
10322 // For backward compatibility:
10323 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
10324 FormatStyle::SBPO_Never);
10325 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
10326 FormatStyle::SBPO_ControlStatements);
10327
Alexander Kornienkod6538332013-05-07 15:32:14 +000010328 Style.ColumnLimit = 123;
10329 FormatStyle BaseStyle = getLLVMStyle();
10330 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
10331 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
10332
Manuel Klimeka8eb9142013-05-13 12:51:40 +000010333 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
10334 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
10335 FormatStyle::BS_Attach);
10336 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
10337 FormatStyle::BS_Linux);
Birunthan Mohanathas305fa9c2015-07-12 03:13:54 +000010338 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces,
10339 FormatStyle::BS_Mozilla);
Manuel Klimeka8eb9142013-05-13 12:51:40 +000010340 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
10341 FormatStyle::BS_Stroustrup);
Alexander Kornienko3a33f022013-12-12 09:49:52 +000010342 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
10343 FormatStyle::BS_Allman);
10344 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
Daniel Jasperc1bc38e2015-09-29 14:57:55 +000010345 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces,
10346 FormatStyle::BS_WebKit);
10347 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces,
10348 FormatStyle::BS_Custom);
Manuel Klimeka8eb9142013-05-13 12:51:40 +000010349
Zachary Turner448592e2015-12-18 22:20:15 +000010350 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
10351 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
10352 FormatStyle::RTBS_None);
10353 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
10354 FormatStyle::RTBS_All);
10355 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",
Zachary Turner6bc7f972015-12-18 22:58:42 +000010356 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel);
Zachary Turner448592e2015-12-18 22:20:15 +000010357 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions",
10358 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions);
10359 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions",
10360 AlwaysBreakAfterReturnType,
10361 FormatStyle::RTBS_TopLevelDefinitions);
10362
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +000010363 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
10364 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None",
10365 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None);
10366 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All",
10367 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All);
10368 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel",
10369 AlwaysBreakAfterDefinitionReturnType,
10370 FormatStyle::DRTBS_TopLevel);
10371
Daniel Jasper65ee3472013-07-31 23:16:02 +000010372 Style.NamespaceIndentation = FormatStyle::NI_All;
10373 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
10374 FormatStyle::NI_None);
10375 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
10376 FormatStyle::NI_Inner);
10377 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
10378 FormatStyle::NI_All);
Daniel Jaspere1e43192014-04-01 12:55:11 +000010379
Daniel Jasper8ce1b8d2015-10-06 11:54:18 +000010380 // FIXME: This is required because parsing a configuration simply overwrites
10381 // the first N elements of the list instead of resetting it.
Daniel Jaspere1e43192014-04-01 12:55:11 +000010382 Style.ForEachMacros.clear();
Aaron Ballman2b9036d2014-04-01 16:30:35 +000010383 std::vector<std::string> BoostForeach;
10384 BoostForeach.push_back("BOOST_FOREACH");
Daniel Jaspere1e43192014-04-01 12:55:11 +000010385 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
Aaron Ballman2b9036d2014-04-01 16:30:35 +000010386 std::vector<std::string> BoostAndQForeach;
10387 BoostAndQForeach.push_back("BOOST_FOREACH");
10388 BoostAndQForeach.push_back("Q_FOREACH");
Daniel Jaspere1e43192014-04-01 12:55:11 +000010389 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
10390 BoostAndQForeach);
Daniel Jasper8ce1b8d2015-10-06 11:54:18 +000010391
10392 Style.IncludeCategories.clear();
10393 std::vector<FormatStyle::IncludeCategory> ExpectedCategories = {{"abc/.*", 2},
10394 {".*", 1}};
10395 CHECK_PARSE("IncludeCategories:\n"
10396 " - Regex: abc/.*\n"
10397 " Priority: 2\n"
10398 " - Regex: .*\n"
10399 " Priority: 1",
10400 IncludeCategories, ExpectedCategories);
Daniel Jasper9c8ff352016-03-21 14:11:27 +000010401 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeIsMainRegex, "abc$");
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +000010402
10403 Style.RawStringFormats.clear();
10404 std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = {
10405 {"pb", FormatStyle::LK_TextProto, "llvm"},
10406 {"cpp", FormatStyle::LK_Cpp, "google"}};
10407
10408 CHECK_PARSE("RawStringFormats:\n"
10409 " - Delimiter: 'pb'\n"
10410 " Language: TextProto\n"
10411 " BasedOnStyle: llvm\n"
10412 " - Delimiter: 'cpp'\n"
10413 " Language: Cpp\n"
10414 " BasedOnStyle: google",
10415 RawStringFormats, ExpectedRawStringFormats);
Alexander Kornienkocabdd732013-11-29 15:19:43 +000010416}
10417
10418TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
10419 FormatStyle Style = {};
10420 Style.Language = FormatStyle::LK_Cpp;
10421 CHECK_PARSE("Language: Cpp\n"
10422 "IndentWidth: 12",
10423 IndentWidth, 12u);
Rafael Espindola1f243172014-06-12 11:35:17 +000010424 EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
10425 "IndentWidth: 34",
10426 &Style),
10427 ParseError::Unsuitable);
Alexander Kornienkocabdd732013-11-29 15:19:43 +000010428 EXPECT_EQ(12u, Style.IndentWidth);
10429 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
10430 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
10431
10432 Style.Language = FormatStyle::LK_JavaScript;
10433 CHECK_PARSE("Language: JavaScript\n"
10434 "IndentWidth: 12",
10435 IndentWidth, 12u);
10436 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
Rafael Espindola1f243172014-06-12 11:35:17 +000010437 EXPECT_EQ(parseConfiguration("Language: Cpp\n"
10438 "IndentWidth: 34",
10439 &Style),
10440 ParseError::Unsuitable);
Alexander Kornienkocabdd732013-11-29 15:19:43 +000010441 EXPECT_EQ(23u, Style.IndentWidth);
10442 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
10443 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
10444
10445 CHECK_PARSE("BasedOnStyle: LLVM\n"
10446 "IndentWidth: 67",
10447 IndentWidth, 67u);
10448
10449 CHECK_PARSE("---\n"
10450 "Language: JavaScript\n"
10451 "IndentWidth: 12\n"
10452 "---\n"
10453 "Language: Cpp\n"
10454 "IndentWidth: 34\n"
10455 "...\n",
10456 IndentWidth, 12u);
10457
10458 Style.Language = FormatStyle::LK_Cpp;
10459 CHECK_PARSE("---\n"
10460 "Language: JavaScript\n"
10461 "IndentWidth: 12\n"
10462 "---\n"
10463 "Language: Cpp\n"
10464 "IndentWidth: 34\n"
10465 "...\n",
10466 IndentWidth, 34u);
10467 CHECK_PARSE("---\n"
10468 "IndentWidth: 78\n"
10469 "---\n"
10470 "Language: JavaScript\n"
10471 "IndentWidth: 56\n"
10472 "...\n",
10473 IndentWidth, 78u);
10474
10475 Style.ColumnLimit = 123;
10476 Style.IndentWidth = 234;
10477 Style.BreakBeforeBraces = FormatStyle::BS_Linux;
10478 Style.TabWidth = 345;
Rafael Espindola3ae06202014-05-31 03:20:52 +000010479 EXPECT_FALSE(parseConfiguration("---\n"
10480 "IndentWidth: 456\n"
10481 "BreakBeforeBraces: Allman\n"
10482 "---\n"
10483 "Language: JavaScript\n"
10484 "IndentWidth: 111\n"
10485 "TabWidth: 111\n"
10486 "---\n"
10487 "Language: Cpp\n"
10488 "BreakBeforeBraces: Stroustrup\n"
10489 "TabWidth: 789\n"
10490 "...\n",
10491 &Style));
Alexander Kornienkocabdd732013-11-29 15:19:43 +000010492 EXPECT_EQ(123u, Style.ColumnLimit);
10493 EXPECT_EQ(456u, Style.IndentWidth);
10494 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
10495 EXPECT_EQ(789u, Style.TabWidth);
10496
Rafael Espindola1f243172014-06-12 11:35:17 +000010497 EXPECT_EQ(parseConfiguration("---\n"
10498 "Language: JavaScript\n"
10499 "IndentWidth: 56\n"
10500 "---\n"
10501 "IndentWidth: 78\n"
10502 "...\n",
10503 &Style),
10504 ParseError::Error);
10505 EXPECT_EQ(parseConfiguration("---\n"
10506 "Language: JavaScript\n"
10507 "IndentWidth: 56\n"
10508 "---\n"
10509 "Language: JavaScript\n"
10510 "IndentWidth: 78\n"
10511 "...\n",
10512 &Style),
10513 ParseError::Error);
Alexander Kornienkocabdd732013-11-29 15:19:43 +000010514
10515 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
10516}
Daniel Jasper65ee3472013-07-31 23:16:02 +000010517
Alexander Kornienkod6bd7472013-12-30 16:11:28 +000010518#undef CHECK_PARSE
Alexander Kornienkod6bd7472013-12-30 16:11:28 +000010519
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010520TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
10521 FormatStyle Style = {};
10522 Style.Language = FormatStyle::LK_JavaScript;
10523 Style.BreakBeforeTernaryOperators = true;
Alexander Kornienkod6bd7472013-12-30 16:11:28 +000010524 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
Daniel Jaspere551bb72014-11-05 17:22:31 +000010525 EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
Alexander Kornienkod6bd7472013-12-30 16:11:28 +000010526
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010527 Style.BreakBeforeTernaryOperators = true;
Alexander Kornienkod6bd7472013-12-30 16:11:28 +000010528 EXPECT_EQ(0, parseConfiguration("---\n"
Daniel Jaspera44991332015-04-29 13:06:49 +000010529 "BasedOnStyle: Google\n"
10530 "---\n"
10531 "Language: JavaScript\n"
10532 "IndentWidth: 76\n"
10533 "...\n",
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +000010534 &Style)
10535 .value());
Daniel Jaspere551bb72014-11-05 17:22:31 +000010536 EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000010537 EXPECT_EQ(76u, Style.IndentWidth);
10538 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
10539}
10540
Alexander Kornienkod6538332013-05-07 15:32:14 +000010541TEST_F(FormatTest, ConfigurationRoundTripTest) {
10542 FormatStyle Style = getLLVMStyle();
10543 std::string YAML = configurationAsText(Style);
10544 FormatStyle ParsedStyle = {};
Alexander Kornienkocabdd732013-11-29 15:19:43 +000010545 ParsedStyle.Language = FormatStyle::LK_Cpp;
Alexander Kornienkod6538332013-05-07 15:32:14 +000010546 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
10547 EXPECT_EQ(Style, ParsedStyle);
10548}
10549
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010550TEST_F(FormatTest, WorksFor8bitEncodings) {
10551 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
10552 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
10553 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
10554 "\"\xef\xee\xf0\xf3...\"",
10555 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
10556 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
10557 "\xef\xee\xf0\xf3...\"",
10558 getLLVMStyleWithColumns(12)));
10559}
10560
Alexander Kornienko393e3082013-11-13 14:04:17 +000010561TEST_F(FormatTest, HandlesUTF8BOM) {
10562 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
10563 EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
10564 format("\xef\xbb\xbf#include <iostream>"));
10565 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
10566 format("\xef\xbb\xbf\n#include <iostream>"));
10567}
10568
NAKAMURA Takumi5238eba2013-06-06 01:14:58 +000010569// FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
10570#if !defined(_MSC_VER)
10571
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010572TEST_F(FormatTest, CountsUTF8CharactersProperly) {
10573 verifyFormat("\"Однажды в студёную зимнюю пору...\"",
10574 getLLVMStyleWithColumns(35));
10575 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010576 getLLVMStyleWithColumns(31));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010577 verifyFormat("// Однажды в студёную зимнюю пору...",
10578 getLLVMStyleWithColumns(36));
Daniel Jaspera44991332015-04-29 13:06:49 +000010579 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010580 verifyFormat("/* Однажды в студёную зимнюю пору... */",
10581 getLLVMStyleWithColumns(39));
10582 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010583 getLLVMStyleWithColumns(35));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010584}
10585
10586TEST_F(FormatTest, SplitsUTF8Strings) {
Alexander Kornienko71d95d62013-11-26 10:38:53 +000010587 // Non-printable characters' width is currently considered to be the length in
10588 // bytes in UTF8. The characters can be displayed in very different manner
10589 // (zero-width, single width with a substitution glyph, expanded to their code
10590 // (e.g. "<8d>"), so there's no single correct way to handle them.
10591 EXPECT_EQ("\"aaaaÄ\"\n"
Alexander Kornienkofd1d7002013-11-26 13:31:46 +000010592 "\"\xc2\x8d\";",
10593 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
Alexander Kornienko71d95d62013-11-26 10:38:53 +000010594 EXPECT_EQ("\"aaaaaaaÄ\"\n"
Alexander Kornienkofd1d7002013-11-26 13:31:46 +000010595 "\"\xc2\x8d\";",
10596 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
Daniel Jaspera44991332015-04-29 13:06:49 +000010597 EXPECT_EQ("\"Однажды, в \"\n"
10598 "\"студёную \"\n"
10599 "\"зимнюю \"\n"
10600 "\"пору,\"",
10601 format("\"Однажды, в студёную зимнюю пору,\"",
10602 getLLVMStyleWithColumns(13)));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010603 EXPECT_EQ(
Daniel Jaspera44991332015-04-29 13:06:49 +000010604 "\"一 二 三 \"\n"
10605 "\"四 五六 \"\n"
10606 "\"七 八 九 \"\n"
10607 "\"十\"",
10608 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
Manuel Klimek93699f42017-11-29 14:29:43 +000010609 EXPECT_EQ("\"一\t\"\n"
10610 "\"二 \t\"\n"
10611 "\"三 四 \"\n"
10612 "\"五\t\"\n"
10613 "\"六 \t\"\n"
10614 "\"七 \"\n"
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010615 "\"八九十\tqq\"",
10616 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
10617 getLLVMStyleWithColumns(11)));
Daniel Jaspere35c2202015-07-20 23:28:07 +000010618
10619 // UTF8 character in an escape sequence.
10620 EXPECT_EQ("\"aaaaaa\"\n"
10621 "\"\\\xC2\x8D\"",
10622 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10)));
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010623}
10624
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010625TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
10626 EXPECT_EQ("const char *sssss =\n"
10627 " \"一二三四五六七八\\\n"
10628 " 九 十\";",
10629 format("const char *sssss = \"一二三四五六七八\\\n"
10630 " 九 十\";",
10631 getLLVMStyleWithColumns(30)));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010632}
10633
10634TEST_F(FormatTest, SplitsUTF8LineComments) {
Alexander Kornienkofd1d7002013-11-26 13:31:46 +000010635 EXPECT_EQ("// aaaaÄ\xc2\x8d",
10636 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010637 EXPECT_EQ("// Я из лесу\n"
10638 "// вышел; был\n"
10639 "// сильный\n"
10640 "// мороз.",
10641 format("// Я из лесу вышел; был сильный мороз.",
10642 getLLVMStyleWithColumns(13)));
10643 EXPECT_EQ("// 一二三\n"
10644 "// 四五六七\n"
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010645 "// 八 九\n"
10646 "// 十",
10647 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9)));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010648}
10649
10650TEST_F(FormatTest, SplitsUTF8BlockComments) {
10651 EXPECT_EQ("/* Гляжу,\n"
10652 " * поднимается\n"
10653 " * медленно в\n"
10654 " * гору\n"
10655 " * Лошадка,\n"
10656 " * везущая\n"
10657 " * хворосту\n"
10658 " * воз. */",
10659 format("/* Гляжу, поднимается медленно в гору\n"
10660 " * Лошадка, везущая хворосту воз. */",
10661 getLLVMStyleWithColumns(13)));
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010662 EXPECT_EQ(
10663 "/* 一二三\n"
10664 " * 四五六七\n"
10665 " * 八 九\n"
10666 " * 十 */",
10667 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9)));
Alexander Kornienkoff73c202013-06-05 15:08:20 +000010668 EXPECT_EQ("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯\n"
10669 " * 𝕓𝕪𝕥𝕖\n"
10670 " * 𝖀𝕿𝕱-𝟠 */",
10671 format("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯 𝕓𝕪𝕥𝕖 𝖀𝕿𝕱-𝟠 */", getLLVMStyleWithColumns(12)));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +000010672}
10673
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +000010674#endif // _MSC_VER
10675
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010676TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
10677 FormatStyle Style = getLLVMStyle();
10678
10679 Style.ConstructorInitializerIndentWidth = 4;
10680 verifyFormat(
10681 "SomeClass::Constructor()\n"
10682 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
10683 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
10684 Style);
10685
10686 Style.ConstructorInitializerIndentWidth = 2;
10687 verifyFormat(
10688 "SomeClass::Constructor()\n"
10689 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
10690 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
10691 Style);
10692
10693 Style.ConstructorInitializerIndentWidth = 0;
10694 verifyFormat(
10695 "SomeClass::Constructor()\n"
10696 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
10697 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
10698 Style);
Daniel Jasperb618a982016-02-02 10:28:11 +000010699 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
10700 verifyFormat(
10701 "SomeLongTemplateVariableName<\n"
10702 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>",
10703 Style);
10704 verifyFormat(
10705 "bool smaller = 1 < bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
10706 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
10707 Style);
Daniel Jasper00853002014-09-16 16:22:30 +000010708}
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010709
Daniel Jasper00853002014-09-16 16:22:30 +000010710TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
10711 FormatStyle Style = getLLVMStyle();
Francois Ferranda6b6d512017-05-24 11:36:58 +000010712 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010713 Style.ConstructorInitializerIndentWidth = 4;
10714 verifyFormat("SomeClass::Constructor()\n"
10715 " : a(a)\n"
10716 " , b(b)\n"
10717 " , c(c) {}",
10718 Style);
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010719 verifyFormat("SomeClass::Constructor()\n"
10720 " : a(a) {}",
10721 Style);
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010722
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010723 Style.ColumnLimit = 0;
10724 verifyFormat("SomeClass::Constructor()\n"
10725 " : a(a) {}",
10726 Style);
Daniel Jasper56ef6ac2016-03-01 21:41:58 +000010727 verifyFormat("SomeClass::Constructor() noexcept\n"
10728 " : a(a) {}",
10729 Style);
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010730 verifyFormat("SomeClass::Constructor()\n"
10731 " : a(a)\n"
10732 " , b(b)\n"
10733 " , c(c) {}",
10734 Style);
10735 verifyFormat("SomeClass::Constructor()\n"
10736 " : a(a) {\n"
10737 " foo();\n"
10738 " bar();\n"
10739 "}",
10740 Style);
10741
Daniel Jasperd74cf402014-04-08 12:46:38 +000010742 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010743 verifyFormat("SomeClass::Constructor()\n"
10744 " : a(a)\n"
10745 " , b(b)\n"
10746 " , c(c) {\n}",
10747 Style);
10748 verifyFormat("SomeClass::Constructor()\n"
10749 " : a(a) {\n}",
10750 Style);
10751
10752 Style.ColumnLimit = 80;
Daniel Jasperd74cf402014-04-08 12:46:38 +000010753 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010754 Style.ConstructorInitializerIndentWidth = 2;
10755 verifyFormat("SomeClass::Constructor()\n"
10756 " : a(a)\n"
10757 " , b(b)\n"
10758 " , c(c) {}",
10759 Style);
10760
10761 Style.ConstructorInitializerIndentWidth = 0;
10762 verifyFormat("SomeClass::Constructor()\n"
10763 ": a(a)\n"
10764 ", b(b)\n"
10765 ", c(c) {}",
10766 Style);
Daniel Jasperec01cd62013-10-08 05:11:18 +000010767
10768 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
10769 Style.ConstructorInitializerIndentWidth = 4;
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010770 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
10771 verifyFormat(
10772 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
10773 Style);
Daniel Jasperec01cd62013-10-08 05:11:18 +000010774 verifyFormat(
10775 "SomeClass::Constructor()\n"
10776 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
10777 Style);
10778 Style.ConstructorInitializerIndentWidth = 4;
10779 Style.ColumnLimit = 60;
10780 verifyFormat("SomeClass::Constructor()\n"
10781 " : aaaaaaaa(aaaaaaaa)\n"
10782 " , aaaaaaaa(aaaaaaaa)\n"
10783 " , aaaaaaaa(aaaaaaaa) {}",
10784 Style);
Daniel Jaspercdaffa42013-08-13 10:58:30 +000010785}
10786
Daniel Jasper38efc132014-10-21 07:51:54 +000010787TEST_F(FormatTest, Destructors) {
10788 verifyFormat("void F(int &i) { i.~int(); }");
10789 verifyFormat("void F(int &i) { i->~int(); }");
10790}
10791
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010792TEST_F(FormatTest, FormatsWithWebKitStyle) {
10793 FormatStyle Style = getWebKitStyle();
10794
10795 // Don't indent in outer namespaces.
10796 verifyFormat("namespace outer {\n"
10797 "int i;\n"
10798 "namespace inner {\n"
Daniel Jasper65ee3472013-07-31 23:16:02 +000010799 " int i;\n"
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010800 "} // namespace inner\n"
10801 "} // namespace outer\n"
10802 "namespace other_outer {\n"
10803 "int i;\n"
10804 "}",
10805 Style);
10806
10807 // Don't indent case labels.
10808 verifyFormat("switch (variable) {\n"
10809 "case 1:\n"
10810 "case 2:\n"
10811 " doSomething();\n"
10812 " break;\n"
10813 "default:\n"
10814 " ++variable;\n"
10815 "}",
10816 Style);
10817
10818 // Wrap before binary operators.
Daniel Jaspera44991332015-04-29 13:06:49 +000010819 EXPECT_EQ("void f()\n"
10820 "{\n"
10821 " if (aaaaaaaaaaaaaaaa\n"
10822 " && bbbbbbbbbbbbbbbbbbbbbbbb\n"
10823 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
10824 " return;\n"
10825 "}",
10826 format("void f() {\n"
10827 "if (aaaaaaaaaaaaaaaa\n"
10828 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
10829 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
10830 "return;\n"
10831 "}",
10832 Style));
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010833
Daniel Jasper35995672014-04-29 14:05:20 +000010834 // Allow functions on a single line.
10835 verifyFormat("void f() { return; }", Style);
10836
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010837 // Constructor initializers are formatted one per line with the "," on the
10838 // new line.
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010839 verifyFormat("Constructor()\n"
10840 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
10841 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
Daniel Jasper3aa9a6a2014-11-18 23:55:27 +000010842 " aaaaaaaaaaaaaa)\n"
Daniel Jasper234379f2013-12-24 13:31:25 +000010843 " , aaaaaaaaaaaaaaaaaaaaaaa()\n"
10844 "{\n"
10845 "}",
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010846 Style);
10847 verifyFormat("SomeClass::Constructor()\n"
10848 " : a(a)\n"
Daniel Jasper234379f2013-12-24 13:31:25 +000010849 "{\n"
10850 "}",
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010851 Style);
Daniel Jasper234379f2013-12-24 13:31:25 +000010852 EXPECT_EQ("SomeClass::Constructor()\n"
10853 " : a(a)\n"
10854 "{\n"
10855 "}",
10856 format("SomeClass::Constructor():a(a){}", Style));
10857 verifyFormat("SomeClass::Constructor()\n"
10858 " : a(a)\n"
10859 " , b(b)\n"
10860 " , c(c)\n"
10861 "{\n"
Daniel Jaspera44991332015-04-29 13:06:49 +000010862 "}",
10863 Style);
Alexander Kornienkoa594ba82013-12-16 14:35:51 +000010864 verifyFormat("SomeClass::Constructor()\n"
10865 " : a(a)\n"
10866 "{\n"
10867 " foo();\n"
10868 " bar();\n"
10869 "}",
10870 Style);
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010871
Daniel Jasper65ee3472013-07-31 23:16:02 +000010872 // Access specifiers should be aligned left.
10873 verifyFormat("class C {\n"
10874 "public:\n"
10875 " int i;\n"
10876 "};",
10877 Style);
10878
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010879 // Do not align comments.
Daniel Jasper552f4a72013-07-31 23:55:15 +000010880 verifyFormat("int a; // Do not\n"
10881 "double b; // align comments.",
10882 Style);
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010883
Daniel Jasper3219e432014-12-02 13:24:51 +000010884 // Do not align operands.
10885 EXPECT_EQ("ASSERT(aaaa\n"
10886 " || bbbb);",
10887 format("ASSERT ( aaaa\n||bbbb);", Style));
10888
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010889 // Accept input's line breaks.
10890 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
10891 " || bbbbbbbbbbbbbbb) {\n"
10892 " i++;\n"
10893 "}",
10894 format("if (aaaaaaaaaaaaaaa\n"
10895 "|| bbbbbbbbbbbbbbb) { i++; }",
10896 Style));
10897 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
10898 " i++;\n"
10899 "}",
10900 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
Daniel Jasper98fb6e12013-11-08 17:33:27 +000010901
10902 // Don't automatically break all macro definitions (llvm.org/PR17842).
10903 verifyFormat("#define aNumber 10", Style);
10904 // However, generally keep the line breaks that the user authored.
10905 EXPECT_EQ("#define aNumber \\\n"
10906 " 10",
10907 format("#define aNumber \\\n"
10908 " 10",
10909 Style));
Daniel Jasperaf4fee22014-04-14 12:05:05 +000010910
10911 // Keep empty and one-element array literals on a single line.
Daniel Jasper7f0c5172014-05-19 08:06:34 +000010912 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
10913 " copyItems:YES];",
10914 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
10915 "copyItems:YES];",
10916 Style));
10917 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
10918 " copyItems:YES];",
10919 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
10920 " copyItems:YES];",
10921 Style));
Daniel Jasper335ff262014-05-28 09:11:53 +000010922 // FIXME: This does not seem right, there should be more indentation before
10923 // the array literal's entries. Nested blocks have the same problem.
Daniel Jasperdb8804b2014-04-14 12:11:07 +000010924 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
Daniel Jasper335ff262014-05-28 09:11:53 +000010925 " @\"a\",\n"
10926 " @\"a\"\n"
10927 "]\n"
Daniel Jasperdb8804b2014-04-14 12:11:07 +000010928 " copyItems:YES];",
10929 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
10930 " @\"a\",\n"
10931 " @\"a\"\n"
10932 " ]\n"
10933 " copyItems:YES];",
10934 Style));
Daniel Jasper7f0c5172014-05-19 08:06:34 +000010935 EXPECT_EQ(
Daniel Jasperdb8804b2014-04-14 12:11:07 +000010936 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
10937 " copyItems:YES];",
Daniel Jasper7f0c5172014-05-19 08:06:34 +000010938 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
10939 " copyItems:YES];",
10940 Style));
10941
10942 verifyFormat("[self.a b:c c:d];", Style);
10943 EXPECT_EQ("[self.a b:c\n"
10944 " c:d];",
10945 format("[self.a b:c\n"
10946 "c:d];",
10947 Style));
Daniel Jasperffefb3d2013-07-24 13:10:59 +000010948}
10949
Manuel Klimekffdeb592013-09-03 15:10:01 +000010950TEST_F(FormatTest, FormatsLambdas) {
Daniel Jasper5f3ea472014-05-22 08:36:53 +000010951 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
10952 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
10953 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
10954 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
10955 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
Chandler Carruthf8b72662014-03-02 12:37:31 +000010956 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
Manuel Klimek9f0a4e52017-09-19 09:59:30 +000010957 verifyFormat("auto c = [a = [b = 42] {}] {};\n");
10958 verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n");
Daniel Jasper3ade3be2016-11-01 06:23:05 +000010959 verifyFormat("int x = f(*+[] {});");
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +000010960 verifyFormat("void f() {\n"
10961 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
10962 "}\n");
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +000010963 verifyFormat("void f() {\n"
10964 " other(x.begin(), //\n"
10965 " x.end(), //\n"
Daniel Jasper9a8d48b2013-09-05 10:04:31 +000010966 " [&](int, int) { return 1; });\n"
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +000010967 "}\n");
Daniel Jasper21397a32014-04-09 12:21:48 +000010968 verifyFormat("SomeFunction([]() { // A cool function...\n"
10969 " return 43;\n"
10970 "});");
Daniel Jasper56346192014-10-27 16:31:46 +000010971 EXPECT_EQ("SomeFunction([]() {\n"
10972 "#define A a\n"
10973 " return 43;\n"
10974 "});",
10975 format("SomeFunction([](){\n"
10976 "#define A a\n"
10977 "return 43;\n"
10978 "});"));
Daniel Jasper0e6c51c2014-05-05 12:36:29 +000010979 verifyFormat("void f() {\n"
10980 " SomeFunction([](decltype(x), A *a) {});\n"
10981 "}");
Daniel Jaspera2fb50f2014-06-24 09:15:49 +000010982 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
10983 " [](const aaaaaaaaaa &a) { return a; });");
Daniel Jaspera5621202014-08-08 12:00:13 +000010984 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
10985 " SomeOtherFunctioooooooooooooooooooooooooon();\n"
10986 "});");
Daniel Jasperd6a1cab2015-01-12 10:23:24 +000010987 verifyFormat("Constructor()\n"
10988 " : Field([] { // comment\n"
10989 " int i;\n"
10990 " }) {}");
Daniel Jasper0ad28142015-05-13 08:47:16 +000010991 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
10992 " return some_parameter.size();\n"
10993 "};");
Daniel Jasper9c8a7742016-01-04 07:29:40 +000010994 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n"
10995 " [](const string &s) { return s; };");
Daniel Jasperc4144ea2015-05-13 16:09:21 +000010996 verifyFormat("int i = aaaaaa ? 1 //\n"
10997 " : [] {\n"
10998 " return 2; //\n"
10999 " }();");
11000 verifyFormat("llvm::errs() << \"number of twos is \"\n"
11001 " << std::count_if(v.begin(), v.end(), [](int x) {\n"
11002 " return x == 2; // force break\n"
11003 " });");
Daniel Jasperd9b319e2017-02-20 12:43:48 +000011004 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
11005 " [=](int iiiiiiiiiiii) {\n"
11006 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n"
11007 " aaaaaaaaaaaaaaaaaaaaaaa;\n"
11008 " });",
Daniel Jasperb9edcfb2015-07-07 13:50:50 +000011009 getLLVMStyleWithColumns(60));
Daniel Jasperea40cee2015-07-14 11:26:14 +000011010 verifyFormat("SomeFunction({[&] {\n"
11011 " // comment\n"
11012 " },\n"
11013 " [&] {\n"
11014 " // comment\n"
11015 " }});");
11016 verifyFormat("SomeFunction({[&] {\n"
11017 " // comment\n"
11018 "}});");
Daniel Jasper100ffc62015-08-21 11:44:57 +000011019 verifyFormat("virtual aaaaaaaaaaaaaaaa(std::function<bool()> bbbbbbbbbbbb =\n"
11020 " [&]() { return true; },\n"
11021 " aaaaa aaaaaaaaa);");
Daniel Jasperbf02b2c12013-09-05 11:49:39 +000011022
Daniel Jaspercb51cf42014-01-16 09:11:55 +000011023 // Lambdas with return types.
Daniel Jasper81a20782014-03-10 10:02:02 +000011024 verifyFormat("int c = []() -> int { return 2; }();\n");
Daniel Jasper60ba32d2015-06-12 09:59:16 +000011025 verifyFormat("int c = []() -> int * { return 2; }();\n");
Daniel Jasper81a20782014-03-10 10:02:02 +000011026 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
11027 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
Daniel Jasperbcb55ee2014-11-21 14:08:38 +000011028 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};");
Daniel Jasper3431b752014-12-08 13:22:37 +000011029 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};");
Daniel Jasperbcb55ee2014-11-21 14:08:38 +000011030 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};");
11031 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};");
Daniel Jasper5eaa0092015-08-13 13:37:08 +000011032 verifyFormat("[a, a]() -> a<1> {};");
Daniel Jasper8f59ae52014-03-11 11:03:26 +000011033 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
11034 " int j) -> int {\n"
Daniel Jaspera2fb50f2014-06-24 09:15:49 +000011035 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n"
Daniel Jasper8f59ae52014-03-11 11:03:26 +000011036 "};");
Daniel Jaspere6623162015-03-02 10:35:13 +000011037 verifyFormat(
11038 "aaaaaaaaaaaaaaaaaaaaaa(\n"
11039 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n"
11040 " return aaaaaaaaaaaaaaaaa;\n"
11041 " });",
11042 getLLVMStyleWithColumns(70));
Daniel Jasper87448c52016-06-13 07:48:45 +000011043 verifyFormat("[]() //\n"
11044 " -> int {\n"
11045 " return 1; //\n"
11046 "};");
Daniel Jaspercb51cf42014-01-16 09:11:55 +000011047
Daniel Jasper3ae6f5a2014-04-09 12:08:39 +000011048 // Multiple lambdas in the same parentheses change indentation rules.
Daniel Jasper4b444492014-11-21 13:38:53 +000011049 verifyFormat("SomeFunction(\n"
11050 " []() {\n"
11051 " int i = 42;\n"
11052 " return i;\n"
11053 " },\n"
11054 " []() {\n"
11055 " int j = 43;\n"
11056 " return j;\n"
11057 " });");
Daniel Jasper3ae6f5a2014-04-09 12:08:39 +000011058
Daniel Jasperda18fd82014-06-10 06:39:03 +000011059 // More complex introducers.
11060 verifyFormat("return [i, args...] {};");
11061
Daniel Jasperbf02b2c12013-09-05 11:49:39 +000011062 // Not lambdas.
Chandler Carruthf8b72662014-03-02 12:37:31 +000011063 verifyFormat("constexpr char hello[]{\"hello\"};");
Daniel Jasperb4b99982013-09-06 21:25:51 +000011064 verifyFormat("double &operator[](int i) { return 0; }\n"
11065 "int i;");
Daniel Jasper6b70ec02014-01-22 17:01:47 +000011066 verifyFormat("std::unique_ptr<int[]> foo() {}");
Daniel Jasperd3c7ab92014-03-11 09:59:36 +000011067 verifyFormat("int i = a[a][a]->f();");
Daniel Jaspera58dd5d2014-03-11 10:03:33 +000011068 verifyFormat("int i = (*b)[a]->f();");
Daniel Jasper84a12e12014-03-10 15:06:25 +000011069
11070 // Other corner cases.
11071 verifyFormat("void f() {\n"
11072 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n"
Martin Probst2c1cdae2017-05-15 11:15:29 +000011073 " );\n"
Daniel Jasper84a12e12014-03-10 15:06:25 +000011074 "}");
Daniel Jasperc580af92014-03-11 09:29:46 +000011075
11076 // Lambdas created through weird macros.
11077 verifyFormat("void f() {\n"
11078 " MACRO((const AA &a) { return 1; });\n"
Daniel Jasper54353da2016-01-07 14:36:11 +000011079 " MACRO((AA &a) { return 1; });\n"
Daniel Jasperc580af92014-03-11 09:29:46 +000011080 "}");
Daniel Jasper11a0ac62014-12-12 09:40:58 +000011081
11082 verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
11083 " doo_dah();\n"
11084 " doo_dah();\n"
11085 " })) {\n"
11086 "}");
Daniel Jasper6a7d5a72017-06-19 07:40:49 +000011087 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n"
11088 " doo_dah();\n"
11089 " doo_dah();\n"
11090 " })) {\n"
11091 "}");
Daniel Jasper29d39d52015-02-08 09:34:49 +000011092 verifyFormat("auto lambda = []() {\n"
11093 " int a = 2\n"
11094 "#if A\n"
11095 " + 2\n"
11096 "#endif\n"
11097 " ;\n"
11098 "};");
Daniel Jasperd9b319e2017-02-20 12:43:48 +000011099
11100 // Lambdas with complex multiline introducers.
11101 verifyFormat(
11102 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
11103 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n"
11104 " -> ::std::unordered_set<\n"
11105 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n"
11106 " //\n"
11107 " });");
Manuel Klimekffdeb592013-09-03 15:10:01 +000011108}
11109
Martin Probsta004b3f2017-11-17 18:06:33 +000011110TEST_F(FormatTest, EmptyLinesInLambdas) {
11111 verifyFormat("auto lambda = []() {\n"
11112 " x(); //\n"
11113 "};",
11114 "auto lambda = []() {\n"
11115 "\n"
11116 " x(); //\n"
11117 "\n"
11118 "};");
11119}
11120
Manuel Klimek516e0542013-09-04 13:25:30 +000011121TEST_F(FormatTest, FormatsBlocks) {
Daniel Jasper76284682014-10-22 09:12:44 +000011122 FormatStyle ShortBlocks = getLLVMStyle();
11123 ShortBlocks.AllowShortBlocksOnASingleLine = true;
11124 verifyFormat("int (^Block)(int, int);", ShortBlocks);
11125 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
11126 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
11127 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
11128 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
11129 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
Daniel Jasper31745732014-01-19 07:46:32 +000011130
Daniel Jasper76284682014-10-22 09:12:44 +000011131 verifyFormat("foo(^{ bar(); });", ShortBlocks);
11132 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
11133 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
Daniel Jasper31745732014-01-19 07:46:32 +000011134
Daniel Jasper76284682014-10-22 09:12:44 +000011135 verifyFormat("[operation setCompletionBlock:^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011136 " [self onOperationDone];\n"
Daniel Jasper76284682014-10-22 09:12:44 +000011137 "}];");
11138 verifyFormat("int i = {[operation setCompletionBlock:^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011139 " [self onOperationDone];\n"
Daniel Jasper76284682014-10-22 09:12:44 +000011140 "}]};");
11141 verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011142 " f();\n"
Daniel Jasper76284682014-10-22 09:12:44 +000011143 "}];");
11144 verifyFormat("int a = [operation block:^int(int *i) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011145 " return 1;\n"
Daniel Jasper76284682014-10-22 09:12:44 +000011146 "}];");
Daniel Jaspera225bce2014-01-16 19:14:34 +000011147 verifyFormat("[myObject doSomethingWith:arg1\n"
Daniel Jasper76284682014-10-22 09:12:44 +000011148 " aaa:^int(int *a) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011149 " return 1;\n"
Daniel Jasper76284682014-10-22 09:12:44 +000011150 " }\n"
Daniel Jasper5f3ea472014-05-22 08:36:53 +000011151 " bbb:f(a * bbbbbbbb)];");
Daniel Jasperb88b25f2013-12-23 07:29:06 +000011152
11153 verifyFormat("[operation setCompletionBlock:^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011154 " [self.delegate newDataAvailable];\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000011155 "}];",
11156 getLLVMStyleWithColumns(60));
11157 verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011158 " NSString *path = [self sessionFilePath];\n"
11159 " if (path) {\n"
11160 " // ...\n"
11161 " }\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000011162 "});");
11163 verifyFormat("[[SessionService sharedService]\n"
11164 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011165 " if (window) {\n"
11166 " [self windowDidLoad:window];\n"
11167 " } else {\n"
11168 " [self errorLoadingWindow];\n"
11169 " }\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000011170 " }];");
11171 verifyFormat("void (^largeBlock)(void) = ^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011172 " // ...\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000011173 "};\n",
11174 getLLVMStyleWithColumns(40));
11175 verifyFormat("[[SessionService sharedService]\n"
11176 " loadWindowWithCompletionBlock: //\n"
11177 " ^(SessionWindow *window) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011178 " if (window) {\n"
11179 " [self windowDidLoad:window];\n"
11180 " } else {\n"
11181 " [self errorLoadingWindow];\n"
11182 " }\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000011183 " }];",
11184 getLLVMStyleWithColumns(60));
11185 verifyFormat("[myObject doSomethingWith:arg1\n"
11186 " firstBlock:^(Foo *a) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011187 " // ...\n"
11188 " int i;\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000011189 " }\n"
11190 " secondBlock:^(Bar *b) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011191 " // ...\n"
11192 " int i;\n"
Daniel Jasperc13ee342014-03-27 09:43:54 +000011193 " }\n"
11194 " thirdBlock:^Foo(Bar *b) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011195 " // ...\n"
11196 " int i;\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +000011197 " }];");
Daniel Jasperb77105d2014-04-08 14:04:31 +000011198 verifyFormat("[myObject doSomethingWith:arg1\n"
11199 " firstBlock:-1\n"
11200 " secondBlock:^(Bar *b) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011201 " // ...\n"
11202 " int i;\n"
Daniel Jasperb77105d2014-04-08 14:04:31 +000011203 " }];");
Daniel Jasperac7e34e2014-03-13 10:11:17 +000011204
11205 verifyFormat("f(^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011206 " @autoreleasepool {\n"
11207 " if (a) {\n"
11208 " g();\n"
Daniel Jasperac7e34e2014-03-13 10:11:17 +000011209 " }\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +000011210 " }\n"
Daniel Jasperac7e34e2014-03-13 10:11:17 +000011211 "});");
Daniel Jasperbb86d842014-11-23 19:15:35 +000011212 verifyFormat("Block b = ^int *(A *a, B *b) {}");
Daniel Jaspere31388a2016-09-26 22:19:08 +000011213 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
11214 "};");
Daniel Jasper50d634b2014-10-28 16:53:38 +000011215
11216 FormatStyle FourIndent = getLLVMStyle();
11217 FourIndent.ObjCBlockIndentWidth = 4;
11218 verifyFormat("[operation setCompletionBlock:^{\n"
11219 " [self onOperationDone];\n"
11220 "}];",
11221 FourIndent);
Manuel Klimek516e0542013-09-04 13:25:30 +000011222}
11223
Daniel Jasper289afc02015-04-23 09:23:17 +000011224TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) {
11225 FormatStyle ZeroColumn = getLLVMStyle();
11226 ZeroColumn.ColumnLimit = 0;
11227
11228 verifyFormat("[[SessionService sharedService] "
11229 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
11230 " if (window) {\n"
11231 " [self windowDidLoad:window];\n"
11232 " } else {\n"
11233 " [self errorLoadingWindow];\n"
11234 " }\n"
11235 "}];",
11236 ZeroColumn);
11237 EXPECT_EQ("[[SessionService sharedService]\n"
11238 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
11239 " if (window) {\n"
11240 " [self windowDidLoad:window];\n"
11241 " } else {\n"
11242 " [self errorLoadingWindow];\n"
11243 " }\n"
11244 " }];",
11245 format("[[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 ZeroColumn));
11254 verifyFormat("[myObject doSomethingWith:arg1\n"
11255 " firstBlock:^(Foo *a) {\n"
11256 " // ...\n"
11257 " int i;\n"
11258 " }\n"
11259 " secondBlock:^(Bar *b) {\n"
11260 " // ...\n"
11261 " int i;\n"
11262 " }\n"
11263 " thirdBlock:^Foo(Bar *b) {\n"
11264 " // ...\n"
11265 " int i;\n"
11266 " }];",
11267 ZeroColumn);
11268 verifyFormat("f(^{\n"
11269 " @autoreleasepool {\n"
11270 " if (a) {\n"
11271 " g();\n"
11272 " }\n"
11273 " }\n"
11274 "});",
11275 ZeroColumn);
11276 verifyFormat("void (^largeBlock)(void) = ^{\n"
11277 " // ...\n"
11278 "};",
11279 ZeroColumn);
11280
11281 ZeroColumn.AllowShortBlocksOnASingleLine = true;
11282 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +000011283 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn));
Daniel Jasper289afc02015-04-23 09:23:17 +000011284 ZeroColumn.AllowShortBlocksOnASingleLine = false;
11285 EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
11286 " int i;\n"
11287 "};",
11288 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn));
11289}
11290
Alexander Kornienko9e649af2013-09-11 12:25:57 +000011291TEST_F(FormatTest, SupportsCRLF) {
11292 EXPECT_EQ("int a;\r\n"
11293 "int b;\r\n"
11294 "int c;\r\n",
11295 format("int a;\r\n"
11296 " int b;\r\n"
11297 " int c;\r\n",
11298 getLLVMStyle()));
11299 EXPECT_EQ("int a;\r\n"
11300 "int b;\r\n"
11301 "int c;\r\n",
11302 format("int a;\r\n"
11303 " int b;\n"
11304 " int c;\r\n",
11305 getLLVMStyle()));
11306 EXPECT_EQ("int a;\n"
11307 "int b;\n"
11308 "int c;\n",
11309 format("int a;\r\n"
11310 " int b;\n"
11311 " int c;\n",
11312 getLLVMStyle()));
11313 EXPECT_EQ("\"aaaaaaa \"\r\n"
11314 "\"bbbbbbb\";\r\n",
11315 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
11316 EXPECT_EQ("#define A \\\r\n"
11317 " b; \\\r\n"
11318 " c; \\\r\n"
11319 " d;\r\n",
11320 format("#define A \\\r\n"
11321 " b; \\\r\n"
11322 " c; d; \r\n",
11323 getGoogleStyle()));
Daniel Jasper580da272013-10-30 07:36:40 +000011324
11325 EXPECT_EQ("/*\r\n"
11326 "multi line block comments\r\n"
11327 "should not introduce\r\n"
11328 "an extra carriage return\r\n"
11329 "*/\r\n",
11330 format("/*\r\n"
11331 "multi line block comments\r\n"
11332 "should not introduce\r\n"
11333 "an extra carriage return\r\n"
11334 "*/\r\n"));
Alexander Kornienko9e649af2013-09-11 12:25:57 +000011335}
11336
Manuel Klimekb212f3b2013-10-12 22:46:56 +000011337TEST_F(FormatTest, MunchSemicolonAfterBlocks) {
11338 verifyFormat("MY_CLASS(C) {\n"
11339 " int i;\n"
11340 " int j;\n"
11341 "};");
11342}
11343
Daniel Jasper6633ab82013-10-18 10:38:14 +000011344TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {
11345 FormatStyle TwoIndent = getLLVMStyleWithColumns(15);
11346 TwoIndent.ContinuationIndentWidth = 2;
11347
11348 EXPECT_EQ("int i =\n"
11349 " longFunction(\n"
11350 " arg);",
11351 format("int i = longFunction(arg);", TwoIndent));
11352
11353 FormatStyle SixIndent = getLLVMStyleWithColumns(20);
11354 SixIndent.ContinuationIndentWidth = 6;
11355
11356 EXPECT_EQ("int i =\n"
11357 " longFunction(\n"
11358 " arg);",
11359 format("int i = longFunction(arg);", SixIndent));
11360}
11361
Daniel Jasperdd978ae2013-10-29 14:52:02 +000011362TEST_F(FormatTest, SpacesInAngles) {
11363 FormatStyle Spaces = getLLVMStyle();
11364 Spaces.SpacesInAngles = true;
11365
11366 verifyFormat("static_cast< int >(arg);", Spaces);
11367 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
11368 verifyFormat("f< int, float >();", Spaces);
11369 verifyFormat("template <> g() {}", Spaces);
11370 verifyFormat("template < std::vector< int > > f() {}", Spaces);
Daniel Jasper74331d42015-10-26 12:08:47 +000011371 verifyFormat("std::function< void(int, int) > fct;", Spaces);
11372 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }",
11373 Spaces);
Daniel Jasperdd978ae2013-10-29 14:52:02 +000011374
11375 Spaces.Standard = FormatStyle::LS_Cpp03;
11376 Spaces.SpacesInAngles = true;
11377 verifyFormat("A< A< int > >();", Spaces);
11378
11379 Spaces.SpacesInAngles = false;
11380 verifyFormat("A<A<int> >();", Spaces);
11381
11382 Spaces.Standard = FormatStyle::LS_Cpp11;
11383 Spaces.SpacesInAngles = true;
11384 verifyFormat("A< A< int > >();", Spaces);
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000011385
Daniel Jasperdd978ae2013-10-29 14:52:02 +000011386 Spaces.SpacesInAngles = false;
11387 verifyFormat("A<A<int>>();", Spaces);
11388}
11389
Sylvestre Ledru83bbd572016-08-09 14:24:40 +000011390TEST_F(FormatTest, SpaceAfterTemplateKeyword) {
11391 FormatStyle Style = getLLVMStyle();
11392 Style.SpaceAfterTemplateKeyword = false;
11393 verifyFormat("template<int> void foo();", Style);
11394}
11395
Jacques Pienaarfc275112015-02-18 23:48:37 +000011396TEST_F(FormatTest, TripleAngleBrackets) {
11397 verifyFormat("f<<<1, 1>>>();");
11398 verifyFormat("f<<<1, 1, 1, s>>>();");
11399 verifyFormat("f<<<a, b, c, d>>>();");
Daniel Jaspera44991332015-04-29 13:06:49 +000011400 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
Jacques Pienaarfc275112015-02-18 23:48:37 +000011401 verifyFormat("f<param><<<1, 1>>>();");
11402 verifyFormat("f<1><<<1, 1>>>();");
Daniel Jaspera44991332015-04-29 13:06:49 +000011403 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
Jacques Pienaarfc275112015-02-18 23:48:37 +000011404 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
11405 "aaaaaaaaaaa<<<\n 1, 1>>>();");
Daniel Jaspera4322082016-11-05 17:43:16 +000011406 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
11407 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();");
Jacques Pienaarfc275112015-02-18 23:48:37 +000011408}
11409
11410TEST_F(FormatTest, MergeLessLessAtEnd) {
Jacques Pienaar68a7dbf2015-02-20 21:09:01 +000011411 verifyFormat("<<");
Jacques Pienaar411b2512015-02-24 23:23:24 +000011412 EXPECT_EQ("< < <", format("\\\n<<<"));
Jacques Pienaarfc275112015-02-18 23:48:37 +000011413 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
11414 "aaallvm::outs() <<");
11415 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
11416 "aaaallvm::outs()\n <<");
11417}
11418
Manuel Klimek819788d2014-03-18 11:22:45 +000011419TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {
11420 std::string code = "#if A\n"
11421 "#if B\n"
11422 "a.\n"
11423 "#endif\n"
11424 " a = 1;\n"
11425 "#else\n"
11426 "#endif\n"
11427 "#if C\n"
11428 "#else\n"
11429 "#endif\n";
11430 EXPECT_EQ(code, format(code));
11431}
11432
Manuel Klimek68b03042014-04-14 09:14:11 +000011433TEST_F(FormatTest, HandleConflictMarkers) {
11434 // Git/SVN conflict markers.
11435 EXPECT_EQ("int a;\n"
11436 "void f() {\n"
11437 " callme(some(parameter1,\n"
11438 "<<<<<<< text by the vcs\n"
11439 " parameter2),\n"
11440 "||||||| text by the vcs\n"
11441 " parameter2),\n"
11442 " parameter3,\n"
11443 "======= text by the vcs\n"
11444 " parameter2, parameter3),\n"
11445 ">>>>>>> text by the vcs\n"
11446 " otherparameter);\n",
11447 format("int a;\n"
11448 "void f() {\n"
11449 " callme(some(parameter1,\n"
11450 "<<<<<<< text by the vcs\n"
11451 " parameter2),\n"
11452 "||||||| text by the vcs\n"
11453 " parameter2),\n"
11454 " parameter3,\n"
11455 "======= text by the vcs\n"
11456 " parameter2,\n"
11457 " parameter3),\n"
11458 ">>>>>>> text by the vcs\n"
11459 " otherparameter);\n"));
11460
11461 // Perforce markers.
11462 EXPECT_EQ("void f() {\n"
11463 " function(\n"
11464 ">>>> text by the vcs\n"
11465 " parameter,\n"
11466 "==== text by the vcs\n"
11467 " parameter,\n"
11468 "==== text by the vcs\n"
11469 " parameter,\n"
11470 "<<<< text by the vcs\n"
11471 " parameter);\n",
11472 format("void f() {\n"
11473 " function(\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 "<<<< text by the vcs\n"
11481 " parameter);\n"));
11482
11483 EXPECT_EQ("<<<<<<<\n"
11484 "|||||||\n"
11485 "=======\n"
11486 ">>>>>>>",
11487 format("<<<<<<<\n"
11488 "|||||||\n"
11489 "=======\n"
11490 ">>>>>>>"));
11491
11492 EXPECT_EQ("<<<<<<<\n"
11493 "|||||||\n"
11494 "int i;\n"
11495 "=======\n"
11496 ">>>>>>>",
11497 format("<<<<<<<\n"
11498 "|||||||\n"
11499 "int i;\n"
11500 "=======\n"
11501 ">>>>>>>"));
11502
11503 // FIXME: Handle parsing of macros around conflict markers correctly:
11504 EXPECT_EQ("#define Macro \\\n"
11505 "<<<<<<<\n"
11506 "Something \\\n"
11507 "|||||||\n"
11508 "Else \\\n"
11509 "=======\n"
11510 "Other \\\n"
11511 ">>>>>>>\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +000011512 " End int i;\n",
Manuel Klimek68b03042014-04-14 09:14:11 +000011513 format("#define Macro \\\n"
11514 "<<<<<<<\n"
11515 " Something \\\n"
11516 "|||||||\n"
11517 " Else \\\n"
11518 "=======\n"
11519 " Other \\\n"
11520 ">>>>>>>\n"
11521 " End\n"
11522 "int i;\n"));
11523}
11524
Daniel Jasper471894432014-08-06 13:40:26 +000011525TEST_F(FormatTest, DisableRegions) {
11526 EXPECT_EQ("int i;\n"
11527 "// clang-format off\n"
11528 " int j;\n"
11529 "// clang-format on\n"
11530 "int k;",
11531 format(" int i;\n"
11532 " // clang-format off\n"
11533 " int j;\n"
11534 " // clang-format on\n"
11535 " int k;"));
Roman Kashitsyn650ecb52014-09-11 14:47:20 +000011536 EXPECT_EQ("int i;\n"
11537 "/* clang-format off */\n"
11538 " int j;\n"
11539 "/* clang-format on */\n"
11540 "int k;",
11541 format(" int i;\n"
11542 " /* clang-format off */\n"
11543 " int j;\n"
11544 " /* clang-format on */\n"
11545 " int k;"));
Krasimir Georgiev91834222017-01-25 13:58:58 +000011546
11547 // Don't reflow comments within disabled regions.
11548 EXPECT_EQ(
11549 "// clang-format off\n"
11550 "// long long long long long long line\n"
11551 "/* clang-format on */\n"
11552 "/* long long long\n"
11553 " * long long long\n"
11554 " * line */\n"
11555 "int i;\n"
11556 "/* clang-format off */\n"
11557 "/* long long long long long long line */\n",
11558 format("// clang-format off\n"
11559 "// long long long long long long line\n"
11560 "/* clang-format on */\n"
11561 "/* long long long long long long line */\n"
11562 "int i;\n"
11563 "/* clang-format off */\n"
11564 "/* long long long long long long line */\n",
11565 getLLVMStyleWithColumns(20)));
Daniel Jasper471894432014-08-06 13:40:26 +000011566}
11567
Manuel Klimekf0c95b32015-06-11 10:14:13 +000011568TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
11569 format("? ) =");
11570 verifyNoCrash("#define a\\\n /**/}");
11571}
Manuel Klimek5f594f82014-08-13 14:00:41 +000011572
Daniel Jasper498f5582015-12-25 08:53:31 +000011573TEST_F(FormatTest, FormatsTableGenCode) {
11574 FormatStyle Style = getLLVMStyle();
11575 Style.Language = FormatStyle::LK_TableGen;
11576 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);
11577}
11578
Nico Weberb2673a12016-11-10 21:49:25 +000011579TEST_F(FormatTest, ArrayOfTemplates) {
11580 EXPECT_EQ("auto a = new unique_ptr<int>[10];",
11581 format("auto a = new unique_ptr<int > [ 10];"));
11582
11583 FormatStyle Spaces = getLLVMStyle();
11584 Spaces.SpacesInSquareBrackets = true;
11585 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];",
11586 format("auto a = new unique_ptr<int > [10];", Spaces));
11587}
11588
11589TEST_F(FormatTest, ArrayAsTemplateType) {
11590 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;",
11591 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;"));
11592
11593 FormatStyle Spaces = getLLVMStyle();
11594 Spaces.SpacesInSquareBrackets = true;
11595 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",
11596 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces));
11597}
11598
Martin Probstc9c51c42017-03-16 10:21:35 +000011599TEST_F(FormatTest, NoSpaceAfterSuper) {
11600 verifyFormat("__super::FooBar();");
11601}
11602
Eric Liu547d8792016-03-24 13:22:42 +000011603TEST(FormatStyle, GetStyleOfFile) {
11604 vfs::InMemoryFileSystem FS;
11605 // Test 1: format file in the same directory.
11606 ASSERT_TRUE(
11607 FS.addFile("/a/.clang-format", 0,
11608 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
11609 ASSERT_TRUE(
11610 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
Daniel Jasper03a04fe2016-12-12 12:42:29 +000011611 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS);
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +000011612 ASSERT_TRUE((bool)Style1);
11613 ASSERT_EQ(*Style1, getLLVMStyle());
Eric Liu547d8792016-03-24 13:22:42 +000011614
Antonio Maiorano7eb75072017-01-20 01:22:42 +000011615 // Test 2.1: fallback to default.
Eric Liu547d8792016-03-24 13:22:42 +000011616 ASSERT_TRUE(
11617 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
Daniel Jasper03a04fe2016-12-12 12:42:29 +000011618 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS);
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +000011619 ASSERT_TRUE((bool)Style2);
11620 ASSERT_EQ(*Style2, getMozillaStyle());
Eric Liu547d8792016-03-24 13:22:42 +000011621
Antonio Maiorano7eb75072017-01-20 01:22:42 +000011622 // Test 2.2: no format on 'none' fallback style.
11623 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
11624 ASSERT_TRUE((bool)Style2);
11625 ASSERT_EQ(*Style2, getNoStyle());
11626
11627 // Test 2.3: format if config is found with no based style while fallback is
11628 // 'none'.
11629 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
11630 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2")));
11631 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
11632 ASSERT_TRUE((bool)Style2);
11633 ASSERT_EQ(*Style2, getLLVMStyle());
11634
11635 // Test 2.4: format if yaml with no based style, while fallback is 'none'.
11636 Style2 = getStyle("{}", "a.h", "none", "", &FS);
11637 ASSERT_TRUE((bool)Style2);
11638 ASSERT_EQ(*Style2, getLLVMStyle());
11639
Eric Liu547d8792016-03-24 13:22:42 +000011640 // Test 3: format file in parent directory.
11641 ASSERT_TRUE(
11642 FS.addFile("/c/.clang-format", 0,
11643 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
11644 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
11645 llvm::MemoryBuffer::getMemBuffer("int i;")));
Daniel Jasper03a04fe2016-12-12 12:42:29 +000011646 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS);
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +000011647 ASSERT_TRUE((bool)Style3);
11648 ASSERT_EQ(*Style3, getGoogleStyle());
11649
11650 // Test 4: error on invalid fallback style
11651 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS);
11652 ASSERT_FALSE((bool)Style4);
11653 llvm::consumeError(Style4.takeError());
11654
11655 // Test 5: error on invalid yaml on command line
11656 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS);
11657 ASSERT_FALSE((bool)Style5);
11658 llvm::consumeError(Style5.takeError());
11659
11660 // Test 6: error on invalid style
11661 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS);
11662 ASSERT_FALSE((bool)Style6);
11663 llvm::consumeError(Style6.takeError());
11664
11665 // Test 7: found config file, error on parsing it
11666 ASSERT_TRUE(
11667 FS.addFile("/d/.clang-format", 0,
11668 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n"
11669 "InvalidKey: InvalidValue")));
11670 ASSERT_TRUE(
11671 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
11672 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS);
11673 ASSERT_FALSE((bool)Style7);
11674 llvm::consumeError(Style7.takeError());
Eric Liu547d8792016-03-24 13:22:42 +000011675}
11676
Manuel Klimekb12e5a52016-03-01 12:37:30 +000011677TEST_F(ReplacementTest, FormatCodeAfterReplacements) {
11678 // Column limit is 20.
11679 std::string Code = "Type *a =\n"
11680 " new Type();\n"
11681 "g(iiiii, 0, jjjjj,\n"
11682 " 0, kkkkk, 0, mm);\n"
11683 "int bad = format ;";
11684 std::string Expected = "auto a = new Type();\n"
11685 "g(iiiii, nullptr,\n"
11686 " jjjjj, nullptr,\n"
11687 " kkkkk, nullptr,\n"
11688 " mm);\n"
11689 "int bad = format ;";
11690 FileID ID = Context.createInMemoryFile("format.cpp", Code);
Eric Liu40ef2fb2016-08-01 10:16:37 +000011691 tooling::Replacements Replaces = toReplacements(
11692 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6,
11693 "auto "),
11694 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1,
11695 "nullptr"),
11696 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1,
11697 "nullptr"),
11698 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1,
11699 "nullptr")});
Manuel Klimekb12e5a52016-03-01 12:37:30 +000011700
11701 format::FormatStyle Style = format::getLLVMStyle();
11702 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility.
Eric Liu4f8d9942016-07-11 13:53:12 +000011703 auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
11704 EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
11705 << llvm::toString(FormattedReplaces.takeError()) << "\n";
11706 auto Result = applyAllReplacements(Code, *FormattedReplaces);
11707 EXPECT_TRUE(static_cast<bool>(Result));
11708 EXPECT_EQ(Expected, *Result);
Manuel Klimekb12e5a52016-03-01 12:37:30 +000011709}
11710
Eric Liubaf58c22016-05-18 13:43:48 +000011711TEST_F(ReplacementTest, SortIncludesAfterReplacement) {
11712 std::string Code = "#include \"a.h\"\n"
11713 "#include \"c.h\"\n"
11714 "\n"
11715 "int main() {\n"
11716 " return 0;\n"
11717 "}";
11718 std::string Expected = "#include \"a.h\"\n"
11719 "#include \"b.h\"\n"
11720 "#include \"c.h\"\n"
11721 "\n"
11722 "int main() {\n"
11723 " return 0;\n"
11724 "}";
11725 FileID ID = Context.createInMemoryFile("fix.cpp", Code);
Eric Liu40ef2fb2016-08-01 10:16:37 +000011726 tooling::Replacements Replaces = toReplacements(
11727 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0,
11728 "#include \"b.h\"\n")});
Eric Liubaf58c22016-05-18 13:43:48 +000011729
11730 format::FormatStyle Style = format::getLLVMStyle();
11731 Style.SortIncludes = true;
Eric Liu4f8d9942016-07-11 13:53:12 +000011732 auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
11733 EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
11734 << llvm::toString(FormattedReplaces.takeError()) << "\n";
11735 auto Result = applyAllReplacements(Code, *FormattedReplaces);
11736 EXPECT_TRUE(static_cast<bool>(Result));
11737 EXPECT_EQ(Expected, *Result);
Eric Liubaf58c22016-05-18 13:43:48 +000011738}
11739
Krasimir Georgievac16a202017-06-23 11:46:03 +000011740TEST_F(FormatTest, FormatSortsUsingDeclarations) {
11741 EXPECT_EQ("using std::cin;\n"
11742 "using std::cout;",
11743 format("using std::cout;\n"
11744 "using std::cin;", getGoogleStyle()));
11745}
11746
Nico Weberdc065182017-04-05 18:10:42 +000011747TEST_F(FormatTest, UTF8CharacterLiteralCpp03) {
11748 format::FormatStyle Style = format::getLLVMStyle();
11749 Style.Standard = FormatStyle::LS_Cpp03;
11750 // cpp03 recognize this string as identifier u8 and literal character 'a'
11751 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style));
11752}
11753
11754TEST_F(FormatTest, UTF8CharacterLiteralCpp11) {
11755 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers
11756 // all modes, including C++11, C++14 and C++17
11757 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';"));
11758}
11759
Krasimir Georgieva2e7d0d2017-08-29 13:51:38 +000011760TEST_F(FormatTest, DoNotFormatLikelyXml) {
11761 EXPECT_EQ("<!-- ;> -->",
11762 format("<!-- ;> -->", getGoogleStyle()));
11763 EXPECT_EQ(" <!-- >; -->",
11764 format(" <!-- >; -->", getGoogleStyle()));
11765}
11766
Marek Kurdejceeb8b92017-09-07 14:28:32 +000011767TEST_F(FormatTest, StructuredBindings) {
11768 // Structured bindings is a C++17 feature.
11769 // all modes, including C++11, C++14 and C++17
11770 verifyFormat("auto [a, b] = f();");
11771 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();"));
11772 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();"));
11773 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();"));
11774 EXPECT_EQ("auto const volatile [a, b] = f();",
11775 format("auto const volatile[a, b] = f();"));
11776 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();"));
Chih-Hung Hsieh30cd3012017-09-27 00:58:45 +000011777 EXPECT_EQ("auto &[a, b, c] = f();",
Marek Kurdejceeb8b92017-09-07 14:28:32 +000011778 format("auto &[ a , b,c ] = f();"));
Chih-Hung Hsieh30cd3012017-09-27 00:58:45 +000011779 EXPECT_EQ("auto &&[a, b, c] = f();",
Marek Kurdejceeb8b92017-09-07 14:28:32 +000011780 format("auto &&[ a , b,c ] = f();"));
Chih-Hung Hsieh30cd3012017-09-27 00:58:45 +000011781 EXPECT_EQ("auto const &[a, b] = f();", format("auto const&[a, b] = f();"));
11782 EXPECT_EQ("auto const volatile &&[a, b] = f();",
Marek Kurdejceeb8b92017-09-07 14:28:32 +000011783 format("auto const volatile &&[a, b] = f();"));
Chih-Hung Hsieh30cd3012017-09-27 00:58:45 +000011784 EXPECT_EQ("auto const &&[a, b] = f();", format("auto const && [a, b] = f();"));
11785 EXPECT_EQ("const auto &[a, b] = f();", format("const auto & [a, b] = f();"));
11786 EXPECT_EQ("const auto volatile &&[a, b] = f();",
11787 format("const auto volatile &&[a, b] = f();"));
11788 EXPECT_EQ("volatile const auto &&[a, b] = f();",
11789 format("volatile const auto &&[a, b] = f();"));
11790 EXPECT_EQ("const auto &&[a, b] = f();", format("const auto && [a, b] = f();"));
Marek Kurdejceeb8b92017-09-07 14:28:32 +000011791
Manuel Klimeke411aa82017-09-20 09:29:37 +000011792 // Make sure we don't mistake structured bindings for lambdas.
Chih-Hung Hsieh30cd3012017-09-27 00:58:45 +000011793 FormatStyle PointerMiddle = getLLVMStyle();
11794 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
11795 verifyFormat("auto [a1, b]{A * i};", getGoogleStyle());
11796 verifyFormat("auto [a2, b]{A * i};", getLLVMStyle());
11797 verifyFormat("auto [a3, b]{A * i};", PointerMiddle);
11798 verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle());
11799 verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle());
11800 verifyFormat("auto const [a3, b]{A * i};", PointerMiddle);
11801 verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle());
11802 verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle());
11803 verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle);
11804 verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle());
11805 verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle());
11806 verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle);
11807
11808 EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}",
11809 format("for (const auto && [a, b] : some_range) {\n}"));
11810 EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}",
11811 format("for (const auto & [a, b] : some_range) {\n}"));
11812 EXPECT_EQ("for (const auto [a, b] : some_range) {\n}",
11813 format("for (const auto[a, b] : some_range) {\n}"));
11814 EXPECT_EQ("auto [x, y](expr);", format("auto[x,y] (expr);"));
11815 EXPECT_EQ("auto &[x, y](expr);", format("auto & [x,y] (expr);"));
11816 EXPECT_EQ("auto &&[x, y](expr);", format("auto && [x,y] (expr);"));
11817 EXPECT_EQ("auto const &[x, y](expr);", format("auto const & [x,y] (expr);"));
11818 EXPECT_EQ("auto const &&[x, y](expr);", format("auto const && [x,y] (expr);"));
11819 EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y] {expr};"));
11820 EXPECT_EQ("auto const &[x, y]{expr};", format("auto const & [x,y] {expr};"));
11821 EXPECT_EQ("auto const &&[x, y]{expr};", format("auto const && [x,y] {expr};"));
Manuel Klimeke411aa82017-09-20 09:29:37 +000011822
Marek Kurdejceeb8b92017-09-07 14:28:32 +000011823 format::FormatStyle Spaces = format::getLLVMStyle();
11824 Spaces.SpacesInSquareBrackets = true;
11825 verifyFormat("auto [ a, b ] = f();", Spaces);
Chih-Hung Hsieh30cd3012017-09-27 00:58:45 +000011826 verifyFormat("auto &&[ a, b ] = f();", Spaces);
11827 verifyFormat("auto &[ a, b ] = f();", Spaces);
11828 verifyFormat("auto const &&[ a, b ] = f();", Spaces);
11829 verifyFormat("auto const &[ a, b ] = f();", Spaces);
Marek Kurdejceeb8b92017-09-07 14:28:32 +000011830}
11831
Daniel Jasperd246a5a2015-06-15 15:25:11 +000011832} // end namespace
11833} // end namespace format
Daniel Jasper8d1832e2013-01-07 13:26:07 +000011834} // end namespace clang