blob: 6b8bff167abd2dfe656ef8cf2299b431c0d5b924 [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
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000010#include "FormatTestUtils.h"
Chandler Carruth320d9662012-12-04 09:45:34 +000011#include "clang/Format/Format.h"
Chandler Carruth4b417452013-01-19 08:09:44 +000012#include "llvm/Support/Debug.h"
13#include "gtest/gtest.h"
Manuel Klimek24998102013-01-16 14:55:28 +000014
Chandler Carruth10346662014-04-22 03:17:02 +000015#define DEBUG_TYPE "format-test"
16
Daniel Jasperf7935112012-12-03 18:12:45 +000017namespace clang {
18namespace format {
Daniel Jasperd246a5a2015-06-15 15:25:11 +000019namespace {
Daniel Jasperf7935112012-12-03 18:12:45 +000020
Daniel Jaspera44991332015-04-29 13:06:49 +000021FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); }
Nico Weber514ecc82014-02-02 20:50:45 +000022
Daniel Jasperf7935112012-12-03 18:12:45 +000023class FormatTest : public ::testing::Test {
24protected:
Manuel Klimekec5c3db2015-05-07 12:26:30 +000025 enum IncompleteCheck {
26 IC_ExpectComplete,
27 IC_ExpectIncomplete,
28 IC_DoNotCheck
29 };
30
Daniel Jasperd246a5a2015-06-15 15:25:11 +000031 std::string format(llvm::StringRef Code,
32 const FormatStyle &Style = getLLVMStyle(),
Manuel Klimekec5c3db2015-05-07 12:26:30 +000033 IncompleteCheck CheckIncomplete = IC_ExpectComplete) {
Manuel Klimek24998102013-01-16 14:55:28 +000034 DEBUG(llvm::errs() << "---\n");
Manuel Klimek71814b42013-10-11 21:25:45 +000035 DEBUG(llvm::errs() << Code << "\n\n");
Daniel Jasperd246a5a2015-06-15 15:25:11 +000036 std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));
Manuel Klimekec5c3db2015-05-07 12:26:30 +000037 bool IncompleteFormat = false;
38 tooling::Replacements Replaces =
39 reformat(Style, Code, Ranges, "<stdin>", &IncompleteFormat);
40 if (CheckIncomplete != IC_DoNotCheck) {
41 bool ExpectedIncompleteFormat = CheckIncomplete == IC_ExpectIncomplete;
42 EXPECT_EQ(ExpectedIncompleteFormat, IncompleteFormat) << Code << "\n\n";
43 }
Daniel Jasperec04c0d2013-05-16 10:40:07 +000044 ReplacementCount = Replaces.size();
45 std::string Result = applyAllReplacements(Code, Replaces);
46 EXPECT_NE("", Result);
47 DEBUG(llvm::errs() << "\n" << Result << "\n\n");
48 return Result;
Daniel Jasperf7935112012-12-03 18:12:45 +000049 }
50
Manuel Klimekb69e3c62013-01-02 18:33:23 +000051 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) {
52 FormatStyle Style = getLLVMStyle();
53 Style.ColumnLimit = ColumnLimit;
54 return Style;
55 }
56
Daniel Jasper1b750ed2013-01-14 16:24:39 +000057 FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) {
58 FormatStyle Style = getGoogleStyle();
59 Style.ColumnLimit = ColumnLimit;
60 return Style;
61 }
62
Manuel Klimekb69e3c62013-01-02 18:33:23 +000063 void verifyFormat(llvm::StringRef Code,
64 const FormatStyle &Style = getLLVMStyle()) {
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000065 EXPECT_EQ(Code.str(), format(test::messUp(Code), Style));
Daniel Jasperf7935112012-12-03 18:12:45 +000066 }
67
Manuel Klimekec5c3db2015-05-07 12:26:30 +000068 void verifyIncompleteFormat(llvm::StringRef Code,
69 const FormatStyle &Style = getLLVMStyle()) {
70 EXPECT_EQ(Code.str(),
71 format(test::messUp(Code), Style, IC_ExpectIncomplete));
72 }
73
Daniel Jasperf7935112012-12-03 18:12:45 +000074 void verifyGoogleFormat(llvm::StringRef Code) {
Manuel Klimekb69e3c62013-01-02 18:33:23 +000075 verifyFormat(Code, getGoogleStyle());
Daniel Jasperf7935112012-12-03 18:12:45 +000076 }
Daniel Jasper5b49f472013-01-23 12:10:53 +000077
78 void verifyIndependentOfContext(llvm::StringRef text) {
79 verifyFormat(text);
80 verifyFormat(llvm::Twine("void f() { " + text + " }").str());
81 }
Daniel Jasper7b038a22013-01-30 09:46:12 +000082
Daniel Jasper675b4f82015-01-19 10:51:23 +000083 /// \brief Verify that clang-format does not crash on the given input.
84 void verifyNoCrash(llvm::StringRef Code,
85 const FormatStyle &Style = getLLVMStyle()) {
Manuel Klimekec5c3db2015-05-07 12:26:30 +000086 format(Code, Style, IC_DoNotCheck);
Daniel Jasper675b4f82015-01-19 10:51:23 +000087 }
88
Daniel Jasper7b038a22013-01-30 09:46:12 +000089 int ReplacementCount;
Daniel Jasperf7935112012-12-03 18:12:45 +000090};
91
Manuel Klimek52b15152013-01-09 15:25:02 +000092TEST_F(FormatTest, MessUp) {
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000093 EXPECT_EQ("1 2 3", test::messUp("1 2 3"));
94 EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n"));
95 EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc"));
96 EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc"));
97 EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne"));
Manuel Klimek52b15152013-01-09 15:25:02 +000098}
99
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000100//===----------------------------------------------------------------------===//
101// Basic function tests.
102//===----------------------------------------------------------------------===//
103
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +0000104TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) {
Daniel Jasperf7935112012-12-03 18:12:45 +0000105 EXPECT_EQ(";", format(";"));
106}
107
108TEST_F(FormatTest, FormatsGlobalStatementsAt0) {
109 EXPECT_EQ("int i;", format(" int i;"));
Alexander Kornienko9e649af2013-09-11 12:25:57 +0000110 EXPECT_EQ("\nint i;", format(" \n\t \v \f int i;"));
Daniel Jasperf7935112012-12-03 18:12:45 +0000111 EXPECT_EQ("int i;\nint j;", format(" int i; int j;"));
112 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;"));
113}
114
115TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) {
116 EXPECT_EQ("int i;", format("int\ni;"));
117}
118
119TEST_F(FormatTest, FormatsNestedBlockStatements) {
Manuel Klimeke7d10a12013-01-10 13:24:24 +0000120 EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}"));
Daniel Jasperf7935112012-12-03 18:12:45 +0000121}
122
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000123TEST_F(FormatTest, FormatsNestedCall) {
124 verifyFormat("Method(f1, f2(f3));");
125 verifyFormat("Method(f1(f2, f3()));");
Daniel Jasper48cb3b92013-01-13 08:19:51 +0000126 verifyFormat("Method(f1(f2, (f3())));");
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000127}
128
Daniel Jasper14556742013-02-07 21:08:36 +0000129TEST_F(FormatTest, NestedNameSpecifiers) {
Chandler Carruthf8b72662014-03-02 12:37:31 +0000130 verifyFormat("vector<::Type> v;");
Daniel Jasper14556742013-02-07 21:08:36 +0000131 verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())");
Daniel Jasper11be8ac2013-08-28 07:07:07 +0000132 verifyFormat("static constexpr bool Bar = decltype(bar())::value;");
Daniel Jasperf322eb52014-10-23 20:22:22 +0000133 verifyFormat("bool a = 2 < ::SomeFunction();");
Daniel Jasper736c14f2013-01-16 07:19:28 +0000134}
135
Daniel Jasper7b038a22013-01-30 09:46:12 +0000136TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) {
137 EXPECT_EQ("if (a) {\n"
138 " f();\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000139 "}",
140 format("if(a){f();}"));
Daniel Jasper7b038a22013-01-30 09:46:12 +0000141 EXPECT_EQ(4, ReplacementCount);
142 EXPECT_EQ("if (a) {\n"
143 " f();\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000144 "}",
145 format("if (a) {\n"
146 " f();\n"
147 "}"));
Daniel Jasper7b038a22013-01-30 09:46:12 +0000148 EXPECT_EQ(0, ReplacementCount);
Daniel Jasperd6e61882015-06-17 12:23:15 +0000149 EXPECT_EQ("/*\r\n"
150 "\r\n"
151 "*/\r\n",
152 format("/*\r\n"
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +0000153 "\r\n"
154 "*/\r\n"));
Daniel Jasperd6e61882015-06-17 12:23:15 +0000155 EXPECT_EQ(0, ReplacementCount);
Daniel Jasper7b038a22013-01-30 09:46:12 +0000156}
157
Daniel Jasper1027c6e2013-06-03 16:16:41 +0000158TEST_F(FormatTest, RemovesEmptyLines) {
159 EXPECT_EQ("class C {\n"
160 " int i;\n"
161 "};",
162 format("class C {\n"
163 " int i;\n"
164 "\n"
165 "};"));
166
Nico Weber34272652014-11-13 16:25:37 +0000167 // Don't remove empty lines at the start of namespaces or extern "C" blocks.
Daniel Jasper01b35482014-03-21 13:03:33 +0000168 EXPECT_EQ("namespace N {\n"
169 "\n"
170 "int i;\n"
171 "}",
172 format("namespace N {\n"
173 "\n"
174 "int i;\n"
Daniel Jaspera26fc5c2014-03-21 13:43:14 +0000175 "}",
176 getGoogleStyle()));
Nico Weber34272652014-11-13 16:25:37 +0000177 EXPECT_EQ("extern /**/ \"C\" /**/ {\n"
178 "\n"
179 "int i;\n"
180 "}",
181 format("extern /**/ \"C\" /**/ {\n"
182 "\n"
183 "int i;\n"
184 "}",
185 getGoogleStyle()));
186
187 // ...but do keep inlining and removing empty lines for non-block extern "C"
188 // functions.
189 verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle());
190 EXPECT_EQ("extern \"C\" int f() {\n"
191 " int i = 42;\n"
192 " return i;\n"
193 "}",
194 format("extern \"C\" int f() {\n"
195 "\n"
196 " int i = 42;\n"
197 " return i;\n"
198 "}",
199 getGoogleStyle()));
Daniel Jasper01b35482014-03-21 13:03:33 +0000200
Daniel Jasper11164bd2014-03-21 12:58:53 +0000201 // Remove empty lines at the beginning and end of blocks.
202 EXPECT_EQ("void f() {\n"
Daniel Jaspera26fc5c2014-03-21 13:43:14 +0000203 "\n"
204 " if (a) {\n"
205 "\n"
206 " f();\n"
207 " }\n"
208 "}",
209 format("void f() {\n"
210 "\n"
211 " if (a) {\n"
212 "\n"
213 " f();\n"
214 "\n"
215 " }\n"
216 "\n"
217 "}",
218 getLLVMStyle()));
219 EXPECT_EQ("void f() {\n"
Daniel Jasper11164bd2014-03-21 12:58:53 +0000220 " if (a) {\n"
221 " f();\n"
222 " }\n"
223 "}",
224 format("void f() {\n"
225 "\n"
226 " if (a) {\n"
227 "\n"
228 " f();\n"
229 "\n"
230 " }\n"
231 "\n"
Daniel Jaspera26fc5c2014-03-21 13:43:14 +0000232 "}",
233 getGoogleStyle()));
Daniel Jasper11164bd2014-03-21 12:58:53 +0000234
Daniel Jasper1027c6e2013-06-03 16:16:41 +0000235 // Don't remove empty lines in more complex control statements.
236 EXPECT_EQ("void f() {\n"
237 " if (a) {\n"
238 " f();\n"
239 "\n"
240 " } else if (b) {\n"
241 " f();\n"
242 " }\n"
243 "}",
244 format("void f() {\n"
245 " if (a) {\n"
246 " f();\n"
247 "\n"
248 " } else if (b) {\n"
249 " f();\n"
250 "\n"
251 " }\n"
252 "\n"
253 "}"));
254
255 // FIXME: This is slightly inconsistent.
256 EXPECT_EQ("namespace {\n"
257 "int i;\n"
258 "}",
259 format("namespace {\n"
260 "int i;\n"
261 "\n"
262 "}"));
263 EXPECT_EQ("namespace {\n"
264 "int i;\n"
265 "\n"
266 "} // namespace",
267 format("namespace {\n"
268 "int i;\n"
269 "\n"
270 "} // namespace"));
271}
272
Nikola Smiljanice08a91e2014-05-08 00:05:13 +0000273TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) {
Daniel Jaspera44991332015-04-29 13:06:49 +0000274 verifyFormat("x = (a) and (b);");
275 verifyFormat("x = (a) or (b);");
276 verifyFormat("x = (a) bitand (b);");
277 verifyFormat("x = (a) bitor (b);");
278 verifyFormat("x = (a) not_eq (b);");
279 verifyFormat("x = (a) and_eq (b);");
280 verifyFormat("x = (a) or_eq (b);");
281 verifyFormat("x = (a) xor (b);");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +0000282}
283
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000284//===----------------------------------------------------------------------===//
285// Tests for control statements.
286//===----------------------------------------------------------------------===//
287
Daniel Jaspercdd06622013-05-14 10:31:09 +0000288TEST_F(FormatTest, FormatIfWithoutCompoundStatement) {
Daniel Jasper1b750ed2013-01-14 16:24:39 +0000289 verifyFormat("if (true)\n f();\ng();");
290 verifyFormat("if (a)\n if (b)\n if (c)\n g();\nh();");
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000291 verifyFormat("if (a)\n if (b) {\n f();\n }\ng();");
Daniel Jasperced17f82013-01-16 15:44:34 +0000292
Daniel Jasper3a685df2013-05-16 12:12:21 +0000293 FormatStyle AllowsMergedIf = getLLVMStyle();
Daniel Jasperced17f82013-01-16 15:44:34 +0000294 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true;
295 verifyFormat("if (a)\n"
296 " // comment\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000297 " f();",
298 AllowsMergedIf);
Daniel Jasper3a685df2013-05-16 12:12:21 +0000299 verifyFormat("if (a)\n"
300 " ;",
301 AllowsMergedIf);
302 verifyFormat("if (a)\n"
303 " if (b) return;",
304 AllowsMergedIf);
Daniel Jasperced17f82013-01-16 15:44:34 +0000305
Daniel Jasper3a685df2013-05-16 12:12:21 +0000306 verifyFormat("if (a) // Can't merge this\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000307 " f();\n",
308 AllowsMergedIf);
Daniel Jasperced17f82013-01-16 15:44:34 +0000309 verifyFormat("if (a) /* still don't merge */\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000310 " f();",
311 AllowsMergedIf);
Daniel Jasper3a685df2013-05-16 12:12:21 +0000312 verifyFormat("if (a) { // Never merge this\n"
Daniel Jasperced17f82013-01-16 15:44:34 +0000313 " f();\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000314 "}",
315 AllowsMergedIf);
Chandler Carruthf8b72662014-03-02 12:37:31 +0000316 verifyFormat("if (a) {/* Never merge this */\n"
Daniel Jasperced17f82013-01-16 15:44:34 +0000317 " f();\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000318 "}",
319 AllowsMergedIf);
Daniel Jasperced17f82013-01-16 15:44:34 +0000320
321 AllowsMergedIf.ColumnLimit = 14;
322 verifyFormat("if (a) return;", AllowsMergedIf);
Daniel Jasper3e9218e2013-01-14 16:02:06 +0000323 verifyFormat("if (aaaaaaaaa)\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000324 " return;",
325 AllowsMergedIf);
Daniel Jasperced17f82013-01-16 15:44:34 +0000326
327 AllowsMergedIf.ColumnLimit = 13;
328 verifyFormat("if (a)\n return;", AllowsMergedIf);
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000329}
330
Daniel Jasper3a685df2013-05-16 12:12:21 +0000331TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) {
332 FormatStyle AllowsMergedLoops = getLLVMStyle();
333 AllowsMergedLoops.AllowShortLoopsOnASingleLine = true;
334 verifyFormat("while (true) continue;", AllowsMergedLoops);
335 verifyFormat("for (;;) continue;", AllowsMergedLoops);
336 verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops);
337 verifyFormat("while (true)\n"
338 " ;",
339 AllowsMergedLoops);
340 verifyFormat("for (;;)\n"
341 " ;",
342 AllowsMergedLoops);
343 verifyFormat("for (;;)\n"
344 " for (;;) continue;",
345 AllowsMergedLoops);
346 verifyFormat("for (;;) // Can't merge this\n"
347 " continue;",
348 AllowsMergedLoops);
349 verifyFormat("for (;;) /* still don't merge */\n"
350 " continue;",
351 AllowsMergedLoops);
352}
353
Daniel Jasper17605d32014-05-14 09:33:35 +0000354TEST_F(FormatTest, FormatShortBracedStatements) {
355 FormatStyle AllowSimpleBracedStatements = getLLVMStyle();
356 AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine = true;
357
358 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = true;
359 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
360
361 verifyFormat("if (true) {}", AllowSimpleBracedStatements);
362 verifyFormat("while (true) {}", AllowSimpleBracedStatements);
363 verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
364 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
365 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
366 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
367 verifyFormat("if (true) { //\n"
368 " f();\n"
369 "}",
370 AllowSimpleBracedStatements);
371 verifyFormat("if (true) {\n"
372 " f();\n"
373 " f();\n"
374 "}",
375 AllowSimpleBracedStatements);
Daniel Jaspere9f53572015-04-30 09:24:17 +0000376 verifyFormat("if (true) {\n"
377 " f();\n"
378 "} else {\n"
379 " f();\n"
380 "}",
381 AllowSimpleBracedStatements);
Daniel Jasper17605d32014-05-14 09:33:35 +0000382
Daniel Jasperbd630732014-05-22 13:25:26 +0000383 verifyFormat("template <int> struct A2 {\n"
384 " struct B {};\n"
385 "};",
386 AllowSimpleBracedStatements);
387
Daniel Jasper17605d32014-05-14 09:33:35 +0000388 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = false;
389 verifyFormat("if (true) {\n"
390 " f();\n"
391 "}",
392 AllowSimpleBracedStatements);
Daniel Jaspere9f53572015-04-30 09:24:17 +0000393 verifyFormat("if (true) {\n"
394 " f();\n"
395 "} else {\n"
396 " f();\n"
397 "}",
398 AllowSimpleBracedStatements);
Daniel Jasper17605d32014-05-14 09:33:35 +0000399
400 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
401 verifyFormat("while (true) {\n"
402 " f();\n"
403 "}",
404 AllowSimpleBracedStatements);
405 verifyFormat("for (;;) {\n"
406 " f();\n"
407 "}",
408 AllowSimpleBracedStatements);
409}
410
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000411TEST_F(FormatTest, ParseIfElse) {
412 verifyFormat("if (true)\n"
413 " if (true)\n"
414 " if (true)\n"
415 " f();\n"
416 " else\n"
417 " g();\n"
418 " else\n"
419 " h();\n"
420 "else\n"
421 " i();");
422 verifyFormat("if (true)\n"
423 " if (true)\n"
424 " if (true) {\n"
Daniel Jasper1b750ed2013-01-14 16:24:39 +0000425 " if (true)\n"
426 " f();\n"
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000427 " } else {\n"
428 " g();\n"
429 " }\n"
430 " else\n"
431 " h();\n"
432 "else {\n"
433 " i();\n"
434 "}");
Daniel Jasper88f92222013-09-17 08:28:05 +0000435 verifyFormat("void f() {\n"
436 " if (a) {\n"
437 " } else {\n"
438 " }\n"
439 "}");
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000440}
441
442TEST_F(FormatTest, ElseIf) {
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000443 verifyFormat("if (a) {\n} else if (b) {\n}");
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000444 verifyFormat("if (a)\n"
445 " f();\n"
446 "else if (b)\n"
447 " g();\n"
448 "else\n"
449 " h();");
Daniel Jasper16fc7542013-10-30 14:04:10 +0000450 verifyFormat("if (a) {\n"
451 " f();\n"
452 "}\n"
453 "// or else ..\n"
454 "else {\n"
455 " g()\n"
456 "}");
Daniel Jasper8acf8222014-05-07 09:23:05 +0000457
458 verifyFormat("if (a) {\n"
459 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
460 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
461 "}");
Daniel Jaspera42de762015-02-26 09:49:08 +0000462 verifyFormat("if (a) {\n"
463 "} else if (\n"
464 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
465 "}",
466 getLLVMStyleWithColumns(62));
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000467}
468
Daniel Jasperf7935112012-12-03 18:12:45 +0000469TEST_F(FormatTest, FormatsForLoop) {
470 verifyFormat(
471 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n"
Alexander Kornienko37d6c942012-12-05 15:06:06 +0000472 " ++VeryVeryLongLoopVariable)\n"
473 " ;");
474 verifyFormat("for (;;)\n"
475 " f();");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000476 verifyFormat("for (;;) {\n}");
Alexander Kornienko37d6c942012-12-05 15:06:06 +0000477 verifyFormat("for (;;) {\n"
478 " f();\n"
479 "}");
Daniel Jasper72463d32013-05-03 14:50:50 +0000480 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}");
Daniel Jasperfbde69e2012-12-21 14:37:20 +0000481
482 verifyFormat(
483 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
484 " E = UnwrappedLines.end();\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000485 " I != E; ++I) {\n}");
Daniel Jasperfbde69e2012-12-21 14:37:20 +0000486
487 verifyFormat(
488 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000489 " ++IIIII) {\n}");
Daniel Jaspera628c982013-04-03 13:36:17 +0000490 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n"
491 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000492 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}");
Daniel Jasper37905f72013-02-21 15:00:29 +0000493 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n"
494 " I = FD->getDeclsInPrototypeScope().begin(),\n"
495 " E = FD->getDeclsInPrototypeScope().end();\n"
496 " I != E; ++I) {\n}");
Daniel Jasperd6e09e82015-05-19 11:51:39 +0000497 verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n"
498 " I = Container.begin(),\n"
499 " E = Container.end();\n"
500 " I != E; ++I) {\n}",
501 getLLVMStyleWithColumns(76));
Daniel Jasper48c62f92013-01-28 17:30:17 +0000502
Daniel Jasper48c62f92013-01-28 17:30:17 +0000503 verifyFormat(
504 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
505 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n"
Daniel Jasper98f8ae32015-03-06 10:57:12 +0000506 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
507 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
Daniel Jasper48c62f92013-01-28 17:30:17 +0000508 " ++aaaaaaaaaaa) {\n}");
Daniel Jasper98f8ae32015-03-06 10:57:12 +0000509 verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
510 " bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n"
511 " ++i) {\n}");
Daniel Jasper2cf17bf2013-02-27 09:47:53 +0000512 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n"
513 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
514 "}");
Daniel Jaspera628c982013-04-03 13:36:17 +0000515 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n"
516 " aaaaaaaaaa);\n"
517 " iter; ++iter) {\n"
518 "}");
Daniel Jasperf7f13c02013-02-04 07:30:30 +0000519
Daniel Jasper2cf17bf2013-02-27 09:47:53 +0000520 FormatStyle NoBinPacking = getLLVMStyle();
521 NoBinPacking.BinPackParameters = false;
522 verifyFormat("for (int aaaaaaaaaaa = 1;\n"
523 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n"
524 " aaaaaaaaaaaaaaaa,\n"
525 " aaaaaaaaaaaaaaaa,\n"
526 " aaaaaaaaaaaaaaaa);\n"
527 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
528 "}",
529 NoBinPacking);
530 verifyFormat(
Daniel Jaspercd8599e2013-02-23 21:01:55 +0000531 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
532 " E = UnwrappedLines.end();\n"
533 " I != E;\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +0000534 " ++I) {\n}",
535 NoBinPacking);
Daniel Jasperf7935112012-12-03 18:12:45 +0000536}
537
Daniel Jasper0b41cbb2013-01-28 13:21:16 +0000538TEST_F(FormatTest, RangeBasedForLoops) {
539 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
540 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
541 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n"
542 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}");
Daniel Jasper16b35622013-02-26 13:18:08 +0000543 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n"
544 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasper9cc3e972014-02-07 10:09:46 +0000545 verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n"
546 " aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}");
Daniel Jasper0b41cbb2013-01-28 13:21:16 +0000547}
548
Daniel Jaspere1e43192014-04-01 12:55:11 +0000549TEST_F(FormatTest, ForEachLoops) {
550 verifyFormat("void f() {\n"
551 " foreach (Item *item, itemlist) {}\n"
552 " Q_FOREACH (Item *item, itemlist) {}\n"
553 " BOOST_FOREACH (Item *item, itemlist) {}\n"
554 " UNKNOWN_FORACH(Item * item, itemlist) {}\n"
555 "}");
Daniel Jasper229628b2015-06-11 08:38:19 +0000556
557 // As function-like macros.
558 verifyFormat("#define foreach(x, y)\n"
559 "#define Q_FOREACH(x, y)\n"
560 "#define BOOST_FOREACH(x, y)\n"
561 "#define UNKNOWN_FOREACH(x, y)\n");
562
563 // Not as function-like macros.
564 verifyFormat("#define foreach (x, y)\n"
565 "#define Q_FOREACH (x, y)\n"
566 "#define BOOST_FOREACH (x, y)\n"
567 "#define UNKNOWN_FOREACH (x, y)\n");
Daniel Jaspere1e43192014-04-01 12:55:11 +0000568}
569
Daniel Jasperf7935112012-12-03 18:12:45 +0000570TEST_F(FormatTest, FormatsWhileLoop) {
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000571 verifyFormat("while (true) {\n}");
Alexander Kornienko37d6c942012-12-05 15:06:06 +0000572 verifyFormat("while (true)\n"
573 " f();");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000574 verifyFormat("while () {\n}");
Alexander Kornienko37d6c942012-12-05 15:06:06 +0000575 verifyFormat("while () {\n"
576 " f();\n"
577 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +0000578}
579
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000580TEST_F(FormatTest, FormatsDoWhile) {
581 verifyFormat("do {\n"
582 " do_something();\n"
583 "} while (something());");
584 verifyFormat("do\n"
585 " do_something();\n"
586 "while (something());");
Daniel Jasperf7935112012-12-03 18:12:45 +0000587}
588
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000589TEST_F(FormatTest, FormatsSwitchStatement) {
Daniel Jasperf7935112012-12-03 18:12:45 +0000590 verifyFormat("switch (x) {\n"
591 "case 1:\n"
592 " f();\n"
593 " break;\n"
594 "case kFoo:\n"
595 "case ns::kBar:\n"
596 "case kBaz:\n"
597 " break;\n"
598 "default:\n"
599 " g();\n"
600 " break;\n"
601 "}");
602 verifyFormat("switch (x) {\n"
603 "case 1: {\n"
604 " f();\n"
605 " break;\n"
606 "}\n"
Daniel Jasper922349c2014-04-04 06:46:23 +0000607 "case 2: {\n"
608 " break;\n"
609 "}\n"
Daniel Jasperf7935112012-12-03 18:12:45 +0000610 "}");
Nico Webera5510af2013-01-18 05:50:57 +0000611 verifyFormat("switch (x) {\n"
612 "case 1: {\n"
613 " f();\n"
614 " {\n"
615 " g();\n"
616 " h();\n"
617 " }\n"
618 " break;\n"
619 "}\n"
620 "}");
621 verifyFormat("switch (x) {\n"
622 "case 1: {\n"
623 " f();\n"
624 " if (foo) {\n"
625 " g();\n"
626 " h();\n"
627 " }\n"
628 " break;\n"
629 "}\n"
630 "}");
631 verifyFormat("switch (x) {\n"
632 "case 1: {\n"
633 " f();\n"
634 " g();\n"
635 "} break;\n"
636 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +0000637 verifyFormat("switch (test)\n"
638 " ;");
Daniel Jasper18104652013-03-12 12:26:55 +0000639 verifyFormat("switch (x) {\n"
640 "default: {\n"
641 " // Do nothing.\n"
Manuel Klimek1a18c402013-04-12 14:13:36 +0000642 "}\n"
Daniel Jasper18104652013-03-12 12:26:55 +0000643 "}");
Daniel Jasper0f8ed9e2013-03-13 15:53:12 +0000644 verifyFormat("switch (x) {\n"
Daniel Jasperb67cc422013-04-09 17:46:55 +0000645 "// comment\n"
Daniel Jasper0f8ed9e2013-03-13 15:53:12 +0000646 "// if 1, do f()\n"
647 "case 1:\n"
648 " f();\n"
649 "}");
Daniel Jasper2bd32ca2013-03-19 18:33:58 +0000650 verifyFormat("switch (x) {\n"
651 "case 1:\n"
652 " // Do amazing stuff\n"
653 " {\n"
654 " f();\n"
655 " g();\n"
656 " }\n"
657 " break;\n"
658 "}");
Daniel Jaspera1275122013-03-20 10:23:53 +0000659 verifyFormat("#define A \\\n"
660 " switch (x) { \\\n"
661 " case a: \\\n"
662 " foo = b; \\\n"
Daniel Jaspera44991332015-04-29 13:06:49 +0000663 " }",
664 getLLVMStyleWithColumns(20));
Daniel Jasper72407622013-09-02 08:26:29 +0000665 verifyFormat("#define OPERATION_CASE(name) \\\n"
666 " case OP_name: \\\n"
667 " return operations::Operation##name\n",
668 getLLVMStyleWithColumns(40));
Daniel Jasper1fe0d5c2015-05-06 15:19:47 +0000669 verifyFormat("switch (x) {\n"
670 "case 1:;\n"
671 "default:;\n"
672 " int i;\n"
673 "}");
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000674
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000675 verifyGoogleFormat("switch (x) {\n"
676 " case 1:\n"
677 " f();\n"
678 " break;\n"
679 " case kFoo:\n"
680 " case ns::kBar:\n"
681 " case kBaz:\n"
682 " break;\n"
683 " default:\n"
684 " g();\n"
685 " break;\n"
686 "}");
687 verifyGoogleFormat("switch (x) {\n"
688 " case 1: {\n"
689 " f();\n"
690 " break;\n"
691 " }\n"
692 "}");
693 verifyGoogleFormat("switch (test)\n"
Daniel Jasper516d7972013-07-25 11:31:57 +0000694 " ;");
695
696 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n"
697 " case OP_name: \\\n"
698 " return operations::Operation##name\n");
699 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n"
700 " // Get the correction operation class.\n"
701 " switch (OpCode) {\n"
702 " CASE(Add);\n"
703 " CASE(Subtract);\n"
704 " default:\n"
705 " return operations::Unknown;\n"
706 " }\n"
707 "#undef OPERATION_CASE\n"
708 "}");
Daniel Jasper1c5d9df2013-09-06 07:54:20 +0000709 verifyFormat("DEBUG({\n"
710 " switch (x) {\n"
711 " case A:\n"
712 " f();\n"
713 " break;\n"
714 " // On B:\n"
715 " case B:\n"
716 " g();\n"
717 " break;\n"
718 " }\n"
719 "});");
Daniel Jasper031e2402014-04-28 07:48:36 +0000720 verifyFormat("switch (a) {\n"
721 "case (b):\n"
722 " return;\n"
723 "}");
Daniel Jasperd39312ec2014-05-28 10:09:11 +0000724
725 verifyFormat("switch (a) {\n"
726 "case some_namespace::\n"
727 " some_constant:\n"
728 " return;\n"
729 "}",
730 getLLVMStyleWithColumns(34));
Daniel Jasperf7935112012-12-03 18:12:45 +0000731}
732
Daniel Jasper2d0cd492013-10-20 16:56:16 +0000733TEST_F(FormatTest, CaseRanges) {
734 verifyFormat("switch (x) {\n"
735 "case 'A' ... 'Z':\n"
736 "case 1 ... 5:\n"
737 " break;\n"
738 "}");
739}
740
Daniel Jasperb87899b2014-09-10 13:11:45 +0000741TEST_F(FormatTest, ShortCaseLabels) {
742 FormatStyle Style = getLLVMStyle();
743 Style.AllowShortCaseLabelsOnASingleLine = true;
744 verifyFormat("switch (a) {\n"
745 "case 1: x = 1; break;\n"
746 "case 2: return;\n"
747 "case 3:\n"
748 "case 4:\n"
749 "case 5: return;\n"
Daniel Jasperd081e882014-11-21 12:36:25 +0000750 "case 6: // comment\n"
751 " return;\n"
752 "case 7:\n"
753 " // comment\n"
754 " return;\n"
Daniel Jasperb87899b2014-09-10 13:11:45 +0000755 "default: y = 1; break;\n"
756 "}",
757 Style);
758 verifyFormat("switch (a) {\n"
Daniel Jasper79f226e2014-11-23 21:45:03 +0000759 "#if FOO\n"
760 "case 0: return 0;\n"
761 "#endif\n"
762 "}",
763 Style);
764 verifyFormat("switch (a) {\n"
Daniel Jasperb87899b2014-09-10 13:11:45 +0000765 "case 1: {\n"
766 "}\n"
767 "case 2: {\n"
768 " return;\n"
769 "}\n"
770 "case 3: {\n"
771 " x = 1;\n"
772 " return;\n"
773 "}\n"
774 "case 4:\n"
775 " if (x)\n"
776 " return;\n"
777 "}",
778 Style);
779 Style.ColumnLimit = 21;
780 verifyFormat("switch (a) {\n"
781 "case 1: x = 1; break;\n"
782 "case 2: return;\n"
783 "case 3:\n"
784 "case 4:\n"
785 "case 5: return;\n"
786 "default:\n"
787 " y = 1;\n"
788 " break;\n"
789 "}",
790 Style);
791}
792
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000793TEST_F(FormatTest, FormatsLabels) {
Daniel Jasperf7935112012-12-03 18:12:45 +0000794 verifyFormat("void f() {\n"
795 " some_code();\n"
796 "test_label:\n"
797 " some_other_code();\n"
798 " {\n"
799 " some_more_code();\n"
800 " another_label:\n"
801 " some_more_code();\n"
802 " }\n"
803 "}");
Daniel Jasper676e5162015-04-07 14:36:33 +0000804 verifyFormat("{\n"
805 " some_code();\n"
Daniel Jasperf7935112012-12-03 18:12:45 +0000806 "test_label:\n"
Daniel Jasper676e5162015-04-07 14:36:33 +0000807 " some_other_code();\n"
808 "}");
Daniel Jasper1fe0d5c2015-05-06 15:19:47 +0000809 verifyFormat("{\n"
810 " some_code();\n"
811 "test_label:;\n"
812 " int i = 0;\n"
813 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +0000814}
815
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000816//===----------------------------------------------------------------------===//
817// Tests for comments.
818//===----------------------------------------------------------------------===//
819
820TEST_F(FormatTest, UnderstandsSingleLineComments) {
Daniel Jasper55213652013-03-22 10:01:29 +0000821 verifyFormat("//* */");
Daniel Jasper3f69a1b2012-12-18 19:56:56 +0000822 verifyFormat("// line 1\n"
823 "// line 2\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +0000824 "void f() {}\n");
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000825
Daniel Jasper3f69a1b2012-12-18 19:56:56 +0000826 verifyFormat("void f() {\n"
827 " // Doesn't do anything\n"
828 "}");
Daniel Jasper185de242013-07-11 13:48:16 +0000829 verifyFormat("SomeObject\n"
830 " // Calling someFunction on SomeObject\n"
831 " .someFunction();");
Daniel Jaspera0407742014-02-11 10:08:11 +0000832 verifyFormat("auto result = SomeObject\n"
833 " // Calling someFunction on SomeObject\n"
834 " .someFunction();");
Daniel Jasperaa701fa2013-01-18 08:44:07 +0000835 verifyFormat("void f(int i, // some comment (probably for i)\n"
836 " int j, // some comment (probably for j)\n"
Daniel Jasper942ee722013-01-13 16:10:20 +0000837 " int k); // some comment (probably for k)");
838 verifyFormat("void f(int i,\n"
839 " // some comment (probably for j)\n"
840 " int j,\n"
841 " // some comment (probably for k)\n"
842 " int k);");
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000843
Daniel Jasperaa701fa2013-01-18 08:44:07 +0000844 verifyFormat("int i // This is a fancy variable\n"
845 " = 5; // with nicely aligned comment.");
846
847 verifyFormat("// Leading comment.\n"
848 "int a; // Trailing comment.");
849 verifyFormat("int a; // Trailing comment\n"
850 " // on 2\n"
851 " // or 3 lines.\n"
852 "int b;");
853 verifyFormat("int a; // Trailing comment\n"
854 "\n"
855 "// Leading comment.\n"
856 "int b;");
857 verifyFormat("int a; // Comment.\n"
858 " // More details.\n"
859 "int bbbb; // Another comment.");
860 verifyFormat(
861 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; // comment\n"
862 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; // comment\n"
863 "int cccccccccccccccccccccccccccccc; // comment\n"
864 "int ddd; // looooooooooooooooooooooooong comment\n"
865 "int aaaaaaaaaaaaaaaaaaaaaaa; // comment\n"
866 "int bbbbbbbbbbbbbbbbbbbbb; // comment\n"
867 "int ccccccccccccccccccc; // comment");
868
Daniel Jasper997b08c2013-01-18 09:19:33 +0000869 verifyFormat("#include \"a\" // comment\n"
870 "#include \"a/b/c\" // comment");
871 verifyFormat("#include <a> // comment\n"
872 "#include <a/b/c> // comment");
Daniel Jasper98857842013-10-30 13:54:53 +0000873 EXPECT_EQ("#include \"a\" // comment\n"
Manuel Klimek5c24cca2013-05-23 10:56:37 +0000874 "#include \"a/b/c\" // comment",
875 format("#include \\\n"
876 " \"a\" // comment\n"
877 "#include \"a/b/c\" // comment"));
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000878
Daniel Jasper3f69a1b2012-12-18 19:56:56 +0000879 verifyFormat("enum E {\n"
880 " // comment\n"
Daniel Jasper5ad1e192013-01-07 11:09:06 +0000881 " VAL_A, // comment\n"
Daniel Jasper3f69a1b2012-12-18 19:56:56 +0000882 " VAL_B\n"
883 "};");
Daniel Jaspere25509f2012-12-17 11:29:41 +0000884
885 verifyFormat(
886 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Daniel Jasper5ad1e192013-01-07 11:09:06 +0000887 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; // Trailing comment");
Daniel Jasperd8bb2db2013-01-09 09:33:39 +0000888 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
889 " // Comment inside a statement.\n"
890 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
Daniel Jasper4281c5a2014-10-07 14:45:34 +0000891 verifyFormat("SomeFunction(a,\n"
892 " // comment\n"
893 " b + x);");
894 verifyFormat("SomeFunction(a, a,\n"
895 " // comment\n"
896 " b + x);");
Daniel Jasper38396592013-02-06 15:23:09 +0000897 verifyFormat(
898 "bool aaaaaaaaaaaaa = // comment\n"
899 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
900 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Manuel Klimekc74d2922013-01-07 08:54:53 +0000901
Daniel Jasper525264c2013-02-13 19:25:54 +0000902 verifyFormat("int aaaa; // aaaaa\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000903 "int aa; // aaaaaaa",
904 getLLVMStyleWithColumns(20));
Daniel Jasper525264c2013-02-13 19:25:54 +0000905
Daniel Jasper304a9862013-01-21 22:49:20 +0000906 EXPECT_EQ("void f() { // This does something ..\n"
907 "}\n"
908 "int a; // This is unrelated",
909 format("void f() { // This does something ..\n"
910 " }\n"
911 "int a; // This is unrelated"));
Daniel Jasper251b3c92013-07-01 11:22:57 +0000912 EXPECT_EQ("class C {\n"
913 " void f() { // This does something ..\n"
914 " } // awesome..\n"
Daniel Jasper304a9862013-01-21 22:49:20 +0000915 "\n"
Daniel Jasper251b3c92013-07-01 11:22:57 +0000916 " int a; // This is unrelated\n"
917 "};",
918 format("class C{void f() { // This does something ..\n"
Daniel Jasper304a9862013-01-21 22:49:20 +0000919 " } // awesome..\n"
920 " \n"
Daniel Jasper251b3c92013-07-01 11:22:57 +0000921 "int a; // This is unrelated\n"
922 "};"));
Daniel Jasper304a9862013-01-21 22:49:20 +0000923
Daniel Jasper5ad1e192013-01-07 11:09:06 +0000924 EXPECT_EQ("int i; // single line trailing comment",
Manuel Klimekc74d2922013-01-07 08:54:53 +0000925 format("int i;\\\n// single line trailing comment"));
Daniel Jasper5ad1e192013-01-07 11:09:06 +0000926
927 verifyGoogleFormat("int a; // Trailing comment.");
Daniel Jasperddaa9be2013-01-29 19:41:55 +0000928
929 verifyFormat("someFunction(anotherFunction( // Force break.\n"
930 " parameter));");
Daniel Jaspera885dbe2013-02-05 09:34:14 +0000931
932 verifyGoogleFormat("#endif // HEADER_GUARD");
Daniel Jasperf79f9352013-02-06 22:04:05 +0000933
934 verifyFormat("const char *test[] = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +0000935 " // A\n"
936 " \"aaaa\",\n"
937 " // B\n"
938 " \"aaaaa\"};");
Daniel Jaspereef30492013-02-11 12:36:37 +0000939 verifyGoogleFormat(
940 "aaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Alexander Kornienkodd7ece52013-06-07 16:02:52 +0000941 " aaaaaaaaaaaaaaaaaaaaaa); // 81_cols_with_this_comment");
Alexander Kornienkob1be9d62013-04-03 12:38:53 +0000942 EXPECT_EQ("D(a, {\n"
943 " // test\n"
944 " int a;\n"
945 "});",
946 format("D(a, {\n"
947 "// test\n"
948 "int a;\n"
949 "});"));
Manuel Klimekc5730802013-05-23 11:42:52 +0000950
951 EXPECT_EQ("lineWith(); // comment\n"
952 "// at start\n"
953 "otherLine();",
954 format("lineWith(); // comment\n"
955 "// at start\n"
956 "otherLine();"));
957 EXPECT_EQ("lineWith(); // comment\n"
958 " // at start\n"
959 "otherLine();",
960 format("lineWith(); // comment\n"
961 " // at start\n"
962 "otherLine();"));
Manuel Klimekb27375f2013-05-23 19:54:43 +0000963
964 EXPECT_EQ("lineWith(); // comment\n"
965 "// at start\n"
966 "otherLine(); // comment",
967 format("lineWith(); // comment\n"
968 "// at start\n"
969 "otherLine(); // comment"));
Manuel Klimek75ef31f2013-05-23 20:46:07 +0000970 EXPECT_EQ("lineWith();\n"
971 "// at start\n"
972 "otherLine(); // comment",
973 format("lineWith();\n"
974 " // at start\n"
975 "otherLine(); // comment"));
976 EXPECT_EQ("// first\n"
977 "// at start\n"
978 "otherLine(); // comment",
979 format("// first\n"
980 " // at start\n"
981 "otherLine(); // comment"));
982 EXPECT_EQ("f();\n"
983 "// first\n"
984 "// at start\n"
985 "otherLine(); // comment",
986 format("f();\n"
987 "// first\n"
988 " // at start\n"
989 "otherLine(); // comment"));
Daniel Jasper0e93cdb2013-11-08 23:31:14 +0000990 verifyFormat("f(); // comment\n"
991 "// first\n"
992 "// at start\n"
993 "otherLine();");
994 EXPECT_EQ("f(); // comment\n"
995 "// first\n"
996 "// at start\n"
997 "otherLine();",
998 format("f(); // comment\n"
999 "// first\n"
1000 " // at start\n"
1001 "otherLine();"));
1002 EXPECT_EQ("f(); // comment\n"
1003 " // first\n"
1004 "// at start\n"
1005 "otherLine();",
1006 format("f(); // comment\n"
1007 " // first\n"
1008 "// at start\n"
1009 "otherLine();"));
Daniel Jasper49532102015-01-07 14:00:11 +00001010 EXPECT_EQ("void f() {\n"
1011 " lineWith(); // comment\n"
1012 " // at start\n"
1013 "}",
1014 format("void f() {\n"
1015 " lineWith(); // comment\n"
1016 " // at start\n"
1017 "}"));
Daniel Jasper66935022014-04-27 10:03:19 +00001018
Daniel Jaspera44991332015-04-29 13:06:49 +00001019 verifyFormat("#define A \\\n"
1020 " int i; /* iiiiiiiiiiiiiiiiiiiii */ \\\n"
1021 " int jjjjjjjjjjjjjjjjjjjjjjjj; /* */",
1022 getLLVMStyleWithColumns(60));
Daniel Jasper66935022014-04-27 10:03:19 +00001023 verifyFormat(
1024 "#define A \\\n"
1025 " int i; /* iiiiiiiiiiiiiiiiiiiii */ \\\n"
1026 " int jjjjjjjjjjjjjjjjjjjjjjjj; /* */",
1027 getLLVMStyleWithColumns(61));
Daniel Jasper8acf8222014-05-07 09:23:05 +00001028
1029 verifyFormat("if ( // This is some comment\n"
1030 " x + 3) {\n"
1031 "}");
1032 EXPECT_EQ("if ( // This is some comment\n"
1033 " // spanning two lines\n"
1034 " x + 3) {\n"
1035 "}",
1036 format("if( // This is some comment\n"
1037 " // spanning two lines\n"
1038 " x + 3) {\n"
1039 "}"));
Daniel Jasper9b79efb2015-01-19 11:49:32 +00001040
1041 verifyNoCrash("/\\\n/");
1042 verifyNoCrash("/\\\n* */");
Daniel Jasper62c78f52015-05-06 08:58:57 +00001043 // The 0-character somehow makes the lexer return a proper comment.
1044 verifyNoCrash(StringRef("/*\\\0\n/", 6));
Daniel Jaspere25509f2012-12-17 11:29:41 +00001045}
1046
Daniel Jasper14e58e52014-03-21 11:58:45 +00001047TEST_F(FormatTest, KeepsParameterWithTrailingCommentsOnTheirOwnLine) {
1048 EXPECT_EQ("SomeFunction(a,\n"
1049 " b, // comment\n"
1050 " c);",
1051 format("SomeFunction(a,\n"
1052 " b, // comment\n"
1053 " c);"));
Daniel Jasper28df0a32014-03-21 12:15:40 +00001054 EXPECT_EQ("SomeFunction(a, b,\n"
1055 " // comment\n"
1056 " c);",
1057 format("SomeFunction(a,\n"
1058 " b,\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00001059 " // comment\n"
Daniel Jasper28df0a32014-03-21 12:15:40 +00001060 " c);"));
Daniel Jasper14e58e52014-03-21 11:58:45 +00001061 EXPECT_EQ("SomeFunction(a, b, // comment (unclear relation)\n"
1062 " c);",
1063 format("SomeFunction(a, b, // comment (unclear relation)\n"
1064 " c);"));
1065 EXPECT_EQ("SomeFunction(a, // comment\n"
1066 " b,\n"
1067 " c); // comment",
1068 format("SomeFunction(a, // comment\n"
1069 " b,\n"
1070 " c); // comment"));
1071}
1072
Daniel Jasper3324cbe2013-03-01 16:45:59 +00001073TEST_F(FormatTest, RemovesTrailingWhitespaceOfComments) {
1074 EXPECT_EQ("// comment", format("// comment "));
1075 EXPECT_EQ("int aaaaaaa, bbbbbbb; // comment",
1076 format("int aaaaaaa, bbbbbbb; // comment ",
1077 getLLVMStyleWithColumns(33)));
Alexander Kornienko9ab4a772013-09-06 17:24:54 +00001078 EXPECT_EQ("// comment\\\n", format("// comment\\\n \t \v \f "));
1079 EXPECT_EQ("// comment \\\n", format("// comment \\\n \t \v \f "));
Daniel Jasper3324cbe2013-03-01 16:45:59 +00001080}
1081
Alexander Kornienkoa3555e22013-06-19 19:50:11 +00001082TEST_F(FormatTest, UnderstandsBlockComments) {
Nico Weber8084cff2013-06-26 00:15:19 +00001083 verifyFormat("f(/*noSpaceAfterParameterNamingComment=*/true);");
Daniel Jasper40bc7462013-11-23 14:51:47 +00001084 verifyFormat("void f() { g(/*aaa=*/x, /*bbb=*/!y); }");
Daniel Jasper38c82402013-11-29 09:27:43 +00001085 EXPECT_EQ("f(aaaaaaaaaaaaaaaaaaaaaaaaa, /* Trailing comment for aa... */\n"
1086 " bbbbbbbbbbbbbbbbbbbbbbbbb);",
1087 format("f(aaaaaaaaaaaaaaaaaaaaaaaaa , \\\n"
1088 "/* Trailing comment for aa... */\n"
1089 " bbbbbbbbbbbbbbbbbbbbbbbbb);"));
Daniel Jasper11cb81c2013-01-17 12:53:34 +00001090 EXPECT_EQ(
1091 "f(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
1092 " /* Leading comment for bb... */ bbbbbbbbbbbbbbbbbbbbbbbbb);",
1093 format("f(aaaaaaaaaaaaaaaaaaaaaaaaa , \n"
1094 "/* Leading comment for bb... */ bbbbbbbbbbbbbbbbbbbbbbbbb);"));
Daniel Jasper61a40782013-06-06 16:08:57 +00001095 EXPECT_EQ(
1096 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
1097 " aaaaaaaaaaaaaaaaaa,\n"
Daniel Jasperee7539a2013-07-08 14:25:23 +00001098 " aaaaaaaaaaaaaaaaaa) { /*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*/\n"
Daniel Jasper61a40782013-06-06 16:08:57 +00001099 "}",
1100 format("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
1101 " aaaaaaaaaaaaaaaaaa ,\n"
Daniel Jasperee7539a2013-07-08 14:25:23 +00001102 " aaaaaaaaaaaaaaaaaa) { /*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*/\n"
Daniel Jasper61a40782013-06-06 16:08:57 +00001103 "}"));
Daniel Jasperddaa9be2013-01-29 19:41:55 +00001104
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00001105 FormatStyle NoBinPacking = getLLVMStyle();
1106 NoBinPacking.BinPackParameters = false;
1107 verifyFormat("aaaaaaaa(/* parameter 1 */ aaaaaa,\n"
1108 " /* parameter 2 */ aaaaaa,\n"
1109 " /* parameter 3 */ aaaaaa,\n"
1110 " /* parameter 4 */ aaaaaa);",
1111 NoBinPacking);
Daniel Jasper03b1bc72014-03-28 15:06:01 +00001112
1113 // Aligning block comments in macros.
1114 verifyGoogleFormat("#define A \\\n"
1115 " int i; /*a*/ \\\n"
1116 " int jjj; /*b*/");
Daniel Jasper11cb81c2013-01-17 12:53:34 +00001117}
1118
Alexander Kornienkoa3555e22013-06-19 19:50:11 +00001119TEST_F(FormatTest, AlignsBlockComments) {
Alexander Kornienkodd8ed852013-03-14 16:10:54 +00001120 EXPECT_EQ("/*\n"
1121 " * Really multi-line\n"
1122 " * comment.\n"
1123 " */\n"
1124 "void f() {}",
1125 format(" /*\n"
1126 " * Really multi-line\n"
1127 " * comment.\n"
1128 " */\n"
1129 " void f() {}"));
Alexander Kornienkodd8ed852013-03-14 16:10:54 +00001130 EXPECT_EQ("class C {\n"
1131 " /*\n"
1132 " * Another multi-line\n"
1133 " * comment.\n"
1134 " */\n"
1135 " void f() {}\n"
1136 "};",
1137 format("class C {\n"
1138 "/*\n"
1139 " * Another multi-line\n"
1140 " * comment.\n"
1141 " */\n"
1142 "void f() {}\n"
1143 "};"));
Alexander Kornienko79d6c722013-03-15 13:42:02 +00001144 EXPECT_EQ("/*\n"
1145 " 1. This is a comment with non-trivial formatting.\n"
1146 " 1.1. We have to indent/outdent all lines equally\n"
1147 " 1.1.1. to keep the formatting.\n"
1148 " */",
1149 format(" /*\n"
1150 " 1. This is a comment with non-trivial formatting.\n"
1151 " 1.1. We have to indent/outdent all lines equally\n"
1152 " 1.1.1. to keep the formatting.\n"
1153 " */"));
1154 EXPECT_EQ("/*\n"
Daniel Jasper65ee3472013-07-31 23:16:02 +00001155 "Don't try to outdent if there's not enough indentation.\n"
Manuel Klimek9043c742013-05-27 15:23:34 +00001156 "*/",
Alexander Kornienko79d6c722013-03-15 13:42:02 +00001157 format(" /*\n"
Daniel Jasper65ee3472013-07-31 23:16:02 +00001158 " Don't try to outdent if there's not enough indentation.\n"
Alexander Kornienko79d6c722013-03-15 13:42:02 +00001159 " */"));
Manuel Klimek281dcbe2013-05-28 08:55:01 +00001160
1161 EXPECT_EQ("int i; /* Comment with empty...\n"
1162 " *\n"
1163 " * line. */",
1164 format("int i; /* Comment with empty...\n"
1165 " *\n"
1166 " * line. */"));
Alexander Kornienko67d9c8c2014-04-17 16:12:46 +00001167 EXPECT_EQ("int foobar = 0; /* comment */\n"
1168 "int bar = 0; /* multiline\n"
1169 " comment 1 */\n"
1170 "int baz = 0; /* multiline\n"
1171 " comment 2 */\n"
1172 "int bzz = 0; /* multiline\n"
1173 " comment 3 */",
1174 format("int foobar = 0; /* comment */\n"
1175 "int bar = 0; /* multiline\n"
1176 " comment 1 */\n"
1177 "int baz = 0; /* multiline\n"
1178 " comment 2 */\n"
1179 "int bzz = 0; /* multiline\n"
1180 " comment 3 */"));
1181 EXPECT_EQ("int foobar = 0; /* comment */\n"
1182 "int bar = 0; /* multiline\n"
1183 " comment */\n"
1184 "int baz = 0; /* multiline\n"
1185 "comment */",
1186 format("int foobar = 0; /* comment */\n"
1187 "int bar = 0; /* multiline\n"
1188 "comment */\n"
1189 "int baz = 0; /* multiline\n"
1190 "comment */"));
Alexander Kornienkodd8ed852013-03-14 16:10:54 +00001191}
1192
Alexander Kornienkoa3555e22013-06-19 19:50:11 +00001193TEST_F(FormatTest, CorrectlyHandlesLengthOfBlockComments) {
1194 EXPECT_EQ("double *x; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
1195 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */",
1196 format("double *x; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
1197 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */"));
Alexander Kornienkoaa620e12013-07-01 13:42:42 +00001198 EXPECT_EQ(
1199 "void ffffffffffff(\n"
1200 " int aaaaaaaa, int bbbbbbbb,\n"
1201 " int cccccccccccc) { /*\n"
1202 " aaaaaaaaaa\n"
1203 " aaaaaaaaaaaaa\n"
1204 " bbbbbbbbbbbbbb\n"
1205 " bbbbbbbbbb\n"
1206 " */\n"
1207 "}",
1208 format("void ffffffffffff(int aaaaaaaa, int bbbbbbbb, int cccccccccccc)\n"
1209 "{ /*\n"
1210 " aaaaaaaaaa aaaaaaaaaaaaa\n"
1211 " bbbbbbbbbbbbbb bbbbbbbbbb\n"
1212 " */\n"
1213 "}",
1214 getLLVMStyleWithColumns(40)));
Alexander Kornienkoa3555e22013-06-19 19:50:11 +00001215}
1216
Alexander Kornienko94042342013-07-16 23:47:22 +00001217TEST_F(FormatTest, DontBreakNonTrailingBlockComments) {
Daniel Jaspere068ac72014-10-27 17:13:59 +00001218 EXPECT_EQ("void ffffffffff(\n"
1219 " int aaaaa /* test */);",
Alexander Kornienko94042342013-07-16 23:47:22 +00001220 format("void ffffffffff(int aaaaa /* test */);",
1221 getLLVMStyleWithColumns(35)));
1222}
1223
Alexander Kornienkoffd6d042013-03-27 11:52:18 +00001224TEST_F(FormatTest, SplitsLongCxxComments) {
1225 EXPECT_EQ("// A comment that\n"
1226 "// doesn't fit on\n"
1227 "// one line",
1228 format("// A comment that doesn't fit on one line",
1229 getLLVMStyleWithColumns(20)));
Daniel Jasperdee894f2015-06-09 13:16:54 +00001230 EXPECT_EQ("/// A comment that\n"
1231 "/// doesn't fit on\n"
1232 "/// one line",
1233 format("/// A comment that doesn't fit on one line",
1234 getLLVMStyleWithColumns(20)));
1235 EXPECT_EQ("//! A comment that\n"
1236 "//! doesn't fit on\n"
1237 "//! one line",
1238 format("//! A comment that doesn't fit on one line",
1239 getLLVMStyleWithColumns(20)));
Alexander Kornienko9e90b622013-04-17 17:34:05 +00001240 EXPECT_EQ("// a b c d\n"
1241 "// e f g\n"
1242 "// h i j k",
Daniel Jaspera44991332015-04-29 13:06:49 +00001243 format("// a b c d e f g h i j k", getLLVMStyleWithColumns(10)));
1244 EXPECT_EQ(
1245 "// a b c d\n"
1246 "// e f g\n"
1247 "// h i j k",
1248 format("\\\n// a b c d e f g h i j k", getLLVMStyleWithColumns(10)));
Alexander Kornienkoffd6d042013-03-27 11:52:18 +00001249 EXPECT_EQ("if (true) // A comment that\n"
1250 " // doesn't fit on\n"
1251 " // one line",
1252 format("if (true) // A comment that doesn't fit on one line ",
1253 getLLVMStyleWithColumns(30)));
1254 EXPECT_EQ("// Don't_touch_leading_whitespace",
1255 format("// Don't_touch_leading_whitespace",
1256 getLLVMStyleWithColumns(20)));
Alexander Kornienko555efc32013-06-11 16:01:49 +00001257 EXPECT_EQ("// Add leading\n"
1258 "// whitespace",
1259 format("//Add leading whitespace", getLLVMStyleWithColumns(20)));
Daniel Jasperdee894f2015-06-09 13:16:54 +00001260 EXPECT_EQ("/// Add leading\n"
1261 "/// whitespace",
1262 format("///Add leading whitespace", getLLVMStyleWithColumns(20)));
1263 EXPECT_EQ("//! Add leading\n"
1264 "//! whitespace",
1265 format("//!Add leading whitespace", getLLVMStyleWithColumns(20)));
Alexander Kornienko555efc32013-06-11 16:01:49 +00001266 EXPECT_EQ("// whitespace", format("//whitespace", getLLVMStyle()));
1267 EXPECT_EQ("// Even if it makes the line exceed the column\n"
1268 "// limit",
1269 format("//Even if it makes the line exceed the column limit",
1270 getLLVMStyleWithColumns(51)));
1271 EXPECT_EQ("//--But not here", format("//--But not here", getLLVMStyle()));
Alexander Kornienko875395f2013-11-12 17:50:13 +00001272
1273 EXPECT_EQ("// aa bb cc dd",
1274 format("// aa bb cc dd ",
1275 getLLVMStyleWithColumns(15)));
1276
Alexander Kornienkoefd98382013-03-28 18:40:55 +00001277 EXPECT_EQ("// A comment before\n"
1278 "// a macro\n"
1279 "// definition\n"
1280 "#define a b",
1281 format("// A comment before a macro definition\n"
1282 "#define a b",
1283 getLLVMStyleWithColumns(20)));
Daniel Jaspere068ac72014-10-27 17:13:59 +00001284 EXPECT_EQ("void ffffff(\n"
1285 " int aaaaaaaaa, // wwww\n"
1286 " int bbbbbbbbbb, // xxxxxxx\n"
1287 " // yyyyyyyyyy\n"
1288 " int c, int d, int e) {}",
Alexander Kornienko4d26b6e2013-06-17 12:59:44 +00001289 format("void ffffff(\n"
1290 " int aaaaaaaaa, // wwww\n"
Daniel Jasper19a541e2013-12-19 16:45:34 +00001291 " int bbbbbbbbbb, // xxxxxxx yyyyyyyyyy\n"
Alexander Kornienko4d26b6e2013-06-17 12:59:44 +00001292 " int c, int d, int e) {}",
1293 getLLVMStyleWithColumns(40)));
Alexander Kornienkob93062e2013-06-20 13:58:37 +00001294 EXPECT_EQ("//\t aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
1295 format("//\t aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
1296 getLLVMStyleWithColumns(20)));
Alexander Kornienko3abbb8a2013-11-12 17:30:49 +00001297 EXPECT_EQ(
1298 "#define XXX // a b c d\n"
1299 " // e f g h",
1300 format("#define XXX // a b c d e f g h", getLLVMStyleWithColumns(22)));
1301 EXPECT_EQ(
1302 "#define XXX // q w e r\n"
1303 " // t y u i",
1304 format("#define XXX //q w e r t y u i", getLLVMStyleWithColumns(22)));
Alexander Kornienkodd7ece52013-06-07 16:02:52 +00001305}
Manuel Klimek9043c742013-05-27 15:23:34 +00001306
Alexander Kornienko4504f932014-03-10 13:14:56 +00001307TEST_F(FormatTest, PreservesHangingIndentInCxxComments) {
1308 EXPECT_EQ("// A comment\n"
1309 "// that doesn't\n"
1310 "// fit on one\n"
1311 "// line",
1312 format("// A comment that doesn't fit on one line",
1313 getLLVMStyleWithColumns(20)));
1314 EXPECT_EQ("/// A comment\n"
1315 "/// that doesn't\n"
1316 "/// fit on one\n"
1317 "/// line",
1318 format("/// A comment that doesn't fit on one line",
1319 getLLVMStyleWithColumns(20)));
1320}
1321
Alexander Kornienko657c67b2013-07-16 21:06:13 +00001322TEST_F(FormatTest, DontSplitLineCommentsWithEscapedNewlines) {
1323 EXPECT_EQ("// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
1324 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
1325 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
1326 format("// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
1327 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
1328 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
1329 EXPECT_EQ("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
1330 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
1331 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
1332 format("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
1333 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
1334 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
1335 getLLVMStyleWithColumns(50)));
1336 // FIXME: One day we might want to implement adjustment of leading whitespace
1337 // of the consecutive lines in this kind of comment:
Daniel Jasper4355e7f2014-07-09 07:50:33 +00001338 EXPECT_EQ("double\n"
1339 " a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
1340 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
1341 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
1342 format("double a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
1343 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
1344 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
Alexander Kornienko657c67b2013-07-16 21:06:13 +00001345 getLLVMStyleWithColumns(49)));
1346}
1347
Alexander Kornienkoce9161a2014-01-02 15:13:14 +00001348TEST_F(FormatTest, DontSplitLineCommentsWithPragmas) {
1349 FormatStyle Pragmas = getLLVMStyleWithColumns(30);
1350 Pragmas.CommentPragmas = "^ IWYU pragma:";
1351 EXPECT_EQ(
1352 "// IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb",
1353 format("// IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb", Pragmas));
1354 EXPECT_EQ(
1355 "/* IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb */",
1356 format("/* IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb */", Pragmas));
1357}
1358
Alexander Kornienkodd7ece52013-06-07 16:02:52 +00001359TEST_F(FormatTest, PriorityOfCommentBreaking) {
Daniel Jasper2739af32013-08-28 10:03:58 +00001360 EXPECT_EQ("if (xxx ==\n"
1361 " yyy && // aaaaaaaaaaaa bbbbbbbbb\n"
Alexander Kornienkodd7ece52013-06-07 16:02:52 +00001362 " zzz)\n"
1363 " q();",
1364 format("if (xxx == yyy && // aaaaaaaaaaaa bbbbbbbbb\n"
1365 " zzz) q();",
1366 getLLVMStyleWithColumns(40)));
1367 EXPECT_EQ("if (xxxxxxxxxx ==\n"
1368 " yyy && // aaaaaa bbbbbbbb cccc\n"
1369 " zzz)\n"
1370 " q();",
1371 format("if (xxxxxxxxxx == yyy && // aaaaaa bbbbbbbb cccc\n"
1372 " zzz) q();",
1373 getLLVMStyleWithColumns(40)));
1374 EXPECT_EQ("if (xxxxxxxxxx &&\n"
1375 " yyy || // aaaaaa bbbbbbbb cccc\n"
1376 " zzz)\n"
1377 " q();",
1378 format("if (xxxxxxxxxx && yyy || // aaaaaa bbbbbbbb cccc\n"
1379 " zzz) q();",
1380 getLLVMStyleWithColumns(40)));
Daniel Jasper19a541e2013-12-19 16:45:34 +00001381 EXPECT_EQ("fffffffff(\n"
1382 " &xxx, // aaaaaaaaaaaa bbbbbbbbbbb\n"
1383 " zzz);",
Alexander Kornienkodd7ece52013-06-07 16:02:52 +00001384 format("fffffffff(&xxx, // aaaaaaaaaaaa bbbbbbbbbbb\n"
1385 " zzz);",
1386 getLLVMStyleWithColumns(40)));
Manuel Klimek9043c742013-05-27 15:23:34 +00001387}
1388
1389TEST_F(FormatTest, MultiLineCommentsInDefines) {
Alexander Kornienkoa3555e22013-06-19 19:50:11 +00001390 EXPECT_EQ("#define A(x) /* \\\n"
1391 " a comment \\\n"
1392 " inside */ \\\n"
Manuel Klimek9043c742013-05-27 15:23:34 +00001393 " f();",
1394 format("#define A(x) /* \\\n"
1395 " a comment \\\n"
1396 " inside */ \\\n"
1397 " f();",
1398 getLLVMStyleWithColumns(17)));
Alexander Kornienkoa3555e22013-06-19 19:50:11 +00001399 EXPECT_EQ("#define A( \\\n"
1400 " x) /* \\\n"
1401 " a comment \\\n"
1402 " inside */ \\\n"
Manuel Klimek9043c742013-05-27 15:23:34 +00001403 " f();",
1404 format("#define A( \\\n"
1405 " x) /* \\\n"
1406 " a comment \\\n"
1407 " inside */ \\\n"
1408 " f();",
1409 getLLVMStyleWithColumns(17)));
Alexander Kornienkoffd6d042013-03-27 11:52:18 +00001410}
1411
Alexander Kornienkob5dad752013-04-02 13:04:06 +00001412TEST_F(FormatTest, ParsesCommentsAdjacentToPPDirectives) {
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001413 EXPECT_EQ("namespace {}\n// Test\n#define A",
Alexander Kornienkob5dad752013-04-02 13:04:06 +00001414 format("namespace {}\n // Test\n#define A"));
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001415 EXPECT_EQ("namespace {}\n/* Test */\n#define A",
Alexander Kornienkob5dad752013-04-02 13:04:06 +00001416 format("namespace {}\n /* Test */\n#define A"));
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001417 EXPECT_EQ("namespace {}\n/* Test */ #define A",
Alexander Kornienkob5dad752013-04-02 13:04:06 +00001418 format("namespace {}\n /* Test */ #define A"));
1419}
1420
Alexander Kornienkoafcef332013-03-19 17:41:36 +00001421TEST_F(FormatTest, SplitsLongLinesInComments) {
1422 EXPECT_EQ("/* This is a long\n"
Alexander Kornienko547a9f522013-03-21 12:28:10 +00001423 " * comment that\n"
1424 " * doesn't\n"
1425 " * fit on one line.\n"
1426 " */",
Alexander Kornienkoafcef332013-03-19 17:41:36 +00001427 format("/* "
1428 "This is a long "
Alexander Kornienko547a9f522013-03-21 12:28:10 +00001429 "comment that "
1430 "doesn't "
Alexander Kornienkoafcef332013-03-19 17:41:36 +00001431 "fit on one line. */",
1432 getLLVMStyleWithColumns(20)));
Daniel Jaspera44991332015-04-29 13:06:49 +00001433 EXPECT_EQ(
1434 "/* a b c d\n"
1435 " * e f g\n"
1436 " * h i j k\n"
1437 " */",
1438 format("/* a b c d e f g h i j k */", getLLVMStyleWithColumns(10)));
1439 EXPECT_EQ(
1440 "/* a b c d\n"
1441 " * e f g\n"
1442 " * h i j k\n"
1443 " */",
1444 format("\\\n/* a b c d e f g h i j k */", getLLVMStyleWithColumns(10)));
Alexander Kornienkoafcef332013-03-19 17:41:36 +00001445 EXPECT_EQ("/*\n"
1446 "This is a long\n"
1447 "comment that doesn't\n"
1448 "fit on one line.\n"
1449 "*/",
1450 format("/*\n"
1451 "This is a long "
1452 "comment that doesn't "
1453 "fit on one line. \n"
Daniel Jaspera44991332015-04-29 13:06:49 +00001454 "*/",
1455 getLLVMStyleWithColumns(20)));
Alexander Kornienkoafcef332013-03-19 17:41:36 +00001456 EXPECT_EQ("/*\n"
1457 " * This is a long\n"
1458 " * comment that\n"
1459 " * doesn't fit on\n"
1460 " * one line.\n"
1461 " */",
Alexander Kornienko547a9f522013-03-21 12:28:10 +00001462 format("/* \n"
Alexander Kornienkoafcef332013-03-19 17:41:36 +00001463 " * This is a long "
1464 " comment that "
1465 " doesn't fit on "
1466 " one line. \n"
Daniel Jaspera44991332015-04-29 13:06:49 +00001467 " */",
1468 getLLVMStyleWithColumns(20)));
Alexander Kornienkoafcef332013-03-19 17:41:36 +00001469 EXPECT_EQ("/*\n"
1470 " * This_is_a_comment_with_words_that_dont_fit_on_one_line\n"
1471 " * so_it_should_be_broken\n"
1472 " * wherever_a_space_occurs\n"
1473 " */",
1474 format("/*\n"
1475 " * This_is_a_comment_with_words_that_dont_fit_on_one_line "
1476 " so_it_should_be_broken "
1477 " wherever_a_space_occurs \n"
1478 " */",
1479 getLLVMStyleWithColumns(20)));
1480 EXPECT_EQ("/*\n"
Alexander Kornienkoffd6d042013-03-27 11:52:18 +00001481 " * This_comment_can_not_be_broken_into_lines\n"
Alexander Kornienkoafcef332013-03-19 17:41:36 +00001482 " */",
1483 format("/*\n"
Alexander Kornienkoffd6d042013-03-27 11:52:18 +00001484 " * This_comment_can_not_be_broken_into_lines\n"
Alexander Kornienkoafcef332013-03-19 17:41:36 +00001485 " */",
1486 getLLVMStyleWithColumns(20)));
1487 EXPECT_EQ("{\n"
1488 " /*\n"
1489 " This is another\n"
1490 " long comment that\n"
1491 " doesn't fit on one\n"
1492 " line 1234567890\n"
1493 " */\n"
1494 "}",
1495 format("{\n"
1496 "/*\n"
1497 "This is another "
1498 " long comment that "
1499 " doesn't fit on one"
1500 " line 1234567890\n"
1501 "*/\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00001502 "}",
1503 getLLVMStyleWithColumns(20)));
Alexander Kornienkoafcef332013-03-19 17:41:36 +00001504 EXPECT_EQ("{\n"
1505 " /*\n"
1506 " * This i s\n"
1507 " * another comment\n"
1508 " * t hat doesn' t\n"
1509 " * fit on one l i\n"
1510 " * n e\n"
1511 " */\n"
1512 "}",
1513 format("{\n"
1514 "/*\n"
1515 " * This i s"
1516 " another comment"
1517 " t hat doesn' t"
1518 " fit on one l i"
1519 " n e\n"
1520 " */\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00001521 "}",
1522 getLLVMStyleWithColumns(20)));
Alexander Kornienkoafcef332013-03-19 17:41:36 +00001523 EXPECT_EQ("/*\n"
1524 " * This is a long\n"
1525 " * comment that\n"
1526 " * doesn't fit on\n"
1527 " * one line\n"
1528 " */",
1529 format(" /*\n"
1530 " * This is a long comment that doesn't fit on one line\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00001531 " */",
1532 getLLVMStyleWithColumns(20)));
Alexander Kornienko547a9f522013-03-21 12:28:10 +00001533 EXPECT_EQ("{\n"
1534 " if (something) /* This is a\n"
Manuel Klimek9043c742013-05-27 15:23:34 +00001535 " long\n"
1536 " comment */\n"
Alexander Kornienko547a9f522013-03-21 12:28:10 +00001537 " ;\n"
1538 "}",
1539 format("{\n"
1540 " if (something) /* This is a long comment */\n"
1541 " ;\n"
1542 "}",
1543 getLLVMStyleWithColumns(30)));
Alexander Kornienkodd7ece52013-06-07 16:02:52 +00001544
1545 EXPECT_EQ("/* A comment before\n"
1546 " * a macro\n"
1547 " * definition */\n"
1548 "#define a b",
1549 format("/* A comment before a macro definition */\n"
1550 "#define a b",
1551 getLLVMStyleWithColumns(20)));
1552
1553 EXPECT_EQ("/* some comment\n"
1554 " * a comment\n"
1555 "* that we break\n"
1556 " * another comment\n"
1557 "* we have to break\n"
1558 "* a left comment\n"
1559 " */",
1560 format(" /* some comment\n"
1561 " * a comment that we break\n"
1562 " * another comment we have to break\n"
1563 "* a left comment\n"
1564 " */",
1565 getLLVMStyleWithColumns(20)));
1566
Daniel Jasper6d9b88d2015-05-06 07:17:22 +00001567 EXPECT_EQ("/**\n"
1568 " * multiline block\n"
1569 " * comment\n"
1570 " *\n"
1571 " */",
1572 format("/**\n"
1573 " * multiline block comment\n"
1574 " *\n"
1575 " */",
1576 getLLVMStyleWithColumns(20)));
1577
Alexander Kornienkodd7ece52013-06-07 16:02:52 +00001578 EXPECT_EQ("/*\n"
1579 "\n"
1580 "\n"
1581 " */\n",
1582 format(" /* \n"
1583 " \n"
1584 " \n"
1585 " */\n"));
Alexander Kornienko875395f2013-11-12 17:50:13 +00001586
1587 EXPECT_EQ("/* a a */",
1588 format("/* a a */", getLLVMStyleWithColumns(15)));
1589 EXPECT_EQ("/* a a bc */",
1590 format("/* a a bc */", getLLVMStyleWithColumns(15)));
1591 EXPECT_EQ("/* aaa aaa\n"
1592 " * aaaaa */",
1593 format("/* aaa aaa aaaaa */", getLLVMStyleWithColumns(15)));
1594 EXPECT_EQ("/* aaa aaa\n"
1595 " * aaaaa */",
1596 format("/* aaa aaa aaaaa */", getLLVMStyleWithColumns(15)));
Alexander Kornienkoafcef332013-03-19 17:41:36 +00001597}
1598
1599TEST_F(FormatTest, SplitsLongLinesInCommentsInPreprocessor) {
1600 EXPECT_EQ("#define X \\\n"
Alexander Kornienko547a9f522013-03-21 12:28:10 +00001601 " /* \\\n"
1602 " Test \\\n"
Alexander Kornienkoafcef332013-03-19 17:41:36 +00001603 " Macro comment \\\n"
1604 " with a long \\\n"
1605 " line \\\n"
Alexander Kornienkocb45bc12013-04-15 14:28:00 +00001606 " */ \\\n"
Alexander Kornienkoafcef332013-03-19 17:41:36 +00001607 " A + B",
1608 format("#define X \\\n"
1609 " /*\n"
Alexander Kornienko547a9f522013-03-21 12:28:10 +00001610 " Test\n"
Alexander Kornienkoafcef332013-03-19 17:41:36 +00001611 " Macro comment with a long line\n"
1612 " */ \\\n"
1613 " A + B",
1614 getLLVMStyleWithColumns(20)));
1615 EXPECT_EQ("#define X \\\n"
1616 " /* Macro comment \\\n"
Alexander Kornienko547a9f522013-03-21 12:28:10 +00001617 " with a long \\\n"
Alexander Kornienkocb45bc12013-04-15 14:28:00 +00001618 " line */ \\\n"
Alexander Kornienko547a9f522013-03-21 12:28:10 +00001619 " A + B",
1620 format("#define X \\\n"
1621 " /* Macro comment with a long\n"
1622 " line */ \\\n"
1623 " A + B",
1624 getLLVMStyleWithColumns(20)));
1625 EXPECT_EQ("#define X \\\n"
1626 " /* Macro comment \\\n"
1627 " * with a long \\\n"
Alexander Kornienkocb45bc12013-04-15 14:28:00 +00001628 " * line */ \\\n"
Alexander Kornienkoafcef332013-03-19 17:41:36 +00001629 " A + B",
1630 format("#define X \\\n"
1631 " /* Macro comment with a long line */ \\\n"
1632 " A + B",
1633 getLLVMStyleWithColumns(20)));
1634}
1635
Daniel Jasper11cb81c2013-01-17 12:53:34 +00001636TEST_F(FormatTest, CommentsInStaticInitializers) {
1637 EXPECT_EQ(
Chandler Carruthf8b72662014-03-02 12:37:31 +00001638 "static SomeType type = {aaaaaaaaaaaaaaaaaaaa, /* comment */\n"
1639 " aaaaaaaaaaaaaaaaaaaa /* comment */,\n"
1640 " /* comment */ aaaaaaaaaaaaaaaaaaaa,\n"
1641 " aaaaaaaaaaaaaaaaaaaa, // comment\n"
1642 " aaaaaaaaaaaaaaaaaaaa};",
Daniel Jasper11cb81c2013-01-17 12:53:34 +00001643 format("static SomeType type = { aaaaaaaaaaaaaaaaaaaa , /* comment */\n"
1644 " aaaaaaaaaaaaaaaaaaaa /* comment */ ,\n"
1645 " /* comment */ aaaaaaaaaaaaaaaaaaaa ,\n"
1646 " aaaaaaaaaaaaaaaaaaaa , // comment\n"
1647 " aaaaaaaaaaaaaaaaaaaa };"));
Chandler Carruthf8b72662014-03-02 12:37:31 +00001648 verifyFormat("static SomeType type = {aaaaaaaaaaa, // comment for aa...\n"
1649 " bbbbbbbbbbb, ccccccccccc};");
1650 verifyFormat("static SomeType type = {aaaaaaaaaaa,\n"
1651 " // comment for bb....\n"
1652 " bbbbbbbbbbb, ccccccccccc};");
Daniel Jasper11cb81c2013-01-17 12:53:34 +00001653 verifyGoogleFormat(
Daniel Jaspere5777d22013-05-23 10:15:45 +00001654 "static SomeType type = {aaaaaaaaaaa, // comment for aa...\n"
1655 " bbbbbbbbbbb, ccccccccccc};");
1656 verifyGoogleFormat("static SomeType type = {aaaaaaaaaaa,\n"
1657 " // comment for bb....\n"
1658 " bbbbbbbbbbb, ccccccccccc};");
Daniel Jasper11cb81c2013-01-17 12:53:34 +00001659
Chandler Carruthf8b72662014-03-02 12:37:31 +00001660 verifyFormat("S s = {{a, b, c}, // Group #1\n"
1661 " {d, e, f}, // Group #2\n"
1662 " {g, h, i}}; // Group #3");
1663 verifyFormat("S s = {{// Group #1\n"
1664 " a, b, c},\n"
1665 " {// Group #2\n"
1666 " d, e, f},\n"
1667 " {// Group #3\n"
1668 " g, h, i}};");
Daniel Jasperdc7d5812013-02-20 12:56:39 +00001669
1670 EXPECT_EQ("S s = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00001671 " // Some comment\n"
1672 " a,\n"
Daniel Jasperdc7d5812013-02-20 12:56:39 +00001673 "\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00001674 " // Comment after empty line\n"
1675 " b}",
Daniel Jasperfb5e2412013-02-26 13:10:34 +00001676 format("S s = {\n"
1677 " // Some comment\n"
1678 " a,\n"
1679 " \n"
1680 " // Comment after empty line\n"
1681 " b\n"
1682 "}"));
Alexander Kornienkof370ad92013-06-12 19:04:12 +00001683 EXPECT_EQ("S s = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00001684 " /* Some comment */\n"
1685 " a,\n"
Alexander Kornienkof370ad92013-06-12 19:04:12 +00001686 "\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00001687 " /* Comment after empty line */\n"
1688 " b}",
Alexander Kornienkof370ad92013-06-12 19:04:12 +00001689 format("S s = {\n"
1690 " /* Some comment */\n"
1691 " a,\n"
1692 " \n"
1693 " /* Comment after empty line */\n"
1694 " b\n"
1695 "}"));
Daniel Jaspera400cab2013-02-28 15:04:12 +00001696 verifyFormat("const uint8_t aaaaaaaaaaaaaaaaaaaaaa[0] = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00001697 " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n"
1698 " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n"
1699 " 0x00, 0x00, 0x00, 0x00}; // comment\n");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001700}
1701
Alexander Kornienkof2e02122013-05-24 18:24:24 +00001702TEST_F(FormatTest, IgnoresIf0Contents) {
1703 EXPECT_EQ("#if 0\n"
1704 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n"
1705 "#endif\n"
1706 "void f() {}",
1707 format("#if 0\n"
1708 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n"
1709 "#endif\n"
1710 "void f( ) { }"));
1711 EXPECT_EQ("#if false\n"
1712 "void f( ) { }\n"
1713 "#endif\n"
1714 "void g() {}\n",
1715 format("#if false\n"
1716 "void f( ) { }\n"
1717 "#endif\n"
1718 "void g( ) { }\n"));
1719 EXPECT_EQ("enum E {\n"
1720 " One,\n"
1721 " Two,\n"
1722 "#if 0\n"
1723 "Three,\n"
1724 " Four,\n"
1725 "#endif\n"
1726 " Five\n"
1727 "};",
1728 format("enum E {\n"
1729 " One,Two,\n"
1730 "#if 0\n"
1731 "Three,\n"
1732 " Four,\n"
1733 "#endif\n"
1734 " Five};"));
1735 EXPECT_EQ("enum F {\n"
1736 " One,\n"
1737 "#if 1\n"
1738 " Two,\n"
1739 "#if 0\n"
1740 "Three,\n"
1741 " Four,\n"
1742 "#endif\n"
1743 " Five\n"
1744 "#endif\n"
1745 "};",
1746 format("enum F {\n"
1747 "One,\n"
1748 "#if 1\n"
1749 "Two,\n"
1750 "#if 0\n"
1751 "Three,\n"
1752 " Four,\n"
1753 "#endif\n"
1754 "Five\n"
1755 "#endif\n"
1756 "};"));
1757 EXPECT_EQ("enum G {\n"
1758 " One,\n"
1759 "#if 0\n"
1760 "Two,\n"
1761 "#else\n"
1762 " Three,\n"
1763 "#endif\n"
1764 " Four\n"
1765 "};",
1766 format("enum G {\n"
1767 "One,\n"
1768 "#if 0\n"
1769 "Two,\n"
1770 "#else\n"
1771 "Three,\n"
1772 "#endif\n"
1773 "Four\n"
1774 "};"));
1775 EXPECT_EQ("enum H {\n"
1776 " One,\n"
1777 "#if 0\n"
1778 "#ifdef Q\n"
1779 "Two,\n"
1780 "#else\n"
1781 "Three,\n"
1782 "#endif\n"
1783 "#endif\n"
1784 " Four\n"
1785 "};",
1786 format("enum H {\n"
1787 "One,\n"
1788 "#if 0\n"
1789 "#ifdef Q\n"
1790 "Two,\n"
1791 "#else\n"
1792 "Three,\n"
1793 "#endif\n"
1794 "#endif\n"
1795 "Four\n"
1796 "};"));
1797 EXPECT_EQ("enum I {\n"
1798 " One,\n"
1799 "#if /* test */ 0 || 1\n"
1800 "Two,\n"
1801 "Three,\n"
1802 "#endif\n"
1803 " Four\n"
1804 "};",
1805 format("enum I {\n"
1806 "One,\n"
1807 "#if /* test */ 0 || 1\n"
1808 "Two,\n"
1809 "Three,\n"
1810 "#endif\n"
1811 "Four\n"
1812 "};"));
1813 EXPECT_EQ("enum J {\n"
1814 " One,\n"
1815 "#if 0\n"
1816 "#if 0\n"
1817 "Two,\n"
1818 "#else\n"
1819 "Three,\n"
1820 "#endif\n"
1821 "Four,\n"
1822 "#endif\n"
1823 " Five\n"
1824 "};",
1825 format("enum J {\n"
1826 "One,\n"
1827 "#if 0\n"
1828 "#if 0\n"
1829 "Two,\n"
1830 "#else\n"
1831 "Three,\n"
1832 "#endif\n"
1833 "Four,\n"
1834 "#endif\n"
1835 "Five\n"
1836 "};"));
Alexander Kornienkof2e02122013-05-24 18:24:24 +00001837}
1838
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001839//===----------------------------------------------------------------------===//
1840// Tests for classes, namespaces, etc.
1841//===----------------------------------------------------------------------===//
1842
1843TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) {
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001844 verifyFormat("class A {};");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001845}
1846
1847TEST_F(FormatTest, UnderstandsAccessSpecifiers) {
1848 verifyFormat("class A {\n"
1849 "public:\n"
Daniel Jasperc04baae2013-04-10 09:49:49 +00001850 "public: // comment\n"
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001851 "protected:\n"
1852 "private:\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00001853 " void f() {}\n"
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001854 "};");
1855 verifyGoogleFormat("class A {\n"
1856 " public:\n"
1857 " protected:\n"
1858 " private:\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00001859 " void f() {}\n"
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001860 "};");
Daniel Jasper84c47a12013-11-23 17:53:41 +00001861 verifyFormat("class A {\n"
1862 "public slots:\n"
1863 " void f() {}\n"
Daniel Jasper1556b592013-11-29 08:51:56 +00001864 "public Q_SLOTS:\n"
1865 " void f() {}\n"
Daniel Jasper53395402015-04-07 15:04:40 +00001866 "signals:\n"
1867 " void g();\n"
Daniel Jasper84c47a12013-11-23 17:53:41 +00001868 "};");
Daniel Jasperde0d1f32015-04-24 07:50:34 +00001869
1870 // Don't interpret 'signals' the wrong way.
1871 verifyFormat("signals.set();");
1872 verifyFormat("for (Signals signals : f()) {\n}");
Daniel Jasper03618142015-05-06 19:21:23 +00001873 verifyFormat("{\n"
1874 " signals.set(); // This needs indentation.\n"
1875 "}");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001876}
1877
Alexander Kornienkofd433362013-03-27 17:08:02 +00001878TEST_F(FormatTest, SeparatesLogicalBlocks) {
1879 EXPECT_EQ("class A {\n"
1880 "public:\n"
1881 " void f();\n"
1882 "\n"
1883 "private:\n"
1884 " void g() {}\n"
1885 " // test\n"
1886 "protected:\n"
1887 " int h;\n"
1888 "};",
1889 format("class A {\n"
1890 "public:\n"
1891 "void f();\n"
1892 "private:\n"
1893 "void g() {}\n"
1894 "// test\n"
1895 "protected:\n"
1896 "int h;\n"
1897 "};"));
Daniel Jasper320997e2013-10-06 11:40:08 +00001898 EXPECT_EQ("class A {\n"
1899 "protected:\n"
1900 "public:\n"
1901 " void f();\n"
1902 "};",
1903 format("class A {\n"
1904 "protected:\n"
1905 "\n"
1906 "public:\n"
1907 "\n"
1908 " void f();\n"
1909 "};"));
Daniel Jasperac5c97e32015-03-09 08:13:55 +00001910
1911 // Even ensure proper spacing inside macros.
1912 EXPECT_EQ("#define B \\\n"
1913 " class A { \\\n"
1914 " protected: \\\n"
1915 " public: \\\n"
1916 " void f(); \\\n"
1917 " };",
1918 format("#define B \\\n"
1919 " class A { \\\n"
1920 " protected: \\\n"
1921 " \\\n"
1922 " public: \\\n"
1923 " \\\n"
1924 " void f(); \\\n"
1925 " };",
1926 getGoogleStyle()));
1927 // But don't remove empty lines after macros ending in access specifiers.
1928 EXPECT_EQ("#define A private:\n"
1929 "\n"
1930 "int i;",
1931 format("#define A private:\n"
1932 "\n"
1933 "int i;"));
Alexander Kornienkofd433362013-03-27 17:08:02 +00001934}
1935
Daniel Jasper83193602013-04-05 17:22:09 +00001936TEST_F(FormatTest, FormatsClasses) {
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001937 verifyFormat("class A : public B {};");
1938 verifyFormat("class A : public ::B {};");
Daniel Jaspereead02b2013-02-14 08:42:54 +00001939
1940 verifyFormat(
1941 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001942 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
Daniel Jaspera61aefb2013-05-06 06:45:09 +00001943 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
1944 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001945 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
Daniel Jaspereead02b2013-02-14 08:42:54 +00001946 verifyFormat(
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001947 "class A : public B, public C, public D, public E, public F {};");
Daniel Jaspereead02b2013-02-14 08:42:54 +00001948 verifyFormat("class AAAAAAAAAAAA : public B,\n"
1949 " public C,\n"
1950 " public D,\n"
1951 " public E,\n"
1952 " public F,\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001953 " public G {};");
Daniel Jasper83193602013-04-05 17:22:09 +00001954
1955 verifyFormat("class\n"
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00001956 " ReallyReallyLongClassName {\n"
1957 " int i;\n"
1958 "};",
Daniel Jasper83193602013-04-05 17:22:09 +00001959 getLLVMStyleWithColumns(32));
Daniel Jasperf9a5e402013-10-08 16:24:07 +00001960 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n"
1961 " aaaaaaaaaaaaaaaa> {};");
1962 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n"
1963 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n"
1964 " aaaaaaaaaaaaaaaaaaaaaa> {};");
Daniel Jasper3a122c02014-02-14 18:22:40 +00001965 verifyFormat("template <class R, class C>\n"
1966 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n"
1967 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};");
Manuel Klimek45bf56c2014-07-31 07:19:30 +00001968 verifyFormat("class ::A::B {};");
Daniel Jasperf7935112012-12-03 18:12:45 +00001969}
1970
Manuel Klimek28cacc72013-01-07 18:10:23 +00001971TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) {
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00001972 verifyFormat("class A {\n} a, b;");
1973 verifyFormat("struct A {\n} a, b;");
1974 verifyFormat("union A {\n} a;");
Manuel Klimek28cacc72013-01-07 18:10:23 +00001975}
1976
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001977TEST_F(FormatTest, FormatsEnum) {
Alexander Kornienkob7076a22012-12-04 14:46:19 +00001978 verifyFormat("enum {\n"
1979 " Zero,\n"
1980 " One = 1,\n"
1981 " Two = One + 1,\n"
1982 " Three = (One + Two),\n"
1983 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1984 " Five = (One, Two, Three, Four, 5)\n"
1985 "};");
Daniel Jasper015ed022013-09-13 09:20:45 +00001986 verifyGoogleFormat("enum {\n"
1987 " Zero,\n"
1988 " One = 1,\n"
1989 " Two = One + 1,\n"
1990 " Three = (One + Two),\n"
1991 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1992 " Five = (One, Two, Three, Four, 5)\n"
1993 "};");
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001994 verifyFormat("enum Enum {};");
1995 verifyFormat("enum {};");
Daniel Jasper015ed022013-09-13 09:20:45 +00001996 verifyFormat("enum X E {} d;");
1997 verifyFormat("enum __attribute__((...)) E {} d;");
1998 verifyFormat("enum __declspec__((...)) E {} d;");
Daniel Jasper015ed022013-09-13 09:20:45 +00001999 verifyFormat("enum {\n"
2000 " Bar = Foo<int, int>::value\n"
Daniel Jasper96972812014-01-05 12:38:10 +00002001 "};",
2002 getLLVMStyleWithColumns(30));
2003
2004 verifyFormat("enum ShortEnum { A, B, C };");
Daniel Jasper1a148b42014-01-05 13:23:23 +00002005 verifyGoogleFormat("enum ShortEnum { A, B, C };");
Daniel Jaspera69ca9b2014-06-04 12:40:57 +00002006
2007 EXPECT_EQ("enum KeepEmptyLines {\n"
2008 " ONE,\n"
2009 "\n"
2010 " TWO,\n"
2011 "\n"
2012 " THREE\n"
2013 "}",
2014 format("enum KeepEmptyLines {\n"
2015 " ONE,\n"
2016 "\n"
2017 " TWO,\n"
2018 "\n"
2019 "\n"
2020 " THREE\n"
2021 "}"));
Daniel Jasper90818052014-06-10 10:42:26 +00002022 verifyFormat("enum E { // comment\n"
2023 " ONE,\n"
2024 " TWO\n"
Daniel Jasper502fac32014-11-05 10:55:36 +00002025 "};\n"
2026 "int i;");
Daniel Jasper47721ac2015-06-18 15:45:17 +00002027 // Not enums.
2028 verifyFormat("enum X f() {\n"
2029 " a();\n"
2030 " return 42;\n"
2031 "}");
Daniel Jasperb5a0b852015-06-19 08:17:32 +00002032 verifyFormat("enum X Type::f() {\n"
2033 " a();\n"
2034 " return 42;\n"
2035 "}");
Daniel Jasper47721ac2015-06-18 15:45:17 +00002036 verifyFormat("enum ::X f() {\n"
2037 " a();\n"
2038 " return 42;\n"
2039 "}");
2040 verifyFormat("enum ns::X f() {\n"
2041 " a();\n"
2042 " return 42;\n"
2043 "}");
Alexander Kornienkob7076a22012-12-04 14:46:19 +00002044}
2045
Daniel Jasperb7150872013-08-30 10:10:19 +00002046TEST_F(FormatTest, FormatsEnumsWithErrors) {
2047 verifyFormat("enum Type {\n"
Daniel Jasper96972812014-01-05 12:38:10 +00002048 " One = 0; // These semicolons should be commas.\n"
Daniel Jasperb7150872013-08-30 10:10:19 +00002049 " Two = 1;\n"
2050 "};");
2051 verifyFormat("namespace n {\n"
2052 "enum Type {\n"
2053 " One,\n"
Daniel Jasper96972812014-01-05 12:38:10 +00002054 " Two, // missing };\n"
Daniel Jasperb7150872013-08-30 10:10:19 +00002055 " int i;\n"
2056 "}\n"
2057 "void g() {}");
2058}
2059
Daniel Jasper2b41a822013-08-20 12:42:50 +00002060TEST_F(FormatTest, FormatsEnumStruct) {
2061 verifyFormat("enum struct {\n"
2062 " Zero,\n"
2063 " One = 1,\n"
2064 " Two = One + 1,\n"
2065 " Three = (One + Two),\n"
2066 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
2067 " Five = (One, Two, Three, Four, 5)\n"
2068 "};");
2069 verifyFormat("enum struct Enum {};");
2070 verifyFormat("enum struct {};");
Daniel Jasper015ed022013-09-13 09:20:45 +00002071 verifyFormat("enum struct X E {} d;");
2072 verifyFormat("enum struct __attribute__((...)) E {} d;");
2073 verifyFormat("enum struct __declspec__((...)) E {} d;");
Daniel Jasper2b41a822013-08-20 12:42:50 +00002074 verifyFormat("enum struct X f() {\n a();\n return 42;\n}");
2075}
2076
2077TEST_F(FormatTest, FormatsEnumClass) {
2078 verifyFormat("enum class {\n"
2079 " Zero,\n"
2080 " One = 1,\n"
2081 " Two = One + 1,\n"
2082 " Three = (One + Two),\n"
2083 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
2084 " Five = (One, Two, Three, Four, 5)\n"
2085 "};");
2086 verifyFormat("enum class Enum {};");
2087 verifyFormat("enum class {};");
Daniel Jasper015ed022013-09-13 09:20:45 +00002088 verifyFormat("enum class X E {} d;");
2089 verifyFormat("enum class __attribute__((...)) E {} d;");
2090 verifyFormat("enum class __declspec__((...)) E {} d;");
Daniel Jasper2b41a822013-08-20 12:42:50 +00002091 verifyFormat("enum class X f() {\n a();\n return 42;\n}");
2092}
2093
Manuel Klimek9a53c7f2013-09-05 15:34:55 +00002094TEST_F(FormatTest, FormatsEnumTypes) {
2095 verifyFormat("enum X : int {\n"
Daniel Jasper96972812014-01-05 12:38:10 +00002096 " A, // Force multiple lines.\n"
Manuel Klimek9a53c7f2013-09-05 15:34:55 +00002097 " B\n"
2098 "};");
Daniel Jasper96972812014-01-05 12:38:10 +00002099 verifyFormat("enum X : int { A, B };");
2100 verifyFormat("enum X : std::uint32_t { A, B };");
Manuel Klimek9a53c7f2013-09-05 15:34:55 +00002101}
2102
Daniel Jaspera88f80a2014-01-30 14:38:37 +00002103TEST_F(FormatTest, FormatsNSEnums) {
2104 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }");
2105 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n"
2106 " // Information about someDecentlyLongValue.\n"
2107 " someDecentlyLongValue,\n"
2108 " // Information about anotherDecentlyLongValue.\n"
2109 " anotherDecentlyLongValue,\n"
2110 " // Information about aThirdDecentlyLongValue.\n"
2111 " aThirdDecentlyLongValue\n"
2112 "};");
Daniel Jasper31f6c542014-12-05 10:42:21 +00002113 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n"
2114 " a = 1,\n"
2115 " b = 2,\n"
2116 " c = 3,\n"
2117 "};");
2118 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n"
2119 " a = 1,\n"
2120 " b = 2,\n"
2121 " c = 3,\n"
2122 "};");
2123 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n"
2124 " a = 1,\n"
2125 " b = 2,\n"
2126 " c = 3,\n"
2127 "};");
Daniel Jaspera88f80a2014-01-30 14:38:37 +00002128}
2129
Nico Weber7769a902013-01-14 05:49:49 +00002130TEST_F(FormatTest, FormatsBitfields) {
2131 verifyFormat("struct Bitfields {\n"
2132 " unsigned sClass : 8;\n"
2133 " unsigned ValueKind : 2;\n"
2134 "};");
Alexander Kornienko60d1b042013-10-10 13:36:20 +00002135 verifyFormat("struct A {\n"
2136 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n"
2137 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n"
2138 "};");
Daniel Jasper676e5162015-04-07 14:36:33 +00002139 verifyFormat("struct MyStruct {\n"
2140 " uchar data;\n"
2141 " uchar : 8;\n"
2142 " uchar : 8;\n"
2143 " uchar other;\n"
2144 "};");
Nico Weber7769a902013-01-14 05:49:49 +00002145}
2146
Alexander Kornienko578fdd82012-12-06 18:03:27 +00002147TEST_F(FormatTest, FormatsNamespaces) {
2148 verifyFormat("namespace some_namespace {\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00002149 "class A {};\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00002150 "void f() { f(); }\n"
Alexander Kornienko578fdd82012-12-06 18:03:27 +00002151 "}");
2152 verifyFormat("namespace {\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00002153 "class A {};\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00002154 "void f() { f(); }\n"
Alexander Kornienko578fdd82012-12-06 18:03:27 +00002155 "}");
Dmitri Gribenko58d64e22012-12-30 21:27:25 +00002156 verifyFormat("inline namespace X {\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00002157 "class A {};\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00002158 "void f() { f(); }\n"
Dmitri Gribenko58d64e22012-12-30 21:27:25 +00002159 "}");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00002160 verifyFormat("using namespace some_namespace;\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00002161 "class A {};\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00002162 "void f() { f(); }");
Manuel Klimek046b9302013-02-06 16:08:09 +00002163
2164 // This code is more common than we thought; if we
2165 // layout this correctly the semicolon will go into
Alp Tokerf6a24ce2013-12-05 16:25:25 +00002166 // its own line, which is undesirable.
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00002167 verifyFormat("namespace {};");
Manuel Klimek046b9302013-02-06 16:08:09 +00002168 verifyFormat("namespace {\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00002169 "class A {};\n"
Manuel Klimek046b9302013-02-06 16:08:09 +00002170 "};");
Daniel Jasper251b3c92013-07-01 11:22:57 +00002171
2172 verifyFormat("namespace {\n"
2173 "int SomeVariable = 0; // comment\n"
2174 "} // namespace");
2175 EXPECT_EQ("#ifndef HEADER_GUARD\n"
2176 "#define HEADER_GUARD\n"
2177 "namespace my_namespace {\n"
2178 "int i;\n"
2179 "} // my_namespace\n"
2180 "#endif // HEADER_GUARD",
2181 format("#ifndef HEADER_GUARD\n"
2182 " #define HEADER_GUARD\n"
2183 " namespace my_namespace {\n"
2184 "int i;\n"
2185 "} // my_namespace\n"
2186 "#endif // HEADER_GUARD"));
Daniel Jasper65ee3472013-07-31 23:16:02 +00002187
2188 FormatStyle Style = getLLVMStyle();
2189 Style.NamespaceIndentation = FormatStyle::NI_All;
2190 EXPECT_EQ("namespace out {\n"
2191 " int i;\n"
2192 " namespace in {\n"
2193 " int i;\n"
2194 " } // namespace\n"
2195 "} // namespace",
2196 format("namespace out {\n"
2197 "int i;\n"
2198 "namespace in {\n"
2199 "int i;\n"
2200 "} // namespace\n"
2201 "} // namespace",
2202 Style));
2203
2204 Style.NamespaceIndentation = FormatStyle::NI_Inner;
2205 EXPECT_EQ("namespace out {\n"
2206 "int i;\n"
2207 "namespace in {\n"
2208 " int i;\n"
2209 "} // namespace\n"
2210 "} // namespace",
2211 format("namespace out {\n"
2212 "int i;\n"
2213 "namespace in {\n"
2214 "int i;\n"
2215 "} // namespace\n"
2216 "} // namespace",
2217 Style));
Alexander Kornienko578fdd82012-12-06 18:03:27 +00002218}
2219
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002220TEST_F(FormatTest, FormatsExternC) { verifyFormat("extern \"C\" {\nint a;"); }
Manuel Klimekae610d12013-01-21 14:32:05 +00002221
Daniel Jasper40aacf42013-03-14 13:45:21 +00002222TEST_F(FormatTest, FormatsInlineASM) {
2223 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));");
Daniel Jasperb23e20b2014-09-16 16:36:57 +00002224 verifyFormat("asm(\"nop\" ::: \"memory\");");
Daniel Jasper40aacf42013-03-14 13:45:21 +00002225 verifyFormat(
2226 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
2227 " \"cpuid\\n\\t\"\n"
2228 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
Daniel Jasper5dad58e2013-05-15 07:51:51 +00002229 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n"
Daniel Jasper40aacf42013-03-14 13:45:21 +00002230 " : \"a\"(value));");
Daniel Jasper8f463652014-08-26 23:15:12 +00002231 EXPECT_EQ(
2232 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n"
Daniel Jasper2337f282015-01-12 10:14:56 +00002233 " __asm {\n"
Daniel Jasper8f463652014-08-26 23:15:12 +00002234 " mov edx,[that] // vtable in edx\n"
2235 " mov eax,methodIndex\n"
2236 " call [edx][eax*4] // stdcall\n"
Daniel Jasper2337f282015-01-12 10:14:56 +00002237 " }\n"
Daniel Jasper8f463652014-08-26 23:15:12 +00002238 "}",
2239 format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n"
2240 " __asm {\n"
2241 " mov edx,[that] // vtable in edx\n"
2242 " mov eax,methodIndex\n"
2243 " call [edx][eax*4] // stdcall\n"
2244 " }\n"
2245 "}"));
Daniel Jasperc6366072015-05-10 08:42:04 +00002246 EXPECT_EQ("_asm {\n"
2247 " xor eax, eax;\n"
2248 " cpuid;\n"
2249 "}",
2250 format("_asm {\n"
2251 " xor eax, eax;\n"
2252 " cpuid;\n"
2253 "}"));
Daniel Jasper2337f282015-01-12 10:14:56 +00002254 verifyFormat("void function() {\n"
2255 " // comment\n"
2256 " asm(\"\");\n"
2257 "}");
Daniel Jasper790d4f92015-05-11 11:59:46 +00002258 EXPECT_EQ("__asm {\n"
2259 "}\n"
2260 "int i;",
2261 format("__asm {\n"
2262 "}\n"
2263 "int i;"));
Daniel Jasper40aacf42013-03-14 13:45:21 +00002264}
2265
Nico Weberd5650bd2013-01-07 16:36:17 +00002266TEST_F(FormatTest, FormatTryCatch) {
2267 verifyFormat("try {\n"
2268 " throw a * b;\n"
Daniel Jasper04a71a42014-05-08 11:58:24 +00002269 "} catch (int a) {\n"
Nico Weberd5650bd2013-01-07 16:36:17 +00002270 " // Do nothing.\n"
Daniel Jasper04a71a42014-05-08 11:58:24 +00002271 "} catch (...) {\n"
Nico Weberd5650bd2013-01-07 16:36:17 +00002272 " exit(42);\n"
2273 "}");
2274
2275 // Function-level try statements.
Daniel Jasper04a71a42014-05-08 11:58:24 +00002276 verifyFormat("int f() try { return 4; } catch (...) {\n"
Nico Weberd5650bd2013-01-07 16:36:17 +00002277 " return 5;\n"
2278 "}");
2279 verifyFormat("class A {\n"
2280 " int a;\n"
Daniel Jasper04a71a42014-05-08 11:58:24 +00002281 " A() try : a(0) {\n"
2282 " } catch (...) {\n"
Nico Weberd5650bd2013-01-07 16:36:17 +00002283 " throw;\n"
2284 " }\n"
2285 "};\n");
Daniel Jasper2bd7a642015-01-19 10:50:51 +00002286
2287 // Incomplete try-catch blocks.
Manuel Klimekec5c3db2015-05-07 12:26:30 +00002288 verifyIncompleteFormat("try {} catch (");
Nico Weberd5650bd2013-01-07 16:36:17 +00002289}
2290
Nico Weberfac23712015-02-04 15:26:27 +00002291TEST_F(FormatTest, FormatSEHTryCatch) {
2292 verifyFormat("__try {\n"
2293 " int a = b * c;\n"
2294 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n"
2295 " // Do nothing.\n"
2296 "}");
2297
2298 verifyFormat("__try {\n"
2299 " int a = b * c;\n"
2300 "} __finally {\n"
2301 " // Do nothing.\n"
2302 "}");
2303
2304 verifyFormat("DEBUG({\n"
2305 " __try {\n"
2306 " } __finally {\n"
2307 " }\n"
2308 "});\n");
2309}
2310
Daniel Jasper04a71a42014-05-08 11:58:24 +00002311TEST_F(FormatTest, IncompleteTryCatchBlocks) {
2312 verifyFormat("try {\n"
2313 " f();\n"
2314 "} catch {\n"
2315 " g();\n"
2316 "}");
2317 verifyFormat("try {\n"
2318 " f();\n"
2319 "} catch (A a) MACRO(x) {\n"
2320 " g();\n"
2321 "} catch (B b) MACRO(x) {\n"
2322 " g();\n"
2323 "}");
2324}
2325
2326TEST_F(FormatTest, FormatTryCatchBraceStyles) {
2327 FormatStyle Style = getLLVMStyle();
2328 Style.BreakBeforeBraces = FormatStyle::BS_Attach;
2329 verifyFormat("try {\n"
2330 " // something\n"
2331 "} catch (...) {\n"
2332 " // something\n"
2333 "}",
2334 Style);
2335 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
2336 verifyFormat("try {\n"
2337 " // something\n"
2338 "}\n"
2339 "catch (...) {\n"
2340 " // something\n"
2341 "}",
2342 Style);
Nico Weberfac23712015-02-04 15:26:27 +00002343 verifyFormat("__try {\n"
2344 " // something\n"
2345 "}\n"
2346 "__finally {\n"
2347 " // something\n"
2348 "}",
2349 Style);
Nico Weber33381f52015-02-07 01:57:32 +00002350 verifyFormat("@try {\n"
2351 " // something\n"
2352 "}\n"
2353 "@finally {\n"
2354 " // something\n"
2355 "}",
2356 Style);
Daniel Jasper04a71a42014-05-08 11:58:24 +00002357 Style.BreakBeforeBraces = FormatStyle::BS_Allman;
2358 verifyFormat("try\n"
2359 "{\n"
2360 " // something\n"
2361 "}\n"
2362 "catch (...)\n"
2363 "{\n"
2364 " // something\n"
2365 "}",
2366 Style);
2367 Style.BreakBeforeBraces = FormatStyle::BS_GNU;
2368 verifyFormat("try\n"
2369 " {\n"
2370 " // something\n"
2371 " }\n"
2372 "catch (...)\n"
2373 " {\n"
2374 " // something\n"
2375 " }",
2376 Style);
2377}
2378
Nico Weberd5650bd2013-01-07 16:36:17 +00002379TEST_F(FormatTest, FormatObjCTryCatch) {
Manuel Klimek2acb7b72013-01-11 19:17:44 +00002380 verifyFormat("@try {\n"
2381 " f();\n"
Nico Weber33381f52015-02-07 01:57:32 +00002382 "} @catch (NSException e) {\n"
Manuel Klimek2acb7b72013-01-11 19:17:44 +00002383 " @throw;\n"
Nico Weber33381f52015-02-07 01:57:32 +00002384 "} @finally {\n"
Manuel Klimek2acb7b72013-01-11 19:17:44 +00002385 " exit(42);\n"
2386 "}");
Nico Weber33381f52015-02-07 01:57:32 +00002387 verifyFormat("DEBUG({\n"
2388 " @try {\n"
2389 " } @finally {\n"
2390 " }\n"
2391 "});\n");
Nico Weberd5650bd2013-01-07 16:36:17 +00002392}
2393
Nico Weber45c48122015-06-28 01:06:16 +00002394TEST_F(FormatTest, FormatObjCAutoreleasepool) {
2395 FormatStyle Style = getLLVMStyle();
2396 verifyFormat("@autoreleasepool {\n"
2397 " f();\n"
2398 "}\n"
2399 "@autoreleasepool {\n"
2400 " f();\n"
2401 "}\n",
2402 Style);
2403 Style.BreakBeforeBraces = FormatStyle::BS_Allman;
2404 verifyFormat("@autoreleasepool\n"
2405 "{\n"
2406 " f();\n"
2407 "}\n"
2408 "@autoreleasepool\n"
2409 "{\n"
2410 " f();\n"
2411 "}\n",
2412 Style);
2413}
2414
Daniel Jaspere25509f2012-12-17 11:29:41 +00002415TEST_F(FormatTest, StaticInitializers) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00002416 verifyFormat("static SomeClass SC = {1, 'a'};");
Daniel Jaspere25509f2012-12-17 11:29:41 +00002417
Daniel Jaspera44991332015-04-29 13:06:49 +00002418 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n"
2419 " 100000000, "
2420 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};");
Manuel Klimek0ddd57a2013-01-10 15:58:26 +00002421
Daniel Jasper473c62c2013-05-17 09:35:01 +00002422 // Here, everything other than the "}" would fit on a line.
2423 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00002424 " 10000000000000000000000000};");
Daniel Jaspera69ca9b2014-06-04 12:40:57 +00002425 EXPECT_EQ("S s = {a,\n"
2426 "\n"
2427 " b};",
2428 format("S s = {\n"
2429 " a,\n"
2430 "\n"
2431 " b\n"
2432 "};"));
Daniel Jasper473c62c2013-05-17 09:35:01 +00002433
2434 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first
2435 // line. However, the formatting looks a bit off and this probably doesn't
2436 // happen often in practice.
2437 verifyFormat("static int Variable[1] = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00002438 " {1000000000000000000000000000000000000}};",
Daniel Jasper473c62c2013-05-17 09:35:01 +00002439 getLLVMStyleWithColumns(40));
Daniel Jaspere25509f2012-12-17 11:29:41 +00002440}
2441
Daniel Jasperbca4bbe2013-05-28 11:30:49 +00002442TEST_F(FormatTest, DesignatedInitializers) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00002443 verifyFormat("const struct A a = {.a = 1, .b = 2};");
2444 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n"
2445 " .bbbbbbbbbb = 2,\n"
2446 " .cccccccccc = 3,\n"
2447 " .dddddddddd = 4,\n"
2448 " .eeeeeeeeee = 5};");
Daniel Jasperbca4bbe2013-05-28 11:30:49 +00002449 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00002450 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n"
2451 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n"
2452 " .ccccccccccccccccccccccccccc = 3,\n"
2453 " .ddddddddddddddddddddddddddd = 4,\n"
2454 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};");
Daniel Jasperbca4bbe2013-05-28 11:30:49 +00002455
2456 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};");
2457}
2458
Manuel Klimeka54d1a92013-01-14 16:41:43 +00002459TEST_F(FormatTest, NestedStaticInitializers) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00002460 verifyFormat("static A x = {{{}}};\n");
2461 verifyFormat("static A x = {{{init1, init2, init3, init4},\n"
2462 " {init1, init2, init3, init4}}};",
2463 getLLVMStyleWithColumns(50));
Daniel Jasper9278eb92013-01-16 14:59:02 +00002464
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002465 verifyFormat("somes Status::global_reps[3] = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00002466 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2467 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2468 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};",
2469 getLLVMStyleWithColumns(60));
Daniel Jaspere5777d22013-05-23 10:15:45 +00002470 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n"
Daniel Jasper6ab54682013-07-16 18:22:10 +00002471 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2472 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2473 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};");
Daniel Jaspera44991332015-04-29 13:06:49 +00002474 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n"
2475 " {rect.fRight - rect.fLeft, rect.fBottom - "
2476 "rect.fTop}};");
Manuel Klimeka54d1a92013-01-14 16:41:43 +00002477
Daniel Jasper8a8ce242013-01-31 14:59:26 +00002478 verifyFormat(
Chandler Carruthf8b72662014-03-02 12:37:31 +00002479 "SomeArrayOfSomeType a = {\n"
2480 " {{1, 2, 3},\n"
2481 " {1, 2, 3},\n"
2482 " {111111111111111111111111111111, 222222222222222222222222222222,\n"
2483 " 333333333333333333333333333333},\n"
2484 " {1, 2, 3},\n"
2485 " {1, 2, 3}}};");
Daniel Jasper1ca05cc2013-02-03 18:07:15 +00002486 verifyFormat(
Daniel Jasper6ab54682013-07-16 18:22:10 +00002487 "SomeArrayOfSomeType a = {\n"
Daniel Jasper01603472014-01-09 13:42:56 +00002488 " {{1, 2, 3}},\n"
2489 " {{1, 2, 3}},\n"
Daniel Jasper6ab54682013-07-16 18:22:10 +00002490 " {{111111111111111111111111111111, 222222222222222222222222222222,\n"
2491 " 333333333333333333333333333333}},\n"
Daniel Jasper01603472014-01-09 13:42:56 +00002492 " {{1, 2, 3}},\n"
2493 " {{1, 2, 3}}};");
Daniel Jasper8a8ce242013-01-31 14:59:26 +00002494
Daniel Jaspera44991332015-04-29 13:06:49 +00002495 verifyFormat("struct {\n"
2496 " unsigned bit;\n"
2497 " const char *const name;\n"
2498 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n"
2499 " {kOsWin, \"Windows\"},\n"
2500 " {kOsLinux, \"Linux\"},\n"
2501 " {kOsCrOS, \"Chrome OS\"}};");
2502 verifyFormat("struct {\n"
2503 " unsigned bit;\n"
2504 " const char *const name;\n"
2505 "} kBitsToOs[] = {\n"
2506 " {kOsMac, \"Mac\"},\n"
2507 " {kOsWin, \"Windows\"},\n"
2508 " {kOsLinux, \"Linux\"},\n"
2509 " {kOsCrOS, \"Chrome OS\"},\n"
2510 "};");
Manuel Klimeka54d1a92013-01-14 16:41:43 +00002511}
2512
Manuel Klimeka71e5d82013-01-02 16:30:12 +00002513TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) {
2514 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("
2515 " \\\n"
2516 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)");
2517}
2518
Daniel Jasperda16db32013-01-07 10:48:50 +00002519TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) {
Alexander Kornienko384b40b2013-10-11 21:43:05 +00002520 verifyFormat("virtual void write(ELFWriter *writerrr,\n"
2521 " OwningPtr<FileOutputBuffer> &buffer) = 0;");
Daniel Jaspercaf84fe2015-04-23 12:59:09 +00002522
2523 // Do break defaulted and deleted functions.
2524 verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
2525 " default;",
2526 getLLVMStyleWithColumns(40));
2527 verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
2528 " delete;",
2529 getLLVMStyleWithColumns(40));
Alexander Kornienko384b40b2013-10-11 21:43:05 +00002530}
2531
2532TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) {
2533 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3",
2534 getLLVMStyleWithColumns(40));
2535 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
2536 getLLVMStyleWithColumns(40));
2537 EXPECT_EQ("#define Q \\\n"
2538 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n"
2539 " \"aaaaaaaa.cpp\"",
2540 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
2541 getLLVMStyleWithColumns(40)));
2542}
2543
2544TEST_F(FormatTest, UnderstandsLinePPDirective) {
2545 EXPECT_EQ("# 123 \"A string literal\"",
2546 format(" # 123 \"A string literal\""));
Daniel Jasperda16db32013-01-07 10:48:50 +00002547}
2548
Manuel Klimek591b5802013-01-31 15:58:48 +00002549TEST_F(FormatTest, LayoutUnknownPPDirective) {
Manuel Klimek591b5802013-01-31 15:58:48 +00002550 EXPECT_EQ("#;", format("#;"));
Manuel Klimek78725712013-01-07 10:03:37 +00002551 verifyFormat("#\n;\n;\n;");
Manuel Klimeka71e5d82013-01-02 16:30:12 +00002552}
2553
2554TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) {
2555 EXPECT_EQ("#line 42 \"test\"\n",
2556 format("# \\\n line \\\n 42 \\\n \"test\"\n"));
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002557 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n",
2558 getLLVMStyleWithColumns(12)));
Manuel Klimeka71e5d82013-01-02 16:30:12 +00002559}
2560
2561TEST_F(FormatTest, EndOfFileEndsPPDirective) {
2562 EXPECT_EQ("#line 42 \"test\"",
2563 format("# \\\n line \\\n 42 \\\n \"test\""));
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002564 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B"));
Manuel Klimeka71e5d82013-01-02 16:30:12 +00002565}
2566
Daniel Jasper877615c2013-10-11 19:45:02 +00002567TEST_F(FormatTest, DoesntRemoveUnknownTokens) {
2568 verifyFormat("#define A \\x20");
2569 verifyFormat("#define A \\ x20");
2570 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20"));
2571 verifyFormat("#define A ''");
2572 verifyFormat("#define A ''qqq");
2573 verifyFormat("#define A `qqq");
2574 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");
Daniel Jasperda353cd2014-03-12 08:24:47 +00002575 EXPECT_EQ("const char *c = STRINGIFY(\n"
2576 "\\na : b);",
2577 format("const char * c = STRINGIFY(\n"
2578 "\\na : b);"));
Daniel Jasper30029c62015-02-05 11:05:31 +00002579
2580 verifyFormat("a\r\\");
2581 verifyFormat("a\v\\");
2582 verifyFormat("a\f\\");
Daniel Jasper877615c2013-10-11 19:45:02 +00002583}
2584
Manuel Klimekb69e3c62013-01-02 18:33:23 +00002585TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {
Daniel Jasperc22f5b42013-02-28 11:05:57 +00002586 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
2587 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12));
Manuel Klimekb69e3c62013-01-02 18:33:23 +00002588 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12));
Daniel Jasperc22f5b42013-02-28 11:05:57 +00002589 // FIXME: We never break before the macro name.
Daniel Jaspera49393f2013-08-28 09:07:32 +00002590 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12));
Daniel Jasper39825ea2013-01-14 15:40:57 +00002591
2592 verifyFormat("#define A A\n#define A A");
2593 verifyFormat("#define A(X) A\n#define A A");
2594
Daniel Jasperc22f5b42013-02-28 11:05:57 +00002595 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
2596 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22));
Manuel Klimekb69e3c62013-01-02 18:33:23 +00002597}
2598
2599TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {
Alexander Kornienkoefd98382013-03-28 18:40:55 +00002600 EXPECT_EQ("// somecomment\n"
Manuel Klimek1abf7892013-01-04 23:34:14 +00002601 "#include \"a.h\"\n"
Daniel Jasperc22f5b42013-02-28 11:05:57 +00002602 "#define A( \\\n"
2603 " A, B)\n"
Manuel Klimek1abf7892013-01-04 23:34:14 +00002604 "#include \"b.h\"\n"
Alexander Kornienkoffd6d042013-03-27 11:52:18 +00002605 "// somecomment\n",
Alexander Kornienkoefd98382013-03-28 18:40:55 +00002606 format(" // somecomment\n"
Manuel Klimek1abf7892013-01-04 23:34:14 +00002607 " #include \"a.h\"\n"
2608 "#define A(A,\\\n"
2609 " B)\n"
2610 " #include \"b.h\"\n"
Alexander Kornienkoffd6d042013-03-27 11:52:18 +00002611 " // somecomment\n",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002612 getLLVMStyleWithColumns(13)));
Manuel Klimekb69e3c62013-01-02 18:33:23 +00002613}
2614
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002615TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
Manuel Klimek1abf7892013-01-04 23:34:14 +00002616
2617TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
2618 EXPECT_EQ("#define A \\\n"
2619 " c; \\\n"
2620 " e;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002621 "f;",
2622 format("#define A c; e;\n"
2623 "f;",
2624 getLLVMStyleWithColumns(14)));
Manuel Klimek1abf7892013-01-04 23:34:14 +00002625}
2626
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002627TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
Manuel Klimek1abf7892013-01-04 23:34:14 +00002628
Manuel Klimek1abf7892013-01-04 23:34:14 +00002629TEST_F(FormatTest, MacroDefinitionInsideStatement) {
Manuel Klimek52b15152013-01-09 15:25:02 +00002630 EXPECT_EQ("int x,\n"
2631 "#define A\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002632 " y;",
2633 format("int x,\n#define A\ny;"));
Manuel Klimek1abf7892013-01-04 23:34:14 +00002634}
2635
Manuel Klimek09e07972013-01-05 21:34:55 +00002636TEST_F(FormatTest, HashInMacroDefinition) {
Alexander Kornienkod8d47fa2013-09-10 13:41:43 +00002637 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle()));
Manuel Klimek09e07972013-01-05 21:34:55 +00002638 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11));
Daniel Jaspera49393f2013-08-28 09:07:32 +00002639 verifyFormat("#define A \\\n"
2640 " { \\\n"
2641 " f(#c); \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002642 " }",
2643 getLLVMStyleWithColumns(11));
Daniel Jasper4f397152013-01-08 16:17:54 +00002644
2645 verifyFormat("#define A(X) \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002646 " void function##X()",
2647 getLLVMStyleWithColumns(22));
Daniel Jasper4f397152013-01-08 16:17:54 +00002648
2649 verifyFormat("#define A(a, b, c) \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002650 " void a##b##c()",
2651 getLLVMStyleWithColumns(22));
Daniel Jasper4f397152013-01-08 16:17:54 +00002652
Daniel Jasper39825ea2013-01-14 15:40:57 +00002653 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
Manuel Klimek09e07972013-01-05 21:34:55 +00002654}
2655
Manuel Klimekd053c5b2013-01-23 14:37:36 +00002656TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) {
Alexander Kornienkofdca83d2013-12-10 10:18:34 +00002657 EXPECT_EQ("#define A (x)", format("#define A (x)"));
2658 EXPECT_EQ("#define A(x)", format("#define A(x)"));
Manuel Klimekd053c5b2013-01-23 14:37:36 +00002659}
2660
Manuel Klimek0c137952013-02-11 12:33:24 +00002661TEST_F(FormatTest, EmptyLinesInMacroDefinitions) {
2662 EXPECT_EQ("#define A b;", format("#define A \\\n"
2663 " \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002664 " b;",
2665 getLLVMStyleWithColumns(25)));
Manuel Klimek0c137952013-02-11 12:33:24 +00002666 EXPECT_EQ("#define A \\\n"
2667 " \\\n"
2668 " a; \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002669 " b;",
2670 format("#define A \\\n"
2671 " \\\n"
2672 " a; \\\n"
2673 " b;",
2674 getLLVMStyleWithColumns(11)));
Manuel Klimek0c137952013-02-11 12:33:24 +00002675 EXPECT_EQ("#define A \\\n"
2676 " a; \\\n"
2677 " \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002678 " b;",
2679 format("#define A \\\n"
2680 " a; \\\n"
2681 " \\\n"
2682 " b;",
2683 getLLVMStyleWithColumns(11)));
Manuel Klimek0c137952013-02-11 12:33:24 +00002684}
2685
Daniel Jasper00475962013-02-19 17:14:38 +00002686TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
Manuel Klimekec5c3db2015-05-07 12:26:30 +00002687 verifyIncompleteFormat("#define A :");
Daniel Jasper00475962013-02-19 17:14:38 +00002688 verifyFormat("#define SOMECASES \\\n"
Daniel Jaspera1275122013-03-20 10:23:53 +00002689 " case 1: \\\n"
Daniel Jasper00475962013-02-19 17:14:38 +00002690 " case 2\n",
2691 getLLVMStyleWithColumns(20));
Daniel Jasper00475962013-02-19 17:14:38 +00002692 verifyFormat("#define A template <typename T>");
Manuel Klimekec5c3db2015-05-07 12:26:30 +00002693 verifyIncompleteFormat("#define STR(x) #x\n"
2694 "f(STR(this_is_a_string_literal{));");
Daniel Jasper96df37a2013-08-28 09:17:37 +00002695 verifyFormat("#pragma omp threadprivate( \\\n"
2696 " y)), // expected-warning",
2697 getLLVMStyleWithColumns(28));
Daniel Jasperb1567c12015-01-19 10:50:08 +00002698 verifyFormat("#d, = };");
Daniel Jasper9d22bcc2015-01-19 10:51:05 +00002699 verifyFormat("#if \"a");
Manuel Klimekec5c3db2015-05-07 12:26:30 +00002700 verifyIncompleteFormat("({\n"
Manuel Klimek3d3ea842015-05-12 09:23:57 +00002701 "#define b \\\n"
2702 " } \\\n"
Manuel Klimekec5c3db2015-05-07 12:26:30 +00002703 " a\n"
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00002704 "a",
2705 getLLVMStyleWithColumns(15));
Daniel Jasper9ecb0e92015-03-13 13:32:11 +00002706 verifyFormat("#define A \\\n"
2707 " { \\\n"
2708 " {\n"
2709 "#define B \\\n"
2710 " } \\\n"
2711 " }",
2712 getLLVMStyleWithColumns(15));
Daniel Jasperfd725c02015-01-21 17:35:29 +00002713 verifyNoCrash("#if a\na(\n#else\n#endif\n{a");
Daniel Jasperd1debfc2015-01-21 18:04:02 +00002714 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}");
Daniel Jasper04b979d2015-01-21 18:35:47 +00002715 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};");
Daniel Jasperd1c13732015-01-23 19:37:25 +00002716 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}");
Daniel Jasper00475962013-02-19 17:14:38 +00002717}
2718
Daniel Jasper40e19212013-05-29 13:16:10 +00002719TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) {
2720 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
2721 EXPECT_EQ("class A : public QObject {\n"
2722 " Q_OBJECT\n"
2723 "\n"
2724 " A() {}\n"
2725 "};",
2726 format("class A : public QObject {\n"
2727 " Q_OBJECT\n"
2728 "\n"
2729 " A() {\n}\n"
2730 "} ;"));
Daniel Jaspere60cba12015-05-13 11:35:53 +00002731 EXPECT_EQ("MACRO\n"
2732 "/*static*/ int i;",
2733 format("MACRO\n"
2734 " /*static*/ int i;"));
Daniel Jasper41a0f782013-05-29 14:09:17 +00002735 EXPECT_EQ("SOME_MACRO\n"
2736 "namespace {\n"
2737 "void f();\n"
2738 "}",
2739 format("SOME_MACRO\n"
2740 " namespace {\n"
2741 "void f( );\n"
2742 "}"));
Daniel Jasper40e19212013-05-29 13:16:10 +00002743 // Only if the identifier contains at least 5 characters.
Daniel Jaspera44991332015-04-29 13:06:49 +00002744 EXPECT_EQ("HTTP f();", format("HTTP\nf();"));
2745 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();"));
Daniel Jasper40e19212013-05-29 13:16:10 +00002746 // Only if everything is upper case.
2747 EXPECT_EQ("class A : public QObject {\n"
2748 " Q_Object A() {}\n"
2749 "};",
2750 format("class A : public QObject {\n"
2751 " Q_Object\n"
Daniel Jasper40e19212013-05-29 13:16:10 +00002752 " A() {\n}\n"
2753 "} ;"));
Daniel Jasper680b09b2014-11-05 10:48:04 +00002754
2755 // Only if the next line can actually start an unwrapped line.
2756 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;",
2757 format("SOME_WEIRD_LOG_MACRO\n"
2758 "<< SomeThing;"));
Nico Weber23846262014-12-09 23:22:35 +00002759
2760 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), "
Daniel Jaspera44991332015-04-29 13:06:49 +00002761 "(n, buffers))\n",
2762 getChromiumStyle(FormatStyle::LK_Cpp));
Daniel Jasper40e19212013-05-29 13:16:10 +00002763}
2764
Alexander Kornienkode644272013-04-08 22:16:06 +00002765TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) {
2766 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
2767 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
2768 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00002769 "class X {};\n"
Alexander Kornienkode644272013-04-08 22:16:06 +00002770 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
2771 "int *createScopDetectionPass() { return 0; }",
2772 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
2773 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
2774 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
2775 " class X {};\n"
2776 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
2777 " int *createScopDetectionPass() { return 0; }"));
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002778 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as
2779 // braces, so that inner block is indented one level more.
2780 EXPECT_EQ("int q() {\n"
2781 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
2782 " IPC_MESSAGE_HANDLER(xxx, qqq)\n"
2783 " IPC_END_MESSAGE_MAP()\n"
2784 "}",
2785 format("int q() {\n"
2786 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
2787 " IPC_MESSAGE_HANDLER(xxx, qqq)\n"
2788 " IPC_END_MESSAGE_MAP()\n"
2789 "}"));
Daniel Jasper545c6522013-09-17 09:26:07 +00002790
Daniel Jasper352dae12014-01-03 11:50:46 +00002791 // Same inside macros.
2792 EXPECT_EQ("#define LIST(L) \\\n"
2793 " L(A) \\\n"
2794 " L(B) \\\n"
2795 " L(C)",
2796 format("#define LIST(L) \\\n"
2797 " L(A) \\\n"
2798 " L(B) \\\n"
2799 " L(C)",
2800 getGoogleStyle()));
2801
Daniel Jasper545c6522013-09-17 09:26:07 +00002802 // These must not be recognized as macros.
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002803 EXPECT_EQ("int q() {\n"
2804 " f(x);\n"
2805 " f(x) {}\n"
2806 " f(x)->g();\n"
2807 " f(x)->*g();\n"
2808 " f(x).g();\n"
2809 " f(x) = x;\n"
2810 " f(x) += x;\n"
2811 " f(x) -= x;\n"
2812 " f(x) *= x;\n"
2813 " f(x) /= x;\n"
2814 " f(x) %= x;\n"
2815 " f(x) &= x;\n"
2816 " f(x) |= x;\n"
2817 " f(x) ^= x;\n"
2818 " f(x) >>= x;\n"
2819 " f(x) <<= x;\n"
2820 " f(x)[y].z();\n"
2821 " LOG(INFO) << x;\n"
2822 " ifstream(x) >> x;\n"
2823 "}\n",
2824 format("int q() {\n"
2825 " f(x)\n;\n"
2826 " f(x)\n {}\n"
2827 " f(x)\n->g();\n"
2828 " f(x)\n->*g();\n"
2829 " f(x)\n.g();\n"
2830 " f(x)\n = x;\n"
2831 " f(x)\n += x;\n"
2832 " f(x)\n -= x;\n"
2833 " f(x)\n *= x;\n"
2834 " f(x)\n /= x;\n"
2835 " f(x)\n %= x;\n"
2836 " f(x)\n &= x;\n"
2837 " f(x)\n |= x;\n"
2838 " f(x)\n ^= x;\n"
2839 " f(x)\n >>= x;\n"
2840 " f(x)\n <<= x;\n"
2841 " f(x)\n[y].z();\n"
2842 " LOG(INFO)\n << x;\n"
2843 " ifstream(x)\n >> x;\n"
2844 "}\n"));
2845 EXPECT_EQ("int q() {\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002846 " F(x)\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002847 " if (1) {\n"
2848 " }\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002849 " F(x)\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002850 " while (1) {\n"
2851 " }\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002852 " F(x)\n"
2853 " G(x);\n"
2854 " F(x)\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002855 " try {\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002856 " Q();\n"
Daniel Jasper04a71a42014-05-08 11:58:24 +00002857 " } catch (...) {\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002858 " }\n"
2859 "}\n",
2860 format("int q() {\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002861 "F(x)\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002862 "if (1) {}\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002863 "F(x)\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002864 "while (1) {}\n"
Alexander Kornienkoce081262014-03-18 14:35:20 +00002865 "F(x)\n"
2866 "G(x);\n"
2867 "F(x)\n"
2868 "try { Q(); } catch (...) {}\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002869 "}\n"));
2870 EXPECT_EQ("class A {\n"
2871 " A() : t(0) {}\n"
Daniel Jasper5ebb2f32014-05-21 13:08:17 +00002872 " A(int i) noexcept() : {}\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002873 " A(X x)\n" // FIXME: function-level try blocks are broken.
2874 " try : t(0) {\n"
Daniel Jasper04a71a42014-05-08 11:58:24 +00002875 " } catch (...) {\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002876 " }\n"
2877 "};",
2878 format("class A {\n"
2879 " A()\n : t(0) {}\n"
Daniel Jasper5ebb2f32014-05-21 13:08:17 +00002880 " A(int i)\n noexcept() : {}\n"
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00002881 " A(X x)\n"
2882 " try : t(0) {} catch (...) {}\n"
2883 "};"));
Daniel Jaspera44991332015-04-29 13:06:49 +00002884 EXPECT_EQ("class SomeClass {\n"
2885 "public:\n"
2886 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
2887 "};",
2888 format("class SomeClass {\n"
2889 "public:\n"
2890 " SomeClass()\n"
2891 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
2892 "};"));
2893 EXPECT_EQ("class SomeClass {\n"
2894 "public:\n"
2895 " SomeClass()\n"
2896 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
2897 "};",
2898 format("class SomeClass {\n"
2899 "public:\n"
2900 " SomeClass()\n"
2901 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
2902 "};",
2903 getLLVMStyleWithColumns(40)));
Alexander Kornienkode644272013-04-08 22:16:06 +00002904}
2905
Manuel Klimek4fe43002013-05-22 12:51:29 +00002906TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) {
2907 verifyFormat("#define A \\\n"
2908 " f({ \\\n"
2909 " g(); \\\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00002910 " });",
2911 getLLVMStyleWithColumns(11));
Manuel Klimek4fe43002013-05-22 12:51:29 +00002912}
2913
Manuel Klimekef2cfb12013-01-05 22:14:16 +00002914TEST_F(FormatTest, IndentPreprocessorDirectivesAtZero) {
2915 EXPECT_EQ("{\n {\n#define A\n }\n}", format("{{\n#define A\n}}"));
2916}
2917
Manuel Klimek52d0fd82013-01-05 22:56:06 +00002918TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) {
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00002919 verifyFormat("{\n { a #c; }\n}");
Manuel Klimek52d0fd82013-01-05 22:56:06 +00002920}
2921
Manuel Klimek1058d982013-01-06 20:07:31 +00002922TEST_F(FormatTest, FormatUnbalancedStructuralElements) {
2923 EXPECT_EQ("#define A \\\n { \\\n {\nint i;",
2924 format("#define A { {\nint i;", getLLVMStyleWithColumns(11)));
2925 EXPECT_EQ("#define A \\\n } \\\n }\nint i;",
2926 format("#define A } }\nint i;", getLLVMStyleWithColumns(11)));
2927}
Manuel Klimek1abf7892013-01-04 23:34:14 +00002928
Daniel Jaspere2408e32015-05-06 11:16:43 +00002929TEST_F(FormatTest, EscapedNewlines) {
Daniel Jasper8d1832e2013-01-07 13:26:07 +00002930 EXPECT_EQ(
2931 "#define A \\\n int i; \\\n int j;",
2932 format("#define A \\\nint i;\\\n int j;", getLLVMStyleWithColumns(11)));
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00002933 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;"));
Alexander Kornienkoee4ca9b2013-06-07 17:45:07 +00002934 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
Alexander Kornienkobe633902013-06-14 11:46:10 +00002935 EXPECT_EQ("/* \\ \\ \\\n*/", format("\\\n/* \\ \\ \\\n*/"));
Daniel Jaspere2408e32015-05-06 11:16:43 +00002936 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>"));
Alexander Kornienkobe633902013-06-14 11:46:10 +00002937}
2938
Alexander Kornienko00691cf2015-01-12 13:11:12 +00002939TEST_F(FormatTest, DontCrashOnBlockComments) {
2940 EXPECT_EQ(
2941 "int xxxxxxxxx; /* "
2942 "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy\n"
2943 "zzzzzz\n"
2944 "0*/",
2945 format("int xxxxxxxxx; /* "
2946 "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy zzzzzz\n"
2947 "0*/"));
2948}
2949
Manuel Klimek38ba11e2013-01-07 09:24:17 +00002950TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) {
2951 verifyFormat("#define A \\\n"
2952 " int v( \\\n"
2953 " a); \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002954 " int i;",
2955 getLLVMStyleWithColumns(11));
Manuel Klimek38ba11e2013-01-07 09:24:17 +00002956}
2957
Manuel Klimeka71e5d82013-01-02 16:30:12 +00002958TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) {
Manuel Klimek1abf7892013-01-04 23:34:14 +00002959 EXPECT_EQ(
2960 "#define ALooooooooooooooooooooooooooooooooooooooongMacro("
2961 " \\\n"
2962 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
2963 "\n"
2964 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
2965 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n",
2966 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro("
2967 "\\\n"
2968 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
2969 " \n"
2970 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
2971 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n"));
Manuel Klimeka71e5d82013-01-02 16:30:12 +00002972}
2973
Manuel Klimek52b15152013-01-09 15:25:02 +00002974TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {
2975 EXPECT_EQ("int\n"
2976 "#define A\n"
Daniel Jasper8e357692013-05-06 08:27:33 +00002977 " a;",
Daniel Jasper4355e7f2014-07-09 07:50:33 +00002978 format("int\n#define A\na;"));
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002979 verifyFormat("functionCallTo(\n"
2980 " someOtherFunction(\n"
2981 " withSomeParameters, whichInSequence,\n"
2982 " areLongerThanALine(andAnotherCall,\n"
2983 "#define A B\n"
2984 " withMoreParamters,\n"
2985 " whichStronglyInfluenceTheLayout),\n"
Daniel Jasper37905f72013-02-21 15:00:29 +00002986 " andMoreParameters),\n"
2987 " trailing);",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002988 getLLVMStyleWithColumns(69));
Daniel Jasperfb81b092013-09-17 09:52:48 +00002989 verifyFormat("Foo::Foo()\n"
2990 "#ifdef BAR\n"
2991 " : baz(0)\n"
2992 "#endif\n"
2993 "{\n"
2994 "}");
Manuel Klimek71814b42013-10-11 21:25:45 +00002995 verifyFormat("void f() {\n"
2996 " if (true)\n"
2997 "#ifdef A\n"
2998 " f(42);\n"
2999 " x();\n"
3000 "#else\n"
3001 " g();\n"
3002 " x();\n"
3003 "#endif\n"
3004 "}");
3005 verifyFormat("void f(param1, param2,\n"
3006 " param3,\n"
3007 "#ifdef A\n"
3008 " param4(param5,\n"
3009 "#ifdef A1\n"
3010 " param6,\n"
3011 "#ifdef A2\n"
3012 " param7),\n"
3013 "#else\n"
3014 " param8),\n"
3015 " param9,\n"
3016 "#endif\n"
3017 " param10,\n"
3018 "#endif\n"
3019 " param11)\n"
3020 "#else\n"
3021 " param12)\n"
3022 "#endif\n"
3023 "{\n"
3024 " x();\n"
3025 "}",
3026 getLLVMStyleWithColumns(28));
Daniel Jasper53bd1672013-10-12 13:32:56 +00003027 verifyFormat("#if 1\n"
3028 "int i;");
Daniel Jaspera44991332015-04-29 13:06:49 +00003029 verifyFormat("#if 1\n"
3030 "#endif\n"
3031 "#if 1\n"
3032 "#else\n"
3033 "#endif\n");
Daniel Jasper472da862013-10-24 15:23:11 +00003034 verifyFormat("DEBUG({\n"
3035 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3036 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
3037 "});\n"
3038 "#if a\n"
3039 "#else\n"
3040 "#endif");
Daniel Jasper193cdd32015-01-19 10:52:16 +00003041
Manuel Klimekec5c3db2015-05-07 12:26:30 +00003042 verifyIncompleteFormat("void f(\n"
3043 "#if A\n"
3044 " );\n"
3045 "#else\n"
3046 "#endif");
Manuel Klimek52b15152013-01-09 15:25:02 +00003047}
3048
Manuel Klimek14bd9172014-01-29 08:49:02 +00003049TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) {
3050 verifyFormat("#endif\n"
3051 "#if B");
3052}
3053
Manuel Klimek88033d72013-10-21 08:11:15 +00003054TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) {
3055 FormatStyle SingleLine = getLLVMStyle();
3056 SingleLine.AllowShortIfStatementsOnASingleLine = true;
Daniel Jaspera44991332015-04-29 13:06:49 +00003057 verifyFormat("#if 0\n"
3058 "#elif 1\n"
3059 "#endif\n"
3060 "void foo() {\n"
3061 " if (test) foo2();\n"
3062 "}",
3063 SingleLine);
Manuel Klimek88033d72013-10-21 08:11:15 +00003064}
3065
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00003066TEST_F(FormatTest, LayoutBlockInsideParens) {
Daniel Jasperacf67e32015-04-07 08:20:35 +00003067 verifyFormat("functionCall({ int i; });");
3068 verifyFormat("functionCall({\n"
3069 " int i;\n"
3070 " int j;\n"
3071 "});");
3072 verifyFormat("functionCall({\n"
3073 " int i;\n"
3074 " int j;\n"
3075 "}, aaaa, bbbb, cccc);");
3076 verifyFormat("functionA(functionB({\n"
3077 " int i;\n"
3078 " int j;\n"
3079 " }),\n"
3080 " aaaa, bbbb, cccc);");
3081 verifyFormat("functionCall(\n"
3082 " {\n"
3083 " int i;\n"
3084 " int j;\n"
3085 " },\n"
3086 " aaaa, bbbb, // comment\n"
3087 " cccc);");
3088 verifyFormat("functionA(functionB({\n"
3089 " int i;\n"
3090 " int j;\n"
3091 " }),\n"
3092 " aaaa, bbbb, // comment\n"
3093 " cccc);");
3094 verifyFormat("functionCall(aaaa, bbbb, { int i; });");
3095 verifyFormat("functionCall(aaaa, bbbb, {\n"
3096 " int i;\n"
3097 " int j;\n"
3098 "});");
Daniel Jasper393564f2013-05-31 14:56:29 +00003099 verifyFormat(
Daniel Jaspera44991332015-04-29 13:06:49 +00003100 "Aaa(\n" // FIXME: There shouldn't be a linebreak here.
Daniel Jasper4b444492014-11-21 13:38:53 +00003101 " {\n"
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00003102 " int i; // break\n"
3103 " },\n"
Daniel Jasper393564f2013-05-31 14:56:29 +00003104 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
3105 " ccccccccccccccccc));");
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00003106 verifyFormat("DEBUG({\n"
3107 " if (a)\n"
3108 " f();\n"
3109 "});");
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00003110}
3111
3112TEST_F(FormatTest, LayoutBlockInsideStatement) {
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00003113 EXPECT_EQ("SOME_MACRO { int i; }\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003114 "int i;",
3115 format(" SOME_MACRO {int i;} int i;"));
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00003116}
3117
3118TEST_F(FormatTest, LayoutNestedBlocks) {
3119 verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
3120 " struct s {\n"
3121 " int i;\n"
3122 " };\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00003123 " s kBitsToOs[] = {{10}};\n"
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00003124 " for (int i = 0; i < 10; ++i)\n"
3125 " return;\n"
3126 "}");
Daniel Jasper1c5d9df2013-09-06 07:54:20 +00003127 verifyFormat("call(parameter, {\n"
3128 " something();\n"
3129 " // Comment using all columns.\n"
3130 " somethingelse();\n"
3131 "});",
3132 getLLVMStyleWithColumns(40));
Daniel Jaspere40caf92013-11-29 08:46:20 +00003133 verifyFormat("DEBUG( //\n"
3134 " { f(); }, a);");
3135 verifyFormat("DEBUG( //\n"
3136 " {\n"
3137 " f(); //\n"
3138 " },\n"
3139 " a);");
3140
Daniel Jasper1c5d9df2013-09-06 07:54:20 +00003141 EXPECT_EQ("call(parameter, {\n"
3142 " something();\n"
3143 " // Comment too\n"
3144 " // looooooooooong.\n"
3145 " somethingElse();\n"
3146 "});",
3147 format("call(parameter, {\n"
3148 " something();\n"
3149 " // Comment too looooooooooong.\n"
3150 " somethingElse();\n"
3151 "});",
3152 getLLVMStyleWithColumns(29)));
Daniel Jasper9b246e02013-09-08 14:07:57 +00003153 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });"));
Daniel Jasperdcd5da12013-10-20 17:28:32 +00003154 EXPECT_EQ("DEBUG({ // comment\n"
3155 " int i;\n"
3156 "});",
3157 format("DEBUG({ // comment\n"
3158 "int i;\n"
3159 "});"));
Daniel Jasper9b246e02013-09-08 14:07:57 +00003160 EXPECT_EQ("DEBUG({\n"
3161 " int i;\n"
3162 "\n"
3163 " // comment\n"
3164 " int j;\n"
3165 "});",
3166 format("DEBUG({\n"
3167 " int i;\n"
3168 "\n"
3169 " // comment\n"
3170 " int j;\n"
3171 "});"));
Daniel Jasperbbf5c1c2013-11-05 19:10:03 +00003172
3173 verifyFormat("DEBUG({\n"
3174 " if (a)\n"
3175 " return;\n"
3176 "});");
3177 verifyGoogleFormat("DEBUG({\n"
3178 " if (a) return;\n"
3179 "});");
3180 FormatStyle Style = getGoogleStyle();
3181 Style.ColumnLimit = 45;
3182 verifyFormat("Debug(aaaaa, {\n"
Daniel Jasper4b444492014-11-21 13:38:53 +00003183 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n"
3184 "}, a);",
3185 Style);
Daniel Jasper47b35ae2015-01-29 10:47:14 +00003186
3187 verifyNoCrash("^{v^{a}}");
Daniel Jasper9c199562013-11-28 15:58:55 +00003188}
3189
Daniel Jasper5fc133e2015-05-12 10:16:02 +00003190TEST_F(FormatTest, FormatNestedBlocksInMacros) {
3191 EXPECT_EQ("#define MACRO() \\\n"
3192 " Debug(aaa, /* force line break */ \\\n"
3193 " { \\\n"
3194 " int i; \\\n"
3195 " int j; \\\n"
3196 " })",
3197 format("#define MACRO() Debug(aaa, /* force line break */ \\\n"
3198 " { int i; int j; })",
3199 getGoogleStyle()));
Daniel Jasper1a028222015-05-26 07:03:42 +00003200
3201 EXPECT_EQ("#define A \\\n"
3202 " [] { \\\n"
3203 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
3204 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n"
3205 " }",
3206 format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
3207 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }",
3208 getGoogleStyle()));
Daniel Jasper5fc133e2015-05-12 10:16:02 +00003209}
3210
Manuel Klimeke7d10a12013-01-10 13:24:24 +00003211TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) {
3212 EXPECT_EQ("{}", format("{}"));
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00003213 verifyFormat("enum E {};");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003214 verifyFormat("enum E {}");
Manuel Klimeke7d10a12013-01-10 13:24:24 +00003215}
3216
Alexander Kornienko578fdd82012-12-06 18:03:27 +00003217//===----------------------------------------------------------------------===//
3218// Line break tests.
3219//===----------------------------------------------------------------------===//
3220
Daniel Jasperf79b0b12013-08-30 08:29:25 +00003221TEST_F(FormatTest, PreventConfusingIndents) {
Alexander Kornienko578fdd82012-12-06 18:03:27 +00003222 verifyFormat(
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00003223 "void f() {\n"
3224 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n"
3225 " parameter, parameter, parameter)),\n"
3226 " SecondLongCall(parameter));\n"
3227 "}");
Daniel Jasper7b5773e92013-01-28 07:35:34 +00003228 verifyFormat(
3229 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3230 " aaaaaaaaaaaaaaaaaaaaaaaa(\n"
3231 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3232 " aaaaaaaaaaaaaaaaaaaaaaaa);");
3233 verifyFormat(
Daniel Jasperaea3bde2013-07-12 11:19:37 +00003234 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3235 " [aaaaaaaaaaaaaaaaaaaaaaaa\n"
3236 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
3237 " [aaaaaaaaaaaaaaaaaaaaaaaa]];");
Daniel Jasper7b5773e92013-01-28 07:35:34 +00003238 verifyFormat(
3239 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
3240 " aaaaaaaaaaaaaaaaaaaaaaaa<\n"
3241 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n"
3242 " aaaaaaaaaaaaaaaaaaaaaaaa>;");
Daniel Jasper20b09ef2013-01-28 09:35:24 +00003243 verifyFormat("int a = bbbb && ccc && fffff(\n"
3244 "#define A Just forcing a new line\n"
3245 " ddd);");
Daniel Jasper7b5773e92013-01-28 07:35:34 +00003246}
3247
Daniel Jasperd69fc772013-05-08 14:12:04 +00003248TEST_F(FormatTest, LineBreakingInBinaryExpressions) {
3249 verifyFormat(
3250 "bool aaaaaaa =\n"
3251 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n"
3252 " bbbbbbbb();");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00003253 verifyFormat(
3254 "bool aaaaaaa =\n"
3255 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n"
3256 " bbbbbbbb();");
3257
Daniel Jasperd69fc772013-05-08 14:12:04 +00003258 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
3259 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n"
3260 " ccccccccc == ddddddddddd;");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00003261 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
3262 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n"
3263 " ccccccccc == ddddddddddd;");
3264 verifyFormat(
3265 "bool aaaaaaaaaaaaaaaaaaaaa =\n"
3266 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n"
3267 " ccccccccc == ddddddddddd;");
Daniel Jasperd69fc772013-05-08 14:12:04 +00003268
3269 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
3270 " aaaaaa) &&\n"
3271 " bbbbbb && cccccc;");
Daniel Jasper9f82df22013-05-28 07:42:44 +00003272 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
3273 " aaaaaa) >>\n"
3274 " bbbbbb;");
Daniel Jasperd69fc772013-05-08 14:12:04 +00003275 verifyFormat("Whitespaces.addUntouchableComment(\n"
3276 " SourceMgr.getSpellingColumnNumber(\n"
3277 " TheLine.Last->FormatTok.Tok.getLocation()) -\n"
3278 " 1);");
Daniel Jasper571f1af2013-05-14 20:39:56 +00003279
Daniel Jasper68d888c2013-06-03 08:42:05 +00003280 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3281 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n"
3282 " cccccc) {\n}");
Daniel Jasper3eb341c2014-11-11 23:04:51 +00003283 verifyFormat("b = a &&\n"
3284 " // Comment\n"
3285 " b.c && d;");
Daniel Jasper68d888c2013-06-03 08:42:05 +00003286
Daniel Jasper7ae41cd2013-07-03 10:34:47 +00003287 // If the LHS of a comparison is not a binary expression itself, the
3288 // additional linebreak confuses many people.
3289 verifyFormat(
3290 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3291 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n"
3292 "}");
3293 verifyFormat(
3294 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3295 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
3296 "}");
Daniel Jasper562ecd42013-09-06 08:08:14 +00003297 verifyFormat(
3298 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n"
3299 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
3300 "}");
Daniel Jasper7ae41cd2013-07-03 10:34:47 +00003301 // Even explicit parentheses stress the precedence enough to make the
3302 // additional break unnecessary.
Daniel Jaspera44991332015-04-29 13:06:49 +00003303 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3304 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
3305 "}");
Daniel Jasper7ae41cd2013-07-03 10:34:47 +00003306 // This cases is borderline, but with the indentation it is still readable.
3307 verifyFormat(
3308 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3309 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3310 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
3311 "}",
3312 getLLVMStyleWithColumns(75));
3313
3314 // If the LHS is a binary expression, we should still use the additional break
3315 // as otherwise the formatting hides the operator precedence.
Daniel Jaspera44991332015-04-29 13:06:49 +00003316 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3317 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
3318 " 5) {\n"
3319 "}");
Daniel Jasper7ae41cd2013-07-03 10:34:47 +00003320
Daniel Jasper571f1af2013-05-14 20:39:56 +00003321 FormatStyle OnePerLine = getLLVMStyle();
3322 OnePerLine.BinPackParameters = false;
3323 verifyFormat(
3324 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3325 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3326 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}",
3327 OnePerLine);
Daniel Jasperd69fc772013-05-08 14:12:04 +00003328}
3329
Daniel Jasper6bee6822013-04-08 20:33:42 +00003330TEST_F(FormatTest, ExpressionIndentation) {
3331 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3332 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3333 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
3334 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
3335 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
3336 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n"
3337 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
3338 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n"
3339 " ccccccccccccccccccccccccccccccccccccccccc;");
3340 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
3341 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3342 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
3343 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
3344 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3345 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
3346 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
3347 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
3348 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
3349 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
3350 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3351 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
Daniel Jasper6dcecb62013-06-06 09:11:58 +00003352 verifyFormat("if () {\n"
Daniel Jasper5c332652014-04-03 12:00:33 +00003353 "} else if (aaaaa &&\n"
3354 " bbbbb > // break\n"
3355 " ccccc) {\n"
Daniel Jasper6dcecb62013-06-06 09:11:58 +00003356 "}");
Alexander Kornienkoafaa8f52013-06-17 13:19:53 +00003357
3358 // Presence of a trailing comment used to change indentation of b.
3359 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
3360 " b;\n"
3361 "return aaaaaaaaaaaaaaaaaaa +\n"
3362 " b; //",
3363 getLLVMStyleWithColumns(30));
Daniel Jasper6bee6822013-04-08 20:33:42 +00003364}
3365
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003366TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) {
3367 // Not sure what the best system is here. Like this, the LHS can be found
3368 // immediately above an operator (everything with the same or a higher
3369 // indent). The RHS is aligned right of the operator and so compasses
3370 // everything until something with the same indent as the operator is found.
3371 // FIXME: Is this a good system?
3372 FormatStyle Style = getLLVMStyle();
Daniel Jasperac043c92014-09-15 11:11:00 +00003373 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003374 verifyFormat(
3375 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00003376 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3377 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3378 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3379 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
3380 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003381 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00003382 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3383 " > ccccccccccccccccccccccccccccccccccccccccc;",
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003384 Style);
3385 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00003386 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3387 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003388 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
3389 Style);
3390 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00003391 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3392 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003393 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
3394 Style);
3395 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3396 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00003397 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3398 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003399 Style);
3400 verifyFormat("if () {\n"
Daniel Jasperc0d606a2014-04-14 11:08:45 +00003401 "} else if (aaaaa\n"
3402 " && bbbbb // break\n"
Daniel Jasper8c6e9ef2014-12-02 09:46:56 +00003403 " > ccccc) {\n"
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003404 "}",
3405 Style);
Daniel Jasper119ff532014-11-14 12:31:14 +00003406 verifyFormat("return (a)\n"
3407 " // comment\n"
3408 " + b;",
3409 Style);
Daniel Jaspera44991332015-04-29 13:06:49 +00003410 verifyFormat(
3411 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3412 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
3413 " + cc;",
3414 Style);
Daniel Jasper9e5ede02013-11-08 19:56:28 +00003415
Daniel Jaspere92bf6f2015-05-06 14:23:38 +00003416 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3417 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
3418 Style);
3419
Daniel Jasper9e5ede02013-11-08 19:56:28 +00003420 // Forced by comments.
3421 verifyFormat(
3422 "unsigned ContentSize =\n"
3423 " sizeof(int16_t) // DWARF ARange version number\n"
3424 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
3425 " + sizeof(int8_t) // Pointer Size (in bytes)\n"
3426 " + sizeof(int8_t); // Segment Size (in bytes)");
Daniel Jasper446d1cd2013-11-23 14:45:49 +00003427
3428 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
3429 " == boost::fusion::at_c<1>(iiii).second;",
3430 Style);
Daniel Jasper0a1e5ac2014-05-13 08:01:47 +00003431
3432 Style.ColumnLimit = 60;
3433 verifyFormat("zzzzzzzzzz\n"
3434 " = bbbbbbbbbbbbbbbbb\n"
3435 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
3436 Style);
Daniel Jaspere33d4af2013-07-26 16:56:36 +00003437}
3438
Daniel Jasper3219e432014-12-02 13:24:51 +00003439TEST_F(FormatTest, NoOperandAlignment) {
3440 FormatStyle Style = getLLVMStyle();
3441 Style.AlignOperands = false;
3442 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
Daniel Jaspera44991332015-04-29 13:06:49 +00003443 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3444 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3445 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3446 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3447 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
3448 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
3449 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3450 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3451 " > ccccccccccccccccccccccccccccccccccccccccc;",
3452 Style);
Daniel Jasper3219e432014-12-02 13:24:51 +00003453
3454 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3455 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
3456 " + cc;",
3457 Style);
3458 verifyFormat("int a = aa\n"
3459 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
3460 " * cccccccccccccccccccccccccccccccccccc;",
3461 Style);
Daniel Jasperc0956632014-12-03 14:02:59 +00003462
3463 Style.AlignAfterOpenBracket = false;
3464 verifyFormat("return (a > b\n"
3465 " // comment1\n"
3466 " // comment2\n"
3467 " || c);",
3468 Style);
Daniel Jasper3219e432014-12-02 13:24:51 +00003469}
3470
Daniel Jasperac043c92014-09-15 11:11:00 +00003471TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) {
3472 FormatStyle Style = getLLVMStyle();
3473 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
3474 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
3475 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper3219e432014-12-02 13:24:51 +00003476 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
3477 Style);
Daniel Jasperac043c92014-09-15 11:11:00 +00003478}
3479
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003480TEST_F(FormatTest, ConstructorInitializers) {
Manuel Klimeke7d10a12013-01-10 13:24:24 +00003481 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
Daniel Jasper2408a8c2013-01-11 11:37:55 +00003482 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
3483 getLLVMStyleWithColumns(45));
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003484 verifyFormat("Constructor()\n"
3485 " : Inttializer(FitsOnTheLine) {}",
Daniel Jasper2408a8c2013-01-11 11:37:55 +00003486 getLLVMStyleWithColumns(44));
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003487 verifyFormat("Constructor()\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003488 " : Inttializer(FitsOnTheLine) {}",
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003489 getLLVMStyleWithColumns(43));
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003490
3491 verifyFormat(
3492 "SomeClass::Constructor()\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003493 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003494
3495 verifyFormat(
3496 "SomeClass::Constructor()\n"
Daniel Jasper2408a8c2013-01-11 11:37:55 +00003497 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003498 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}");
Daniel Jasper2408a8c2013-01-11 11:37:55 +00003499 verifyFormat(
3500 "SomeClass::Constructor()\n"
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003501 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003502 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003503
3504 verifyFormat("Constructor()\n"
3505 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3506 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3507 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003508 " aaaaaaaaaaaaaaaaaaaaaaa() {}");
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003509
Daniel Jasper65585ed2013-01-28 13:31:35 +00003510 verifyFormat("Constructor()\n"
3511 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003512 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasper65585ed2013-01-28 13:31:35 +00003513
Daniel Jasper62e68172013-02-25 15:59:54 +00003514 verifyFormat("Constructor(int Parameter = 0)\n"
3515 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
3516 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}");
Daniel Jasper87f18f12013-09-06 21:46:41 +00003517 verifyFormat("Constructor()\n"
3518 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
3519 "}",
3520 getLLVMStyleWithColumns(60));
Daniel Jasper4fcc8b92013-11-07 17:52:51 +00003521 verifyFormat("Constructor()\n"
3522 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3523 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}");
Daniel Jasper62e68172013-02-25 15:59:54 +00003524
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003525 // Here a line could be saved by splitting the second initializer onto two
Alp Tokerf6a24ce2013-12-05 16:25:25 +00003526 // lines, but that is not desirable.
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003527 verifyFormat("Constructor()\n"
3528 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
3529 " aaaaaaaaaaa(aaaaaaaaaaa),\n"
3530 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003531
Daniel Jasper23e8e0c2013-02-15 16:49:44 +00003532 FormatStyle OnePerLine = getLLVMStyle();
3533 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
3534 verifyFormat("SomeClass::Constructor()\n"
3535 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
3536 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003537 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003538 OnePerLine);
Daniel Jasper23e8e0c2013-02-15 16:49:44 +00003539 verifyFormat("SomeClass::Constructor()\n"
3540 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
3541 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003542 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003543 OnePerLine);
Daniel Jasper23e8e0c2013-02-15 16:49:44 +00003544 verifyFormat("MyClass::MyClass(int var)\n"
3545 " : some_var_(var), // 4 space indent\n"
3546 " some_other_var_(var + 1) { // lined up\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003547 "}",
3548 OnePerLine);
Daniel Jasperead41b62013-02-28 09:39:12 +00003549 verifyFormat("Constructor()\n"
3550 " : aaaaa(aaaaaa),\n"
3551 " aaaaa(aaaaaa),\n"
3552 " aaaaa(aaaaaa),\n"
3553 " aaaaa(aaaaaa),\n"
3554 " aaaaa(aaaaaa) {}",
3555 OnePerLine);
Daniel Jaspercc960fa2013-04-22 07:59:53 +00003556 verifyFormat("Constructor()\n"
3557 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
3558 " aaaaaaaaaaaaaaaaaaaaaa) {}",
3559 OnePerLine);
Daniel Jasperf6c7c182014-01-13 14:10:04 +00003560
3561 EXPECT_EQ("Constructor()\n"
3562 " : // Comment forcing unwanted break.\n"
3563 " aaaa(aaaa) {}",
3564 format("Constructor() :\n"
3565 " // Comment forcing unwanted break.\n"
3566 " aaaa(aaaa) {}"));
Daniel Jaspere3c0e012013-04-25 13:31:51 +00003567}
3568
3569TEST_F(FormatTest, MemoizationTests) {
3570 // This breaks if the memoization lookup does not take \c Indent and
3571 // \c LastSpace into account.
3572 verifyFormat(
3573 "extern CFRunLoopTimerRef\n"
3574 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
3575 " CFTimeInterval interval, CFOptionFlags flags,\n"
3576 " CFIndex order, CFRunLoopTimerCallBack callout,\n"
Daniel Jasper8e357692013-05-06 08:27:33 +00003577 " CFRunLoopTimerContext *context) {}");
Daniel Jaspere3c0e012013-04-25 13:31:51 +00003578
3579 // Deep nesting somewhat works around our memoization.
3580 verifyFormat(
3581 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
3582 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
3583 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
3584 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
3585 " aaaaa())))))))))))))))))))))))))))))))))))))));",
3586 getLLVMStyleWithColumns(65));
Daniel Jaspercc3044c2013-05-13 09:19:24 +00003587 verifyFormat(
3588 "aaaaa(\n"
3589 " aaaaa,\n"
3590 " aaaaa(\n"
3591 " aaaaa,\n"
3592 " aaaaa(\n"
3593 " aaaaa,\n"
3594 " aaaaa(\n"
3595 " aaaaa,\n"
3596 " aaaaa(\n"
3597 " aaaaa,\n"
3598 " aaaaa(\n"
3599 " aaaaa,\n"
3600 " aaaaa(\n"
3601 " aaaaa,\n"
3602 " aaaaa(\n"
3603 " aaaaa,\n"
3604 " aaaaa(\n"
3605 " aaaaa,\n"
3606 " aaaaa(\n"
3607 " aaaaa,\n"
3608 " aaaaa(\n"
3609 " aaaaa,\n"
3610 " aaaaa(\n"
3611 " aaaaa,\n"
3612 " aaaaa))))))))))));",
3613 getLLVMStyleWithColumns(65));
Daniel Jasperf8114cf2013-05-22 05:27:42 +00003614 verifyFormat(
3615 "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"
3616 " a),\n"
3617 " a),\n"
3618 " a),\n"
3619 " a),\n"
3620 " a),\n"
3621 " a),\n"
3622 " a),\n"
3623 " a),\n"
3624 " a),\n"
3625 " a),\n"
3626 " a),\n"
3627 " a),\n"
3628 " a),\n"
3629 " a),\n"
3630 " a),\n"
3631 " a),\n"
3632 " a)",
3633 getLLVMStyleWithColumns(65));
Daniel Jasper7b7877a2013-01-12 07:36:22 +00003634
3635 // This test takes VERY long when memoization is broken.
Daniel Jaspere3c0e012013-04-25 13:31:51 +00003636 FormatStyle OnePerLine = getLLVMStyle();
3637 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003638 OnePerLine.BinPackParameters = false;
Daniel Jasper9278eb92013-01-16 14:59:02 +00003639 std::string input = "Constructor()\n"
Daniel Jasper7a31af12013-01-25 15:43:32 +00003640 " : aaaa(a,\n";
Daniel Jasper9278eb92013-01-16 14:59:02 +00003641 for (unsigned i = 0, e = 80; i != e; ++i) {
3642 input += " a,\n";
3643 }
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003644 input += " a) {}";
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003645 verifyFormat(input, OnePerLine);
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00003646}
3647
Alexander Kornienko578fdd82012-12-06 18:03:27 +00003648TEST_F(FormatTest, BreaksAsHighAsPossible) {
3649 verifyFormat(
Alexander Kornienkoa5151272013-03-12 16:28:18 +00003650 "void f() {\n"
3651 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
3652 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
3653 " f();\n"
3654 "}");
Daniel Jasper70bc8742013-02-26 13:59:14 +00003655 verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00003656 " Intervals[i - 1].getRange().getLast()) {\n}");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00003657}
3658
Daniel Jasper6728fc12013-04-11 14:29:13 +00003659TEST_F(FormatTest, BreaksFunctionDeclarations) {
3660 // Principially, we break function declarations in a certain order:
3661 // 1) break amongst arguments.
3662 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
3663 " Cccccccccccccc cccccccccccccc);");
Daniel Jaspera44991332015-04-29 13:06:49 +00003664 verifyFormat("template <class TemplateIt>\n"
3665 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n"
3666 " TemplateIt *stop) {}");
Daniel Jasper6728fc12013-04-11 14:29:13 +00003667
3668 // 2) break after return type.
Daniel Jasper8e357692013-05-06 08:27:33 +00003669 verifyFormat(
Manuel Klimek836c2862013-06-21 17:25:42 +00003670 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00003671 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);",
Manuel Klimek836c2862013-06-21 17:25:42 +00003672 getGoogleStyle());
Daniel Jasper6728fc12013-04-11 14:29:13 +00003673
3674 // 3) break after (.
3675 verifyFormat(
3676 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
Manuel Klimek836c2862013-06-21 17:25:42 +00003677 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);",
3678 getGoogleStyle());
Daniel Jasper6728fc12013-04-11 14:29:13 +00003679
3680 // 4) break before after nested name specifiers.
3681 verifyFormat(
3682 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00003683 "SomeClasssssssssssssssssssssssssssssssssssssss::\n"
3684 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);",
Manuel Klimek836c2862013-06-21 17:25:42 +00003685 getGoogleStyle());
Daniel Jasper6728fc12013-04-11 14:29:13 +00003686
3687 // However, there are exceptions, if a sufficient amount of lines can be
3688 // saved.
3689 // FIXME: The precise cut-offs wrt. the number of saved lines might need some
3690 // more adjusting.
3691 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
3692 " Cccccccccccccc cccccccccc,\n"
3693 " Cccccccccccccc cccccccccc,\n"
3694 " Cccccccccccccc cccccccccc,\n"
3695 " Cccccccccccccc cccccccccc);");
3696 verifyFormat(
Manuel Klimek836c2862013-06-21 17:25:42 +00003697 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00003698 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3699 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3700 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);",
Manuel Klimek836c2862013-06-21 17:25:42 +00003701 getGoogleStyle());
Daniel Jasper6728fc12013-04-11 14:29:13 +00003702 verifyFormat(
3703 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
3704 " Cccccccccccccc cccccccccc,\n"
3705 " Cccccccccccccc cccccccccc,\n"
3706 " Cccccccccccccc cccccccccc,\n"
3707 " Cccccccccccccc cccccccccc,\n"
3708 " Cccccccccccccc cccccccccc,\n"
3709 " Cccccccccccccc cccccccccc);");
3710 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
3711 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3712 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3713 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3714 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
Daniel Jasper1b8e76f2013-04-15 22:36:37 +00003715
3716 // Break after multi-line parameters.
3717 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3718 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3719 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3720 " bbbb bbbb);");
Daniel Jasper6c0ee172014-11-14 13:14:45 +00003721 verifyFormat("void SomeLoooooooooooongFunction(\n"
3722 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
3723 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3724 " int bbbbbbbbbbbbb);");
Daniel Jasper6331da02013-07-09 07:43:55 +00003725
3726 // Treat overloaded operators like other functions.
3727 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
3728 "operator>(const SomeLoooooooooooooooooooooooooogType &other);");
Daniel Jasperd215b8b2013-08-28 07:27:35 +00003729 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
3730 "operator>>(const SomeLooooooooooooooooooooooooogType &other);");
Alexander Kornienko86b2dfd2014-03-06 15:13:08 +00003731 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
3732 "operator<<(const SomeLooooooooooooooooooooooooogType &other);");
3733 verifyGoogleFormat(
3734 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n"
3735 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
Daniel Jasper6331da02013-07-09 07:43:55 +00003736 verifyGoogleFormat(
3737 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n"
3738 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
Daniel Jasper126153a2013-12-27 06:39:56 +00003739 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3740 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);");
3741 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n"
3742 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);");
Daniel Jasperea79ea12014-08-15 05:00:39 +00003743 verifyGoogleFormat(
3744 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n"
3745 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3746 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}");
Daniel Jasper11309812015-03-18 14:20:13 +00003747
3748 FormatStyle Style = getLLVMStyle();
3749 Style.PointerAlignment = FormatStyle::PAS_Left;
3750 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3751 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}",
3752 Style);
Daniel Jaspera44991332015-04-29 13:06:49 +00003753 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
3754 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
3755 Style);
Daniel Jasper6728fc12013-04-11 14:29:13 +00003756}
3757
Daniel Jasper6cdec7c2013-07-09 14:36:48 +00003758TEST_F(FormatTest, TrailingReturnType) {
3759 verifyFormat("auto foo() -> int;\n");
3760 verifyFormat("struct S {\n"
3761 " auto bar() const -> int;\n"
3762 "};");
3763 verifyFormat("template <size_t Order, typename T>\n"
3764 "auto load_img(const std::string &filename)\n"
3765 " -> alias::tensor<Order, T, mem::tag::cpu> {}");
Daniel Jasperda07a722014-10-17 14:37:40 +00003766 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n"
3767 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}");
Daniel Jasperb52c69e2014-10-22 09:01:12 +00003768 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}");
Daniel Jasper6f2b88a2015-06-05 13:18:09 +00003769 verifyFormat("template <typename T>\n"
3770 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n"
3771 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());");
Daniel Jaspera3501d42013-07-11 14:33:06 +00003772
3773 // Not trailing return types.
3774 verifyFormat("void f() { auto a = b->c(); }");
Daniel Jasper6cdec7c2013-07-09 14:36:48 +00003775}
3776
Daniel Jasper5be31f72013-05-21 09:16:31 +00003777TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) {
Daniel Jasperd8c36d02013-10-18 16:34:40 +00003778 // Avoid breaking before trailing 'const' or other trailing annotations, if
3779 // they are not function-like.
Daniel Jasper13c37b32013-05-22 08:28:26 +00003780 FormatStyle Style = getGoogleStyle();
3781 Style.ColumnLimit = 47;
Daniel Jaspere068ac72014-10-27 17:13:59 +00003782 verifyFormat("void someLongFunction(\n"
3783 " int someLoooooooooooooongParameter) const {\n}",
Daniel Jasper13c37b32013-05-22 08:28:26 +00003784 getLLVMStyleWithColumns(47));
Daniel Jasper13c37b32013-05-22 08:28:26 +00003785 verifyFormat("LoooooongReturnType\n"
3786 "someLoooooooongFunction() const {}",
3787 getLLVMStyleWithColumns(47));
3788 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
3789 " const {}",
3790 Style);
Daniel Jasperd8c36d02013-10-18 16:34:40 +00003791 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
3792 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;");
3793 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
3794 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;");
3795 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
3796 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;");
Daniel Jasper43e6a282013-12-16 15:01:54 +00003797 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n"
3798 " aaaaaaaaaaa aaaaa) const override;");
3799 verifyGoogleFormat(
3800 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
3801 " const override;");
Daniel Jasper5be31f72013-05-21 09:16:31 +00003802
Daniel Jasper5550de62014-02-17 07:57:46 +00003803 // Even if the first parameter has to be wrapped.
3804 verifyFormat("void someLongFunction(\n"
3805 " int someLongParameter) const {}",
Daniel Jasperd8c36d02013-10-18 16:34:40 +00003806 getLLVMStyleWithColumns(46));
Daniel Jasper5550de62014-02-17 07:57:46 +00003807 verifyFormat("void someLongFunction(\n"
3808 " int someLongParameter) const {}",
Daniel Jasperd8c36d02013-10-18 16:34:40 +00003809 Style);
Daniel Jasper5550de62014-02-17 07:57:46 +00003810 verifyFormat("void someLongFunction(\n"
3811 " int someLongParameter) override {}",
3812 Style);
3813 verifyFormat("void someLongFunction(\n"
Daniel Jasperb48d3af2014-04-09 10:01:49 +00003814 " int someLongParameter) OVERRIDE {}",
3815 Style);
3816 verifyFormat("void someLongFunction(\n"
Daniel Jasper5550de62014-02-17 07:57:46 +00003817 " int someLongParameter) final {}",
3818 Style);
3819 verifyFormat("void someLongFunction(\n"
Daniel Jasperb48d3af2014-04-09 10:01:49 +00003820 " int someLongParameter) FINAL {}",
3821 Style);
3822 verifyFormat("void someLongFunction(\n"
Daniel Jasper5550de62014-02-17 07:57:46 +00003823 " int parameter) const override {}",
3824 Style);
3825
Daniel Jaspere3f907f2014-06-02 09:52:08 +00003826 Style.BreakBeforeBraces = FormatStyle::BS_Allman;
3827 verifyFormat("void someLongFunction(\n"
3828 " int someLongParameter) const\n"
3829 "{\n"
3830 "}",
3831 Style);
3832
Daniel Jasper5550de62014-02-17 07:57:46 +00003833 // Unless these are unknown annotations.
Daniel Jasperd8c36d02013-10-18 16:34:40 +00003834 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n"
3835 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3836 " LONG_AND_UGLY_ANNOTATION;");
Daniel Jasper718bd362013-07-11 21:02:56 +00003837
3838 // Breaking before function-like trailing annotations is fine to keep them
3839 // close to their arguments.
Daniel Jasper5be31f72013-05-21 09:16:31 +00003840 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3841 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
3842 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
3843 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
3844 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
3845 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}");
Daniel Jasperf9a09062014-04-09 10:29:11 +00003846 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n"
3847 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);");
Daniel Jasper8b76d602014-07-28 12:08:06 +00003848 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});");
Daniel Jasper5be31f72013-05-21 09:16:31 +00003849
3850 verifyFormat(
3851 "void aaaaaaaaaaaaaaaaaa()\n"
3852 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
3853 " aaaaaaaaaaaaaaaaaaaaaaaaa));");
3854 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3855 " __attribute__((unused));");
Daniel Jasper35ec2b22014-04-14 08:15:20 +00003856 verifyGoogleFormat(
Manuel Klimek836c2862013-06-21 17:25:42 +00003857 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper35ec2b22014-04-14 08:15:20 +00003858 " GUARDED_BY(aaaaaaaaaaaa);");
3859 verifyGoogleFormat(
Daniel Jasper40db06a2013-07-11 12:34:23 +00003860 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper35ec2b22014-04-14 08:15:20 +00003861 " GUARDED_BY(aaaaaaaaaaaa);");
3862 verifyGoogleFormat(
3863 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
3864 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper3ca283a2015-05-15 09:58:11 +00003865 verifyGoogleFormat(
3866 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
3867 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper5be31f72013-05-21 09:16:31 +00003868}
3869
Daniel Jasperf090f032015-05-18 09:47:22 +00003870TEST_F(FormatTest, FunctionAnnotations) {
3871 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
3872 "string OldFunction(const string &parameter) {}");
3873 verifyFormat("template <typename T>\n"
3874 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
3875 "string OldFunction(const string &parameter) {}");
Daniel Jasper47bbda02015-05-18 13:47:23 +00003876
3877 // Not function annotations.
3878 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3879 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
Daniel Jasper32739302015-05-27 04:55:47 +00003880 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n"
3881 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}");
Daniel Jasperf090f032015-05-18 09:47:22 +00003882}
3883
Daniel Jasperf7935112012-12-03 18:12:45 +00003884TEST_F(FormatTest, BreaksDesireably) {
3885 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
3886 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003887 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
Daniel Jasper39e27382013-01-23 20:41:06 +00003888 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3889 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
3890 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +00003891
3892 verifyFormat(
3893 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003894 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasperf7935112012-12-03 18:12:45 +00003895
3896 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3897 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3898 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jasper9b155472012-12-04 10:50:12 +00003899
3900 verifyFormat(
3901 "aaaaaaaa(aaaaaaaaaaaaa, aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3902 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
3903 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3904 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));");
Daniel Jasperaa1c9202012-12-05 14:57:28 +00003905
3906 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3907 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
3908
Daniel Jasper3d0c75c2013-01-02 14:40:02 +00003909 verifyFormat(
Alexander Kornienkoa5151272013-03-12 16:28:18 +00003910 "void f() {\n"
3911 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
3912 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
3913 "}");
Daniel Jasper7a31af12013-01-25 15:43:32 +00003914 verifyFormat(
3915 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3916 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
3917 verifyFormat(
3918 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3919 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jaspera44991332015-04-29 13:06:49 +00003920 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3921 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3922 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper3d0c75c2013-01-02 14:40:02 +00003923
Daniel Jasper739b85f2015-06-29 10:42:59 +00003924 // Indent consistently independent of call expression and unary operator.
3925 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
3926 " dddddddddddddddddddddddddddddd));");
3927 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
3928 " dddddddddddddddddddddddddddddd));");
Daniel Jasperf79b0b12013-08-30 08:29:25 +00003929 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
Daniel Jasperf79b0b12013-08-30 08:29:25 +00003930 " dddddddddddddddddddddddddddddd));");
3931
Daniel Jasperaa1c9202012-12-05 14:57:28 +00003932 // This test case breaks on an incorrect memoization, i.e. an optimization not
3933 // taking into account the StopAt value.
3934 verifyFormat(
3935 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
Daniel Jasper2eda23e2012-12-24 13:43:52 +00003936 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
3937 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
3938 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper6d822722012-12-24 16:43:00 +00003939
Daniel Jasper8d1832e2013-01-07 13:26:07 +00003940 verifyFormat("{\n {\n {\n"
3941 " Annotation.SpaceRequiredBefore =\n"
3942 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
3943 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
3944 " }\n }\n}");
Alexander Kornienko4d26b6e2013-06-17 12:59:44 +00003945
3946 // Break on an outer level if there was a break on an inner level.
3947 EXPECT_EQ("f(g(h(a, // comment\n"
3948 " b, c),\n"
3949 " d, e),\n"
3950 " x, y);",
3951 format("f(g(h(a, // comment\n"
3952 " b, c), d, e), x, y);"));
Daniel Jasperee7539a2013-07-08 14:25:23 +00003953
3954 // Prefer breaking similar line breaks.
3955 verifyFormat(
3956 "const int kTrackingOptions = NSTrackingMouseMoved |\n"
3957 " NSTrackingMouseEnteredAndExited |\n"
3958 " NSTrackingActiveAlways;");
Daniel Jasperf7935112012-12-03 18:12:45 +00003959}
3960
Daniel Jasper18210d72014-10-09 09:52:05 +00003961TEST_F(FormatTest, FormatsDeclarationsOnePerLine) {
3962 FormatStyle NoBinPacking = getGoogleStyle();
3963 NoBinPacking.BinPackParameters = false;
3964 NoBinPacking.BinPackArguments = true;
3965 verifyFormat("void f() {\n"
3966 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n"
3967 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
3968 "}",
3969 NoBinPacking);
3970 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n"
3971 " int aaaaaaaaaaaaaaaaaaaa,\n"
3972 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
3973 NoBinPacking);
3974}
3975
Daniel Jasper9278eb92013-01-16 14:59:02 +00003976TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
Daniel Jaspera628c982013-04-03 13:36:17 +00003977 FormatStyle NoBinPacking = getGoogleStyle();
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003978 NoBinPacking.BinPackParameters = false;
Daniel Jasper18210d72014-10-09 09:52:05 +00003979 NoBinPacking.BinPackArguments = false;
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003980 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
3981 " aaaaaaaaaaaaaaaaaaaa,\n"
3982 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);",
3983 NoBinPacking);
3984 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
3985 " aaaaaaaaaaaaa,\n"
3986 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));",
3987 NoBinPacking);
3988 verifyFormat(
Daniel Jasper9278eb92013-01-16 14:59:02 +00003989 "aaaaaaaa(aaaaaaaaaaaaa,\n"
3990 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3991 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
3992 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003993 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));",
3994 NoBinPacking);
3995 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
3996 " .aaaaaaaaaaaaaaaaaa();",
3997 NoBinPacking);
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00003998 verifyFormat("void f() {\n"
3999 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4000 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n"
4001 "}",
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004002 NoBinPacking);
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00004003
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004004 verifyFormat(
Daniel Jaspere941b162013-01-23 10:08:28 +00004005 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4006 " aaaaaaaaaaaa,\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004007 " aaaaaaaaaaaa);",
4008 NoBinPacking);
4009 verifyFormat(
Daniel Jasper9278eb92013-01-16 14:59:02 +00004010 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
4011 " ddddddddddddddddddddddddddddd),\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004012 " test);",
4013 NoBinPacking);
Daniel Jasper9278eb92013-01-16 14:59:02 +00004014
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004015 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
4016 " aaaaaaaaaaaaaaaaaaaaaaa,\n"
4017 " aaaaaaaaaaaaaaaaaaaaaaa> aaaaaaaaaaaaaaaaaa;",
4018 NoBinPacking);
4019 verifyFormat("a(\"a\"\n"
4020 " \"a\",\n"
4021 " a);");
Daniel Jaspere941b162013-01-23 10:08:28 +00004022
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004023 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
Daniel Jasperf7db4332013-01-29 16:03:49 +00004024 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
Daniel Jaspere941b162013-01-23 10:08:28 +00004025 " aaaaaaaaa,\n"
Daniel Jasperf7db4332013-01-29 16:03:49 +00004026 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004027 NoBinPacking);
Daniel Jasper687af3b2013-02-14 14:26:07 +00004028 verifyFormat(
4029 "void f() {\n"
4030 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
4031 " .aaaaaaa();\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00004032 "}",
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004033 NoBinPacking);
Daniel Jasper53e8d852013-05-22 08:55:55 +00004034 verifyFormat(
4035 "template <class SomeType, class SomeOtherType>\n"
4036 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
4037 NoBinPacking);
Daniel Jasper9278eb92013-01-16 14:59:02 +00004038}
4039
Daniel Jasperb10cbc42013-07-10 14:02:49 +00004040TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
4041 FormatStyle Style = getLLVMStyleWithColumns(15);
4042 Style.ExperimentalAutoDetectBinPacking = true;
4043 EXPECT_EQ("aaa(aaaa,\n"
4044 " aaaa,\n"
4045 " aaaa);\n"
4046 "aaa(aaaa,\n"
4047 " aaaa,\n"
4048 " aaaa);",
4049 format("aaa(aaaa,\n" // one-per-line
4050 " aaaa,\n"
4051 " aaaa );\n"
4052 "aaa(aaaa, aaaa, aaaa);", // inconclusive
4053 Style));
4054 EXPECT_EQ("aaa(aaaa, aaaa,\n"
4055 " aaaa);\n"
4056 "aaa(aaaa, aaaa,\n"
4057 " aaaa);",
4058 format("aaa(aaaa, aaaa,\n" // bin-packed
4059 " aaaa );\n"
4060 "aaa(aaaa, aaaa, aaaa);", // inconclusive
4061 Style));
4062}
4063
Daniel Jasper04468962013-01-18 10:56:38 +00004064TEST_F(FormatTest, FormatsBuilderPattern) {
Daniel Jaspera44991332015-04-29 13:06:49 +00004065 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n"
4066 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
4067 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
4068 " .StartsWith(\".init\", ORDER_INIT)\n"
4069 " .StartsWith(\".fini\", ORDER_FINI)\n"
4070 " .StartsWith(\".hash\", ORDER_HASH)\n"
4071 " .Default(ORDER_TEXT);\n");
Daniel Jasperc6fbc212013-05-15 09:35:08 +00004072
Daniel Jaspereb50c672013-02-15 20:33:06 +00004073 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00004074 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
Daniel Jasper9ed9ade2013-02-18 13:24:21 +00004075 verifyFormat(
Daniel Jasperd6877f02013-08-07 05:34:02 +00004076 "aaaaaaa->aaaaaaa->aaaaaaaaaaaaaaaa(\n"
Daniel Jasper9dedc7752015-04-07 06:41:24 +00004077 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
Daniel Jasper9ed9ade2013-02-18 13:24:21 +00004078 " ->aaaaaaaa(aaaaaaaaaaaaaaa);");
Daniel Jaspere53beb22013-02-18 13:52:06 +00004079 verifyFormat(
4080 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
Daniel Jasperf9a84b52013-03-01 16:48:32 +00004081 " aaaaaaaaaaaaaa);");
Daniel Jaspere53beb22013-02-18 13:52:06 +00004082 verifyFormat(
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004083 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n"
4084 " aaaaaa->aaaaaaaaaaaa()\n"
4085 " ->aaaaaaaaaaaaaaaa(\n"
Daniel Jasper9dedc7752015-04-07 06:41:24 +00004086 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004087 " ->aaaaaaaaaaaaaaaaa();");
Daniel Jasper33b909c2013-10-25 14:29:37 +00004088 verifyGoogleFormat(
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00004089 "void f() {\n"
4090 " someo->Add((new util::filetools::Handler(dir))\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004091 " ->OnEvent1(NewPermanentCallback(\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00004092 " this, &HandlerHolderClass::EventHandlerCBA))\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004093 " ->OnEvent2(NewPermanentCallback(\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00004094 " this, &HandlerHolderClass::EventHandlerCBB))\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004095 " ->OnEvent3(NewPermanentCallback(\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00004096 " this, &HandlerHolderClass::EventHandlerCBC))\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004097 " ->OnEvent5(NewPermanentCallback(\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00004098 " this, &HandlerHolderClass::EventHandlerCBD))\n"
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004099 " ->OnEvent6(NewPermanentCallback(\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00004100 " this, &HandlerHolderClass::EventHandlerCBE)));\n"
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00004101 "}");
Daniel Jasper4c6e0052013-08-27 14:24:43 +00004102
4103 verifyFormat(
4104 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();");
4105 verifyFormat("aaaaaaaaaaaaaaa()\n"
4106 " .aaaaaaaaaaaaaaa()\n"
4107 " .aaaaaaaaaaaaaaa()\n"
4108 " .aaaaaaaaaaaaaaa()\n"
4109 " .aaaaaaaaaaaaaaa();");
4110 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
4111 " .aaaaaaaaaaaaaaa()\n"
4112 " .aaaaaaaaaaaaaaa()\n"
4113 " .aaaaaaaaaaaaaaa();");
4114 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
4115 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
4116 " .aaaaaaaaaaaaaaa();");
Daniel Jasperf8151e92013-08-30 07:12:40 +00004117 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
4118 " ->aaaaaaaaaaaaaae(0)\n"
4119 " ->aaaaaaaaaaaaaaa();");
Daniel Jasper36c28ce2013-09-06 08:54:24 +00004120
Daniel Jasper775954b2015-04-24 10:08:09 +00004121 // Don't linewrap after very short segments.
4122 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4123 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4124 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
4125 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4126 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4127 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
4128 verifyFormat("aaa()\n"
4129 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4130 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4131 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
4132
Daniel Jaspercc3114d2013-10-18 15:23:06 +00004133 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
4134 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4135 " .has<bbbbbbbbbbbbbbbbbbbbb>();");
4136 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
4137 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
Daniel Jasper85bde4c2014-01-13 13:42:08 +00004138 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();");
Daniel Jaspercc3114d2013-10-18 15:23:06 +00004139
Daniel Jaspera41aa532014-09-19 08:01:25 +00004140 // Prefer not to break after empty parentheses.
Daniel Jasper36c28ce2013-09-06 08:54:24 +00004141 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
4142 " First->LastNewlineOffset);");
Daniel Jasper04468962013-01-18 10:56:38 +00004143}
4144
Daniel Jasperde5c2072012-12-24 00:13:23 +00004145TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) {
4146 verifyFormat(
4147 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004148 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00004149 verifyFormat(
4150 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n"
4151 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}");
4152
Daniel Jasper8d1832e2013-01-07 13:26:07 +00004153 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004154 " ccccccccccccccccccccccccc) {\n}");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00004155 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n"
4156 " ccccccccccccccccccccccccc) {\n}");
4157
Daniel Jasper8d1832e2013-01-07 13:26:07 +00004158 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004159 " ccccccccccccccccccccccccc) {\n}");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00004160 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n"
4161 " ccccccccccccccccccccccccc) {\n}");
4162
Daniel Jasperde5c2072012-12-24 00:13:23 +00004163 verifyFormat(
4164 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004165 " ccccccccccccccccccccccccc) {\n}");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00004166 verifyFormat(
4167 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n"
4168 " ccccccccccccccccccccccccc) {\n}");
4169
Daniel Jasper400adc62013-02-08 15:28:42 +00004170 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
4171 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
4172 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
4173 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00004174 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n"
4175 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n"
4176 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n"
4177 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
4178
Daniel Jasper400adc62013-02-08 15:28:42 +00004179 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
4180 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
4181 " aaaaaaaaaaaaaaa != aa) {\n}");
Nikola Smiljanice08a91e2014-05-08 00:05:13 +00004182 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n"
4183 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n"
4184 " aaaaaaaaaaaaaaa != aa) {\n}");
Daniel Jasperde5c2072012-12-24 00:13:23 +00004185}
4186
Daniel Jasper43b65482013-01-23 12:27:43 +00004187TEST_F(FormatTest, BreaksAfterAssignments) {
Daniel Jasper206df732013-01-07 13:08:40 +00004188 verifyFormat(
Daniel Jasper43b65482013-01-23 12:27:43 +00004189 "unsigned Cost =\n"
4190 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
4191 " SI->getPointerAddressSpaceee());\n");
Daniel Jasper206df732013-01-07 13:08:40 +00004192 verifyFormat(
Daniel Jasper1565eb32013-01-23 15:55:19 +00004193 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
4194 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
Daniel Jaspera836b902013-01-23 16:58:21 +00004195
4196 verifyFormat(
Daniel Jasperb27c4b72013-08-27 11:09:05 +00004197 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
4198 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper7b27a102013-05-27 12:45:09 +00004199 verifyFormat("unsigned OriginalStartColumn =\n"
4200 " SourceMgr.getSpellingColumnNumber(\n"
4201 " Current.FormatTok.getStartOfNonWhitespace()) -\n"
4202 " 1;");
Daniel Jasper206df732013-01-07 13:08:40 +00004203}
4204
Daniel Jasper2eda23e2012-12-24 13:43:52 +00004205TEST_F(FormatTest, AlignsAfterAssignments) {
4206 verifyFormat(
4207 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper206df732013-01-07 13:08:40 +00004208 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00004209 verifyFormat(
4210 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper206df732013-01-07 13:08:40 +00004211 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00004212 verifyFormat(
4213 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper206df732013-01-07 13:08:40 +00004214 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00004215 verifyFormat(
4216 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper206df732013-01-07 13:08:40 +00004217 " aaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperee7539a2013-07-08 14:25:23 +00004218 verifyFormat(
4219 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n"
4220 " aaaaaaaaaaaaaaaaaaaaaaaa +\n"
4221 " aaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00004222}
4223
4224TEST_F(FormatTest, AlignsAfterReturn) {
4225 verifyFormat(
4226 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4227 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
4228 verifyFormat(
4229 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4230 " aaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperc238c872013-04-02 14:33:13 +00004231 verifyFormat(
4232 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00004233 " aaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasperc238c872013-04-02 14:33:13 +00004234 verifyFormat(
4235 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00004236 " aaaaaaaaaaaaaaaaaaaaaa());");
4237 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4238 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
4239 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4240 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
4241 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jaspereabede62013-09-30 08:29:03 +00004242 verifyFormat("return\n"
4243 " // true if code is one of a or b.\n"
4244 " code == a || code == b;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00004245}
4246
Daniel Jasper3aa9a6a2014-11-18 23:55:27 +00004247TEST_F(FormatTest, AlignsAfterOpenBracket) {
4248 verifyFormat(
4249 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
4250 " aaaaaaaaa aaaaaaa) {}");
4251 verifyFormat(
4252 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
4253 " aaaaaaaaaaa aaaaaaaaa);");
4254 verifyFormat(
4255 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
4256 " aaaaaaaaaaaaaaaaaaaaa));");
4257 FormatStyle Style = getLLVMStyle();
4258 Style.AlignAfterOpenBracket = false;
Daniel Jaspera44991332015-04-29 13:06:49 +00004259 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4260 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}",
4261 Style);
4262 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
4263 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);",
4264 Style);
4265 verifyFormat("SomeLongVariableName->someFunction(\n"
4266 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));",
4267 Style);
Daniel Jasper3aa9a6a2014-11-18 23:55:27 +00004268 verifyFormat(
4269 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
4270 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4271 Style);
4272 verifyFormat(
4273 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
4274 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4275 Style);
4276 verifyFormat(
4277 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
4278 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
4279 Style);
4280}
4281
Daniel Jasper3219e432014-12-02 13:24:51 +00004282TEST_F(FormatTest, ParenthesesAndOperandAlignment) {
4283 FormatStyle Style = getLLVMStyleWithColumns(40);
4284 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
4285 " bbbbbbbbbbbbbbbbbbbbbb);",
4286 Style);
4287 Style.AlignAfterOpenBracket = true;
4288 Style.AlignOperands = false;
4289 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
4290 " bbbbbbbbbbbbbbbbbbbbbb);",
4291 Style);
4292 Style.AlignAfterOpenBracket = false;
4293 Style.AlignOperands = true;
4294 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
4295 " bbbbbbbbbbbbbbbbbbbbbb);",
4296 Style);
4297 Style.AlignAfterOpenBracket = false;
4298 Style.AlignOperands = false;
4299 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
4300 " bbbbbbbbbbbbbbbbbbbbbb);",
4301 Style);
4302}
4303
Daniel Jasper399d24b2013-01-09 07:06:56 +00004304TEST_F(FormatTest, BreaksConditionalExpressions) {
4305 verifyFormat(
Daniel Jasperee7539a2013-07-08 14:25:23 +00004306 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4307 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4308 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper8c5fba92013-01-16 16:23:19 +00004309 verifyFormat(
Daniel Jasperca6623b2013-01-28 12:45:14 +00004310 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4311 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
4312 verifyFormat(
4313 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
4314 " : aaaaaaaaaaaaa);");
4315 verifyFormat(
4316 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasperaab220f2013-03-20 13:53:11 +00004317 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasperca6623b2013-01-28 12:45:14 +00004318 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4319 " aaaaaaaaaaaaa);");
Daniel Jasperb1ae7342013-08-01 22:05:00 +00004320 verifyFormat(
4321 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4322 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4323 " aaaaaaaaaaaaa);");
Daniel Jasperca6623b2013-01-28 12:45:14 +00004324 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4325 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4326 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4327 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4328 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
4329 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4330 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4331 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4332 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4333 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4334 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4335 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperb1ae7342013-08-01 22:05:00 +00004336 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4337 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4338 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4339 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4340 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper54a86022013-02-15 11:07:25 +00004341 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4342 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4343 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasperc238c872013-04-02 14:33:13 +00004344 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
4345 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4346 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4347 " : aaaaaaaaaaaaaaaa;");
Daniel Jaspercd8599e2013-02-23 21:01:55 +00004348 verifyFormat(
4349 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4350 " ? aaaaaaaaaaaaaaa\n"
4351 " : aaaaaaaaaaaaaaa;");
4352 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00004353 " aaaaaaaaa\n"
Daniel Jaspere7de2a32013-04-08 10:45:44 +00004354 " ? b\n"
4355 " : c);");
Daniel Jasper119ff532014-11-14 12:31:14 +00004356 verifyFormat("return aaaa == bbbb\n"
4357 " // comment\n"
4358 " ? aaaa\n"
4359 " : bbbb;");
Daniel Jaspera44991332015-04-29 13:06:49 +00004360 verifyFormat("unsigned Indent =\n"
4361 " format(TheLine.First, IndentForLevel[TheLine.Level] >= 0\n"
4362 " ? IndentForLevel[TheLine.Level]\n"
4363 " : TheLine * 2,\n"
4364 " TheLine.InPPDirective, PreviousEndOfLineColumn);",
4365 getLLVMStyleWithColumns(70));
Daniel Jasper2c611c02013-05-31 14:56:12 +00004366 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
4367 " ? aaaaaaaaaaaaaaa\n"
4368 " : bbbbbbbbbbbbbbb //\n"
4369 " ? ccccccccccccccc\n"
4370 " : ddddddddddddddd;");
4371 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
4372 " ? aaaaaaaaaaaaaaa\n"
4373 " : (bbbbbbbbbbbbbbb //\n"
4374 " ? ccccccccccccccc\n"
4375 " : ddddddddddddddd);");
Daniel Jasperc0d606a2014-04-14 11:08:45 +00004376 verifyFormat(
4377 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4378 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4379 " aaaaaaaaaaaaaaaaaaaaa +\n"
4380 " aaaaaaaaaaaaaaaaaaaaa\n"
4381 " : aaaaaaaaaa;");
Daniel Jasperfc3861a2014-07-17 12:22:04 +00004382 verifyFormat(
4383 "aaaaaa = aaaaaaaaaaaa\n"
4384 " ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4385 " : aaaaaaaaaaaaaaaaaaaaaa\n"
4386 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper54a86022013-02-15 11:07:25 +00004387
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004388 FormatStyle NoBinPacking = getLLVMStyle();
Daniel Jasper18210d72014-10-09 09:52:05 +00004389 NoBinPacking.BinPackArguments = false;
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004390 verifyFormat(
Daniel Jaspercd8599e2013-02-23 21:01:55 +00004391 "void f() {\n"
4392 " g(aaa,\n"
4393 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
4394 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4395 " ? aaaaaaaaaaaaaaa\n"
4396 " : aaaaaaaaaaaaaaa);\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004397 "}",
4398 NoBinPacking);
Daniel Jasperb1ae7342013-08-01 22:05:00 +00004399 verifyFormat(
4400 "void f() {\n"
4401 " g(aaa,\n"
4402 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
4403 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4404 " ?: aaaaaaaaaaaaaaa);\n"
4405 "}",
4406 NoBinPacking);
Daniel Jasper1a31bab2014-10-16 09:10:11 +00004407
4408 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n"
4409 " // comment.\n"
4410 " ccccccccccccccccccccccccccccccccccccccc\n"
4411 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4412 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);");
Daniel Jasper6c22c442014-11-14 13:03:40 +00004413
4414 // Assignments in conditional expressions. Apparently not uncommon :-(.
4415 verifyFormat("return a != b\n"
4416 " // comment\n"
4417 " ? a = b\n"
4418 " : a = b;");
4419 verifyFormat("return a != b\n"
4420 " // comment\n"
4421 " ? a = a != b\n"
4422 " // comment\n"
4423 " ? a = b\n"
4424 " : a\n"
4425 " : a;\n");
4426 verifyFormat("return a != b\n"
4427 " // comment\n"
4428 " ? a\n"
4429 " : a = a != b\n"
4430 " // comment\n"
4431 " ? a = b\n"
4432 " : a;");
Daniel Jasper399d24b2013-01-09 07:06:56 +00004433}
4434
Daniel Jasper165b29e2013-11-08 00:57:11 +00004435TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) {
4436 FormatStyle Style = getLLVMStyle();
4437 Style.BreakBeforeTernaryOperators = false;
4438 Style.ColumnLimit = 70;
4439 verifyFormat(
4440 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4441 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4442 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4443 Style);
4444 verifyFormat(
4445 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4446 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4447 Style);
4448 verifyFormat(
4449 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n"
4450 " aaaaaaaaaaaaa);",
4451 Style);
4452 verifyFormat(
4453 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4454 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4455 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4456 " aaaaaaaaaaaaa);",
4457 Style);
4458 verifyFormat(
4459 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4460 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4461 " aaaaaaaaaaaaa);",
4462 Style);
4463 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4464 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4465 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
4466 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4467 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4468 Style);
4469 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4470 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4471 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4472 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
4473 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4474 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4475 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4476 Style);
4477 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4478 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n"
4479 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4480 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4481 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4482 Style);
4483 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4484 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4485 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4486 Style);
4487 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +00004488 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
Daniel Jasper165b29e2013-11-08 00:57:11 +00004489 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
4490 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4491 Style);
4492 verifyFormat(
4493 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4494 " aaaaaaaaaaaaaaa :\n"
4495 " aaaaaaaaaaaaaaa;",
4496 Style);
4497 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
4498 " aaaaaaaaa ?\n"
4499 " b :\n"
4500 " c);",
4501 Style);
4502 verifyFormat(
4503 "unsigned Indent =\n"
4504 " format(TheLine.First, IndentForLevel[TheLine.Level] >= 0 ?\n"
4505 " IndentForLevel[TheLine.Level] :\n"
4506 " TheLine * 2,\n"
4507 " TheLine.InPPDirective, PreviousEndOfLineColumn);",
4508 Style);
4509 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
4510 " aaaaaaaaaaaaaaa :\n"
4511 " bbbbbbbbbbbbbbb ? //\n"
4512 " ccccccccccccccc :\n"
4513 " ddddddddddddddd;",
4514 Style);
4515 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
4516 " aaaaaaaaaaaaaaa :\n"
4517 " (bbbbbbbbbbbbbbb ? //\n"
4518 " ccccccccccccccc :\n"
4519 " ddddddddddddddd);",
4520 Style);
4521}
4522
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004523TEST_F(FormatTest, DeclarationsOfMultipleVariables) {
4524 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
4525 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();");
4526 verifyFormat("bool a = true, b = false;");
4527
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004528 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Daniel Jaspera628c982013-04-03 13:36:17 +00004529 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004530 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
Daniel Jasperc238c872013-04-02 14:33:13 +00004531 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);");
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004532 verifyFormat(
Daniel Jasper37905f72013-02-21 15:00:29 +00004533 "bool aaaaaaaaaaaaaaaaaaaaa =\n"
Daniel Jaspera628c982013-04-03 13:36:17 +00004534 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
Daniel Jasper37905f72013-02-21 15:00:29 +00004535 " d = e && f;");
Daniel Jasper31c96b92013-04-05 09:38:50 +00004536 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
4537 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;");
4538 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
4539 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;");
4540 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
4541 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;");
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004542
Daniel Jasperbea1ab42015-03-01 18:55:26 +00004543 FormatStyle Style = getGoogleStyle();
4544 Style.PointerAlignment = FormatStyle::PAS_Left;
4545 Style.DerivePointerAlignment = false;
4546 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4547 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
4548 " *b = bbbbbbbbbbbbbbbbbbb;",
4549 Style);
Daniel Jaspera44991332015-04-29 13:06:49 +00004550 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
4551 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;",
4552 Style);
Daniel Jasper38c11ce2013-01-29 11:21:01 +00004553}
4554
Nico Weber4a5030c2013-01-12 01:28:06 +00004555TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
4556 verifyFormat("arr[foo ? bar : baz];");
4557 verifyFormat("f()[foo ? bar : baz];");
4558 verifyFormat("(a + b)[foo ? bar : baz];");
4559 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
4560}
4561
Daniel Jasperf7935112012-12-03 18:12:45 +00004562TEST_F(FormatTest, AlignsStringLiterals) {
4563 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
4564 " \"short literal\");");
4565 verifyFormat(
4566 "looooooooooooooooooooooooongFunction(\n"
4567 " \"short literal\"\n"
4568 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00004569 verifyFormat("someFunction(\"Always break between multi-line\"\n"
4570 " \" string literals\",\n"
4571 " and, other, parameters);");
Manuel Klimek02f640a2013-02-20 15:25:48 +00004572 EXPECT_EQ("fun + \"1243\" /* comment */\n"
4573 " \"5678\";",
4574 format("fun + \"1243\" /* comment */\n"
4575 " \"5678\";",
4576 getLLVMStyleWithColumns(28)));
4577 EXPECT_EQ(
4578 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
4579 " \"aaaaaaaaaaaaaaaaaaaaa\"\n"
4580 " \"aaaaaaaaaaaaaaaa\";",
4581 format("aaaaaa ="
4582 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
4583 "aaaaaaaaaaaaaaaaaaaaa\" "
4584 "\"aaaaaaaaaaaaaaaa\";"));
Manuel Klimek0c915712013-02-20 15:32:58 +00004585 verifyFormat("a = a + \"a\"\n"
4586 " \"a\"\n"
4587 " \"a\";");
Daniel Jasper7dd22c51b2013-05-16 04:26:02 +00004588 verifyFormat("f(\"a\", \"b\"\n"
4589 " \"c\");");
Daniel Jasperaf5ba0e2013-02-23 07:46:38 +00004590
4591 verifyFormat(
4592 "#define LL_FORMAT \"ll\"\n"
4593 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
4594 " \"d, ddddddddd: %\" LL_FORMAT \"d\");");
Daniel Jasper47a04442013-05-13 20:50:15 +00004595
4596 verifyFormat("#define A(X) \\\n"
4597 " \"aaaaa\" #X \"bbbbbb\" \\\n"
4598 " \"ccccc\"",
4599 getLLVMStyleWithColumns(23));
4600 verifyFormat("#define A \"def\"\n"
4601 "f(\"abc\" A \"ghi\"\n"
4602 " \"jkl\");");
Daniel Jasper04b6a082013-12-20 06:22:01 +00004603
4604 verifyFormat("f(L\"a\"\n"
Daniel Jasper015c7a92015-05-11 15:15:48 +00004605 " L\"b\");");
Daniel Jasper04b6a082013-12-20 06:22:01 +00004606 verifyFormat("#define A(X) \\\n"
4607 " L\"aaaaa\" #X L\"bbbbbb\" \\\n"
4608 " L\"ccccc\"",
4609 getLLVMStyleWithColumns(25));
Daniel Jasper015c7a92015-05-11 15:15:48 +00004610
4611 verifyFormat("f(@\"a\"\n"
4612 " @\"b\");");
4613 verifyFormat("NSString s = @\"a\"\n"
Daniel Jasper09285532015-05-17 08:13:23 +00004614 " @\"b\"\n"
4615 " @\"c\";");
4616 verifyFormat("NSString s = @\"a\"\n"
4617 " \"b\"\n"
4618 " \"c\";");
Daniel Jasperf7935112012-12-03 18:12:45 +00004619}
4620
Daniel Jasperca4ea1c2014-08-05 12:16:31 +00004621TEST_F(FormatTest, AlwaysBreakAfterDefinitionReturnType) {
4622 FormatStyle AfterType = getLLVMStyle();
4623 AfterType.AlwaysBreakAfterDefinitionReturnType = true;
4624 verifyFormat("const char *\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004625 "f(void) {\n" // Break here.
Daniel Jasperca4ea1c2014-08-05 12:16:31 +00004626 " return \"\";\n"
4627 "}\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004628 "const char *bar(void);\n", // No break here.
Daniel Jasperca4ea1c2014-08-05 12:16:31 +00004629 AfterType);
Daniel Jasperdb764792014-08-14 11:36:03 +00004630 verifyFormat("template <class T>\n"
4631 "T *\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004632 "f(T &c) {\n" // Break here.
Daniel Jasperdb764792014-08-14 11:36:03 +00004633 " return NULL;\n"
4634 "}\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004635 "template <class T> T *f(T &c);\n", // No break here.
Daniel Jasperdb764792014-08-14 11:36:03 +00004636 AfterType);
4637 AfterType.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
4638 verifyFormat("const char *\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004639 "f(void)\n" // Break here.
Daniel Jasperdb764792014-08-14 11:36:03 +00004640 "{\n"
4641 " return \"\";\n"
4642 "}\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004643 "const char *bar(void);\n", // No break here.
Daniel Jasperdb764792014-08-14 11:36:03 +00004644 AfterType);
4645 verifyFormat("template <class T>\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004646 "T *\n" // Problem here: no line break
4647 "f(T &c)\n" // Break here.
Daniel Jasperdb764792014-08-14 11:36:03 +00004648 "{\n"
4649 " return NULL;\n"
4650 "}\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00004651 "template <class T> T *f(T &c);\n", // No break here.
Daniel Jasperdb764792014-08-14 11:36:03 +00004652 AfterType);
Daniel Jasperca4ea1c2014-08-05 12:16:31 +00004653}
4654
Alexander Kornienko58611712013-07-04 12:02:44 +00004655TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) {
4656 FormatStyle NoBreak = getLLVMStyle();
4657 NoBreak.AlwaysBreakBeforeMultilineStrings = false;
4658 FormatStyle Break = getLLVMStyle();
4659 Break.AlwaysBreakBeforeMultilineStrings = true;
Daniel Jasperc834c702013-07-17 15:38:19 +00004660 verifyFormat("aaaa = \"bbbb\"\n"
4661 " \"cccc\";",
4662 NoBreak);
4663 verifyFormat("aaaa =\n"
4664 " \"bbbb\"\n"
4665 " \"cccc\";",
4666 Break);
4667 verifyFormat("aaaa(\"bbbb\"\n"
4668 " \"cccc\");",
4669 NoBreak);
4670 verifyFormat("aaaa(\n"
4671 " \"bbbb\"\n"
4672 " \"cccc\");",
4673 Break);
4674 verifyFormat("aaaa(qqq, \"bbbb\"\n"
4675 " \"cccc\");",
4676 NoBreak);
Daniel Jasper1bf729c2015-06-18 16:05:17 +00004677 verifyFormat("aaaa(qqq,\n"
4678 " \"bbbb\"\n"
4679 " \"cccc\");",
Daniel Jasperc834c702013-07-17 15:38:19 +00004680 Break);
Daniel Jasper1bf729c2015-06-18 16:05:17 +00004681 verifyFormat("aaaa(qqq,\n"
4682 " L\"bbbb\"\n"
4683 " L\"cccc\");",
4684 Break);
4685 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n"
4686 " \"bbbb\"));",
Daniel Jasper04b6a082013-12-20 06:22:01 +00004687 Break);
Daniel Jasper9fb676a2015-06-19 10:32:28 +00004688 verifyFormat("string s = someFunction(\n"
4689 " \"abc\"\n"
4690 " \"abc\");",
4691 Break);
Daniel Jasperc834c702013-07-17 15:38:19 +00004692
Daniel Jasper3251fff2014-06-10 06:27:23 +00004693 // As we break before unary operators, breaking right after them is bad.
4694 verifyFormat("string foo = abc ? \"x\"\n"
4695 " \"blah blah blah blah blah blah\"\n"
4696 " : \"y\";",
4697 Break);
4698
Daniel Jasperc834c702013-07-17 15:38:19 +00004699 // Don't break if there is no column gain.
4700 verifyFormat("f(\"aaaa\"\n"
4701 " \"bbbb\");",
4702 Break);
4703
4704 // Treat literals with escaped newlines like multi-line string literals.
Alexander Kornienko657c67b2013-07-16 21:06:13 +00004705 EXPECT_EQ("x = \"a\\\n"
4706 "b\\\n"
4707 "c\";",
4708 format("x = \"a\\\n"
4709 "b\\\n"
4710 "c\";",
4711 NoBreak));
Daniel Jasper2aaedd32015-06-18 09:12:47 +00004712 EXPECT_EQ("xxxx =\n"
Alexander Kornienko657c67b2013-07-16 21:06:13 +00004713 " \"a\\\n"
4714 "b\\\n"
4715 "c\";",
Daniel Jasper2aaedd32015-06-18 09:12:47 +00004716 format("xxxx = \"a\\\n"
Alexander Kornienko657c67b2013-07-16 21:06:13 +00004717 "b\\\n"
4718 "c\";",
4719 Break));
Daniel Jasper27943052013-11-09 03:08:25 +00004720
4721 // Exempt ObjC strings for now.
4722 EXPECT_EQ("NSString *const kString = @\"aaaa\"\n"
Daniel Jasper015c7a92015-05-11 15:15:48 +00004723 " @\"bbbb\";",
Daniel Jasper27943052013-11-09 03:08:25 +00004724 format("NSString *const kString = @\"aaaa\"\n"
Daniel Jasper015c7a92015-05-11 15:15:48 +00004725 "@\"bbbb\";",
Daniel Jasper27943052013-11-09 03:08:25 +00004726 Break));
Daniel Jasper6fd5d642015-01-20 12:59:20 +00004727
4728 Break.ColumnLimit = 0;
4729 verifyFormat("const char *hello = \"hello llvm\";", Break);
Alexander Kornienko58611712013-07-04 12:02:44 +00004730}
4731
Alexander Kornienko578fdd82012-12-06 18:03:27 +00004732TEST_F(FormatTest, AlignsPipes) {
4733 verifyFormat(
4734 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4735 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4736 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
4737 verifyFormat(
4738 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
4739 " << aaaaaaaaaaaaaaaaaaaa;");
4740 verifyFormat(
4741 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4742 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
4743 verifyFormat(
4744 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
4745 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
4746 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";");
4747 verifyFormat(
4748 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4749 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4750 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jaspera44991332015-04-29 13:06:49 +00004751 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4752 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4753 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4754 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
Daniel Jasper2fd16632015-05-17 07:27:09 +00004755 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n"
4756 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);");
Daniel Jasper0e617842014-04-16 12:26:54 +00004757 verifyFormat(
4758 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4759 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper2603ee02013-02-04 07:34:48 +00004760
4761 verifyFormat("return out << \"somepacket = {\\n\"\n"
Manuel Klimek71814b42013-10-11 21:25:45 +00004762 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
4763 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
4764 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
4765 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
Daniel Jasper2603ee02013-02-04 07:34:48 +00004766 " << \"}\";");
Daniel Jasperba9ddb62013-02-06 21:04:05 +00004767
Daniel Jasper0d5e44d2013-07-15 14:12:30 +00004768 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
4769 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
4770 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;");
Daniel Jasperba9ddb62013-02-06 21:04:05 +00004771 verifyFormat(
4772 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
4773 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
4774 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
4775 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
4776 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;");
Daniel Jasperf38a0ac2013-03-14 14:00:17 +00004777 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
4778 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
Daniel Jasperfa21c072013-07-15 14:33:14 +00004779 verifyFormat(
4780 "void f() {\n"
4781 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n"
4782 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
4783 "}");
Daniel Jasperc0d606a2014-04-14 11:08:45 +00004784 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n"
4785 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();");
Daniel Jasper173504e2015-05-10 21:15:07 +00004786 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4787 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4788 " aaaaaaaaaaaaaaaaaaaaa)\n"
4789 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper5962fa82015-06-03 09:26:03 +00004790 verifyFormat("LOG_IF(aaa == //\n"
4791 " bbb)\n"
4792 " << a << b;");
Daniel Jasperc238c872013-04-02 14:33:13 +00004793
Daniel Jasper4e9678f2013-07-11 20:41:21 +00004794 // Breaking before the first "<<" is generally not desirable.
4795 verifyFormat(
4796 "llvm::errs()\n"
4797 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4798 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4799 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4800 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4801 getLLVMStyleWithColumns(70));
4802 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
4803 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4804 " << \"aaaaaaaaaaaaaaaaaaa: \"\n"
4805 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4806 " << \"aaaaaaaaaaaaaaaaaaa: \"\n"
4807 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4808 getLLVMStyleWithColumns(70));
4809
Daniel Jasper467ddb12013-08-12 12:58:05 +00004810 // But sometimes, breaking before the first "<<" is desirable.
Daniel Jasper004177e2013-12-19 16:06:40 +00004811 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
4812 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);");
Daniel Jasper77d5d312013-07-12 15:14:05 +00004813 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
4814 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4815 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper467ddb12013-08-12 12:58:05 +00004816 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
4817 " << BEF << IsTemplate << Description << E->getType();");
Daniel Jasper77d5d312013-07-12 15:14:05 +00004818
Daniel Jasperc238c872013-04-02 14:33:13 +00004819 verifyFormat(
4820 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4821 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper0b1f76b2013-09-29 12:02:57 +00004822
4823 // Incomplete string literal.
4824 EXPECT_EQ("llvm::errs() << \"\n"
4825 " << a;",
4826 format("llvm::errs() << \"\n<<a;"));
Manuel Klimek06c84f22013-11-20 11:20:32 +00004827
4828 verifyFormat("void f() {\n"
4829 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n"
4830 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n"
4831 "}");
Daniel Jasperd05d3a82015-01-08 13:56:57 +00004832
4833 // Handle 'endl'.
Daniel Jasper69963122015-02-17 10:05:15 +00004834 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n"
4835 " << bbbbbbbbbbbbbbbbbbbbbb << endl;");
4836 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00004837}
4838
Daniel Jasperf7935112012-12-03 18:12:45 +00004839TEST_F(FormatTest, UnderstandsEquals) {
4840 verifyFormat(
4841 "aaaaaaaaaaaaaaaaa =\n"
4842 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
4843 verifyFormat(
4844 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004845 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasperf7935112012-12-03 18:12:45 +00004846 verifyFormat(
4847 "if (a) {\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00004848 " f();\n"
Daniel Jasperf7935112012-12-03 18:12:45 +00004849 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004850 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
4851 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +00004852
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00004853 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
4854 " 100000000 + 10000000) {\n}");
Daniel Jasperf7935112012-12-03 18:12:45 +00004855}
4856
Daniel Jasper5485d0c2012-12-17 14:34:14 +00004857TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00004858 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
4859 " .looooooooooooooooooooooooooooooooooooooongFunction();");
Daniel Jasper5485d0c2012-12-17 14:34:14 +00004860
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00004861 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
4862 " ->looooooooooooooooooooooooooooooooooooooongFunction();");
Daniel Jasper5485d0c2012-12-17 14:34:14 +00004863
4864 verifyFormat(
4865 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
4866 " Parameter2);");
4867
4868 verifyFormat(
4869 "ShortObject->shortFunction(\n"
4870 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
4871 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);");
4872
4873 verifyFormat("loooooooooooooongFunction(\n"
4874 " LoooooooooooooongObject->looooooooooooooooongFunction());");
4875
4876 verifyFormat(
4877 "function(LoooooooooooooooooooooooooooooooooooongObject\n"
4878 " ->loooooooooooooooooooooooooooooooooooooooongFunction());");
4879
Daniel Jasper687af3b2013-02-14 14:26:07 +00004880 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
4881 " .WillRepeatedly(Return(SomeValue));");
Daniel Jasperd6f17d82014-09-12 16:35:28 +00004882 verifyFormat("void f() {\n"
4883 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
4884 " .Times(2)\n"
4885 " .WillRepeatedly(Return(SomeValue));\n"
4886 "}");
Daniel Jasper4d7a97a2014-01-10 08:40:17 +00004887 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n"
4888 " ccccccccccccccccccccccc);");
Daniel Jasper32a796b2013-05-27 11:50:16 +00004889 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper05cd9292015-03-26 18:46:28 +00004890 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4891 " .aaaaa(aaaaa),\n"
Daniel Jasper32a796b2013-05-27 11:50:16 +00004892 " aaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00004893 verifyFormat("void f() {\n"
4894 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4895 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n"
4896 "}");
Daniel Jaspera44991332015-04-29 13:06:49 +00004897 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4898 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4899 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4900 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4901 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jasperc238c872013-04-02 14:33:13 +00004902 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4903 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4904 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4905 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
4906 "}");
Daniel Jasper687af3b2013-02-14 14:26:07 +00004907
Daniel Jasperc7345cc2013-01-07 07:13:20 +00004908 // Here, it is not necessary to wrap at "." or "->".
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00004909 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004910 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasperc7345cc2013-01-07 07:13:20 +00004911 verifyFormat(
4912 "aaaaaaaaaaa->aaaaaaaaa(\n"
4913 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4914 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
Daniel Jaspere11095a2013-02-14 15:01:34 +00004915
4916 verifyFormat(
4917 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4918 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
Daniel Jasper8f6ae192013-03-13 15:37:48 +00004919 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
4920 " aaaaaaaaa()->aaaaaa()->aaaaa());");
4921 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
4922 " aaaaaaaaa()->aaaaaa()->aaaaa());");
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004923
Daniel Jasper9b334242013-03-15 14:57:30 +00004924 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper05cd9292015-03-26 18:46:28 +00004925 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4926 " .a();");
Daniel Jasper9b334242013-03-15 14:57:30 +00004927
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004928 FormatStyle NoBinPacking = getLLVMStyle();
4929 NoBinPacking.BinPackParameters = false;
4930 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
4931 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
4932 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
4933 " aaaaaaaaaaaaaaaaaaa,\n"
4934 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4935 NoBinPacking);
Daniel Jasperbd058882013-07-09 11:57:27 +00004936
4937 // If there is a subsequent call, change to hanging indentation.
4938 verifyFormat(
4939 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4940 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n"
4941 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
4942 verifyFormat(
4943 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4944 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));");
Daniel Jasper96964352013-12-18 10:44:36 +00004945 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4946 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4947 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
4948 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4949 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4950 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
Daniel Jasper5485d0c2012-12-17 14:34:14 +00004951}
4952
Daniel Jasperac5c1c22013-01-02 15:08:56 +00004953TEST_F(FormatTest, WrapsTemplateDeclarations) {
4954 verifyFormat("template <typename T>\n"
4955 "virtual void loooooooooooongFunction(int Param1, int Param2);");
Daniel Jasper69bd8fb2013-09-27 07:49:08 +00004956 verifyFormat("template <typename T>\n"
4957 "// T should be one of {A, B}.\n"
4958 "virtual void loooooooooooongFunction(int Param1, int Param2);");
Daniel Jasperac5c1c22013-01-02 15:08:56 +00004959 verifyFormat(
Daniel Jasper04468962013-01-18 10:56:38 +00004960 "template <typename T>\n"
Daniel Jasper400adc62013-02-08 15:28:42 +00004961 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;");
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00004962 verifyFormat("template <typename T>\n"
4963 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
4964 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);");
Daniel Jasperac5c1c22013-01-02 15:08:56 +00004965 verifyFormat(
4966 "template <typename T>\n"
4967 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
4968 " int Paaaaaaaaaaaaaaaaaaaaram2);");
Daniel Jasper90e51fd2013-01-02 18:30:06 +00004969 verifyFormat(
4970 "template <typename T>\n"
4971 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
4972 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
4973 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper89058942013-01-09 09:50:48 +00004974 verifyFormat("template <typename T>\n"
4975 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jaspera628c982013-04-03 13:36:17 +00004976 " int aaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperbcab4302013-01-09 10:40:23 +00004977 verifyFormat(
4978 "template <typename T1, typename T2 = char, typename T3 = char,\n"
4979 " typename T4 = char>\n"
4980 "void f();");
Daniel Jasper298c3402013-11-22 07:48:15 +00004981 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n"
4982 " template <typename> class cccccccccccccccccccccc,\n"
4983 " typename ddddddddddddd>\n"
4984 "class C {};");
Daniel Jasper7a31af12013-01-25 15:43:32 +00004985 verifyFormat(
4986 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
4987 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper3a9370c2013-02-04 07:21:18 +00004988
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00004989 verifyFormat("void f() {\n"
4990 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
4991 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n"
4992 "}");
Daniel Jasper61e6bbf2013-05-29 12:07:31 +00004993
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00004994 verifyFormat("template <typename T> class C {};");
Daniel Jasper61e6bbf2013-05-29 12:07:31 +00004995 verifyFormat("template <typename T> void f();");
4996 verifyFormat("template <typename T> void f() {}");
Daniel Jasper0e90c3d2013-07-05 09:14:35 +00004997 verifyFormat(
4998 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
4999 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5000 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
5001 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
5002 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5003 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
5004 " bbbbbbbbbbbbbbbbbbbbbbbb);",
5005 getLLVMStyleWithColumns(72));
Daniel Jasperfcfac102014-07-15 09:00:34 +00005006 EXPECT_EQ("static_cast<A< //\n"
5007 " B> *>(\n"
5008 "\n"
5009 " );",
5010 format("static_cast<A<//\n"
5011 " B>*>(\n"
5012 "\n"
5013 " );"));
Daniel Jasper598dd332014-08-12 13:22:26 +00005014 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5015 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);");
Daniel Jasper5c9e3cd2013-09-14 08:13:22 +00005016
5017 FormatStyle AlwaysBreak = getLLVMStyle();
5018 AlwaysBreak.AlwaysBreakTemplateDeclarations = true;
5019 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
5020 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
5021 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
5022 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5023 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
5024 " ccccccccccccccccccccccccccccccccccccccccccccccc);");
5025 verifyFormat("template <template <typename> class Fooooooo,\n"
5026 " template <typename> class Baaaaaaar>\n"
5027 "struct C {};",
5028 AlwaysBreak);
Daniel Jasperd3e014d2013-10-09 15:06:17 +00005029 verifyFormat("template <typename T> // T can be A, B or C.\n"
5030 "struct C {};",
5031 AlwaysBreak);
Daniel Jasperac5c1c22013-01-02 15:08:56 +00005032}
5033
Daniel Jasper45797022013-01-25 10:57:27 +00005034TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
5035 verifyFormat(
5036 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
5037 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5038 verifyFormat(
5039 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
5040 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5041 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
5042
Daniel Jasper0f0234e2013-05-08 10:00:18 +00005043 // FIXME: Should we have the extra indent after the second break?
Daniel Jasper45797022013-01-25 10:57:27 +00005044 verifyFormat(
5045 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
5046 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
Daniel Jasper0f0234e2013-05-08 10:00:18 +00005047 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper45797022013-01-25 10:57:27 +00005048
Daniel Jasper45797022013-01-25 10:57:27 +00005049 verifyFormat(
5050 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
Daniel Jasper4ad42352013-01-28 07:43:15 +00005051 " cccccccccccccccccccccccccccccccccccccccccccccc());");
Daniel Jasper45797022013-01-25 10:57:27 +00005052
5053 // Breaking at nested name specifiers is generally not desirable.
5054 verifyFormat(
5055 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5056 " aaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperca6623b2013-01-28 12:45:14 +00005057
5058 verifyFormat(
5059 "aaaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
5060 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5061 " aaaaaaaaaaaaaaaaaaaaa);",
5062 getLLVMStyleWithColumns(74));
Daniel Jasperc238c872013-04-02 14:33:13 +00005063
5064 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
5065 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5066 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper45797022013-01-25 10:57:27 +00005067}
5068
Daniel Jasperf7935112012-12-03 18:12:45 +00005069TEST_F(FormatTest, UnderstandsTemplateParameters) {
5070 verifyFormat("A<int> a;");
Chandler Carruthf8b72662014-03-02 12:37:31 +00005071 verifyFormat("A<A<A<int>>> a;");
Daniel Jasperf7935112012-12-03 18:12:45 +00005072 verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
5073 verifyFormat("bool x = a < 1 || 2 > a;");
5074 verifyFormat("bool x = 5 < f<int>();");
5075 verifyFormat("bool x = f<int>() > 5;");
5076 verifyFormat("bool x = 5 < a<int>::x;");
5077 verifyFormat("bool x = a < 4 ? a > 2 : false;");
5078 verifyFormat("bool x = f() ? a < 2 : a > 2;");
5079
5080 verifyGoogleFormat("A<A<int>> a;");
5081 verifyGoogleFormat("A<A<A<int>>> a;");
5082 verifyGoogleFormat("A<A<A<A<int>>>> a;");
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005083 verifyGoogleFormat("A<A<int> > a;");
5084 verifyGoogleFormat("A<A<A<int> > > a;");
5085 verifyGoogleFormat("A<A<A<A<int> > > > a;");
Daniel Jasperfba84ff2013-10-12 05:16:06 +00005086 verifyGoogleFormat("A<::A<int>> a;");
5087 verifyGoogleFormat("A<::A> a;");
5088 verifyGoogleFormat("A< ::A> a;");
5089 verifyGoogleFormat("A< ::A<int> > a;");
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005090 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
5091 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
Daniel Jasperfba84ff2013-10-12 05:16:06 +00005092 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle()));
5093 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle()));
Daniel Jasperf7935112012-12-03 18:12:45 +00005094
Nico Weber7533b4d2014-09-24 17:17:32 +00005095 verifyFormat("A<A>> a;", getChromiumStyle(FormatStyle::LK_Cpp));
5096
Daniel Jasperf7935112012-12-03 18:12:45 +00005097 verifyFormat("test >> a >> b;");
5098 verifyFormat("test << a >> b;");
5099
5100 verifyFormat("f<int>();");
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005101 verifyFormat("template <typename T> void f() {}");
Daniel Jasperb13135b2015-01-08 08:48:21 +00005102 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;");
Daniel Jasper112b50e2015-05-06 14:53:50 +00005103 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : "
5104 "sizeof(char)>::type>;");
Daniel Jasperadba2aa2015-05-18 12:52:00 +00005105 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};");
Daniel Jasperd5893912013-06-01 18:56:00 +00005106
5107 // Not template parameters.
5108 verifyFormat("return a < b && c > d;");
5109 verifyFormat("void f() {\n"
5110 " while (a < b && c > d) {\n"
5111 " }\n"
5112 "}");
Daniel Jasper62c0ac02013-07-30 22:37:19 +00005113 verifyFormat("template <typename... Types>\n"
5114 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}");
Daniel Jasper0de8efa2013-09-17 08:15:46 +00005115
5116 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5117 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);",
5118 getLLVMStyleWithColumns(60));
Daniel Jasper6ba16382014-07-28 13:19:58 +00005119 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");");
Daniel Jasper65df5aa2014-08-04 14:51:02 +00005120 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}");
Daniel Jasper4d9ec172015-05-06 08:38:24 +00005121 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <");
Daniel Jasperf7935112012-12-03 18:12:45 +00005122}
5123
Daniel Jasperd8ffcfa2013-02-28 09:21:10 +00005124TEST_F(FormatTest, UnderstandsBinaryOperators) {
5125 verifyFormat("COMPARE(a, ==, b);");
Alexander Kornienko674be0a2013-03-20 16:41:56 +00005126}
5127
5128TEST_F(FormatTest, UnderstandsPointersToMembers) {
5129 verifyFormat("int A::*x;");
Daniel Jaspercfda5172013-05-08 14:58:20 +00005130 verifyFormat("int (S::*func)(void *);");
Daniel Jasper37194282013-05-28 08:33:00 +00005131 verifyFormat("void f() { int (S::*func)(void *); }");
Daniel Jasper2f34cac2013-05-08 15:06:58 +00005132 verifyFormat("typedef bool *(Class::*Member)() const;");
Daniel Jaspercfda5172013-05-08 14:58:20 +00005133 verifyFormat("void f() {\n"
5134 " (a->*f)();\n"
5135 " a->*x;\n"
5136 " (a.*f)();\n"
5137 " ((*a).*f)();\n"
5138 " a.*x;\n"
5139 "}");
Daniel Jasper998cabc2013-07-18 14:46:07 +00005140 verifyFormat("void f() {\n"
5141 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
5142 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n"
5143 "}");
Daniel Jasper85bcadc2014-07-09 13:07:57 +00005144 verifyFormat(
5145 "(aaaaaaaaaa->*bbbbbbb)(\n"
5146 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jasper2f34cac2013-05-08 15:06:58 +00005147 FormatStyle Style = getLLVMStyle();
Daniel Jasper553d4872014-06-17 12:40:34 +00005148 Style.PointerAlignment = FormatStyle::PAS_Left;
Daniel Jasper2f34cac2013-05-08 15:06:58 +00005149 verifyFormat("typedef bool* (Class::*Member)() const;", Style);
Daniel Jasperd8ffcfa2013-02-28 09:21:10 +00005150}
5151
Daniel Jasper8dd40472012-12-21 09:41:31 +00005152TEST_F(FormatTest, UnderstandsUnaryOperators) {
Daniel Jasperf7935112012-12-03 18:12:45 +00005153 verifyFormat("int a = -2;");
Daniel Jasper8b529712012-12-04 13:02:32 +00005154 verifyFormat("f(-1, -2, -3);");
5155 verifyFormat("a[-1] = 5;");
5156 verifyFormat("int a = 5 + -2;");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00005157 verifyFormat("if (i == -1) {\n}");
5158 verifyFormat("if (i != -1) {\n}");
5159 verifyFormat("if (i > -1) {\n}");
5160 verifyFormat("if (i < -1) {\n}");
Daniel Jasper26333c32012-12-06 13:16:39 +00005161 verifyFormat("++(a->f());");
5162 verifyFormat("--(a->f());");
Daniel Jasper13f23e12013-01-14 12:18:19 +00005163 verifyFormat("(a->f())++;");
5164 verifyFormat("a[42]++;");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00005165 verifyFormat("if (!(a->f())) {\n}");
Daniel Jasper8dd40472012-12-21 09:41:31 +00005166
5167 verifyFormat("a-- > b;");
5168 verifyFormat("b ? -a : c;");
5169 verifyFormat("n * sizeof char16;");
Alexander Kornienko1e808872013-06-28 12:51:24 +00005170 verifyFormat("n * alignof char16;", getGoogleStyle());
Daniel Jasper8dd40472012-12-21 09:41:31 +00005171 verifyFormat("sizeof(char);");
Alexander Kornienko1e808872013-06-28 12:51:24 +00005172 verifyFormat("alignof(char);", getGoogleStyle());
Daniel Jasperda1c68a2013-01-02 15:26:16 +00005173
5174 verifyFormat("return -1;");
5175 verifyFormat("switch (a) {\n"
5176 "case -1:\n"
5177 " break;\n"
5178 "}");
Daniel Jasper399d1ee2013-03-22 10:44:43 +00005179 verifyFormat("#define X -1");
5180 verifyFormat("#define X -kConstant");
Nico Weber63a54eb2013-01-12 05:41:23 +00005181
Chandler Carruthf8b72662014-03-02 12:37:31 +00005182 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};");
5183 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};");
Daniel Jasper71945272013-01-15 14:27:39 +00005184
5185 verifyFormat("int a = /* confusing comment */ -1;");
5186 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case.
5187 verifyFormat("int a = i /* confusing comment */++;");
Daniel Jasperf7935112012-12-03 18:12:45 +00005188}
5189
Daniel Jasper0c214fa2014-02-05 13:43:04 +00005190TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) {
Daniel Jasperf110e202013-08-21 08:39:01 +00005191 verifyFormat("if (!aaaaaaaaaa( // break\n"
Daniel Jasper0c214fa2014-02-05 13:43:04 +00005192 " aaaaa)) {\n"
Daniel Jasperf110e202013-08-21 08:39:01 +00005193 "}");
5194 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
Daniel Jasper739b85f2015-06-29 10:42:59 +00005195 " aaaaa));");
Daniel Jasper0649d362013-08-23 15:14:03 +00005196 verifyFormat("*aaa = aaaaaaa( // break\n"
5197 " bbbbbb);");
Daniel Jasperf110e202013-08-21 08:39:01 +00005198}
5199
Daniel Jasper8863ada2013-08-26 08:10:17 +00005200TEST_F(FormatTest, UnderstandsOverloadedOperators) {
Daniel Jasper537a2962012-12-24 10:56:04 +00005201 verifyFormat("bool operator<();");
5202 verifyFormat("bool operator>();");
5203 verifyFormat("bool operator=();");
5204 verifyFormat("bool operator==();");
5205 verifyFormat("bool operator!=();");
5206 verifyFormat("int operator+();");
5207 verifyFormat("int operator++();");
5208 verifyFormat("bool operator();");
5209 verifyFormat("bool operator()();");
5210 verifyFormat("bool operator[]();");
5211 verifyFormat("operator bool();");
Daniel Jasper35d2dc72013-02-11 08:01:18 +00005212 verifyFormat("operator int();");
5213 verifyFormat("operator void *();");
Daniel Jasper537a2962012-12-24 10:56:04 +00005214 verifyFormat("operator SomeType<int>();");
Daniel Jasper35d2dc72013-02-11 08:01:18 +00005215 verifyFormat("operator SomeType<int, int>();");
Chandler Carruthf8b72662014-03-02 12:37:31 +00005216 verifyFormat("operator SomeType<SomeType<int>>();");
Daniel Jasper537a2962012-12-24 10:56:04 +00005217 verifyFormat("void *operator new(std::size_t size);");
5218 verifyFormat("void *operator new[](std::size_t size);");
5219 verifyFormat("void operator delete(void *ptr);");
5220 verifyFormat("void operator delete[](void *ptr);");
Daniel Jasper8f9624b2013-05-10 07:59:58 +00005221 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
5222 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);");
Daniel Jasper35d2dc72013-02-11 08:01:18 +00005223
Daniel Jasper0af92eb2013-02-15 19:24:08 +00005224 verifyFormat(
5225 "ostream &operator<<(ostream &OutputStream,\n"
5226 " SomeReallyLongType WithSomeReallyLongValue);");
Daniel Jasper54ac8202013-04-05 17:21:59 +00005227 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
5228 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
5229 " return left.group < right.group;\n"
5230 "}");
Daniel Jasper6e8f4ed2013-04-11 08:48:20 +00005231 verifyFormat("SomeType &operator=(const SomeType &S);");
Daniel Jasper8835a322014-10-20 13:56:30 +00005232 verifyFormat("f.template operator()<int>();");
Daniel Jasper0af92eb2013-02-15 19:24:08 +00005233
Daniel Jasper35d2dc72013-02-11 08:01:18 +00005234 verifyGoogleFormat("operator void*();");
5235 verifyGoogleFormat("operator SomeType<SomeType<int>>();");
Daniel Jasperedc5f092013-10-29 12:24:23 +00005236 verifyGoogleFormat("operator ::A();");
Daniel Jasper42401c82013-09-02 09:20:39 +00005237
5238 verifyFormat("using A::operator+;");
Daniel Jasperff974ab2014-01-25 09:16:02 +00005239
Daniel Jasper2520fe92014-06-30 13:54:27 +00005240 verifyFormat("string // break\n"
5241 "operator()() & {}");
5242 verifyFormat("string // break\n"
5243 "operator()() && {}");
Daniel Jasperf7935112012-12-03 18:12:45 +00005244}
5245
Daniel Jasper1c220482015-02-25 10:30:06 +00005246TEST_F(FormatTest, UnderstandsFunctionRefQualification) {
5247 verifyFormat("Deleted &operator=(const Deleted &)& = default;");
5248 verifyFormat("Deleted &operator=(const Deleted &)&& = delete;");
5249 verifyFormat("SomeType MemberFunction(const Deleted &)& = delete;");
5250 verifyFormat("SomeType MemberFunction(const Deleted &)&& = delete;");
5251 verifyFormat("Deleted &operator=(const Deleted &)&;");
5252 verifyFormat("Deleted &operator=(const Deleted &)&&;");
5253 verifyFormat("SomeType MemberFunction(const Deleted &)&;");
5254 verifyFormat("SomeType MemberFunction(const Deleted &)&&;");
5255
5256 verifyGoogleFormat("Deleted& operator=(const Deleted&)& = default;");
5257 verifyGoogleFormat("SomeType MemberFunction(const Deleted&)& = delete;");
5258 verifyGoogleFormat("Deleted& operator=(const Deleted&)&;");
5259 verifyGoogleFormat("SomeType MemberFunction(const Deleted&)&;");
5260
5261 FormatStyle Spaces = getLLVMStyle();
5262 Spaces.SpacesInCStyleCastParentheses = true;
5263 verifyFormat("Deleted &operator=(const Deleted &)& = default;", Spaces);
5264 verifyFormat("SomeType MemberFunction(const Deleted &)& = delete;", Spaces);
5265 verifyFormat("Deleted &operator=(const Deleted &)&;", Spaces);
5266 verifyFormat("SomeType MemberFunction(const Deleted &)&;", Spaces);
5267
5268 Spaces.SpacesInCStyleCastParentheses = false;
5269 Spaces.SpacesInParentheses = true;
5270 verifyFormat("Deleted &operator=( const Deleted & )& = default;", Spaces);
5271 verifyFormat("SomeType MemberFunction( const Deleted & )& = delete;", Spaces);
5272 verifyFormat("Deleted &operator=( const Deleted & )&;", Spaces);
5273 verifyFormat("SomeType MemberFunction( const Deleted & )&;", Spaces);
5274}
5275
Daniel Jasperd6a947f2013-01-11 16:09:04 +00005276TEST_F(FormatTest, UnderstandsNewAndDelete) {
Daniel Jasperba0bda92013-02-23 08:07:18 +00005277 verifyFormat("void f() {\n"
5278 " A *a = new A;\n"
5279 " A *a = new (placement) A;\n"
5280 " delete a;\n"
5281 " delete (A *)a;\n"
5282 "}");
Daniel Jasper71646ec2014-07-30 12:14:10 +00005283 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
5284 " typename aaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper316ab382014-08-06 13:14:58 +00005285 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5286 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
5287 " typename aaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper80222262014-11-02 22:46:42 +00005288 verifyFormat("delete[] h->p;");
Daniel Jasperd6a947f2013-01-11 16:09:04 +00005289}
5290
Daniel Jasper22bcf8a2013-01-02 08:57:10 +00005291TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005292 verifyFormat("int *f(int *a) {}");
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005293 verifyFormat("int main(int argc, char **argv) {}");
Daniel Jasper5065bc42013-02-18 12:44:35 +00005294 verifyFormat("Test::Test(int b) : a(b * b) {}");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005295 verifyIndependentOfContext("f(a, *a);");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005296 verifyFormat("void g() { f(*a); }");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005297 verifyIndependentOfContext("int a = b * 10;");
5298 verifyIndependentOfContext("int a = 10 * b;");
5299 verifyIndependentOfContext("int a = b * c;");
5300 verifyIndependentOfContext("int a += b * c;");
5301 verifyIndependentOfContext("int a -= b * c;");
5302 verifyIndependentOfContext("int a *= b * c;");
5303 verifyIndependentOfContext("int a /= b * c;");
5304 verifyIndependentOfContext("int a = *b;");
5305 verifyIndependentOfContext("int a = *b * c;");
5306 verifyIndependentOfContext("int a = b * *c;");
Daniel Jasper93101662015-05-19 12:29:27 +00005307 verifyIndependentOfContext("int a = b * (10);");
5308 verifyIndependentOfContext("S << b * (10);");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005309 verifyIndependentOfContext("return 10 * b;");
5310 verifyIndependentOfContext("return *b * *c;");
5311 verifyIndependentOfContext("return a & ~b;");
5312 verifyIndependentOfContext("f(b ? *c : *d);");
5313 verifyIndependentOfContext("int a = b ? *c : *d;");
5314 verifyIndependentOfContext("*b = a;");
5315 verifyIndependentOfContext("a * ~b;");
5316 verifyIndependentOfContext("a * !b;");
5317 verifyIndependentOfContext("a * +b;");
5318 verifyIndependentOfContext("a * -b;");
5319 verifyIndependentOfContext("a * ++b;");
5320 verifyIndependentOfContext("a * --b;");
5321 verifyIndependentOfContext("a[4] * b;");
Daniel Jasper8e559272013-02-27 11:43:50 +00005322 verifyIndependentOfContext("a[a * a] = 1;");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005323 verifyIndependentOfContext("f() * b;");
5324 verifyIndependentOfContext("a * [self dostuff];");
Daniel Jasper6e42b1e2013-04-01 17:13:26 +00005325 verifyIndependentOfContext("int x = a * (a + b);");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005326 verifyIndependentOfContext("(a *)(a + b);");
Daniel Jasper942d9712014-04-28 09:19:28 +00005327 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005328 verifyIndependentOfContext("int *pa = (int *)&a;");
Nico Weber44449172013-02-12 16:17:07 +00005329 verifyIndependentOfContext("return sizeof(int **);");
5330 verifyIndependentOfContext("return sizeof(int ******);");
5331 verifyIndependentOfContext("return (int **&)a;");
Daniel Jasper4d03d3b2013-05-28 15:27:10 +00005332 verifyIndependentOfContext("f((*PointerToArray)[10]);");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005333 verifyFormat("void f(Type (*parameter)[10]) {}");
Nico Weber44449172013-02-12 16:17:07 +00005334 verifyGoogleFormat("return sizeof(int**);");
5335 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);");
5336 verifyGoogleFormat("Type** A = static_cast<Type**>(P);");
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00005337 verifyFormat("auto a = [](int **&, int ***) {};");
Daniel Jasperd46e07e2013-10-20 18:15:30 +00005338 verifyFormat("auto PointerBinding = [](const char *S) {};");
Daniel Jasper71665cd2013-09-10 10:26:38 +00005339 verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
Daniel Jasper4ac7de72014-06-11 07:35:16 +00005340 verifyFormat("[](const decltype(*a) &value) {}");
Daniel Jasper99b5a462015-05-12 10:20:32 +00005341 verifyFormat("#define MACRO() [](A *a) { return 1; }");
Daniel Jasper3682fcd2013-12-16 08:36:18 +00005342 verifyIndependentOfContext("typedef void (*f)(int *a);");
Daniel Jasper39485162014-05-22 09:00:33 +00005343 verifyIndependentOfContext("int i{a * b};");
Daniel Jasper7d028292014-06-02 11:54:20 +00005344 verifyIndependentOfContext("aaa && aaa->f();");
Daniel Jasper2ac3fdf2014-07-28 12:08:16 +00005345 verifyIndependentOfContext("int x = ~*p;");
Daniel Jasperd127e3b2014-11-14 17:26:49 +00005346 verifyFormat("Constructor() : a(a), area(width * height) {}");
Daniel Jaspere1e348b2014-11-17 18:42:22 +00005347 verifyFormat("Constructor() : a(a), area(a, width * height) {}");
Daniel Jaspere4ab49e2015-04-20 12:54:29 +00005348 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}");
Daniel Jasper6a3fd832014-11-17 13:55:04 +00005349 verifyFormat("void f() { f(a, c * d); }");
Daniel Jasper3a26a8d2015-05-13 12:54:30 +00005350 verifyFormat("void f() { f(new a(), c * d); }");
Daniel Jasper27234032012-12-07 09:52:15 +00005351
Daniel Jasper5b49f472013-01-23 12:10:53 +00005352 verifyIndependentOfContext("InvalidRegions[*R] = 0;");
Daniel Jasper3c2557d2013-01-04 20:46:38 +00005353
Daniel Jasper5b49f472013-01-23 12:10:53 +00005354 verifyIndependentOfContext("A<int *> a;");
5355 verifyIndependentOfContext("A<int **> a;");
5356 verifyIndependentOfContext("A<int *, int *> a;");
Daniel Jasper139d4a32014-04-08 13:07:41 +00005357 verifyIndependentOfContext("A<int *[]> a;");
Daniel Jasperc697ad22013-02-06 10:05:46 +00005358 verifyIndependentOfContext(
5359 "const char *const p = reinterpret_cast<const char *const>(q);");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005360 verifyIndependentOfContext("A<int **, int **> a;");
Daniel Jasper8035b0a2013-02-06 10:57:42 +00005361 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);");
Daniel Jasperae907642013-03-14 10:50:25 +00005362 verifyFormat("for (char **a = b; *a; ++a) {\n}");
Daniel Jasperc37de302013-05-03 14:41:24 +00005363 verifyFormat("for (; a && b;) {\n}");
Daniel Jasperea2d0422014-05-08 08:50:10 +00005364 verifyFormat("bool foo = true && [] { return false; }();");
Daniel Jaspera4396862012-12-10 18:59:13 +00005365
Daniel Jasper66dcb1c2013-01-08 20:03:18 +00005366 verifyFormat(
5367 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5368 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5369
Daniel Jasper6a968202015-01-07 12:19:53 +00005370 verifyGoogleFormat("**outparam = 1;");
Daniel Jasper75092162015-01-23 19:04:49 +00005371 verifyGoogleFormat("*outparam = a * b;");
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005372 verifyGoogleFormat("int main(int argc, char** argv) {}");
Daniel Jaspera4396862012-12-10 18:59:13 +00005373 verifyGoogleFormat("A<int*> a;");
5374 verifyGoogleFormat("A<int**> a;");
5375 verifyGoogleFormat("A<int*, int*> a;");
5376 verifyGoogleFormat("A<int**, int**> a;");
Daniel Jasper22bcf8a2013-01-02 08:57:10 +00005377 verifyGoogleFormat("f(b ? *c : *d);");
5378 verifyGoogleFormat("int a = b ? *c : *d;");
Daniel Jaspera1dc93a2013-01-16 16:04:06 +00005379 verifyGoogleFormat("Type* t = **x;");
5380 verifyGoogleFormat("Type* t = *++*x;");
5381 verifyGoogleFormat("*++*x;");
5382 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);");
5383 verifyGoogleFormat("Type* t = x++ * y;");
Daniel Jasperc697ad22013-02-06 10:05:46 +00005384 verifyGoogleFormat(
5385 "const char* const p = reinterpret_cast<const char* const>(q);");
Daniel Jasper8184d662014-07-28 12:24:21 +00005386 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);");
Daniel Jasper0bd9a192014-11-10 16:57:30 +00005387 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);");
5388 verifyGoogleFormat("template <typename T>\n"
5389 "void f(int i = 0, SomeType** temps = NULL);");
Manuel Klimek557811f2013-01-14 10:58:01 +00005390
Daniel Jasper1904e9b2014-08-14 10:53:19 +00005391 FormatStyle Left = getLLVMStyle();
5392 Left.PointerAlignment = FormatStyle::PAS_Left;
5393 verifyFormat("x = *a(x) = *a(y);", Left);
5394
Daniel Jasper5b49f472013-01-23 12:10:53 +00005395 verifyIndependentOfContext("a = *(x + y);");
5396 verifyIndependentOfContext("a = &(x + y);");
5397 verifyIndependentOfContext("*(x + y).call();");
5398 verifyIndependentOfContext("&(x + y)->call();");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005399 verifyFormat("void f() { &(*I).first; }");
Daniel Jasper71945272013-01-15 14:27:39 +00005400
Daniel Jasper5b49f472013-01-23 12:10:53 +00005401 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
Daniel Jasper71945272013-01-15 14:27:39 +00005402 verifyFormat(
Daniel Jasperf9fc2152014-04-09 13:18:49 +00005403 "int *MyValues = {\n"
5404 " *A, // Operator detection might be confused by the '{'\n"
5405 " *BB // Operator detection might be confused by previous comment\n"
Daniel Jasper71945272013-01-15 14:27:39 +00005406 "};");
Nico Weber80a82762013-01-17 17:17:19 +00005407
Daniel Jasper5b49f472013-01-23 12:10:53 +00005408 verifyIndependentOfContext("if (int *a = &b)");
5409 verifyIndependentOfContext("if (int &a = *b)");
5410 verifyIndependentOfContext("if (a & b[i])");
5411 verifyIndependentOfContext("if (a::b::c::d & b[i])");
5412 verifyIndependentOfContext("if (*b[i])");
5413 verifyIndependentOfContext("if (int *a = (&b))");
5414 verifyIndependentOfContext("while (int *a = &b)");
Daniel Jasperdf620b22013-09-21 17:31:51 +00005415 verifyIndependentOfContext("size = sizeof *a;");
Daniel Jasperdc4f7252015-03-11 12:59:49 +00005416 verifyIndependentOfContext("if (a && (b = c))");
Daniel Jasper420d7d32013-01-23 12:58:14 +00005417 verifyFormat("void f() {\n"
5418 " for (const int &v : Values) {\n"
5419 " }\n"
5420 "}");
Daniel Jasper5065bc42013-02-18 12:44:35 +00005421 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
5422 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
Daniel Jasper5ca9b712013-09-11 20:37:10 +00005423 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}");
Daniel Jasper0b820602013-01-22 11:46:26 +00005424
Daniel Jaspera98da3d2013-11-07 19:56:07 +00005425 verifyFormat("#define A (!a * b)");
Daniel Jasperb910bbb2013-05-13 07:14:40 +00005426 verifyFormat("#define MACRO \\\n"
5427 " int *i = a * b; \\\n"
5428 " void f(a *b);",
5429 getLLVMStyleWithColumns(19));
5430
Daniel Jasper97b89482013-03-13 07:49:51 +00005431 verifyIndependentOfContext("A = new SomeType *[Length];");
Daniel Jasper5b49f472013-01-23 12:10:53 +00005432 verifyIndependentOfContext("A = new SomeType *[Length]();");
Daniel Jasper6f9c8d22013-07-05 13:30:40 +00005433 verifyIndependentOfContext("T **t = new T *;");
5434 verifyIndependentOfContext("T **t = new T *();");
Daniel Jasper532a0312015-04-23 10:23:53 +00005435 verifyGoogleFormat("A = new SomeType*[Length]();");
5436 verifyGoogleFormat("A = new SomeType*[Length];");
Daniel Jasper6f9c8d22013-07-05 13:30:40 +00005437 verifyGoogleFormat("T** t = new T*;");
5438 verifyGoogleFormat("T** t = new T*();");
Daniel Jasperb910bbb2013-05-13 07:14:40 +00005439
Daniel Jasper990ff972013-05-07 14:17:18 +00005440 FormatStyle PointerLeft = getLLVMStyle();
Daniel Jasper553d4872014-06-17 12:40:34 +00005441 PointerLeft.PointerAlignment = FormatStyle::PAS_Left;
Daniel Jasper990ff972013-05-07 14:17:18 +00005442 verifyFormat("delete *x;", PointerLeft);
Daniel Jaspera65e8872014-03-25 10:52:45 +00005443 verifyFormat("STATIC_ASSERT((a & b) == 0);");
5444 verifyFormat("STATIC_ASSERT(0 == (a & b));");
Manuel Klimekf81e5c02014-03-27 11:17:36 +00005445 verifyFormat("template <bool a, bool b> "
Daniel Jasper4afc6b32014-06-02 10:57:55 +00005446 "typename t::if<x && y>::type f() {}");
5447 verifyFormat("template <int *y> f() {}");
Manuel Klimekf81e5c02014-03-27 11:17:36 +00005448 verifyFormat("vector<int *> v;");
5449 verifyFormat("vector<int *const> v;");
5450 verifyFormat("vector<int *const **const *> v;");
5451 verifyFormat("vector<int *volatile> v;");
5452 verifyFormat("vector<a * b> v;");
Manuel Klimek1f9d80a2014-03-27 19:00:52 +00005453 verifyFormat("foo<b && false>();");
5454 verifyFormat("foo<b & 1>();");
Daniel Jasper73e171f2014-08-29 12:54:38 +00005455 verifyFormat("decltype(*::std::declval<const T &>()) void F();");
Daniel Jasper13a7f462014-10-28 18:11:52 +00005456 verifyFormat(
5457 "template <class T, class = typename std::enable_if<\n"
5458 " std::is_integral<T>::value &&\n"
5459 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n"
Daniel Jasperf0c809a2014-10-28 18:28:22 +00005460 "void F();",
5461 getLLVMStyleWithColumns(76));
5462 verifyFormat(
5463 "template <class T,\n"
5464 " class = typename ::std::enable_if<\n"
5465 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n"
5466 "void F();",
5467 getGoogleStyleWithColumns(68));
Manuel Klimek1f9d80a2014-03-27 19:00:52 +00005468
Daniel Jaspercc7bf7f2014-04-03 09:00:49 +00005469 verifyIndependentOfContext("MACRO(int *i);");
5470 verifyIndependentOfContext("MACRO(auto *a);");
5471 verifyIndependentOfContext("MACRO(const A *a);");
Daniel Jasper91beebd2014-06-30 13:44:47 +00005472 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');");
Daniel Jaspercc7bf7f2014-04-03 09:00:49 +00005473 // FIXME: Is there a way to make this work?
5474 // verifyIndependentOfContext("MACRO(A *a);");
5475
Daniel Jasper32ccb032014-06-23 07:36:18 +00005476 verifyFormat("DatumHandle const *operator->() const { return input_; }");
5477
Daniel Jasper866468a2014-04-14 13:15:29 +00005478 EXPECT_EQ("#define OP(x) \\\n"
5479 " ostream &operator<<(ostream &s, const A &a) { \\\n"
5480 " return s << a.DebugString(); \\\n"
5481 " }",
5482 format("#define OP(x) \\\n"
5483 " ostream &operator<<(ostream &s, const A &a) { \\\n"
5484 " return s << a.DebugString(); \\\n"
5485 " }",
5486 getLLVMStyleWithColumns(50)));
5487
Manuel Klimek1f9d80a2014-03-27 19:00:52 +00005488 // FIXME: We cannot handle this case yet; we might be able to figure out that
5489 // foo<x> d > v; doesn't make sense.
Daniel Jasper6ba16382014-07-28 13:19:58 +00005490 verifyFormat("foo<a<b && c> d> v;");
Daniel Jasper553d4872014-06-17 12:40:34 +00005491
5492 FormatStyle PointerMiddle = getLLVMStyle();
5493 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
5494 verifyFormat("delete *x;", PointerMiddle);
5495 verifyFormat("int * x;", PointerMiddle);
5496 verifyFormat("template <int * y> f() {}", PointerMiddle);
5497 verifyFormat("int * f(int * a) {}", PointerMiddle);
5498 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle);
5499 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle);
5500 verifyFormat("A<int *> a;", PointerMiddle);
5501 verifyFormat("A<int **> a;", PointerMiddle);
5502 verifyFormat("A<int *, int *> a;", PointerMiddle);
5503 verifyFormat("A<int * []> a;", PointerMiddle);
Daniel Jasper532a0312015-04-23 10:23:53 +00005504 verifyFormat("A = new SomeType *[Length]();", PointerMiddle);
5505 verifyFormat("A = new SomeType *[Length];", PointerMiddle);
Daniel Jasper553d4872014-06-17 12:40:34 +00005506 verifyFormat("T ** t = new T *;", PointerMiddle);
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005507}
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005508
Daniel Jasperee6d6502013-07-17 20:25:02 +00005509TEST_F(FormatTest, UnderstandsAttributes) {
5510 verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
Daniel Jasper559b63c2014-01-28 20:13:43 +00005511 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
5512 "aaaaaaaaaaaaaaaaaaaaaaa(int i);");
Daniel Jasperee6d6502013-07-17 20:25:02 +00005513}
5514
Daniel Jasper10cd5812013-05-06 06:35:44 +00005515TEST_F(FormatTest, UnderstandsEllipsis) {
5516 verifyFormat("int printf(const char *fmt, ...);");
5517 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
Daniel Jasperbafa6b72013-07-01 09:47:25 +00005518 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}");
5519
5520 FormatStyle PointersLeft = getLLVMStyle();
Daniel Jasper553d4872014-06-17 12:40:34 +00005521 PointersLeft.PointerAlignment = FormatStyle::PAS_Left;
Daniel Jasperbafa6b72013-07-01 09:47:25 +00005522 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft);
Daniel Jasper10cd5812013-05-06 06:35:44 +00005523}
5524
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005525TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005526 EXPECT_EQ("int *a;\n"
5527 "int *a;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005528 "int *a;",
5529 format("int *a;\n"
5530 "int* a;\n"
5531 "int *a;",
5532 getGoogleStyle()));
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005533 EXPECT_EQ("int* a;\n"
5534 "int* a;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005535 "int* a;",
5536 format("int* a;\n"
5537 "int* a;\n"
5538 "int *a;",
5539 getGoogleStyle()));
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00005540 EXPECT_EQ("int *a;\n"
5541 "int *a;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005542 "int *a;",
5543 format("int *a;\n"
5544 "int * a;\n"
5545 "int * a;",
5546 getGoogleStyle()));
Daniel Jasperf7935112012-12-03 18:12:45 +00005547}
5548
Alexander Kornienkoa5151272013-03-12 16:28:18 +00005549TEST_F(FormatTest, UnderstandsRvalueReferences) {
5550 verifyFormat("int f(int &&a) {}");
5551 verifyFormat("int f(int a, char &&b) {}");
5552 verifyFormat("void f() { int &&a = b; }");
5553 verifyGoogleFormat("int f(int a, char&& b) {}");
5554 verifyGoogleFormat("void f() { int&& a = b; }");
5555
Daniel Jasper1eff9082013-05-27 16:36:33 +00005556 verifyIndependentOfContext("A<int &&> a;");
5557 verifyIndependentOfContext("A<int &&, int &&> a;");
5558 verifyGoogleFormat("A<int&&> a;");
5559 verifyGoogleFormat("A<int&&, int&&> a;");
Daniel Jasper8b1c6352013-08-01 17:58:23 +00005560
5561 // Not rvalue references:
5562 verifyFormat("template <bool B, bool C> class A {\n"
5563 " static_assert(B && C, \"Something is wrong\");\n"
5564 "};");
Daniel Jasper29a98cf2013-08-13 09:09:09 +00005565 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))");
5566 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))");
Daniel Jasper72ab43b2014-04-14 12:50:02 +00005567 verifyFormat("#define A(a, b) (a && b)");
Alexander Kornienkoa5151272013-03-12 16:28:18 +00005568}
5569
Manuel Klimekc1237a82013-01-23 14:08:21 +00005570TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
5571 verifyFormat("void f() {\n"
5572 " x[aaaaaaaaa -\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00005573 " b] = 23;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005574 "}",
5575 getLLVMStyleWithColumns(15));
Manuel Klimekc1237a82013-01-23 14:08:21 +00005576}
5577
Daniel Jasperef906a92013-01-13 08:01:36 +00005578TEST_F(FormatTest, FormatsCasts) {
5579 verifyFormat("Type *A = static_cast<Type *>(P);");
5580 verifyFormat("Type *A = (Type *)P;");
5581 verifyFormat("Type *A = (vector<Type *, int *>)P;");
5582 verifyFormat("int a = (int)(2.0f);");
Daniel Jasperda6f2252013-05-31 16:14:28 +00005583 verifyFormat("int a = (int)2.0f;");
5584 verifyFormat("x[(int32)y];");
5585 verifyFormat("x = (int32)y;");
5586 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
5587 verifyFormat("int a = (int)*b;");
5588 verifyFormat("int a = (int)2.0f;");
5589 verifyFormat("int a = (int)~0;");
5590 verifyFormat("int a = (int)++a;");
5591 verifyFormat("int a = (int)sizeof(int);");
5592 verifyFormat("int a = (int)+2;");
5593 verifyFormat("my_int a = (my_int)2.0f;");
5594 verifyFormat("my_int a = (my_int)sizeof(int);");
Daniel Jasper05866372013-06-06 08:20:20 +00005595 verifyFormat("return (my_int)aaa;");
Daniel Jasper49a94482013-07-15 15:04:42 +00005596 verifyFormat("#define x ((int)-1)");
Daniel Jaspera45eb4c2014-10-06 13:16:43 +00005597 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1");
Daniel Jasper49a94482013-07-15 15:04:42 +00005598 verifyFormat("#define p(q) ((int *)&q)");
Daniel Jasper30646202014-07-14 12:38:38 +00005599 verifyFormat("fn(a)(b) + 1;");
Daniel Jasperef906a92013-01-13 08:01:36 +00005600
Dinesh Dwivedi76f98f82014-05-05 13:14:35 +00005601 verifyFormat("void f() { my_int a = (my_int)*b; }");
5602 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }");
5603 verifyFormat("my_int a = (my_int)~0;");
5604 verifyFormat("my_int a = (my_int)++a;");
Daniel Jaspera45eb4c2014-10-06 13:16:43 +00005605 verifyFormat("my_int a = (my_int)-2;");
Dinesh Dwivedi76f98f82014-05-05 13:14:35 +00005606 verifyFormat("my_int a = (my_int)1;");
5607 verifyFormat("my_int a = (my_int *)1;");
5608 verifyFormat("my_int a = (const my_int)-1;");
5609 verifyFormat("my_int a = (const my_int *)-1;");
Daniel Jasper4b3ba212014-08-25 09:36:07 +00005610 verifyFormat("my_int a = (my_int)(my_int)-1;");
Daniel Jasperf5e5ee62015-05-19 11:18:39 +00005611 verifyFormat("my_int a = (ns::my_int)-2;");
Daniel Jasper554e49f2015-06-12 07:15:33 +00005612 verifyFormat("case (my_int)ONE:");
Dinesh Dwivedi76f98f82014-05-05 13:14:35 +00005613
5614 // FIXME: single value wrapped with paren will be treated as cast.
5615 verifyFormat("void f(int i = (kValue)*kMask) {}");
Daniel Jasperef906a92013-01-13 08:01:36 +00005616
Dinesh Dwivedi2e92e662014-05-06 11:46:49 +00005617 verifyFormat("{ (void)F; }");
5618
Daniel Jasper998cabc2013-07-18 14:46:07 +00005619 // Don't break after a cast's
5620 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5621 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
5622 " bbbbbbbbbbbbbbbbbbbbbb);");
5623
Daniel Jasperef906a92013-01-13 08:01:36 +00005624 // These are not casts.
5625 verifyFormat("void f(int *) {}");
Nico Weber4401b2a2013-02-13 04:32:57 +00005626 verifyFormat("f(foo)->b;");
5627 verifyFormat("f(foo).b;");
5628 verifyFormat("f(foo)(b);");
5629 verifyFormat("f(foo)[b];");
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00005630 verifyFormat("[](foo) { return 4; }(bar);");
Nico Weber4401b2a2013-02-13 04:32:57 +00005631 verifyFormat("(*funptr)(foo)[4];");
5632 verifyFormat("funptrs[4](foo)[4];");
Daniel Jasperef906a92013-01-13 08:01:36 +00005633 verifyFormat("void f(int *);");
5634 verifyFormat("void f(int *) = 0;");
5635 verifyFormat("void f(SmallVector<int>) {}");
5636 verifyFormat("void f(SmallVector<int>);");
5637 verifyFormat("void f(SmallVector<int>) = 0;");
Nico Weber06fcec12013-02-09 18:02:07 +00005638 verifyFormat("void f(int i = (kA * kB) & kMask) {}");
Nico Weber4401b2a2013-02-13 04:32:57 +00005639 verifyFormat("int a = sizeof(int) * b;");
Alexander Kornienko1e808872013-06-28 12:51:24 +00005640 verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
Daniel Jasper05866372013-06-06 08:20:20 +00005641 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
5642 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
Aaron Ballman61005bc2015-02-16 14:14:01 +00005643 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00005644
Daniel Jasperba0bda92013-02-23 08:07:18 +00005645 // These are not casts, but at some point were confused with casts.
5646 verifyFormat("virtual void foo(int *) override;");
5647 verifyFormat("virtual void foo(char &) const;");
5648 verifyFormat("virtual void foo(int *a, char *) const;");
Daniel Jasper8a68b952013-03-13 17:13:53 +00005649 verifyFormat("int a = sizeof(int *) + b;");
Alexander Kornienko1e808872013-06-28 12:51:24 +00005650 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
Daniel Jasper1bc1b502013-07-05 07:58:34 +00005651
5652 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
5653 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
Daniel Jasperaea3bde2013-07-12 11:19:37 +00005654 // FIXME: The indentation here is not ideal.
Daniel Jasper0e90c3d2013-07-05 09:14:35 +00005655 verifyFormat(
Daniel Jasperaea3bde2013-07-12 11:19:37 +00005656 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5657 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
5658 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];");
Daniel Jasperef906a92013-01-13 08:01:36 +00005659}
5660
Daniel Jasperc1fa2812013-01-10 13:08:12 +00005661TEST_F(FormatTest, FormatsFunctionTypes) {
Daniel Jasperc1fa2812013-01-10 13:08:12 +00005662 verifyFormat("A<bool()> a;");
5663 verifyFormat("A<SomeType()> a;");
Daniel Jasper37194282013-05-28 08:33:00 +00005664 verifyFormat("A<void (*)(int, std::string)> a;");
Daniel Jasperb8914dd2013-03-20 09:53:18 +00005665 verifyFormat("A<void *(int)>;");
Daniel Jasper6e42b1e2013-04-01 17:13:26 +00005666 verifyFormat("void *(*a)(int *, SomeType *);");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00005667 verifyFormat("int (*func)(void *);");
Daniel Jasper37194282013-05-28 08:33:00 +00005668 verifyFormat("void f() { int (*func)(void *); }");
Daniel Jasper59036852013-08-12 12:16:34 +00005669 verifyFormat("template <class CallbackClass>\n"
5670 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);");
Daniel Jasperb8914dd2013-03-20 09:53:18 +00005671
Daniel Jasper6e42b1e2013-04-01 17:13:26 +00005672 verifyGoogleFormat("A<void*(int*, SomeType*)>;");
5673 verifyGoogleFormat("void* (*a)(int);");
Daniel Jasper59036852013-08-12 12:16:34 +00005674 verifyGoogleFormat(
5675 "template <class CallbackClass>\n"
5676 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);");
Daniel Jasperabc34212013-05-14 08:34:47 +00005677
Daniel Jasper5dad58e2013-05-15 07:51:51 +00005678 // Other constructs can look somewhat like function types:
Daniel Jasperabc34212013-05-14 08:34:47 +00005679 verifyFormat("A<sizeof(*x)> a;");
Daniel Jasper5dad58e2013-05-15 07:51:51 +00005680 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
Daniel Jasper655d96a2013-07-16 11:37:21 +00005681 verifyFormat("some_var = function(*some_pointer_var)[0];");
5682 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
Daniel Jasperc1fa2812013-01-10 13:08:12 +00005683}
5684
Daniel Jasperbeaa3222015-02-26 11:30:50 +00005685TEST_F(FormatTest, FormatsPointersToArrayTypes) {
5686 verifyFormat("A (*foo_)[6];");
5687 verifyFormat("vector<int> (*foo_)[6];");
5688}
5689
Daniel Jasper4355e7f2014-07-09 07:50:33 +00005690TEST_F(FormatTest, BreaksLongVariableDeclarations) {
5691 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
5692 " LoooooooooooooooooooooooooooooooooooooooongVariable;");
5693 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
5694 " LoooooooooooooooooooooooooooooooooooooooongVariable;");
Daniel Jasperb754a742015-03-12 15:04:53 +00005695 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
5696 " *LoooooooooooooooooooooooooooooooooooooooongVariable;");
Daniel Jasper4355e7f2014-07-09 07:50:33 +00005697
5698 // Different ways of ()-initializiation.
5699 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
5700 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);");
5701 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
5702 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);");
5703 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
5704 " LoooooooooooooooooooooooooooooooooooooooongVariable({});");
Daniel Jasper0faa9132015-04-23 13:58:40 +00005705 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
5706 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);");
Daniel Jasper4355e7f2014-07-09 07:50:33 +00005707}
5708
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00005709TEST_F(FormatTest, BreaksLongDeclarations) {
Daniel Jasper8e357692013-05-06 08:27:33 +00005710 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00005711 " AnotherNameForTheLongType;");
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +00005712 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00005713 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper8e357692013-05-06 08:27:33 +00005714 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +00005715 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
Daniel Jasperb754a742015-03-12 15:04:53 +00005716 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n"
5717 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
Daniel Jasper8e357692013-05-06 08:27:33 +00005718 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
5719 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasper2ad0aba2014-10-28 17:06:04 +00005720 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n"
5721 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasperdba1c552013-07-02 09:47:29 +00005722 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
5723 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasperf10a28d2014-05-05 13:48:09 +00005724 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
5725 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasperc75e1ef2014-07-09 08:42:42 +00005726 FormatStyle Indented = getLLVMStyle();
5727 Indented.IndentWrappedFunctionNames = true;
5728 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
5729 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();",
5730 Indented);
5731 verifyFormat(
5732 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
5733 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
5734 Indented);
5735 verifyFormat(
5736 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
5737 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
5738 Indented);
5739 verifyFormat(
5740 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
5741 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
5742 Indented);
Daniel Jasper8e357692013-05-06 08:27:33 +00005743
5744 // FIXME: Without the comment, this breaks after "(".
Manuel Klimek836c2862013-06-21 17:25:42 +00005745 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n"
5746 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();",
5747 getGoogleStyle());
Daniel Jasper8e357692013-05-06 08:27:33 +00005748
Daniel Jasperd2639ef2013-01-28 15:16:31 +00005749 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00005750 " int LoooooooooooooooooooongParam2) {}");
Daniel Jasperd1926a32013-01-02 08:44:14 +00005751 verifyFormat(
Daniel Jasper6728fc12013-04-11 14:29:13 +00005752 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
5753 " SourceLocation L, IdentifierIn *II,\n"
5754 " Type *T) {}");
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00005755 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
Daniel Jasperb754a742015-03-12 15:04:53 +00005756 "ReallyReaaallyLongFunctionName(\n"
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00005757 " const std::string &SomeParameter,\n"
Daniel Jasperb754a742015-03-12 15:04:53 +00005758 " const SomeType<string, SomeOtherTemplateParameter>\n"
5759 " &ReallyReallyLongParameterName,\n"
5760 " const SomeType<string, SomeOtherTemplateParameter>\n"
5761 " &AnotherLongParameterName) {}");
Daniel Jasperc6fbc212013-05-15 09:35:08 +00005762 verifyFormat("template <typename A>\n"
5763 "SomeLoooooooooooooooooooooongType<\n"
5764 " typename some_namespace::SomeOtherType<A>::Type>\n"
5765 "Function() {}");
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00005766
Daniel Jasperd36ef5e2013-01-28 15:40:20 +00005767 verifyGoogleFormat(
Daniel Jasper53643062013-08-19 10:16:18 +00005768 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
5769 " aaaaaaaaaaaaaaaaaaaaaaa;");
5770 verifyGoogleFormat(
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00005771 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
5772 " SourceLocation L) {}");
Daniel Jasperb9caeac2013-02-13 20:33:44 +00005773 verifyGoogleFormat(
5774 "some_namespace::LongReturnType\n"
5775 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00005776 " int first_long_parameter, int second_parameter) {}");
Daniel Jasperb9caeac2013-02-13 20:33:44 +00005777
5778 verifyGoogleFormat("template <typename T>\n"
5779 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00005780 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
Daniel Jasper57d4a582013-02-28 10:06:05 +00005781 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5782 " int aaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper78b45332014-08-14 10:52:56 +00005783
5784 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
Daniel Jasperb754a742015-03-12 15:04:53 +00005785 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5786 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperde7ca752015-05-04 07:39:00 +00005787 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5788 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
5789 " aaaaaaaaaaaaaaaaaaaaaaaa);");
5790 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5791 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
5792 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n"
5793 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperd1926a32013-01-02 08:44:14 +00005794}
5795
Daniel Jasperaea3bde2013-07-12 11:19:37 +00005796TEST_F(FormatTest, FormatsArrays) {
5797 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
5798 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
5799 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5800 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
5801 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5802 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
5803 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5804 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
5805 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
5806 verifyFormat(
5807 "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
5808 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
5809 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
Daniel Jaspere0ab9e72013-12-06 15:19:50 +00005810
5811 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n"
5812 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];");
Daniel Jasperecaba172014-06-10 13:27:57 +00005813 verifyFormat(
5814 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n"
5815 " .aaaaaaa[0]\n"
5816 " .aaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper675b4f82015-01-19 10:51:23 +00005817
5818 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10));
Daniel Jasperaea3bde2013-07-12 11:19:37 +00005819}
5820
Daniel Jaspere9de2602012-12-06 09:56:08 +00005821TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
5822 verifyFormat("(a)->b();");
5823 verifyFormat("--a;");
5824}
5825
Daniel Jasper8b529712012-12-04 13:02:32 +00005826TEST_F(FormatTest, HandlesIncludeDirectives) {
Daniel Jasper2ab0d012013-01-14 15:52:06 +00005827 verifyFormat("#include <string>\n"
5828 "#include <a/b/c.h>\n"
5829 "#include \"a/b/string\"\n"
5830 "#include \"string.h\"\n"
5831 "#include \"string.h\"\n"
Manuel Klimek99c7baa2013-01-15 15:50:27 +00005832 "#include <a-a>\n"
Daniel Jasperaf5ba0e2013-02-23 07:46:38 +00005833 "#include < path with space >\n"
Daniel Jasperfa3f8fb2015-05-19 11:22:29 +00005834 "#include_next <test.h>"
Daniel Jasper4a4be012013-05-06 10:24:51 +00005835 "#include \"abc.h\" // this is included for ABC\n"
Daniel Jasper8bb99e82013-05-16 12:59:13 +00005836 "#include \"some long include\" // with a comment\n"
Daniel Jasperaf5ba0e2013-02-23 07:46:38 +00005837 "#include \"some very long include paaaaaaaaaaaaaaaaaaaaaaath\"",
5838 getLLVMStyleWithColumns(35));
Daniel Jasper98857842013-10-30 13:54:53 +00005839 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\""));
5840 EXPECT_EQ("#include <a>", format("#include<a>"));
Nico Weber8f83ee42012-12-21 18:21:56 +00005841
Daniel Jasper5ef433f2013-01-13 08:12:18 +00005842 verifyFormat("#import <string>");
5843 verifyFormat("#import <a/b/c.h>");
5844 verifyFormat("#import \"a/b/string\"");
5845 verifyFormat("#import \"string.h\"");
5846 verifyFormat("#import \"string.h\"");
Daniel Jaspered8f1c62013-08-28 08:24:04 +00005847 verifyFormat("#if __has_include(<strstream>)\n"
5848 "#include <strstream>\n"
5849 "#endif");
Daniel Jasper47ef6dd2014-01-17 16:21:39 +00005850
Daniel Jasper343643b2014-08-13 08:29:18 +00005851 verifyFormat("#define MY_IMPORT <a/b>");
5852
Daniel Jasper47ef6dd2014-01-17 16:21:39 +00005853 // Protocol buffer definition or missing "#".
5854 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";",
5855 getLLVMStyleWithColumns(30));
Daniel Jasper9509f182014-05-05 08:08:07 +00005856
5857 FormatStyle Style = getLLVMStyle();
5858 Style.AlwaysBreakBeforeMultilineStrings = true;
5859 Style.ColumnLimit = 0;
5860 verifyFormat("#import \"abc.h\"", Style);
Daniel Jasper86ee0b62014-12-04 08:57:27 +00005861
5862 // But 'import' might also be a regular C++ namespace.
5863 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5864 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper8b529712012-12-04 13:02:32 +00005865}
5866
Alexander Kornienko578fdd82012-12-06 18:03:27 +00005867//===----------------------------------------------------------------------===//
5868// Error recovery tests.
5869//===----------------------------------------------------------------------===//
5870
Daniel Jasper66e9dee2013-02-14 09:19:04 +00005871TEST_F(FormatTest, IncompleteParameterLists) {
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00005872 FormatStyle NoBinPacking = getLLVMStyle();
5873 NoBinPacking.BinPackParameters = false;
5874 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
5875 " double *min_x,\n"
5876 " double *max_x,\n"
5877 " double *min_y,\n"
5878 " double *max_y,\n"
5879 " double *min_z,\n"
5880 " double *max_z, ) {}",
5881 NoBinPacking);
Daniel Jasper66e9dee2013-02-14 09:19:04 +00005882}
5883
Daniel Jasper83a54d22013-01-10 09:26:47 +00005884TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
Alexander Kornienkoae6e53c2013-01-16 11:45:16 +00005885 verifyFormat("void f() { return; }\n42");
5886 verifyFormat("void f() {\n"
5887 " if (0)\n"
5888 " return;\n"
5889 "}\n"
5890 "42");
Alexander Kornienko1231e062013-01-16 11:43:46 +00005891 verifyFormat("void f() { return }\n42");
5892 verifyFormat("void f() {\n"
5893 " if (0)\n"
5894 " return\n"
5895 "}\n"
5896 "42");
5897}
5898
5899TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
5900 EXPECT_EQ("void f() { return }", format("void f ( ) { return }"));
5901 EXPECT_EQ("void f() {\n"
5902 " if (a)\n"
5903 " return\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005904 "}",
5905 format("void f ( ) { if ( a ) return }"));
Daniel Jasperabca58c2013-05-15 14:09:55 +00005906 EXPECT_EQ("namespace N {\n"
5907 "void f()\n"
5908 "}",
5909 format("namespace N { void f() }"));
Alexander Kornienko1231e062013-01-16 11:43:46 +00005910 EXPECT_EQ("namespace N {\n"
5911 "void f() {}\n"
5912 "void g()\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005913 "}",
5914 format("namespace N { void f( ) { } void g( ) }"));
Daniel Jasper83a54d22013-01-10 09:26:47 +00005915}
5916
Daniel Jasper2df93312013-01-09 10:16:05 +00005917TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
5918 verifyFormat("int aaaaaaaa =\n"
Alexander Kornienkoffd6d042013-03-27 11:52:18 +00005919 " // Overlylongcomment\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005920 " b;",
5921 getLLVMStyleWithColumns(20));
Daniel Jasper2df93312013-01-09 10:16:05 +00005922 verifyFormat("function(\n"
5923 " ShortArgument,\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005924 " LoooooooooooongArgument);\n",
5925 getLLVMStyleWithColumns(20));
Daniel Jasper2df93312013-01-09 10:16:05 +00005926}
5927
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00005928TEST_F(FormatTest, IncorrectAccessSpecifier) {
5929 verifyFormat("public:");
5930 verifyFormat("class A {\n"
5931 "public\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005932 " void f() {}\n"
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00005933 "};");
5934 verifyFormat("public\n"
5935 "int qwerty;");
5936 verifyFormat("public\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005937 "B {}");
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00005938 verifyFormat("public\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005939 "{}");
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00005940 verifyFormat("public\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00005941 "B { int x; }");
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00005942}
Daniel Jasperf7935112012-12-03 18:12:45 +00005943
Daniel Jasper291f9362013-03-20 15:58:10 +00005944TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
5945 verifyFormat("{");
5946 verifyFormat("#})");
Daniel Jasperd97d5d52015-02-17 09:58:03 +00005947 verifyNoCrash("(/**/[:!] ?[).");
Daniel Jasper291f9362013-03-20 15:58:10 +00005948}
Alexander Kornienko0ea8e102012-12-04 15:40:36 +00005949
5950TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00005951 verifyFormat("do {\n}");
5952 verifyFormat("do {\n}\n"
Alexander Kornienko0ea8e102012-12-04 15:40:36 +00005953 "f();");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00005954 verifyFormat("do {\n}\n"
Alexander Kornienko0ea8e102012-12-04 15:40:36 +00005955 "wheeee(fun);");
5956 verifyFormat("do {\n"
5957 " f();\n"
Manuel Klimek28cacc72013-01-07 18:10:23 +00005958 "}");
Alexander Kornienko0ea8e102012-12-04 15:40:36 +00005959}
5960
Manuel Klimek9fa8d552013-01-11 19:23:05 +00005961TEST_F(FormatTest, IncorrectCodeMissingParens) {
Manuel Klimekadededf2013-01-11 18:28:36 +00005962 verifyFormat("if {\n foo;\n foo();\n}");
Manuel Klimek9fa8d552013-01-11 19:23:05 +00005963 verifyFormat("switch {\n foo;\n foo();\n}");
Manuel Klimekec5c3db2015-05-07 12:26:30 +00005964 verifyIncompleteFormat("for {\n foo;\n foo();\n}");
Manuel Klimek9fa8d552013-01-11 19:23:05 +00005965 verifyFormat("while {\n foo;\n foo();\n}");
5966 verifyFormat("do {\n foo;\n foo();\n} while;");
Manuel Klimekadededf2013-01-11 18:28:36 +00005967}
5968
Daniel Jasperc0880a92013-01-04 18:52:56 +00005969TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
Manuel Klimekec5c3db2015-05-07 12:26:30 +00005970 verifyIncompleteFormat("namespace {\n"
5971 "class Foo { Foo (\n"
5972 "};\n"
5973 "} // comment");
Daniel Jasperc0880a92013-01-04 18:52:56 +00005974}
5975
Alexander Kornienko870f9eb2012-12-04 17:27:50 +00005976TEST_F(FormatTest, IncorrectCodeErrorDetection) {
Daniel Jasperfbc057e2013-10-18 17:20:57 +00005977 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n"));
Manuel Klimeke7d10a12013-01-10 13:24:24 +00005978 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n"));
5979 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n"));
Daniel Jasperfbc057e2013-10-18 17:20:57 +00005980 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n"));
Alexander Kornienko870f9eb2012-12-04 17:27:50 +00005981
Alexander Kornienko870f9eb2012-12-04 17:27:50 +00005982 EXPECT_EQ("{\n"
Daniel Jasperfbc057e2013-10-18 17:20:57 +00005983 " {\n"
5984 " breakme(\n"
5985 " qwe);\n"
5986 " }\n",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005987 format("{\n"
5988 " {\n"
5989 " breakme(qwe);\n"
5990 "}\n",
5991 getLLVMStyleWithColumns(10)));
Alexander Kornienko870f9eb2012-12-04 17:27:50 +00005992}
5993
Manuel Klimek73a2fdf2013-01-10 14:36:46 +00005994TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005995 verifyFormat("int x = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00005996 " avariable,\n"
5997 " b(alongervariable)};",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00005998 getLLVMStyleWithColumns(25));
Manuel Klimek73a2fdf2013-01-10 14:36:46 +00005999}
6000
Manuel Klimek762dd182013-01-21 10:07:49 +00006001TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
Daniel Jasper4afc6b32014-06-02 10:57:55 +00006002 verifyFormat("return (a)(b){1, 2, 3};");
Manuel Klimek762dd182013-01-21 10:07:49 +00006003}
6004
Daniel Jasperae8e0d82014-04-17 11:32:02 +00006005TEST_F(FormatTest, LayoutCxx11BraceInitializers) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00006006 verifyFormat("vector<int> x{1, 2, 3, 4};");
Daniel Jaspera125d532014-03-21 12:38:57 +00006007 verifyFormat("vector<int> x{\n"
6008 " 1, 2, 3, 4,\n"
6009 "};");
Chandler Carruthf8b72662014-03-02 12:37:31 +00006010 verifyFormat("vector<T> x{{}, {}, {}, {}};");
6011 verifyFormat("f({1, 2});");
6012 verifyFormat("auto v = Foo{-1};");
6013 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});");
6014 verifyFormat("Class::Class : member{1, 2, 3} {}");
6015 verifyFormat("new vector<int>{1, 2, 3};");
6016 verifyFormat("new int[3]{1, 2, 3};");
Daniel Jasper7a2d60e2014-05-07 07:59:03 +00006017 verifyFormat("new int{1};");
Chandler Carruthf8b72662014-03-02 12:37:31 +00006018 verifyFormat("return {arg1, arg2};");
6019 verifyFormat("return {arg1, SomeType{parameter}};");
6020 verifyFormat("int count = set<int>{f(), g(), h()}.size();");
6021 verifyFormat("new T{arg1, arg2};");
6022 verifyFormat("f(MyMap[{composite, key}]);");
6023 verifyFormat("class Class {\n"
6024 " T member = {arg1, arg2};\n"
6025 "};");
6026 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};");
Daniel Jasper91b032a2014-05-22 12:46:38 +00006027 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");");
6028 verifyFormat("int a = std::is_integral<int>{} + 0;");
Daniel Jaspere5777d22013-05-23 10:15:45 +00006029
Daniel Jasper438059e2014-05-22 12:11:13 +00006030 verifyFormat("int foo(int i) { return fo1{}(i); }");
6031 verifyFormat("int foo(int i) { return fo1{}(i); }");
Daniel Jasper4afc6b32014-06-02 10:57:55 +00006032 verifyFormat("auto i = decltype(x){};");
Daniel Jasper610381f2014-08-26 09:37:52 +00006033 verifyFormat("std::vector<int> v = {1, 0 /* comment */};");
Daniel Jasper168c8aa2014-08-27 11:53:26 +00006034 verifyFormat("Node n{1, Node{1000}, //\n"
6035 " 2};");
Daniel Jasperb812e322015-02-26 11:46:29 +00006036 verifyFormat("Aaaa aaaaaaa{\n"
6037 " {\n"
6038 " aaaa,\n"
6039 " },\n"
6040 "};");
Daniel Jaspercec9ffd2015-05-18 14:12:24 +00006041 verifyFormat("class C : public D {\n"
6042 " SomeClass SC{2};\n"
6043 "};");
Daniel Jasper3c883d12015-05-18 14:49:19 +00006044 verifyFormat("class C : public A {\n"
6045 " class D : public B {\n"
6046 " void f() { int i{2}; }\n"
6047 " };\n"
6048 "};");
Daniel Jasper438059e2014-05-22 12:11:13 +00006049
Daniel Jasper08434342015-05-26 07:26:26 +00006050 // In combination with BinPackArguments = false.
Daniel Jasperae8e0d82014-04-17 11:32:02 +00006051 FormatStyle NoBinPacking = getLLVMStyle();
Daniel Jasper08434342015-05-26 07:26:26 +00006052 NoBinPacking.BinPackArguments = false;
Daniel Jasperae8e0d82014-04-17 11:32:02 +00006053 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n"
6054 " bbbbb,\n"
6055 " ccccc,\n"
6056 " ddddd,\n"
6057 " eeeee,\n"
6058 " ffffff,\n"
6059 " ggggg,\n"
6060 " hhhhhh,\n"
6061 " iiiiii,\n"
6062 " jjjjjj,\n"
6063 " kkkkkk};",
6064 NoBinPacking);
6065 verifyFormat("const Aaaaaa aaaaa = {\n"
6066 " aaaaa,\n"
6067 " bbbbb,\n"
6068 " ccccc,\n"
6069 " ddddd,\n"
6070 " eeeee,\n"
6071 " ffffff,\n"
6072 " ggggg,\n"
6073 " hhhhhh,\n"
6074 " iiiiii,\n"
6075 " jjjjjj,\n"
6076 " kkkkkk,\n"
6077 "};",
6078 NoBinPacking);
Daniel Jasper839922e2014-08-13 08:46:21 +00006079 verifyFormat(
6080 "const Aaaaaa aaaaa = {\n"
6081 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n"
6082 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n"
6083 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n"
6084 "};",
6085 NoBinPacking);
Daniel Jasperae8e0d82014-04-17 11:32:02 +00006086
Chandler Carruthf8b72662014-03-02 12:37:31 +00006087 // FIXME: The alignment of these trailing comments might be bad. Then again,
6088 // this might be utterly useless in real code.
6089 verifyFormat("Constructor::Constructor()\n"
Daniel Jasper64a328e2014-11-11 19:34:57 +00006090 " : some_value{ //\n"
6091 " aaaaaaa, //\n"
6092 " bbbbbbb} {}");
Daniel Jasper5a611392013-12-19 21:41:37 +00006093
Chandler Carruthf8b72662014-03-02 12:37:31 +00006094 // In braced lists, the first comment is always assumed to belong to the
6095 // first element. Thus, it can be moved to the next or previous line as
6096 // appropriate.
6097 EXPECT_EQ("function({// First element:\n"
6098 " 1,\n"
6099 " // Second element:\n"
6100 " 2});",
6101 format("function({\n"
6102 " // First element:\n"
6103 " 1,\n"
6104 " // Second element:\n"
6105 " 2});"));
6106 EXPECT_EQ("std::vector<int> MyNumbers{\n"
6107 " // First element:\n"
6108 " 1,\n"
6109 " // Second element:\n"
6110 " 2};",
6111 format("std::vector<int> MyNumbers{// First element:\n"
6112 " 1,\n"
6113 " // Second element:\n"
6114 " 2};",
6115 getLLVMStyleWithColumns(30)));
Daniel Jasper64a328e2014-11-11 19:34:57 +00006116 // A trailing comma should still lead to an enforced line break.
6117 EXPECT_EQ("vector<int> SomeVector = {\n"
6118 " // aaa\n"
6119 " 1, 2,\n"
6120 "};",
6121 format("vector<int> SomeVector = { // aaa\n"
6122 " 1, 2, };"));
Daniel Jasper5a611392013-12-19 21:41:37 +00006123
Chandler Carruthf8b72662014-03-02 12:37:31 +00006124 FormatStyle ExtraSpaces = getLLVMStyle();
6125 ExtraSpaces.Cpp11BracedListStyle = false;
6126 ExtraSpaces.ColumnLimit = 75;
6127 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces);
6128 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces);
6129 verifyFormat("f({ 1, 2 });", ExtraSpaces);
6130 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces);
6131 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces);
6132 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces);
6133 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces);
6134 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces);
6135 verifyFormat("return { arg1, arg2 };", ExtraSpaces);
6136 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces);
6137 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces);
6138 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces);
6139 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces);
6140 verifyFormat("class Class {\n"
6141 " T member = { arg1, arg2 };\n"
6142 "};",
6143 ExtraSpaces);
6144 verifyFormat(
6145 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6146 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
6147 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
6148 " bbbbbbbbbbbbbbbbbbbb, bbbbb };",
6149 ExtraSpaces);
6150 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces);
Daniel Jasper610381f2014-08-26 09:37:52 +00006151 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });",
Chandler Carruthf8b72662014-03-02 12:37:31 +00006152 ExtraSpaces);
6153 verifyFormat(
6154 "someFunction(OtherParam,\n"
6155 " BracedList{ // comment 1 (Forcing interesting break)\n"
6156 " param1, param2,\n"
6157 " // comment 2\n"
Daniel Jasper11a0ac62014-12-12 09:40:58 +00006158 " param3, param4 });",
Chandler Carruthf8b72662014-03-02 12:37:31 +00006159 ExtraSpaces);
6160 verifyFormat(
6161 "std::this_thread::sleep_for(\n"
6162 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);",
6163 ExtraSpaces);
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00006164 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaa{\n"
6165 " aaaaaaa,\n"
6166 " aaaaaaaaaa,\n"
6167 " aaaaa,\n"
6168 " aaaaaaaaaaaaaaa,\n"
6169 " aaa,\n"
6170 " aaaaaaaaaa,\n"
6171 " a,\n"
6172 " aaaaaaaaaaaaaaaaaaaaa,\n"
6173 " aaaaaaaaaaaa,\n"
6174 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n"
6175 " aaaaaaa,\n"
6176 " a};");
Chandler Carruthf8b72662014-03-02 12:37:31 +00006177 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces);
Manuel Klimekab419912013-05-23 09:41:43 +00006178}
6179
Daniel Jasper33b909c2013-10-25 14:29:37 +00006180TEST_F(FormatTest, FormatsBracedListsInColumnLayout) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00006181 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6182 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6183 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6184 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6185 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6186 " 1, 22, 333, 4444, 55555, 666666, 7777777};");
Daniel Jasper731dde92015-05-15 09:41:59 +00006187 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006188 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
Daniel Jasper731dde92015-05-15 09:41:59 +00006189 " 1, 22, 333, 4444, 55555, //\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006190 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6191 " 1, 22, 333, 4444, 55555, 666666, 7777777};");
Daniel Jasper8de9ed02013-08-22 15:00:41 +00006192 verifyFormat(
Chandler Carruthf8b72662014-03-02 12:37:31 +00006193 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6194 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6195 " 1, 22, 333, 4444, 55555, 666666, // comment\n"
6196 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
6197 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
6198 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
6199 " 7777777};");
Daniel Jasper8de9ed02013-08-22 15:00:41 +00006200 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006201 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
6202 " X86::R8, X86::R9, X86::R10, X86::R11, 0};");
Daniel Jasper731dde92015-05-15 09:41:59 +00006203 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
6204 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
6205 " // Separating comment.\n"
6206 " X86::R8, X86::R9, X86::R10, X86::R11, 0};");
6207 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
6208 " // Leading comment\n"
6209 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
6210 " X86::R8, X86::R9, X86::R10, X86::R11, 0};");
Chandler Carruthf8b72662014-03-02 12:37:31 +00006211 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
6212 " 1, 1, 1, 1};",
Daniel Jasper8de9ed02013-08-22 15:00:41 +00006213 getLLVMStyleWithColumns(39));
Chandler Carruthf8b72662014-03-02 12:37:31 +00006214 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
6215 " 1, 1, 1, 1};",
Daniel Jasper8de9ed02013-08-22 15:00:41 +00006216 getLLVMStyleWithColumns(38));
6217 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006218 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};",
6219 getLLVMStyleWithColumns(43));
Daniel Jaspere4c16c72015-05-08 13:51:14 +00006220 verifyFormat(
6221 "static unsigned SomeValues[10][3] = {\n"
6222 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n"
6223 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};");
6224 verifyFormat("static auto fields = new vector<string>{\n"
6225 " \"aaaaaaaaaaaaa\",\n"
6226 " \"aaaaaaaaaaaaa\",\n"
6227 " \"aaaaaaaaaaaa\",\n"
6228 " \"aaaaaaaaaaaaaa\",\n"
6229 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
6230 " \"aaaaaaaaaaaa\",\n"
6231 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
6232 "};");
Daniel Jasperd57843d2015-05-11 13:35:40 +00006233 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};");
6234 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n"
6235 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n"
6236 " 3, cccccccccccccccccccccc};",
6237 getLLVMStyleWithColumns(60));
Daniel Jasperf93551c2013-08-23 10:05:49 +00006238
6239 // Trailing commas.
Daniel Jaspera125d532014-03-21 12:38:57 +00006240 verifyFormat("vector<int> x = {\n"
6241 " 1, 1, 1, 1, 1, 1, 1, 1,\n"
6242 "};",
Daniel Jasperf93551c2013-08-23 10:05:49 +00006243 getLLVMStyleWithColumns(39));
Daniel Jasperb175d572014-04-09 09:53:23 +00006244 verifyFormat("vector<int> x = {\n"
6245 " 1, 1, 1, 1, 1, 1, 1, 1, //\n"
Daniel Jasperf93551c2013-08-23 10:05:49 +00006246 "};",
6247 getLLVMStyleWithColumns(39));
Daniel Jasper610381f2014-08-26 09:37:52 +00006248 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
6249 " 1, 1, 1, 1,\n"
6250 " /**/ /**/};",
Daniel Jasper8863ada2013-08-26 08:10:17 +00006251 getLLVMStyleWithColumns(39));
Daniel Jaspere4c16c72015-05-08 13:51:14 +00006252
Daniel Jasper60c27072015-05-13 08:16:00 +00006253 // Trailing comment in the first line.
6254 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n"
6255 " 1111111111, 2222222222, 33333333333, 4444444444, //\n"
6256 " 111111111, 222222222, 3333333333, 444444444, //\n"
6257 " 11111111, 22222222, 333333333, 44444444};");
6258
Daniel Jaspere4c16c72015-05-08 13:51:14 +00006259 // With nested lists, we should either format one item per line or all nested
6260 // lists one on line.
6261 // FIXME: For some nested lists, we can do better.
Chandler Carruthf8b72662014-03-02 12:37:31 +00006262 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
6263 " {aaaaaaaaaaaaaaaaaaa},\n"
6264 " {aaaaaaaaaaaaaaaaaaaaa},\n"
6265 " {aaaaaaaaaaaaaaaaa}};",
Daniel Jaspercb3f0ed2013-08-27 08:43:47 +00006266 getLLVMStyleWithColumns(60));
Daniel Jasper63af7c42013-12-09 14:40:19 +00006267 verifyFormat(
6268 "SomeStruct my_struct_array = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006269 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n"
6270 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n"
6271 " {aaa, aaa},\n"
6272 " {aaa, aaa},\n"
6273 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n"
6274 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n"
6275 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};");
Daniel Jasper01603472014-01-09 13:42:56 +00006276
6277 // No column layout should be used here.
Chandler Carruthf8b72662014-03-02 12:37:31 +00006278 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
6279 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};");
Daniel Jasper20e8c3b2015-01-19 10:51:42 +00006280
6281 verifyNoCrash("a<,");
Daniel Jasper8de9ed02013-08-22 15:00:41 +00006282}
6283
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00006284TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00006285 FormatStyle DoNotMerge = getLLVMStyle();
Daniel Jasperd74cf402014-04-08 12:46:38 +00006286 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00006287
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00006288 verifyFormat("void f() { return 42; }");
6289 verifyFormat("void f() {\n"
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00006290 " return 42;\n"
6291 "}",
6292 DoNotMerge);
6293 verifyFormat("void f() {\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00006294 " // Comment\n"
6295 "}");
6296 verifyFormat("{\n"
6297 "#error {\n"
6298 " int a;\n"
6299 "}");
6300 verifyFormat("{\n"
6301 " int a;\n"
6302 "#error {\n"
6303 "}");
Daniel Jasperf9eb9b12013-05-16 10:17:39 +00006304 verifyFormat("void f() {} // comment");
6305 verifyFormat("void f() { int a; } // comment");
Daniel Jasper92716502013-05-16 16:54:34 +00006306 verifyFormat("void f() {\n"
6307 "} // comment",
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00006308 DoNotMerge);
6309 verifyFormat("void f() {\n"
6310 " int a;\n"
6311 "} // comment",
6312 DoNotMerge);
6313 verifyFormat("void f() {\n"
6314 "} // comment",
Daniel Jasper92716502013-05-16 16:54:34 +00006315 getLLVMStyleWithColumns(15));
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00006316
6317 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
6318 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22));
6319
6320 verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
6321 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
Alexander Kornienko06dd15a2013-12-04 13:58:27 +00006322 verifyFormat("class C {\n"
6323 " C()\n"
6324 " : iiiiiiii(nullptr),\n"
6325 " kkkkkkk(nullptr),\n"
6326 " mmmmmmm(nullptr),\n"
6327 " nnnnnnn(nullptr) {}\n"
6328 "};",
6329 getGoogleStyle());
Alexander Kornienko31e95542013-12-04 12:21:08 +00006330
6331 FormatStyle NoColumnLimit = getLLVMStyle();
6332 NoColumnLimit.ColumnLimit = 0;
6333 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));
6334 EXPECT_EQ("class C {\n"
6335 " A() : b(0) {}\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00006336 "};",
6337 format("class C{A():b(0){}};", NoColumnLimit));
Alexander Kornienko31e95542013-12-04 12:21:08 +00006338 EXPECT_EQ("A()\n"
6339 " : b(0) {\n"
6340 "}",
6341 format("A()\n:b(0)\n{\n}", NoColumnLimit));
6342
6343 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit;
Daniel Jasperd74cf402014-04-08 12:46:38 +00006344 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine =
6345 FormatStyle::SFS_None;
Alexander Kornienko31e95542013-12-04 12:21:08 +00006346 EXPECT_EQ("A()\n"
6347 " : b(0) {\n"
6348 "}",
6349 format("A():b(0){}", DoNotMergeNoColumnLimit));
6350 EXPECT_EQ("A()\n"
6351 " : b(0) {\n"
6352 "}",
6353 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit));
Daniel Jasper64989962014-02-07 13:45:27 +00006354
6355 verifyFormat("#define A \\\n"
6356 " void f() { \\\n"
6357 " int i; \\\n"
6358 " }",
6359 getLLVMStyleWithColumns(20));
6360 verifyFormat("#define A \\\n"
6361 " void f() { int i; }",
6362 getLLVMStyleWithColumns(21));
6363 verifyFormat("#define A \\\n"
6364 " void f() { \\\n"
6365 " int i; \\\n"
6366 " } \\\n"
6367 " int j;",
6368 getLLVMStyleWithColumns(22));
6369 verifyFormat("#define A \\\n"
6370 " void f() { int i; } \\\n"
6371 " int j;",
6372 getLLVMStyleWithColumns(23));
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00006373}
6374
Daniel Jasperd74cf402014-04-08 12:46:38 +00006375TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) {
6376 FormatStyle MergeInlineOnly = getLLVMStyle();
6377 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
6378 verifyFormat("class C {\n"
6379 " int f() { return 42; }\n"
6380 "};",
6381 MergeInlineOnly);
6382 verifyFormat("int f() {\n"
6383 " return 42;\n"
6384 "}",
6385 MergeInlineOnly);
6386}
6387
Manuel Klimeke01bab52013-01-15 13:38:33 +00006388TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
6389 // Elaborate type variable declarations.
Chandler Carruthf8b72662014-03-02 12:37:31 +00006390 verifyFormat("struct foo a = {bar};\nint n;");
6391 verifyFormat("class foo a = {bar};\nint n;");
6392 verifyFormat("union foo a = {bar};\nint n;");
Manuel Klimeke01bab52013-01-15 13:38:33 +00006393
6394 // Elaborate types inside function definitions.
6395 verifyFormat("struct foo f() {}\nint n;");
6396 verifyFormat("class foo f() {}\nint n;");
6397 verifyFormat("union foo f() {}\nint n;");
6398
6399 // Templates.
6400 verifyFormat("template <class X> void f() {}\nint n;");
6401 verifyFormat("template <struct X> void f() {}\nint n;");
6402 verifyFormat("template <union X> void f() {}\nint n;");
6403
6404 // Actual definitions...
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00006405 verifyFormat("struct {\n} n;");
6406 verifyFormat(
6407 "template <template <class T, class Y>, class Z> class X {\n} n;");
Manuel Klimeke01bab52013-01-15 13:38:33 +00006408 verifyFormat("union Z {\n int n;\n} x;");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00006409 verifyFormat("class MACRO Z {\n} n;");
6410 verifyFormat("class MACRO(X) Z {\n} n;");
6411 verifyFormat("class __attribute__(X) Z {\n} n;");
6412 verifyFormat("class __declspec(X) Z {\n} n;");
Manuel Klimekd2650902013-02-06 15:57:54 +00006413 verifyFormat("class A##B##C {\n} n;");
Manuel Klimek91e48582013-10-07 09:15:41 +00006414 verifyFormat("class alignas(16) Z {\n} n;");
Daniel Jasper04785d02015-05-06 14:03:02 +00006415 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;");
6416 verifyFormat("class MACROA MACRO(X) Z {\n} n;");
Manuel Klimeke01bab52013-01-15 13:38:33 +00006417
Manuel Klimek3c6b7c72013-01-21 10:17:14 +00006418 // Redefinition from nested context:
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00006419 verifyFormat("class A::B::C {\n} n;");
Manuel Klimek3c6b7c72013-01-21 10:17:14 +00006420
Manuel Klimekcdee74d2013-01-21 13:58:54 +00006421 // Template definitions.
Daniel Jasper6f05e592013-05-15 13:46:48 +00006422 verifyFormat(
6423 "template <typename F>\n"
6424 "Matcher(const Matcher<F> &Other,\n"
6425 " typename enable_if_c<is_base_of<F, T>::value &&\n"
6426 " !is_same<F, T>::value>::type * = 0)\n"
6427 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
6428
Manuel Klimekcdee74d2013-01-21 13:58:54 +00006429 // FIXME: This is still incorrectly handled at the formatter side.
Daniel Jasper62c0ac02013-07-30 22:37:19 +00006430 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
Daniel Jasper6f2b88a2015-06-05 13:18:09 +00006431 verifyFormat("int i = SomeFunction(a<b, a> b);");
Manuel Klimekcdee74d2013-01-21 13:58:54 +00006432
6433 // FIXME:
6434 // This now gets parsed incorrectly as class definition.
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00006435 // verifyFormat("class A<int> f() {\n}\nint n;");
Manuel Klimekcdee74d2013-01-21 13:58:54 +00006436
Manuel Klimeke01bab52013-01-15 13:38:33 +00006437 // Elaborate types where incorrectly parsing the structural element would
6438 // break the indent.
6439 verifyFormat("if (true)\n"
6440 " class X x;\n"
6441 "else\n"
6442 " f();\n");
Daniel Jasper1a32a612013-03-20 15:12:38 +00006443
6444 // This is simply incomplete. Formatting is not important, but must not crash.
Daniel Jaspercdaffa42013-08-13 10:58:30 +00006445 verifyFormat("class A:");
Manuel Klimekd5e5f8f2013-01-11 18:13:04 +00006446}
6447
Manuel Klimek99c7baa2013-01-15 15:50:27 +00006448TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
Manuel Klimek71814b42013-10-11 21:25:45 +00006449 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n",
6450 format("#error Leave all white!!!!! space* alone!\n"));
6451 EXPECT_EQ(
6452 "#warning Leave all white!!!!! space* alone!\n",
6453 format("#warning Leave all white!!!!! space* alone!\n"));
Manuel Klimek99c7baa2013-01-15 15:50:27 +00006454 EXPECT_EQ("#error 1", format(" # error 1"));
6455 EXPECT_EQ("#warning 1", format(" # warning 1"));
6456}
6457
Daniel Jasper4431aa92013-04-23 13:54:04 +00006458TEST_F(FormatTest, FormatHashIfExpressions) {
Daniel Jasper7cfde412014-01-21 08:56:09 +00006459 verifyFormat("#if AAAA && BBBB");
Daniel Jasper4431aa92013-04-23 13:54:04 +00006460 // FIXME: Come up with a better indentation for #elif.
6461 verifyFormat(
6462 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n"
6463 " defined(BBBBBBBB)\n"
6464 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n"
6465 " defined(BBBBBBBB)\n"
6466 "#endif",
6467 getLLVMStyleWithColumns(65));
6468}
6469
Manuel Klimekd3b92fa2013-01-18 14:04:34 +00006470TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
6471 FormatStyle AllowsMergedIf = getGoogleStyle();
6472 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true;
6473 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
6474 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
Manuel Klimekda087612013-01-18 14:46:43 +00006475 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf);
6476 EXPECT_EQ("if (true) return 42;",
6477 format("if (true)\nreturn 42;", AllowsMergedIf));
6478 FormatStyle ShortMergedIf = AllowsMergedIf;
6479 ShortMergedIf.ColumnLimit = 25;
Daniel Jasper6fe2f002013-04-25 08:56:26 +00006480 verifyFormat("#define A \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006481 " if (true) return 42;",
6482 ShortMergedIf);
Daniel Jasper6fe2f002013-04-25 08:56:26 +00006483 verifyFormat("#define A \\\n"
6484 " f(); \\\n"
Manuel Klimekda087612013-01-18 14:46:43 +00006485 " if (true)\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006486 "#define B",
6487 ShortMergedIf);
Daniel Jasper6fe2f002013-04-25 08:56:26 +00006488 verifyFormat("#define A \\\n"
6489 " f(); \\\n"
Manuel Klimekda087612013-01-18 14:46:43 +00006490 " if (true)\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006491 "g();",
6492 ShortMergedIf);
Manuel Klimekd5e782b2013-01-21 14:16:56 +00006493 verifyFormat("{\n"
6494 "#ifdef A\n"
6495 " // Comment\n"
6496 " if (true) continue;\n"
6497 "#endif\n"
6498 " // Comment\n"
Manuel Klimek71814b42013-10-11 21:25:45 +00006499 " if (true) continue;\n"
6500 "}",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006501 ShortMergedIf);
Daniel Jasper64989962014-02-07 13:45:27 +00006502 ShortMergedIf.ColumnLimit = 29;
6503 verifyFormat("#define A \\\n"
6504 " if (aaaaaaaaaa) return 1; \\\n"
6505 " return 2;",
6506 ShortMergedIf);
6507 ShortMergedIf.ColumnLimit = 28;
6508 verifyFormat("#define A \\\n"
6509 " if (aaaaaaaaaa) \\\n"
6510 " return 1; \\\n"
6511 " return 2;",
6512 ShortMergedIf);
Manuel Klimekd3b92fa2013-01-18 14:04:34 +00006513}
6514
Manuel Klimekf92f7bc2013-01-22 16:31:55 +00006515TEST_F(FormatTest, BlockCommentsInControlLoops) {
6516 verifyFormat("if (0) /* a comment in a strange place */ {\n"
6517 " f();\n"
6518 "}");
6519 verifyFormat("if (0) /* a comment in a strange place */ {\n"
6520 " f();\n"
6521 "} /* another comment */ else /* comment #3 */ {\n"
6522 " g();\n"
6523 "}");
6524 verifyFormat("while (0) /* a comment in a strange place */ {\n"
6525 " f();\n"
6526 "}");
6527 verifyFormat("for (;;) /* a comment in a strange place */ {\n"
6528 " f();\n"
6529 "}");
6530 verifyFormat("do /* a comment in a strange place */ {\n"
6531 " f();\n"
6532 "} /* another comment */ while (0);");
6533}
6534
6535TEST_F(FormatTest, BlockComments) {
6536 EXPECT_EQ("/* */ /* */ /* */\n/* */ /* */ /* */",
6537 format("/* *//* */ /* */\n/* *//* */ /* */"));
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006538 EXPECT_EQ("/* */ a /* */ b;", format(" /* */ a/* */ b;"));
Daniel Jaspera49393f2013-08-28 09:07:32 +00006539 EXPECT_EQ("#define A /*123*/ \\\n"
Manuel Klimekf92f7bc2013-01-22 16:31:55 +00006540 " b\n"
6541 "/* */\n"
6542 "someCall(\n"
6543 " parameter);",
Alexander Kornienko547a9f522013-03-21 12:28:10 +00006544 format("#define A /*123*/ b\n"
Manuel Klimekf92f7bc2013-01-22 16:31:55 +00006545 "/* */\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006546 "someCall(parameter);",
6547 getLLVMStyleWithColumns(15)));
Manuel Klimekf92f7bc2013-01-22 16:31:55 +00006548
6549 EXPECT_EQ("#define A\n"
6550 "/* */ someCall(\n"
6551 " parameter);",
6552 format("#define A\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006553 "/* */someCall(parameter);",
6554 getLLVMStyleWithColumns(15)));
Daniel Jasper51fb2b22013-05-30 06:40:07 +00006555 EXPECT_EQ("/*\n**\n*/", format("/*\n**\n*/"));
Daniel Jasper58dd2f02013-05-30 15:20:29 +00006556 EXPECT_EQ("/*\n"
6557 "*\n"
6558 " * aaaaaa\n"
Daniel Jasper6d9b88d2015-05-06 07:17:22 +00006559 " * aaaaaa\n"
Daniel Jasper58dd2f02013-05-30 15:20:29 +00006560 "*/",
6561 format("/*\n"
6562 "*\n"
6563 " * aaaaaa aaaaaa\n"
6564 "*/",
6565 getLLVMStyleWithColumns(10)));
Daniel Jasperce257f22013-05-30 17:27:48 +00006566 EXPECT_EQ("/*\n"
6567 "**\n"
6568 "* aaaaaa\n"
Alexander Kornienko614d96a2013-07-08 14:12:07 +00006569 "*aaaaaa\n"
Daniel Jasperce257f22013-05-30 17:27:48 +00006570 "*/",
6571 format("/*\n"
6572 "**\n"
6573 "* aaaaaa aaaaaa\n"
6574 "*/",
6575 getLLVMStyleWithColumns(10)));
Daniel Jasper1f140982013-02-04 07:32:14 +00006576
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00006577 FormatStyle NoBinPacking = getLLVMStyle();
6578 NoBinPacking.BinPackParameters = false;
Daniel Jasper1f140982013-02-04 07:32:14 +00006579 EXPECT_EQ("someFunction(1, /* comment 1 */\n"
6580 " 2, /* comment 2 */\n"
6581 " 3, /* comment 3 */\n"
Daniel Jasper14e40ec2013-02-04 08:34:57 +00006582 " aaaa,\n"
6583 " bbbb);",
Daniel Jasper1f140982013-02-04 07:32:14 +00006584 format("someFunction (1, /* comment 1 */\n"
6585 " 2, /* comment 2 */ \n"
6586 " 3, /* comment 3 */\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006587 "aaaa, bbbb );",
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00006588 NoBinPacking));
Daniel Jasper38396592013-02-06 15:23:09 +00006589 verifyFormat(
6590 "bool aaaaaaaaaaaaa = /* comment: */ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
6591 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6592 EXPECT_EQ(
6593 "bool aaaaaaaaaaaaa = /* trailing comment */\n"
6594 " aaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
6595 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;",
6596 format(
6597 "bool aaaaaaaaaaaaa = /* trailing comment */\n"
6598 " aaaaaaaaaaaaaaaaaaaaaaaaaaa||aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
6599 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;"));
Daniel Jasper94f0e132013-02-06 20:07:35 +00006600 EXPECT_EQ(
6601 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n"
6602 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n"
6603 "int cccccccccccccccccccccccccccccc; /* comment */\n",
6604 format("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n"
6605 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n"
6606 "int cccccccccccccccccccccccccccccc; /* comment */\n"));
Daniel Jasper022612d2013-07-01 09:34:09 +00006607
6608 verifyFormat("void f(int * /* unused */) {}");
Alexander Kornienko614d96a2013-07-08 14:12:07 +00006609
6610 EXPECT_EQ("/*\n"
6611 " **\n"
6612 " */",
6613 format("/*\n"
6614 " **\n"
6615 " */"));
6616 EXPECT_EQ("/*\n"
6617 " *q\n"
6618 " */",
6619 format("/*\n"
6620 " *q\n"
6621 " */"));
6622 EXPECT_EQ("/*\n"
6623 " * q\n"
6624 " */",
6625 format("/*\n"
6626 " * q\n"
6627 " */"));
6628 EXPECT_EQ("/*\n"
6629 " **/",
6630 format("/*\n"
6631 " **/"));
6632 EXPECT_EQ("/*\n"
6633 " ***/",
6634 format("/*\n"
6635 " ***/"));
Manuel Klimekf92f7bc2013-01-22 16:31:55 +00006636}
6637
Manuel Klimek82b836a2013-02-06 16:40:56 +00006638TEST_F(FormatTest, BlockCommentsInMacros) {
6639 EXPECT_EQ("#define A \\\n"
6640 " { \\\n"
6641 " /* one line */ \\\n"
6642 " someCall();",
6643 format("#define A { \\\n"
6644 " /* one line */ \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006645 " someCall();",
6646 getLLVMStyleWithColumns(20)));
Manuel Klimek82b836a2013-02-06 16:40:56 +00006647 EXPECT_EQ("#define A \\\n"
6648 " { \\\n"
6649 " /* previous */ \\\n"
6650 " /* one line */ \\\n"
6651 " someCall();",
6652 format("#define A { \\\n"
6653 " /* previous */ \\\n"
6654 " /* one line */ \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00006655 " someCall();",
6656 getLLVMStyleWithColumns(20)));
Manuel Klimek82b836a2013-02-06 16:40:56 +00006657}
6658
Manuel Klimekae1fbfb2013-05-29 22:06:18 +00006659TEST_F(FormatTest, BlockCommentsAtEndOfLine) {
6660 EXPECT_EQ("a = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006661 " 1111 /* */\n"
Manuel Klimekae1fbfb2013-05-29 22:06:18 +00006662 "};",
Alexander Kornienkof370ad92013-06-12 19:04:12 +00006663 format("a = {1111 /* */\n"
Manuel Klimekae1fbfb2013-05-29 22:06:18 +00006664 "};",
6665 getLLVMStyleWithColumns(15)));
6666 EXPECT_EQ("a = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006667 " 1111 /* */\n"
Manuel Klimekae1fbfb2013-05-29 22:06:18 +00006668 "};",
Alexander Kornienkof370ad92013-06-12 19:04:12 +00006669 format("a = {1111 /* */\n"
Manuel Klimekae1fbfb2013-05-29 22:06:18 +00006670 "};",
6671 getLLVMStyleWithColumns(15)));
6672
6673 // FIXME: The formatting is still wrong here.
6674 EXPECT_EQ("a = {\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00006675 " 1111 /* a\n"
6676 " */\n"
Manuel Klimekae1fbfb2013-05-29 22:06:18 +00006677 "};",
Alexander Kornienkof370ad92013-06-12 19:04:12 +00006678 format("a = {1111 /* a */\n"
Manuel Klimekae1fbfb2013-05-29 22:06:18 +00006679 "};",
6680 getLLVMStyleWithColumns(15)));
6681}
6682
Manuel Klimek82b836a2013-02-06 16:40:56 +00006683TEST_F(FormatTest, IndentLineCommentsInStartOfBlockAtEndOfFile) {
6684 // FIXME: This is not what we want...
6685 verifyFormat("{\n"
6686 "// a"
6687 "// b");
6688}
6689
Manuel Klimekd33516e2013-01-23 10:09:28 +00006690TEST_F(FormatTest, FormatStarDependingOnContext) {
Manuel Klimek0a3a3c92013-01-23 09:32:48 +00006691 verifyFormat("void f(int *a);");
6692 verifyFormat("void f() { f(fint * b); }");
Manuel Klimek39080572013-01-23 11:03:04 +00006693 verifyFormat("class A {\n void f(int *a);\n};");
6694 verifyFormat("class A {\n int *a;\n};");
6695 verifyFormat("namespace a {\n"
6696 "namespace b {\n"
6697 "class A {\n"
6698 " void f() {}\n"
6699 " int *a;\n"
6700 "};\n"
6701 "}\n"
6702 "}");
Manuel Klimek0a3a3c92013-01-23 09:32:48 +00006703}
6704
Manuel Klimekd33516e2013-01-23 10:09:28 +00006705TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
6706 verifyFormat("while");
6707 verifyFormat("operator");
6708}
6709
Nico Weber7e6a7a12013-01-08 17:56:31 +00006710//===----------------------------------------------------------------------===//
6711// Objective-C tests.
6712//===----------------------------------------------------------------------===//
6713
Fariborz Jahanian68a542a2012-12-20 19:54:13 +00006714TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
6715 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
6716 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
6717 format("-(NSUInteger)indexOfObject:(id)anObject;"));
Daniel Jasper8d1832e2013-01-07 13:26:07 +00006718 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
Fariborz Jahanian68a542a2012-12-20 19:54:13 +00006719 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
6720 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
6721 format("-(NSInteger)Method3:(id)anObject;"));
6722 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
6723 format("-(NSInteger)Method4:(id)anObject;"));
6724 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
6725 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
6726 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
6727 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
Daniel Jaspera44991332015-04-29 13:06:49 +00006728 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "
6729 "forAllCells:(BOOL)flag;",
6730 format("- (void)sendAction:(SEL)aSelector to:(id)anObject "
6731 "forAllCells:(BOOL)flag;"));
Fariborz Jahanian9017ec32012-12-21 22:51:18 +00006732
6733 // Very long objectiveC method declaration.
Daniel Jasper55ca6082015-03-12 22:13:45 +00006734 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
6735 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;");
Daniel Jasper1ac3e052013-02-05 10:07:47 +00006736 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
6737 " inRange:(NSRange)range\n"
6738 " outRange:(NSRange)out_range\n"
6739 " outRange1:(NSRange)out_range1\n"
6740 " outRange2:(NSRange)out_range2\n"
6741 " outRange3:(NSRange)out_range3\n"
6742 " outRange4:(NSRange)out_range4\n"
6743 " outRange5:(NSRange)out_range5\n"
6744 " outRange6:(NSRange)out_range6\n"
6745 " outRange7:(NSRange)out_range7\n"
6746 " outRange8:(NSRange)out_range8\n"
6747 " outRange9:(NSRange)out_range9;");
Nico Weberd6f962f2013-01-10 20:18:33 +00006748
Daniel Jaspera2a4d9c2015-05-13 09:38:25 +00006749 // When the function name has to be wrapped.
6750 FormatStyle Style = getLLVMStyle();
6751 Style.IndentWrappedFunctionNames = false;
6752 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
6753 "veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
6754 " anotherName:(NSString)bbbbbbbbbbbbbb {\n"
6755 "}",
6756 Style);
6757 Style.IndentWrappedFunctionNames = true;
6758 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
6759 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
6760 " anotherName:(NSString)bbbbbbbbbbbbbb {\n"
6761 "}",
6762 Style);
6763
Nico Weberd6f962f2013-01-10 20:18:33 +00006764 verifyFormat("- (int)sum:(vector<int>)numbers;");
Nico Weber772fbfd2013-01-17 06:14:50 +00006765 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
Nico Weberd6f962f2013-01-10 20:18:33 +00006766 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
6767 // protocol lists (but not for template classes):
Daniel Jaspera44991332015-04-29 13:06:49 +00006768 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
Nico Weber9efe2912013-01-10 23:11:41 +00006769
Daniel Jasper37194282013-05-28 08:33:00 +00006770 verifyFormat("- (int (*)())foo:(int (*)())f;");
6771 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
Nico Weber9efe2912013-01-10 23:11:41 +00006772
6773 // If there's no return type (very rare in practice!), LLVM and Google style
6774 // agree.
Daniel Jasperdd9276e2013-03-22 16:55:40 +00006775 verifyFormat("- foo;");
Nico Weber9efe2912013-01-10 23:11:41 +00006776 verifyFormat("- foo:(int)f;");
6777 verifyGoogleFormat("- foo:(int)foo;");
Fariborz Jahanian68a542a2012-12-20 19:54:13 +00006778}
6779
Nico Weber7eecf4b2013-01-09 20:25:35 +00006780TEST_F(FormatTest, FormatObjCInterface) {
Nico Webera6087752013-01-10 20:12:55 +00006781 verifyFormat("@interface Foo : NSObject <NSSomeDelegate> {\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00006782 "@public\n"
6783 " int field1;\n"
6784 "@protected\n"
6785 " int field2;\n"
6786 "@private\n"
6787 " int field3;\n"
6788 "@package\n"
6789 " int field4;\n"
6790 "}\n"
6791 "+ (id)init;\n"
6792 "@end");
6793
Nico Weber7eecf4b2013-01-09 20:25:35 +00006794 verifyGoogleFormat("@interface Foo : NSObject<NSSomeDelegate> {\n"
6795 " @public\n"
6796 " int field1;\n"
6797 " @protected\n"
6798 " int field2;\n"
6799 " @private\n"
6800 " int field3;\n"
6801 " @package\n"
6802 " int field4;\n"
6803 "}\n"
Nico Weber772fbfd2013-01-17 06:14:50 +00006804 "+ (id)init;\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00006805 "@end");
6806
Nico Weber6029d4f2013-01-22 16:53:59 +00006807 verifyFormat("@interface /* wait for it */ Foo\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00006808 "+ (id)init;\n"
6809 "// Look, a comment!\n"
6810 "- (int)answerWith:(int)i;\n"
6811 "@end");
6812
6813 verifyFormat("@interface Foo\n"
Nico Weberd8ffe752013-01-09 21:42:32 +00006814 "@end\n"
6815 "@interface Bar\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00006816 "@end");
6817
6818 verifyFormat("@interface Foo : Bar\n"
6819 "+ (id)init;\n"
6820 "@end");
6821
Nico Weber6029d4f2013-01-22 16:53:59 +00006822 verifyFormat("@interface Foo : /**/ Bar /**/ <Baz, /**/ Quux>\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00006823 "+ (id)init;\n"
6824 "@end");
6825
Nico Webera6087752013-01-10 20:12:55 +00006826 verifyGoogleFormat("@interface Foo : Bar<Baz, Quux>\n"
Nico Weber772fbfd2013-01-17 06:14:50 +00006827 "+ (id)init;\n"
Nico Webera6087752013-01-10 20:12:55 +00006828 "@end");
6829
Nico Weber2bb00742013-01-10 19:19:14 +00006830 verifyFormat("@interface Foo (HackStuff)\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00006831 "+ (id)init;\n"
6832 "@end");
6833
Nico Weber2bb00742013-01-10 19:19:14 +00006834 verifyFormat("@interface Foo ()\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00006835 "+ (id)init;\n"
6836 "@end");
6837
Nico Webera6087752013-01-10 20:12:55 +00006838 verifyFormat("@interface Foo (HackStuff) <MyProtocol>\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00006839 "+ (id)init;\n"
6840 "@end");
6841
Daniel Jasper20e15562015-04-16 07:02:19 +00006842 verifyGoogleFormat("@interface Foo (HackStuff)<MyProtocol>\n"
Nico Weber772fbfd2013-01-17 06:14:50 +00006843 "+ (id)init;\n"
Nico Webera6087752013-01-10 20:12:55 +00006844 "@end");
6845
Manuel Klimek2acb7b72013-01-11 19:17:44 +00006846 verifyFormat("@interface Foo {\n"
6847 " int _i;\n"
6848 "}\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00006849 "+ (id)init;\n"
6850 "@end");
6851
Manuel Klimek2acb7b72013-01-11 19:17:44 +00006852 verifyFormat("@interface Foo : Bar {\n"
6853 " int _i;\n"
6854 "}\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00006855 "+ (id)init;\n"
6856 "@end");
6857
Manuel Klimek2acb7b72013-01-11 19:17:44 +00006858 verifyFormat("@interface Foo : Bar <Baz, Quux> {\n"
6859 " int _i;\n"
6860 "}\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00006861 "+ (id)init;\n"
6862 "@end");
6863
Manuel Klimek2acb7b72013-01-11 19:17:44 +00006864 verifyFormat("@interface Foo (HackStuff) {\n"
6865 " int _i;\n"
6866 "}\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00006867 "+ (id)init;\n"
6868 "@end");
6869
Manuel Klimek2acb7b72013-01-11 19:17:44 +00006870 verifyFormat("@interface Foo () {\n"
6871 " int _i;\n"
6872 "}\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00006873 "+ (id)init;\n"
6874 "@end");
6875
Manuel Klimek2acb7b72013-01-11 19:17:44 +00006876 verifyFormat("@interface Foo (HackStuff) <MyProtocol> {\n"
6877 " int _i;\n"
6878 "}\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00006879 "+ (id)init;\n"
6880 "@end");
Daniel Jasper437c3f52014-04-28 07:34:48 +00006881
6882 FormatStyle OnePerLine = getGoogleStyle();
6883 OnePerLine.BinPackParameters = false;
Daniel Jasper20e15562015-04-16 07:02:19 +00006884 verifyFormat("@interface aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ()<\n"
Daniel Jasper437c3f52014-04-28 07:34:48 +00006885 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6886 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6887 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6888 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n"
6889 "}",
6890 OnePerLine);
Nico Weber7eecf4b2013-01-09 20:25:35 +00006891}
6892
Nico Weber2ce0ac52013-01-09 23:25:37 +00006893TEST_F(FormatTest, FormatObjCImplementation) {
6894 verifyFormat("@implementation Foo : NSObject {\n"
6895 "@public\n"
6896 " int field1;\n"
6897 "@protected\n"
6898 " int field2;\n"
6899 "@private\n"
6900 " int field3;\n"
6901 "@package\n"
6902 " int field4;\n"
6903 "}\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00006904 "+ (id)init {\n}\n"
Nico Weber2ce0ac52013-01-09 23:25:37 +00006905 "@end");
6906
6907 verifyGoogleFormat("@implementation Foo : NSObject {\n"
6908 " @public\n"
6909 " int field1;\n"
6910 " @protected\n"
6911 " int field2;\n"
6912 " @private\n"
6913 " int field3;\n"
6914 " @package\n"
6915 " int field4;\n"
6916 "}\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00006917 "+ (id)init {\n}\n"
Nico Weber2ce0ac52013-01-09 23:25:37 +00006918 "@end");
6919
6920 verifyFormat("@implementation Foo\n"
6921 "+ (id)init {\n"
Daniel Jasper1b750ed2013-01-14 16:24:39 +00006922 " if (true)\n"
6923 " return nil;\n"
Nico Weber2ce0ac52013-01-09 23:25:37 +00006924 "}\n"
6925 "// Look, a comment!\n"
Manuel Klimek2acb7b72013-01-11 19:17:44 +00006926 "- (int)answerWith:(int)i {\n"
6927 " return i;\n"
6928 "}\n"
Nico Webera21aaae2013-01-11 21:14:08 +00006929 "+ (int)answerWith:(int)i {\n"
6930 " return i;\n"
6931 "}\n"
Nico Weber2ce0ac52013-01-09 23:25:37 +00006932 "@end");
6933
6934 verifyFormat("@implementation Foo\n"
6935 "@end\n"
6936 "@implementation Bar\n"
6937 "@end");
6938
Daniel Jasper91b032a2014-05-22 12:46:38 +00006939 EXPECT_EQ("@implementation Foo : Bar\n"
6940 "+ (id)init {\n}\n"
6941 "- (void)foo {\n}\n"
6942 "@end",
6943 format("@implementation Foo : Bar\n"
6944 "+(id)init{}\n"
6945 "-(void)foo{}\n"
6946 "@end"));
Nico Weber2ce0ac52013-01-09 23:25:37 +00006947
Manuel Klimek2acb7b72013-01-11 19:17:44 +00006948 verifyFormat("@implementation Foo {\n"
6949 " int _i;\n"
6950 "}\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00006951 "+ (id)init {\n}\n"
Nico Weber2ce0ac52013-01-09 23:25:37 +00006952 "@end");
6953
Manuel Klimek2acb7b72013-01-11 19:17:44 +00006954 verifyFormat("@implementation Foo : Bar {\n"
6955 " int _i;\n"
6956 "}\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00006957 "+ (id)init {\n}\n"
Nico Weber2ce0ac52013-01-09 23:25:37 +00006958 "@end");
6959
Nico Weber2bb00742013-01-10 19:19:14 +00006960 verifyFormat("@implementation Foo (HackStuff)\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00006961 "+ (id)init {\n}\n"
Nico Weber2ce0ac52013-01-09 23:25:37 +00006962 "@end");
Daniel Jaspera15da302013-08-28 08:04:23 +00006963 verifyFormat("@implementation ObjcClass\n"
6964 "- (void)method;\n"
6965 "{}\n"
6966 "@end");
Nico Weber2ce0ac52013-01-09 23:25:37 +00006967}
6968
Nico Weber8696a8d2013-01-09 21:15:03 +00006969TEST_F(FormatTest, FormatObjCProtocol) {
6970 verifyFormat("@protocol Foo\n"
6971 "@property(weak) id delegate;\n"
6972 "- (NSUInteger)numberOfThings;\n"
6973 "@end");
6974
Nico Webera6087752013-01-10 20:12:55 +00006975 verifyFormat("@protocol MyProtocol <NSObject>\n"
Nico Weber8696a8d2013-01-09 21:15:03 +00006976 "- (NSUInteger)numberOfThings;\n"
6977 "@end");
6978
Nico Webera6087752013-01-10 20:12:55 +00006979 verifyGoogleFormat("@protocol MyProtocol<NSObject>\n"
Nico Weber772fbfd2013-01-17 06:14:50 +00006980 "- (NSUInteger)numberOfThings;\n"
Nico Webera6087752013-01-10 20:12:55 +00006981 "@end");
6982
Nico Weber8696a8d2013-01-09 21:15:03 +00006983 verifyFormat("@protocol Foo;\n"
6984 "@protocol Bar;\n");
Nico Weberd8ffe752013-01-09 21:42:32 +00006985
6986 verifyFormat("@protocol Foo\n"
6987 "@end\n"
6988 "@protocol Bar\n"
6989 "@end");
Nico Weber51306d22013-01-10 00:25:19 +00006990
6991 verifyFormat("@protocol myProtocol\n"
6992 "- (void)mandatoryWithInt:(int)i;\n"
6993 "@optional\n"
6994 "- (void)optional;\n"
6995 "@required\n"
6996 "- (void)required;\n"
Nico Weberbbe28b32013-01-10 00:42:07 +00006997 "@optional\n"
6998 "@property(assign) int madProp;\n"
Nico Weber51306d22013-01-10 00:25:19 +00006999 "@end\n");
Daniel Jasper9688ff12013-08-01 13:46:58 +00007000
7001 verifyFormat("@property(nonatomic, assign, readonly)\n"
7002 " int *looooooooooooooooooooooooooooongNumber;\n"
7003 "@property(nonatomic, assign, readonly)\n"
7004 " NSString *looooooooooooooooooooooooooooongName;");
Benjamin Kramere21cb742014-01-08 15:59:42 +00007005
7006 verifyFormat("@implementation PR18406\n"
7007 "}\n"
7008 "@end");
Nico Weber8696a8d2013-01-09 21:15:03 +00007009}
7010
Daniel Jasper1ac3e052013-02-05 10:07:47 +00007011TEST_F(FormatTest, FormatObjCMethodDeclarations) {
7012 verifyFormat("- (void)doSomethingWith:(GTMFoo *)theFoo\n"
7013 " rect:(NSRect)theRect\n"
7014 " interval:(float)theInterval {\n"
7015 "}");
7016 verifyFormat("- (void)shortf:(GTMFoo *)theFoo\n"
7017 " longKeyword:(NSRect)theRect\n"
7018 " evenLongerKeyword:(float)theInterval\n"
7019 " error:(NSError **)theError {\n"
7020 "}");
Daniel Jasperec8e8382014-10-11 08:24:56 +00007021 verifyFormat("- (instancetype)initXxxxxx:(id<x>)x\n"
7022 " y:(id<yyyyyyyyyyyyyyyyyyyy>)y\n"
7023 " NS_DESIGNATED_INITIALIZER;",
7024 getLLVMStyleWithColumns(60));
Daniel Jasper1ac3e052013-02-05 10:07:47 +00007025}
7026
Nico Webera7252d82013-01-12 06:18:40 +00007027TEST_F(FormatTest, FormatObjCMethodExpr) {
7028 verifyFormat("[foo bar:baz];");
7029 verifyFormat("return [foo bar:baz];");
Daniel Jasperea772b4d2014-10-16 08:38:51 +00007030 verifyFormat("return (a)[foo bar:baz];");
Nico Webera7252d82013-01-12 06:18:40 +00007031 verifyFormat("f([foo bar:baz]);");
7032 verifyFormat("f(2, [foo bar:baz]);");
7033 verifyFormat("f(2, a ? b : c);");
7034 verifyFormat("[[self initWithInt:4] bar:[baz quux:arrrr]];");
7035
Nico Weberb76de882013-02-05 16:21:00 +00007036 // Unary operators.
7037 verifyFormat("int a = +[foo bar:baz];");
7038 verifyFormat("int a = -[foo bar:baz];");
7039 verifyFormat("int a = ![foo bar:baz];");
7040 verifyFormat("int a = ~[foo bar:baz];");
7041 verifyFormat("int a = ++[foo bar:baz];");
7042 verifyFormat("int a = --[foo bar:baz];");
7043 verifyFormat("int a = sizeof [foo bar:baz];");
Alexander Kornienko1e808872013-06-28 12:51:24 +00007044 verifyFormat("int a = alignof [foo bar:baz];", getGoogleStyle());
Nico Weber5d2624e2013-02-06 06:20:11 +00007045 verifyFormat("int a = &[foo bar:baz];");
7046 verifyFormat("int a = *[foo bar:baz];");
Nico Weberb76de882013-02-05 16:21:00 +00007047 // FIXME: Make casts work, without breaking f()[4].
Daniel Jaspera44991332015-04-29 13:06:49 +00007048 // verifyFormat("int a = (int)[foo bar:baz];");
7049 // verifyFormat("return (int)[foo bar:baz];");
7050 // verifyFormat("(void)[foo bar:baz];");
Nico Webera7892392013-02-13 03:48:27 +00007051 verifyFormat("return (MyType *)[self.tableView cellForRowAtIndexPath:cell];");
Nico Weberb76de882013-02-05 16:21:00 +00007052
7053 // Binary operators.
Nico Webera7252d82013-01-12 06:18:40 +00007054 verifyFormat("[foo bar:baz], [foo bar:baz];");
7055 verifyFormat("[foo bar:baz] = [foo bar:baz];");
7056 verifyFormat("[foo bar:baz] *= [foo bar:baz];");
7057 verifyFormat("[foo bar:baz] /= [foo bar:baz];");
7058 verifyFormat("[foo bar:baz] %= [foo bar:baz];");
7059 verifyFormat("[foo bar:baz] += [foo bar:baz];");
7060 verifyFormat("[foo bar:baz] -= [foo bar:baz];");
7061 verifyFormat("[foo bar:baz] <<= [foo bar:baz];");
7062 verifyFormat("[foo bar:baz] >>= [foo bar:baz];");
7063 verifyFormat("[foo bar:baz] &= [foo bar:baz];");
7064 verifyFormat("[foo bar:baz] ^= [foo bar:baz];");
7065 verifyFormat("[foo bar:baz] |= [foo bar:baz];");
7066 verifyFormat("[foo bar:baz] ? [foo bar:baz] : [foo bar:baz];");
7067 verifyFormat("[foo bar:baz] || [foo bar:baz];");
7068 verifyFormat("[foo bar:baz] && [foo bar:baz];");
7069 verifyFormat("[foo bar:baz] | [foo bar:baz];");
7070 verifyFormat("[foo bar:baz] ^ [foo bar:baz];");
7071 verifyFormat("[foo bar:baz] & [foo bar:baz];");
7072 verifyFormat("[foo bar:baz] == [foo bar:baz];");
7073 verifyFormat("[foo bar:baz] != [foo bar:baz];");
7074 verifyFormat("[foo bar:baz] >= [foo bar:baz];");
7075 verifyFormat("[foo bar:baz] <= [foo bar:baz];");
7076 verifyFormat("[foo bar:baz] > [foo bar:baz];");
7077 verifyFormat("[foo bar:baz] < [foo bar:baz];");
7078 verifyFormat("[foo bar:baz] >> [foo bar:baz];");
7079 verifyFormat("[foo bar:baz] << [foo bar:baz];");
7080 verifyFormat("[foo bar:baz] - [foo bar:baz];");
7081 verifyFormat("[foo bar:baz] + [foo bar:baz];");
7082 verifyFormat("[foo bar:baz] * [foo bar:baz];");
7083 verifyFormat("[foo bar:baz] / [foo bar:baz];");
7084 verifyFormat("[foo bar:baz] % [foo bar:baz];");
7085 // Whew!
7086
Nico Weber29f9dea2013-02-11 15:32:15 +00007087 verifyFormat("return in[42];");
Daniel Jasper3a623db2014-12-18 12:11:01 +00007088 verifyFormat("for (auto v : in[1]) {\n}");
Daniel Jasper2b1865c2015-04-15 07:26:18 +00007089 verifyFormat("for (int i = 0; i < in[a]; ++i) {\n}");
7090 verifyFormat("for (int i = 0; in[a] < i; ++i) {\n}");
7091 verifyFormat("for (int i = 0; i < n; ++i, ++in[a]) {\n}");
7092 verifyFormat("for (int i = 0; i < n; ++i, in[a]++) {\n}");
7093 verifyFormat("for (int i = 0; i < f(in[a]); ++i, in[a]++) {\n}");
Nico Weber29f9dea2013-02-11 15:32:15 +00007094 verifyFormat("for (id foo in [self getStuffFor:bla]) {\n"
7095 "}");
Daniel Jasper78580792014-10-20 12:01:45 +00007096 verifyFormat("[self aaaaa:MACRO(a, b:, c:)];");
Daniel Jaspercdb58b22015-05-15 09:05:31 +00007097 verifyFormat("[self aaaaa:(1 + 2) bbbbb:3];");
7098 verifyFormat("[self aaaaa:(Type)a bbbbb:3];");
Nico Weber29f9dea2013-02-11 15:32:15 +00007099
Nico Webera7252d82013-01-12 06:18:40 +00007100 verifyFormat("[self stuffWithInt:(4 + 2) float:4.5];");
7101 verifyFormat("[self stuffWithInt:a ? b : c float:4.5];");
7102 verifyFormat("[self stuffWithInt:a ? [self foo:bar] : c];");
7103 verifyFormat("[self stuffWithInt:a ? (e ? f : g) : c];");
7104 verifyFormat("[cond ? obj1 : obj2 methodWithParam:param]");
Nico Weber5c8709b2013-01-12 23:41:33 +00007105 verifyFormat("[button setAction:@selector(zoomOut:)];");
Nico Weber2827a7e2013-01-12 23:48:49 +00007106 verifyFormat("[color getRed:&r green:&g blue:&b alpha:&a];");
Daniel Jasper1ac3e052013-02-05 10:07:47 +00007107
Nico Webera7252d82013-01-12 06:18:40 +00007108 verifyFormat("arr[[self indexForFoo:a]];");
7109 verifyFormat("throw [self errorFor:a];");
7110 verifyFormat("@throw [self errorFor:a];");
7111
Nico Weberec9e4102013-06-25 00:55:57 +00007112 verifyFormat("[(id)foo bar:(id)baz quux:(id)snorf];");
7113 verifyFormat("[(id)foo bar:(id) ? baz : quux];");
7114 verifyFormat("4 > 4 ? (id)a : (id)baz;");
7115
Nico Weberc9d73612013-01-12 22:48:47 +00007116 // This tests that the formatter doesn't break after "backing" but before ":",
7117 // which would be at 80 columns.
Nico Webera7252d82013-01-12 06:18:40 +00007118 verifyFormat(
7119 "void f() {\n"
Daniel Jasper1ac3e052013-02-05 10:07:47 +00007120 " if ((self = [super initWithContentRect:contentRect\n"
Daniel Jasper7cdc78b2013-08-01 23:13:03 +00007121 " styleMask:styleMask ?: otherMask\n"
Daniel Jasper1ac3e052013-02-05 10:07:47 +00007122 " backing:NSBackingStoreBuffered\n"
7123 " defer:YES]))");
7124
Daniel Jasperc697ad22013-02-06 10:05:46 +00007125 verifyFormat(
7126 "[foo checkThatBreakingAfterColonWorksOk:\n"
Daniel Jasper7cdc78b2013-08-01 23:13:03 +00007127 " [bar ifItDoes:reduceOverallLineLengthLikeInThisCase]];");
Daniel Jasper1ac3e052013-02-05 10:07:47 +00007128
7129 verifyFormat("[myObj short:arg1 // Force line break\n"
Daniel Jasper7cdc78b2013-08-01 23:13:03 +00007130 " longKeyword:arg2 != nil ? arg2 : @\"longKeyword\"\n"
7131 " evenLongerKeyword:arg3 ?: @\"evenLongerKeyword\"\n"
Daniel Jasper1ac3e052013-02-05 10:07:47 +00007132 " error:arg4];");
7133 verifyFormat(
7134 "void f() {\n"
7135 " popup_window_.reset([[RenderWidgetPopupWindow alloc]\n"
7136 " initWithContentRect:NSMakeRect(origin_global.x, origin_global.y,\n"
7137 " pos.width(), pos.height())\n"
7138 " styleMask:NSBorderlessWindowMask\n"
7139 " backing:NSBackingStoreBuffered\n"
7140 " defer:NO]);\n"
7141 "}");
Daniel Jasper4478e522013-11-08 17:33:24 +00007142 verifyFormat(
7143 "void f() {\n"
7144 " popup_wdow_.reset([[RenderWidgetPopupWindow alloc]\n"
7145 " iniithContentRect:NSMakRet(origin_global.x, origin_global.y,\n"
7146 " pos.width(), pos.height())\n"
7147 " syeMask:NSBorderlessWindowMask\n"
7148 " bking:NSBackingStoreBuffered\n"
7149 " der:NO]);\n"
7150 "}",
7151 getLLVMStyleWithColumns(70));
Daniel Jasper18210d72014-10-09 09:52:05 +00007152 verifyFormat(
7153 "void f() {\n"
7154 " popup_window_.reset([[RenderWidgetPopupWindow alloc]\n"
7155 " initWithContentRect:NSMakeRect(origin_global.x, origin_global.y,\n"
7156 " pos.width(), pos.height())\n"
7157 " styleMask:NSBorderlessWindowMask\n"
7158 " backing:NSBackingStoreBuffered\n"
7159 " defer:NO]);\n"
7160 "}",
7161 getChromiumStyle(FormatStyle::LK_Cpp));
Daniel Jasperc697ad22013-02-06 10:05:46 +00007162 verifyFormat("[contentsContainer replaceSubview:[subviews objectAtIndex:0]\n"
7163 " with:contentsNativeView];");
7164
7165 verifyFormat(
7166 "[pboard addTypes:[NSArray arrayWithObject:kBookmarkButtonDragType]\n"
7167 " owner:nillllll];");
7168
Daniel Jasperc697ad22013-02-06 10:05:46 +00007169 verifyFormat(
Daniel Jasperacc33662013-02-08 08:22:00 +00007170 "[pboard setData:[NSData dataWithBytes:&button length:sizeof(button)]\n"
Daniel Jasperc697ad22013-02-06 10:05:46 +00007171 " forType:kBookmarkButtonDragType];");
7172
7173 verifyFormat("[defaultCenter addObserver:self\n"
7174 " selector:@selector(willEnterFullscreen)\n"
7175 " name:kWillEnterFullscreenNotification\n"
7176 " object:nil];");
Daniel Jasperc485b4e2013-02-06 16:00:26 +00007177 verifyFormat("[image_rep drawInRect:drawRect\n"
7178 " fromRect:NSZeroRect\n"
7179 " operation:NSCompositeCopy\n"
7180 " fraction:1.0\n"
7181 " respectFlipped:NO\n"
7182 " hints:nil];");
Daniel Jaspereb536682015-05-06 12:48:06 +00007183 verifyFormat("[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7184 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
Daniel Jasper9c950132015-05-07 14:19:59 +00007185 verifyFormat("[aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
7186 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
Daniel Jaspera7b14262015-05-13 10:23:03 +00007187 verifyFormat("[aaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaa[aaaaaaaaaaaaaaaaaaaaa]\n"
7188 " aaaaaaaaaaaaaaaaaaaaaa];");
Daniel Jaspered41f772015-05-19 11:06:33 +00007189 verifyFormat("[call aaaaaaaa.aaaaaa.aaaaaaaa.aaaaaaaa.aaaaaaaa.aaaaaaaa\n"
7190 " .aaaaaaaa];", // FIXME: Indentation seems off.
7191 getLLVMStyleWithColumns(60));
Nico Weberac9bde22013-02-06 16:54:35 +00007192
7193 verifyFormat(
7194 "scoped_nsobject<NSTextField> message(\n"
7195 " // The frame will be fixed up when |-setMessageText:| is called.\n"
7196 " [[NSTextField alloc] initWithFrame:NSMakeRect(0, 0, 0, 0)]);");
Daniel Jasper7cdc78b2013-08-01 23:13:03 +00007197 verifyFormat("[self aaaaaa:bbbbbbbbbbbbb\n"
7198 " aaaaaaaaaa:bbbbbbbbbbbbbbbbb\n"
7199 " aaaaa:bbbbbbbbbbb + bbbbbbbbbbbb\n"
7200 " aaaa:bbb];");
Daniel Jasper4478e522013-11-08 17:33:24 +00007201 verifyFormat("[self param:function( //\n"
7202 " parameter)]");
Daniel Jasperf48b5ab2013-11-07 19:23:49 +00007203 verifyFormat(
7204 "[self aaaaaaaaaa:aaaaaaaaaaaaaaa | aaaaaaaaaaaaaaa | aaaaaaaaaaaaaaa |\n"
7205 " aaaaaaaaaaaaaaa | aaaaaaaaaaaaaaa | aaaaaaaaaaaaaaa |\n"
7206 " aaaaaaaaaaaaaaa | aaaaaaaaaaaaaaa];");
Daniel Jaspera1ea4cb2013-10-26 17:00:22 +00007207
Daniel Jasper2746a302015-05-06 13:13:03 +00007208 // FIXME: This violates the column limit.
7209 verifyFormat(
7210 "[aaaaaaaaaaaaaaaaaaaaaaaaa\n"
7211 " aaaaaaaaaaaaaaaaa:aaaaaaaa\n"
7212 " aaa:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];",
7213 getLLVMStyleWithColumns(60));
7214
Daniel Jaspera1ea4cb2013-10-26 17:00:22 +00007215 // Variadic parameters.
7216 verifyFormat(
7217 "NSArray *myStrings = [NSArray stringarray:@\"a\", @\"b\", nil];");
Daniel Jasperf48b5ab2013-11-07 19:23:49 +00007218 verifyFormat(
7219 "[self aaaaaaaaaaaaa:aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaa,\n"
7220 " aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaa,\n"
7221 " aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaa];");
Daniel Jasperb302f9a2013-11-08 02:08:01 +00007222 verifyFormat("[self // break\n"
7223 " a:a\n"
7224 " aaa:aaa];");
Daniel Jasper3460b252013-12-18 07:08:51 +00007225 verifyFormat("bool a = ([aaaaaaaa aaaaa] == aaaaaaaaaaaaaaaaa ||\n"
7226 " [aaaaaaaa aaaaa] == aaaaaaaaaaaaaaaaaaaa);");
Nico Webera7252d82013-01-12 06:18:40 +00007227}
7228
Nico Weber12d5bab2013-01-07 15:56:25 +00007229TEST_F(FormatTest, ObjCAt) {
Nico Weber803d61d2013-01-07 16:07:07 +00007230 verifyFormat("@autoreleasepool");
Nico Webere89c42f2013-01-07 16:14:28 +00007231 verifyFormat("@catch");
7232 verifyFormat("@class");
Nico Weber803d61d2013-01-07 16:07:07 +00007233 verifyFormat("@compatibility_alias");
7234 verifyFormat("@defs");
Nico Webera8876502013-01-07 15:17:23 +00007235 verifyFormat("@dynamic");
Nico Weber803d61d2013-01-07 16:07:07 +00007236 verifyFormat("@encode");
7237 verifyFormat("@end");
7238 verifyFormat("@finally");
7239 verifyFormat("@implementation");
7240 verifyFormat("@import");
7241 verifyFormat("@interface");
7242 verifyFormat("@optional");
7243 verifyFormat("@package");
Nico Webere89c42f2013-01-07 16:14:28 +00007244 verifyFormat("@private");
Nico Weber803d61d2013-01-07 16:07:07 +00007245 verifyFormat("@property");
Nico Webere89c42f2013-01-07 16:14:28 +00007246 verifyFormat("@protected");
Nico Weber803d61d2013-01-07 16:07:07 +00007247 verifyFormat("@protocol");
Nico Webere89c42f2013-01-07 16:14:28 +00007248 verifyFormat("@public");
Nico Weber803d61d2013-01-07 16:07:07 +00007249 verifyFormat("@required");
7250 verifyFormat("@selector");
7251 verifyFormat("@synchronized");
7252 verifyFormat("@synthesize");
Nico Webere89c42f2013-01-07 16:14:28 +00007253 verifyFormat("@throw");
7254 verifyFormat("@try");
Nico Weber803d61d2013-01-07 16:07:07 +00007255
Nico Weber12d5bab2013-01-07 15:56:25 +00007256 EXPECT_EQ("@interface", format("@ interface"));
7257
7258 // The precise formatting of this doesn't matter, nobody writes code like
7259 // this.
7260 verifyFormat("@ /*foo*/ interface");
Nico Webera8876502013-01-07 15:17:23 +00007261}
7262
Nico Weberd8cdb532013-01-08 19:15:23 +00007263TEST_F(FormatTest, ObjCSnippets) {
Manuel Klimek2acb7b72013-01-11 19:17:44 +00007264 verifyFormat("@autoreleasepool {\n"
7265 " foo();\n"
7266 "}");
Nico Weber7e6a7a12013-01-08 17:56:31 +00007267 verifyFormat("@class Foo, Bar;");
Nico Weberd8cdb532013-01-08 19:15:23 +00007268 verifyFormat("@compatibility_alias AliasName ExistingClass;");
Nico Weber7e6a7a12013-01-08 17:56:31 +00007269 verifyFormat("@dynamic textColor;");
Nico Webere3025672013-01-18 05:11:47 +00007270 verifyFormat("char *buf1 = @encode(int *);");
7271 verifyFormat("char *buf1 = @encode(typeof(4 * 5));");
Nico Weber44449172013-02-12 16:17:07 +00007272 verifyFormat("char *buf1 = @encode(int **);");
Nico Weber4cc98742013-01-08 20:16:23 +00007273 verifyFormat("Protocol *proto = @protocol(p1);");
Nico Weber250fe712013-01-18 02:43:57 +00007274 verifyFormat("SEL s = @selector(foo:);");
Manuel Klimek2acb7b72013-01-11 19:17:44 +00007275 verifyFormat("@synchronized(self) {\n"
7276 " f();\n"
7277 "}");
Nico Weber7e6a7a12013-01-08 17:56:31 +00007278
Nico Webera2a84952013-01-10 21:30:42 +00007279 verifyFormat("@synthesize dropArrowPosition = dropArrowPosition_;");
7280 verifyGoogleFormat("@synthesize dropArrowPosition = dropArrowPosition_;");
7281
Nico Weber7e6a7a12013-01-08 17:56:31 +00007282 verifyFormat("@property(assign, nonatomic) CGFloat hoverAlpha;");
Nico Webera2a84952013-01-10 21:30:42 +00007283 verifyFormat("@property(assign, getter=isEditable) BOOL editable;");
7284 verifyGoogleFormat("@property(assign, getter=isEditable) BOOL editable;");
Daniel Jaspere9beea22014-01-28 15:20:33 +00007285 verifyFormat("@property (assign, getter=isEditable) BOOL editable;",
7286 getMozillaStyle());
7287 verifyFormat("@property BOOL editable;", getMozillaStyle());
7288 verifyFormat("@property (assign, getter=isEditable) BOOL editable;",
7289 getWebKitStyle());
7290 verifyFormat("@property BOOL editable;", getWebKitStyle());
Nico Webere8d78242013-06-25 00:25:40 +00007291
7292 verifyFormat("@import foo.bar;\n"
7293 "@import baz;");
Nico Weber7e6a7a12013-01-08 17:56:31 +00007294}
7295
Nico Weber0588b502013-02-07 00:19:29 +00007296TEST_F(FormatTest, ObjCLiterals) {
7297 verifyFormat("@\"String\"");
7298 verifyFormat("@1");
7299 verifyFormat("@+4.8");
7300 verifyFormat("@-4");
7301 verifyFormat("@1LL");
7302 verifyFormat("@.5");
7303 verifyFormat("@'c'");
7304 verifyFormat("@true");
7305
7306 verifyFormat("NSNumber *smallestInt = @(-INT_MAX - 1);");
7307 verifyFormat("NSNumber *piOverTwo = @(M_PI / 2);");
7308 verifyFormat("NSNumber *favoriteColor = @(Green);");
7309 verifyFormat("NSString *path = @(getenv(\"PATH\"));");
Daniel Jasperb1c19f82014-01-10 07:44:53 +00007310
7311 verifyFormat("[dictionary setObject:@(1) forKey:@\"number\"];");
Daniel Jasperb596fb22013-10-24 10:31:50 +00007312}
Nico Weber0588b502013-02-07 00:19:29 +00007313
Daniel Jasperb596fb22013-10-24 10:31:50 +00007314TEST_F(FormatTest, ObjCDictLiterals) {
Nico Weber0588b502013-02-07 00:19:29 +00007315 verifyFormat("@{");
Nico Weber372d8dc2013-02-10 20:35:35 +00007316 verifyFormat("@{}");
Chandler Carruthf8b72662014-03-02 12:37:31 +00007317 verifyFormat("@{@\"one\" : @1}");
7318 verifyFormat("return @{@\"one\" : @1;");
Daniel Jaspera125d532014-03-21 12:38:57 +00007319 verifyFormat("@{@\"one\" : @1}");
Manuel Klimek1a18c402013-04-12 14:13:36 +00007320
Chandler Carruthf8b72662014-03-02 12:37:31 +00007321 verifyFormat("@{@\"one\" : @{@2 : @1}}");
Daniel Jaspera125d532014-03-21 12:38:57 +00007322 verifyFormat("@{\n"
7323 " @\"one\" : @{@2 : @1},\n"
7324 "}");
Manuel Klimek1a18c402013-04-12 14:13:36 +00007325
Chandler Carruthf8b72662014-03-02 12:37:31 +00007326 verifyFormat("@{1 > 2 ? @\"one\" : @\"two\" : 1 > 2 ? @1 : @2}");
Manuel Klimekec5c3db2015-05-07 12:26:30 +00007327 verifyIncompleteFormat("[self setDict:@{}");
7328 verifyIncompleteFormat("[self setDict:@{@1 : @2}");
Chandler Carruthf8b72662014-03-02 12:37:31 +00007329 verifyFormat("NSLog(@\"%@\", @{@1 : @2, @2 : @3}[@1]);");
Nico Weber372d8dc2013-02-10 20:35:35 +00007330 verifyFormat(
Chandler Carruthf8b72662014-03-02 12:37:31 +00007331 "NSDictionary *masses = @{@\"H\" : @1.0078, @\"He\" : @4.0026};");
Nico Weber33c68e92013-02-10 20:39:05 +00007332 verifyFormat(
Chandler Carruthf8b72662014-03-02 12:37:31 +00007333 "NSDictionary *settings = @{AVEncoderKey : @(AVAudioQualityMax)};");
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00007334
Daniel Jaspera44991332015-04-29 13:06:49 +00007335 verifyFormat("NSDictionary *d = @{\n"
7336 " @\"nam\" : NSUserNam(),\n"
7337 " @\"dte\" : [NSDate date],\n"
7338 " @\"processInfo\" : [NSProcessInfo processInfo]\n"
7339 "};");
Nico Weberced7d412013-05-26 05:39:26 +00007340 verifyFormat(
Daniel Jasperd489dd32013-10-20 16:45:46 +00007341 "@{\n"
7342 " NSFontAttributeNameeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee : "
7343 "regularFont,\n"
7344 "};");
Daniel Jasperb8f61682013-10-22 15:45:58 +00007345 verifyGoogleFormat(
7346 "@{\n"
7347 " NSFontAttributeNameeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee : "
7348 "regularFont,\n"
7349 "};");
Daniel Jasper1fd6f1f2014-03-17 14:32:47 +00007350 verifyFormat(
7351 "@{\n"
7352 " NSFontAttributeNameeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee :\n"
7353 " reeeeeeeeeeeeeeeeeeeeeeeegularFont,\n"
7354 "};");
Daniel Jasperb596fb22013-10-24 10:31:50 +00007355
7356 // We should try to be robust in case someone forgets the "@".
Daniel Jaspera44991332015-04-29 13:06:49 +00007357 verifyFormat("NSDictionary *d = {\n"
7358 " @\"nam\" : NSUserNam(),\n"
7359 " @\"dte\" : [NSDate date],\n"
7360 " @\"processInfo\" : [NSProcessInfo processInfo]\n"
7361 "};");
Daniel Jasper335ff262014-05-28 09:11:53 +00007362 verifyFormat("NSMutableDictionary *dictionary =\n"
7363 " [NSMutableDictionary dictionaryWithDictionary:@{\n"
7364 " aaaaaaaaaaaaaaaaaaaaa : aaaaaaaaaaaaa,\n"
7365 " bbbbbbbbbbbbbbbbbb : bbbbb,\n"
7366 " cccccccccccccccc : ccccccccccccccc\n"
7367 " }];");
Daniel Jasperb596fb22013-10-24 10:31:50 +00007368}
7369
7370TEST_F(FormatTest, ObjCArrayLiterals) {
Manuel Klimekec5c3db2015-05-07 12:26:30 +00007371 verifyIncompleteFormat("@[");
Daniel Jasperb596fb22013-10-24 10:31:50 +00007372 verifyFormat("@[]");
7373 verifyFormat(
7374 "NSArray *array = @[ @\" Hey \", NSApp, [NSNumber numberWithInt:42] ];");
7375 verifyFormat("return @[ @3, @[], @[ @4, @5 ] ];");
7376 verifyFormat("NSArray *array = @[ [foo description] ];");
7377
7378 verifyFormat(
7379 "NSArray *some_variable = @[\n"
7380 " aaaa == bbbbbbbbbbb ? @\"aaaaaaaaaaaa\" : @\"aaaaaaaaaaaaaa\",\n"
7381 " @\"aaaaaaaaaaaaaaaaa\",\n"
7382 " @\"aaaaaaaaaaaaaaaaa\",\n"
7383 " @\"aaaaaaaaaaaaaaaaa\"\n"
Daniel Jasperb8f61682013-10-22 15:45:58 +00007384 "];");
Daniel Jasperb596fb22013-10-24 10:31:50 +00007385 verifyFormat("NSArray *some_variable = @[\n"
7386 " @\"aaaaaaaaaaaaaaaaa\",\n"
7387 " @\"aaaaaaaaaaaaaaaaa\",\n"
7388 " @\"aaaaaaaaaaaaaaaaa\",\n"
7389 " @\"aaaaaaaaaaaaaaaaa\",\n"
7390 "];");
7391 verifyGoogleFormat("NSArray *some_variable = @[\n"
7392 " @\"aaaaaaaaaaaaaaaaa\",\n"
7393 " @\"aaaaaaaaaaaaaaaaa\",\n"
7394 " @\"aaaaaaaaaaaaaaaaa\",\n"
7395 " @\"aaaaaaaaaaaaaaaaa\"\n"
7396 "];");
Daniel Jasper308062b2015-02-27 08:41:05 +00007397 verifyFormat("NSArray *array = @[\n"
7398 " @\"a\",\n"
7399 " @\"a\",\n" // Trailing comma -> one per line.
7400 "];");
Daniel Jasperb596fb22013-10-24 10:31:50 +00007401
7402 // We should try to be robust in case someone forgets the "@".
7403 verifyFormat("NSArray *some_variable = [\n"
7404 " @\"aaaaaaaaaaaaaaaaa\",\n"
7405 " @\"aaaaaaaaaaaaaaaaa\",\n"
7406 " @\"aaaaaaaaaaaaaaaaa\",\n"
7407 " @\"aaaaaaaaaaaaaaaaa\",\n"
7408 "];");
Daniel Jasper4bf0d802013-11-23 14:27:27 +00007409 verifyFormat(
7410 "- (NSAttributedString *)attributedStringForSegment:(NSUInteger)segment\n"
7411 " index:(NSUInteger)index\n"
7412 " nonDigitAttributes:\n"
7413 " (NSDictionary *)noDigitAttributes;");
Daniel Jasperf841d3a2015-05-28 07:21:50 +00007414 verifyFormat("[someFunction someLooooooooooooongParameter:@[\n"
7415 " NSBundle.mainBundle.infoDictionary[@\"a\"]\n"
7416 "]];");
Nico Weber0588b502013-02-07 00:19:29 +00007417}
7418
Alexander Kornienko64a42b82014-04-15 14:52:43 +00007419TEST_F(FormatTest, BreaksStringLiterals) {
Manuel Klimek1998ea22013-02-20 10:15:13 +00007420 EXPECT_EQ("\"some text \"\n"
7421 "\"other\";",
7422 format("\"some text other\";", getLLVMStyleWithColumns(12)));
Alexander Kornienko9e90b622013-04-17 17:34:05 +00007423 EXPECT_EQ("\"some text \"\n"
7424 "\"other\";",
7425 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
Manuel Klimek1998ea22013-02-20 10:15:13 +00007426 EXPECT_EQ(
7427 "#define A \\\n"
7428 " \"some \" \\\n"
7429 " \"text \" \\\n"
7430 " \"other\";",
7431 format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
7432 EXPECT_EQ(
7433 "#define A \\\n"
7434 " \"so \" \\\n"
7435 " \"text \" \\\n"
7436 " \"other\";",
7437 format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
7438
7439 EXPECT_EQ("\"some text\"",
7440 format("\"some text\"", getLLVMStyleWithColumns(1)));
7441 EXPECT_EQ("\"some text\"",
7442 format("\"some text\"", getLLVMStyleWithColumns(11)));
7443 EXPECT_EQ("\"some \"\n"
7444 "\"text\"",
7445 format("\"some text\"", getLLVMStyleWithColumns(10)));
7446 EXPECT_EQ("\"some \"\n"
7447 "\"text\"",
7448 format("\"some text\"", getLLVMStyleWithColumns(7)));
Manuel Klimekb176cff2013-03-01 13:14:08 +00007449 EXPECT_EQ("\"some\"\n"
Alexander Kornienkocb45bc12013-04-15 14:28:00 +00007450 "\" tex\"\n"
7451 "\"t\"",
Manuel Klimek1998ea22013-02-20 10:15:13 +00007452 format("\"some text\"", getLLVMStyleWithColumns(6)));
Manuel Klimekabf6e032013-03-04 20:03:38 +00007453 EXPECT_EQ("\"some\"\n"
7454 "\" tex\"\n"
7455 "\" and\"",
7456 format("\"some tex and\"", getLLVMStyleWithColumns(6)));
7457 EXPECT_EQ("\"some\"\n"
7458 "\"/tex\"\n"
7459 "\"/and\"",
7460 format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
Manuel Klimek1998ea22013-02-20 10:15:13 +00007461
7462 EXPECT_EQ("variable =\n"
7463 " \"long string \"\n"
7464 " \"literal\";",
7465 format("variable = \"long string literal\";",
7466 getLLVMStyleWithColumns(20)));
7467
7468 EXPECT_EQ("variable = f(\n"
7469 " \"long string \"\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00007470 " \"literal\",\n"
7471 " short,\n"
Manuel Klimek1998ea22013-02-20 10:15:13 +00007472 " loooooooooooooooooooong);",
7473 format("variable = f(\"long string literal\", short, "
7474 "loooooooooooooooooooong);",
7475 getLLVMStyleWithColumns(20)));
Alexander Kornienko4d26b6e2013-06-17 12:59:44 +00007476
Daniel Jaspera44991332015-04-29 13:06:49 +00007477 EXPECT_EQ(
7478 "f(g(\"long string \"\n"
7479 " \"literal\"),\n"
7480 " b);",
7481 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20)));
Alexander Kornienko4d26b6e2013-06-17 12:59:44 +00007482 EXPECT_EQ("f(g(\"long string \"\n"
7483 " \"literal\",\n"
7484 " a),\n"
7485 " b);",
7486 format("f(g(\"long string literal\", a), b);",
7487 getLLVMStyleWithColumns(20)));
Manuel Klimek1998ea22013-02-20 10:15:13 +00007488 EXPECT_EQ(
7489 "f(\"one two\".split(\n"
Daniel Jasperf79b0b12013-08-30 08:29:25 +00007490 " variable));",
Manuel Klimek1998ea22013-02-20 10:15:13 +00007491 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
7492 EXPECT_EQ("f(\"one two three four five six \"\n"
7493 " \"seven\".split(\n"
7494 " really_looooong_variable));",
7495 format("f(\"one two three four five six seven\"."
7496 "split(really_looooong_variable));",
7497 getLLVMStyleWithColumns(33)));
7498
7499 EXPECT_EQ("f(\"some \"\n"
7500 " \"text\",\n"
7501 " other);",
7502 format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
Daniel Jasper5497fce2013-02-26 12:52:34 +00007503
7504 // Only break as a last resort.
7505 verifyFormat(
7506 "aaaaaaaaaaaaaaaaaaaa(\n"
7507 " aaaaaaaaaaaaaaaaaaaa,\n"
7508 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
Manuel Klimekb176cff2013-03-01 13:14:08 +00007509
Daniel Jaspera44991332015-04-29 13:06:49 +00007510 EXPECT_EQ("\"splitmea\"\n"
7511 "\"trandomp\"\n"
7512 "\"oint\"",
7513 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
Manuel Klimeke317d1b2013-03-01 13:29:19 +00007514
Daniel Jaspera44991332015-04-29 13:06:49 +00007515 EXPECT_EQ("\"split/\"\n"
7516 "\"pathat/\"\n"
7517 "\"slashes\"",
7518 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
Daniel Jasper6fe2f002013-04-25 08:56:26 +00007519
Daniel Jaspera44991332015-04-29 13:06:49 +00007520 EXPECT_EQ("\"split/\"\n"
7521 "\"pathat/\"\n"
7522 "\"slashes\"",
7523 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
Alexander Kornienko72852072013-06-19 14:22:47 +00007524 EXPECT_EQ("\"split at \"\n"
7525 "\"spaces/at/\"\n"
7526 "\"slashes.at.any$\"\n"
7527 "\"non-alphanumeric%\"\n"
7528 "\"1111111111characte\"\n"
7529 "\"rs\"",
7530 format("\"split at "
7531 "spaces/at/"
7532 "slashes.at."
7533 "any$non-"
7534 "alphanumeric%"
7535 "1111111111characte"
7536 "rs\"",
7537 getLLVMStyleWithColumns(20)));
7538
Daniel Jasper5aad4e52013-07-12 11:37:05 +00007539 // Verify that splitting the strings understands
7540 // Style::AlwaysBreakBeforeMultilineStrings.
Daniel Jasper2aaedd32015-06-18 09:12:47 +00007541 EXPECT_EQ(
7542 "aaaaaaaaaaaa(\n"
7543 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
7544 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
7545 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
7546 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
7547 "aaaaaaaaaaaaaaaaaaaaaa\");",
7548 getGoogleStyle()));
Daniel Jasper2436fe92013-10-18 16:47:55 +00007549 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
7550 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",
7551 format("return \"aaaaaaaaaaaaaaaaaaaaaa "
7552 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
7553 "aaaaaaaaaaaaaaaaaaaaaa\";",
7554 getGoogleStyle()));
Daniel Jasper3dcd7ec2013-08-02 11:01:15 +00007555 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
7556 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
7557 format("llvm::outs() << "
7558 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
7559 "aaaaaaaaaaaaaaaaaaa\";"));
Daniel Jasperf438cb72013-08-23 11:57:34 +00007560 EXPECT_EQ("ffff(\n"
7561 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
7562 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
7563 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
7564 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
7565 getGoogleStyle()));
Daniel Jasper5aad4e52013-07-12 11:37:05 +00007566
Daniel Jasper6fe2f002013-04-25 08:56:26 +00007567 FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
7568 AlignLeft.AlignEscapedNewlinesLeft = true;
Daniel Jaspera44991332015-04-29 13:06:49 +00007569 EXPECT_EQ("#define A \\\n"
7570 " \"some \" \\\n"
7571 " \"text \" \\\n"
7572 " \"other\";",
7573 format("#define A \"some text other\";", AlignLeft));
Manuel Klimek1998ea22013-02-20 10:15:13 +00007574}
7575
Alexander Kornienko64a42b82014-04-15 14:52:43 +00007576TEST_F(FormatTest, BreaksStringLiteralsWithTabs) {
7577 EXPECT_EQ(
7578 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
7579 "(\n"
7580 " \"x\t\");",
7581 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
7582 "aaaaaaa("
7583 "\"x\t\");"));
7584}
7585
Daniel Jasper174b0122014-01-09 14:18:12 +00007586TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {
Alexander Kornienko81e32942013-09-16 20:20:49 +00007587 EXPECT_EQ(
7588 "u8\"utf8 string \"\n"
7589 "u8\"literal\";",
7590 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
7591 EXPECT_EQ(
7592 "u\"utf16 string \"\n"
7593 "u\"literal\";",
7594 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
7595 EXPECT_EQ(
7596 "U\"utf32 string \"\n"
7597 "U\"literal\";",
7598 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
7599 EXPECT_EQ("L\"wide string \"\n"
7600 "L\"literal\";",
7601 format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
Daniel Jasper174b0122014-01-09 14:18:12 +00007602 EXPECT_EQ("@\"NSString \"\n"
7603 "@\"literal\";",
Daniel Jasperd07c2ee2014-01-14 09:53:07 +00007604 format("@\"NSString literal\";", getGoogleStyleWithColumns(19)));
Daniel Jaspere4b48c62015-01-21 19:50:35 +00007605
7606 // This input makes clang-format try to split the incomplete unicode escape
7607 // sequence, which used to lead to a crasher.
7608 verifyNoCrash(
7609 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
7610 getLLVMStyleWithColumns(60));
Alexander Kornienko81e32942013-09-16 20:20:49 +00007611}
7612
Alexander Kornienko732b6bd2014-12-14 20:47:11 +00007613TEST_F(FormatTest, DoesNotBreakRawStringLiterals) {
7614 FormatStyle Style = getGoogleStyleWithColumns(15);
7615 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style));
7616 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style));
7617 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style));
7618 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style));
7619 EXPECT_EQ("u8R\"x(raw literal)x\";",
7620 format("u8R\"x(raw literal)x\";", Style));
Alexander Kornienko81e32942013-09-16 20:20:49 +00007621}
7622
7623TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
7624 FormatStyle Style = getLLVMStyleWithColumns(20);
7625 EXPECT_EQ(
7626 "_T(\"aaaaaaaaaaaaaa\")\n"
7627 "_T(\"aaaaaaaaaaaaaa\")\n"
7628 "_T(\"aaaaaaaaaaaa\")",
7629 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
7630 EXPECT_EQ("f(x, _T(\"aaaaaaaaa\")\n"
7631 " _T(\"aaaaaa\"),\n"
7632 " z);",
7633 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
7634
7635 // FIXME: Handle embedded spaces in one iteration.
7636 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
7637 // "_T(\"aaaaaaaaaaaaa\")\n"
7638 // "_T(\"aaaaaaaaaaaaa\")\n"
7639 // "_T(\"a\")",
7640 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
7641 // getLLVMStyleWithColumns(20)));
7642 EXPECT_EQ(
7643 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
7644 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
Daniel Jaspere99c72f2015-03-26 14:47:35 +00007645 EXPECT_EQ("f(\n"
7646 "#if !TEST\n"
7647 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
7648 "#endif\n"
7649 " );",
7650 format("f(\n"
7651 "#if !TEST\n"
7652 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
7653 "#endif\n"
7654 ");"));
7655 EXPECT_EQ("f(\n"
7656 "\n"
7657 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));",
7658 format("f(\n"
7659 "\n"
7660 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));"));
Alexander Kornienko81e32942013-09-16 20:20:49 +00007661}
7662
Alexander Kornienko657c67b2013-07-16 21:06:13 +00007663TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
Alexander Kornienkod7b837e2013-08-29 17:32:57 +00007664 EXPECT_EQ(
7665 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
7666 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
7667 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
7668 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
7669 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
7670 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
7671}
7672
7673TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
7674 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
Daniel Jasperc39b56f2013-12-16 07:23:08 +00007675 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle()));
Alexander Kornienkod7b837e2013-08-29 17:32:57 +00007676 EXPECT_EQ("fffffffffff(g(R\"x(\n"
7677 "multiline raw string literal xxxxxxxxxxxxxx\n"
7678 ")x\",\n"
7679 " a),\n"
7680 " b);",
7681 format("fffffffffff(g(R\"x(\n"
7682 "multiline raw string literal xxxxxxxxxxxxxx\n"
7683 ")x\", a), b);",
7684 getGoogleStyleWithColumns(20)));
7685 EXPECT_EQ("fffffffffff(\n"
7686 " g(R\"x(qqq\n"
7687 "multiline raw string literal xxxxxxxxxxxxxx\n"
7688 ")x\",\n"
7689 " a),\n"
7690 " b);",
7691 format("fffffffffff(g(R\"x(qqq\n"
7692 "multiline raw string literal xxxxxxxxxxxxxx\n"
7693 ")x\", a), b);",
7694 getGoogleStyleWithColumns(20)));
7695
7696 EXPECT_EQ("fffffffffff(R\"x(\n"
7697 "multiline raw string literal xxxxxxxxxxxxxx\n"
7698 ")x\");",
7699 format("fffffffffff(R\"x(\n"
7700 "multiline raw string literal xxxxxxxxxxxxxx\n"
7701 ")x\");",
7702 getGoogleStyleWithColumns(20)));
7703 EXPECT_EQ("fffffffffff(R\"x(\n"
7704 "multiline raw string literal xxxxxxxxxxxxxx\n"
Daniel Jasper5d2587d2014-03-27 16:14:13 +00007705 ")x\" + bbbbbb);",
Alexander Kornienkod7b837e2013-08-29 17:32:57 +00007706 format("fffffffffff(R\"x(\n"
7707 "multiline raw string literal xxxxxxxxxxxxxx\n"
Daniel Jasper5d2587d2014-03-27 16:14:13 +00007708 ")x\" + bbbbbb);",
Alexander Kornienkod7b837e2013-08-29 17:32:57 +00007709 getGoogleStyleWithColumns(20)));
Daniel Jasperc39b56f2013-12-16 07:23:08 +00007710 EXPECT_EQ("fffffffffff(\n"
7711 " R\"x(\n"
7712 "multiline raw string literal xxxxxxxxxxxxxx\n"
7713 ")x\" +\n"
7714 " bbbbbb);",
7715 format("fffffffffff(\n"
7716 " R\"x(\n"
7717 "multiline raw string literal xxxxxxxxxxxxxx\n"
7718 ")x\" + bbbbbb);",
7719 getGoogleStyleWithColumns(20)));
Alexander Kornienko657c67b2013-07-16 21:06:13 +00007720}
7721
Alexander Kornienkobe633902013-06-14 11:46:10 +00007722TEST_F(FormatTest, SkipsUnknownStringLiterals) {
Daniel Jasper8369aa52013-07-16 20:28:33 +00007723 verifyFormat("string a = \"unterminated;");
7724 EXPECT_EQ("function(\"unterminated,\n"
7725 " OtherParameter);",
7726 format("function( \"unterminated,\n"
7727 " OtherParameter);"));
Alexander Kornienko1e808872013-06-28 12:51:24 +00007728}
7729
7730TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
Chandler Carruthf8b72662014-03-02 12:37:31 +00007731 FormatStyle Style = getLLVMStyle();
7732 Style.Standard = FormatStyle::LS_Cpp03;
Alexander Kornienko1e808872013-06-28 12:51:24 +00007733 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
Chandler Carruthf8b72662014-03-02 12:37:31 +00007734 format("#define x(_a) printf(\"foo\"_a);", Style));
Alexander Kornienkobe633902013-06-14 11:46:10 +00007735}
7736
Daniel Jaspera44991332015-04-29 13:06:49 +00007737TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }
Daniel Jasper20fd3c62014-04-15 08:49:21 +00007738
Manuel Klimek5ecb5fd2013-05-14 09:04:24 +00007739TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
7740 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
7741 " \"ddeeefff\");",
7742 format("someFunction(\"aaabbbcccdddeeefff\");",
7743 getLLVMStyleWithColumns(25)));
7744 EXPECT_EQ("someFunction1234567890(\n"
7745 " \"aaabbbcccdddeeefff\");",
7746 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
7747 getLLVMStyleWithColumns(26)));
7748 EXPECT_EQ("someFunction1234567890(\n"
7749 " \"aaabbbcccdddeeeff\"\n"
7750 " \"f\");",
7751 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
7752 getLLVMStyleWithColumns(25)));
7753 EXPECT_EQ("someFunction1234567890(\n"
7754 " \"aaabbbcccdddeeeff\"\n"
7755 " \"f\");",
7756 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
7757 getLLVMStyleWithColumns(24)));
Daniel Jasper2739af32013-08-28 10:03:58 +00007758 EXPECT_EQ("someFunction(\"aaabbbcc \"\n"
7759 " \"ddde \"\n"
7760 " \"efff\");",
7761 format("someFunction(\"aaabbbcc ddde efff\");",
Manuel Klimek5ecb5fd2013-05-14 09:04:24 +00007762 getLLVMStyleWithColumns(25)));
7763 EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
7764 " \"ddeeefff\");",
7765 format("someFunction(\"aaabbbccc ddeeefff\");",
7766 getLLVMStyleWithColumns(25)));
7767 EXPECT_EQ("someFunction1234567890(\n"
7768 " \"aaabb \"\n"
7769 " \"cccdddeeefff\");",
7770 format("someFunction1234567890(\"aaabb cccdddeeefff\");",
7771 getLLVMStyleWithColumns(25)));
7772 EXPECT_EQ("#define A \\\n"
7773 " string s = \\\n"
7774 " \"123456789\" \\\n"
7775 " \"0\"; \\\n"
7776 " int i;",
7777 format("#define A string s = \"1234567890\"; int i;",
7778 getLLVMStyleWithColumns(20)));
Daniel Jasper2739af32013-08-28 10:03:58 +00007779 // FIXME: Put additional penalties on breaking at non-whitespace locations.
7780 EXPECT_EQ("someFunction(\"aaabbbcc \"\n"
7781 " \"dddeeeff\"\n"
7782 " \"f\");",
7783 format("someFunction(\"aaabbbcc dddeeefff\");",
7784 getLLVMStyleWithColumns(25)));
Manuel Klimek5ecb5fd2013-05-14 09:04:24 +00007785}
7786
Manuel Klimek5085d9b2013-03-08 18:59:48 +00007787TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
Daniel Jaspera44991332015-04-29 13:06:49 +00007788 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3)));
7789 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2)));
Manuel Klimek5085d9b2013-03-08 18:59:48 +00007790 EXPECT_EQ("\"test\"\n"
7791 "\"\\n\"",
7792 format("\"test\\n\"", getLLVMStyleWithColumns(7)));
7793 EXPECT_EQ("\"tes\\\\\"\n"
7794 "\"n\"",
7795 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
7796 EXPECT_EQ("\"\\\\\\\\\"\n"
7797 "\"\\n\"",
7798 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
Daniel Jaspera44991332015-04-29 13:06:49 +00007799 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
Manuel Klimek5085d9b2013-03-08 18:59:48 +00007800 EXPECT_EQ("\"\\uff01\"\n"
7801 "\"test\"",
7802 format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
7803 EXPECT_EQ("\"\\Uff01ff02\"",
7804 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
7805 EXPECT_EQ("\"\\x000000000001\"\n"
7806 "\"next\"",
7807 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
7808 EXPECT_EQ("\"\\x000000000001next\"",
7809 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
7810 EXPECT_EQ("\"\\x000000000001\"",
7811 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
7812 EXPECT_EQ("\"test\"\n"
7813 "\"\\000000\"\n"
7814 "\"000001\"",
7815 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
7816 EXPECT_EQ("\"test\\000\"\n"
Alexander Kornienkocb45bc12013-04-15 14:28:00 +00007817 "\"00000000\"\n"
7818 "\"1\"",
Manuel Klimek5085d9b2013-03-08 18:59:48 +00007819 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
Manuel Klimek5085d9b2013-03-08 18:59:48 +00007820}
7821
Manuel Klimeka3ff45e2013-04-10 09:52:05 +00007822TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
7823 verifyFormat("void f() {\n"
7824 " return g() {}\n"
7825 " void h() {}");
Daniel Jasper4afc6b32014-06-02 10:57:55 +00007826 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
Daniel Jasper1ec31062013-05-28 18:50:02 +00007827 "g();\n"
Manuel Klimeka3ff45e2013-04-10 09:52:05 +00007828 "}");
7829}
7830
Manuel Klimek421147e2014-01-24 09:25:23 +00007831TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) {
7832 verifyFormat(
Daniel Jasper39485162014-05-22 09:00:33 +00007833 "void f() { return C{param1, param2}.SomeCall(param1, param2); }");
Manuel Klimek421147e2014-01-24 09:25:23 +00007834}
7835
Manuel Klimek13b97d82013-05-13 08:42:42 +00007836TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
7837 verifyFormat("class X {\n"
7838 " void f() {\n"
7839 " }\n"
7840 "};",
7841 getLLVMStyleWithColumns(12));
7842}
7843
7844TEST_F(FormatTest, ConfigurableIndentWidth) {
7845 FormatStyle EightIndent = getLLVMStyleWithColumns(18);
7846 EightIndent.IndentWidth = 8;
Chandler Carruthf8b72662014-03-02 12:37:31 +00007847 EightIndent.ContinuationIndentWidth = 8;
Manuel Klimek13b97d82013-05-13 08:42:42 +00007848 verifyFormat("void f() {\n"
7849 " someFunction();\n"
7850 " if (true) {\n"
7851 " f();\n"
7852 " }\n"
7853 "}",
7854 EightIndent);
7855 verifyFormat("class X {\n"
7856 " void f() {\n"
7857 " }\n"
7858 "};",
7859 EightIndent);
7860 verifyFormat("int x[] = {\n"
7861 " call(),\n"
Chandler Carruthf8b72662014-03-02 12:37:31 +00007862 " call()};",
Manuel Klimek13b97d82013-05-13 08:42:42 +00007863 EightIndent);
7864}
7865
Alexander Kornienko34a87e82013-06-22 01:35:36 +00007866TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
Daniel Jaspere068ac72014-10-27 17:13:59 +00007867 verifyFormat("double\n"
Manuel Klimek836c2862013-06-21 17:25:42 +00007868 "f();",
7869 getLLVMStyleWithColumns(8));
7870}
7871
Manuel Klimekb9eae4c2013-05-13 09:22:11 +00007872TEST_F(FormatTest, ConfigurableUseOfTab) {
7873 FormatStyle Tab = getLLVMStyleWithColumns(42);
7874 Tab.IndentWidth = 8;
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00007875 Tab.UseTab = FormatStyle::UT_Always;
Manuel Klimekb9eae4c2013-05-13 09:22:11 +00007876 Tab.AlignEscapedNewlinesLeft = true;
Alexander Kornienkodb4c21f2013-09-27 09:45:40 +00007877
7878 EXPECT_EQ("if (aaaaaaaa && // q\n"
7879 " bb)\t\t// w\n"
7880 "\t;",
7881 format("if (aaaaaaaa &&// q\n"
7882 "bb)// w\n"
7883 ";",
7884 Tab));
7885 EXPECT_EQ("if (aaa && bbb) // w\n"
7886 "\t;",
7887 format("if(aaa&&bbb)// w\n"
7888 ";",
7889 Tab));
7890
Manuel Klimekb9eae4c2013-05-13 09:22:11 +00007891 verifyFormat("class X {\n"
7892 "\tvoid f() {\n"
7893 "\t\tsomeFunction(parameter1,\n"
7894 "\t\t\t parameter2);\n"
7895 "\t}\n"
7896 "};",
7897 Tab);
7898 verifyFormat("#define A \\\n"
7899 "\tvoid f() { \\\n"
7900 "\t\tsomeFunction( \\\n"
7901 "\t\t parameter1, \\\n"
7902 "\t\t parameter2); \\\n"
7903 "\t}",
7904 Tab);
Manuel Klimek34d15152013-05-28 10:01:59 +00007905
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +00007906 Tab.TabWidth = 4;
7907 Tab.IndentWidth = 8;
7908 verifyFormat("class TabWidth4Indent8 {\n"
7909 "\t\tvoid f() {\n"
7910 "\t\t\t\tsomeFunction(parameter1,\n"
7911 "\t\t\t\t\t\t\t parameter2);\n"
7912 "\t\t}\n"
7913 "};",
7914 Tab);
7915
7916 Tab.TabWidth = 4;
7917 Tab.IndentWidth = 4;
7918 verifyFormat("class TabWidth4Indent4 {\n"
7919 "\tvoid f() {\n"
7920 "\t\tsomeFunction(parameter1,\n"
7921 "\t\t\t\t\t parameter2);\n"
7922 "\t}\n"
7923 "};",
7924 Tab);
7925
7926 Tab.TabWidth = 8;
7927 Tab.IndentWidth = 4;
7928 verifyFormat("class TabWidth8Indent4 {\n"
7929 " void f() {\n"
7930 "\tsomeFunction(parameter1,\n"
7931 "\t\t parameter2);\n"
7932 " }\n"
7933 "};",
7934 Tab);
7935
Alexander Kornienko39856b72013-09-10 09:38:25 +00007936 Tab.TabWidth = 8;
7937 Tab.IndentWidth = 8;
7938 EXPECT_EQ("/*\n"
7939 "\t a\t\tcomment\n"
7940 "\t in multiple lines\n"
7941 " */",
7942 format(" /*\t \t \n"
7943 " \t \t a\t\tcomment\t \t\n"
7944 " \t \t in multiple lines\t\n"
7945 " \t */",
7946 Tab));
Alexander Kornienkodb4c21f2013-09-27 09:45:40 +00007947
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00007948 Tab.UseTab = FormatStyle::UT_ForIndentation;
Chandler Carruthf8b72662014-03-02 12:37:31 +00007949 verifyFormat("{\n"
7950 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
7951 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
7952 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
7953 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
7954 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
7955 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
Alexander Kornienkoe2e03872013-10-14 00:46:35 +00007956 "};",
7957 Tab);
7958 verifyFormat("enum A {\n"
Daniel Jasper96972812014-01-05 12:38:10 +00007959 "\ta1, // Force multiple lines\n"
Alexander Kornienkoe2e03872013-10-14 00:46:35 +00007960 "\ta2,\n"
7961 "\ta3\n"
7962 "};",
7963 Tab);
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00007964 EXPECT_EQ("if (aaaaaaaa && // q\n"
7965 " bb) // w\n"
7966 "\t;",
7967 format("if (aaaaaaaa &&// q\n"
7968 "bb)// w\n"
7969 ";",
7970 Tab));
7971 verifyFormat("class X {\n"
7972 "\tvoid f() {\n"
7973 "\t\tsomeFunction(parameter1,\n"
7974 "\t\t parameter2);\n"
7975 "\t}\n"
7976 "};",
7977 Tab);
7978 verifyFormat("{\n"
7979 "\tQ({\n"
Daniel Jasper4b444492014-11-21 13:38:53 +00007980 "\t\tint a;\n"
7981 "\t\tsomeFunction(aaaaaaaa,\n"
7982 "\t\t bbbbbbb);\n"
7983 "\t}, p);\n"
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00007984 "}",
7985 Tab);
7986 EXPECT_EQ("{\n"
7987 "\t/* aaaa\n"
7988 "\t bbbb */\n"
7989 "}",
7990 format("{\n"
7991 "/* aaaa\n"
7992 " bbbb */\n"
7993 "}",
7994 Tab));
7995 EXPECT_EQ("{\n"
7996 "\t/*\n"
7997 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7998 "\t bbbbbbbbbbbbb\n"
7999 "\t*/\n"
8000 "}",
8001 format("{\n"
8002 "/*\n"
8003 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
8004 "*/\n"
8005 "}",
8006 Tab));
8007 EXPECT_EQ("{\n"
8008 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8009 "\t// bbbbbbbbbbbbb\n"
8010 "}",
8011 format("{\n"
8012 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
8013 "}",
8014 Tab));
8015 EXPECT_EQ("{\n"
8016 "\t/*\n"
8017 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8018 "\t bbbbbbbbbbbbb\n"
8019 "\t*/\n"
8020 "}",
8021 format("{\n"
8022 "\t/*\n"
8023 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
8024 "\t*/\n"
8025 "}",
8026 Tab));
8027 EXPECT_EQ("{\n"
8028 "\t/*\n"
8029 "\n"
8030 "\t*/\n"
8031 "}",
8032 format("{\n"
8033 "\t/*\n"
8034 "\n"
8035 "\t*/\n"
Alexander Kornienko45dc1b22013-09-27 16:40:11 +00008036 "}",
8037 Tab));
8038 EXPECT_EQ("{\n"
8039 "\t/*\n"
8040 " asdf\n"
8041 "\t*/\n"
8042 "}",
8043 format("{\n"
8044 "\t/*\n"
8045 " asdf\n"
8046 "\t*/\n"
8047 "}",
8048 Tab));
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00008049
8050 Tab.UseTab = FormatStyle::UT_Never;
Alexander Kornienko39856b72013-09-10 09:38:25 +00008051 EXPECT_EQ("/*\n"
8052 " a\t\tcomment\n"
8053 " in multiple lines\n"
8054 " */",
8055 format(" /*\t \t \n"
8056 " \t \t a\t\tcomment\t \t\n"
8057 " \t \t in multiple lines\t\n"
8058 " \t */",
8059 Tab));
8060 EXPECT_EQ("/* some\n"
8061 " comment */",
Daniel Jaspera44991332015-04-29 13:06:49 +00008062 format(" \t \t /* some\n"
8063 " \t \t comment */",
8064 Tab));
Alexander Kornienko39856b72013-09-10 09:38:25 +00008065 EXPECT_EQ("int a; /* some\n"
8066 " comment */",
Daniel Jaspera44991332015-04-29 13:06:49 +00008067 format(" \t \t int a; /* some\n"
8068 " \t \t comment */",
8069 Tab));
Manuel Klimek34d15152013-05-28 10:01:59 +00008070
Alexander Kornienko39856b72013-09-10 09:38:25 +00008071 EXPECT_EQ("int a; /* some\n"
8072 "comment */",
Daniel Jaspera44991332015-04-29 13:06:49 +00008073 format(" \t \t int\ta; /* some\n"
8074 " \t \t comment */",
8075 Tab));
Alexander Kornienko39856b72013-09-10 09:38:25 +00008076 EXPECT_EQ("f(\"\t\t\"); /* some\n"
8077 " comment */",
Daniel Jaspera44991332015-04-29 13:06:49 +00008078 format(" \t \t f(\"\t\t\"); /* some\n"
8079 " \t \t comment */",
8080 Tab));
Manuel Klimek34d15152013-05-28 10:01:59 +00008081 EXPECT_EQ("{\n"
8082 " /*\n"
8083 " * Comment\n"
8084 " */\n"
8085 " int i;\n"
8086 "}",
8087 format("{\n"
8088 "\t/*\n"
8089 "\t * Comment\n"
8090 "\t */\n"
8091 "\t int i;\n"
8092 "}"));
Manuel Klimekb9eae4c2013-05-13 09:22:11 +00008093}
8094
Alexander Kornienko917f9e02013-09-10 12:29:48 +00008095TEST_F(FormatTest, CalculatesOriginalColumn) {
8096 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8097 "q\"; /* some\n"
8098 " comment */",
8099 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8100 "q\"; /* some\n"
8101 " comment */",
8102 getLLVMStyle()));
8103 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
8104 "/* some\n"
8105 " comment */",
8106 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
8107 " /* some\n"
8108 " comment */",
8109 getLLVMStyle()));
8110 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8111 "qqq\n"
8112 "/* some\n"
8113 " comment */",
8114 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8115 "qqq\n"
8116 " /* some\n"
8117 " comment */",
8118 getLLVMStyle()));
8119 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8120 "wwww; /* some\n"
8121 " comment */",
8122 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
8123 "wwww; /* some\n"
8124 " comment */",
8125 getLLVMStyle()));
8126}
8127
Alexander Kornienkofdca83d2013-12-10 10:18:34 +00008128TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
Daniel Jasperb55acad2013-08-20 12:36:34 +00008129 FormatStyle NoSpace = getLLVMStyle();
Alexander Kornienkofdca83d2013-12-10 10:18:34 +00008130 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never;
Daniel Jasperb55acad2013-08-20 12:36:34 +00008131
8132 verifyFormat("while(true)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008133 " continue;",
8134 NoSpace);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008135 verifyFormat("for(;;)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008136 " continue;",
8137 NoSpace);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008138 verifyFormat("if(true)\n"
8139 " f();\n"
8140 "else if(true)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008141 " f();",
8142 NoSpace);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008143 verifyFormat("do {\n"
8144 " do_something();\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008145 "} while(something());",
8146 NoSpace);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008147 verifyFormat("switch(x) {\n"
8148 "default:\n"
8149 " break;\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008150 "}",
8151 NoSpace);
Chad Rosier0a84f172014-08-05 17:58:54 +00008152 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace);
Daniel Jasper78b194992014-08-06 14:15:41 +00008153 verifyFormat("size_t x = sizeof(x);", NoSpace);
8154 verifyFormat("auto f(int x) -> decltype(x);", NoSpace);
8155 verifyFormat("int f(T x) noexcept(x.create());", NoSpace);
8156 verifyFormat("alignas(128) char a[128];", NoSpace);
8157 verifyFormat("size_t x = alignof(MyType);", NoSpace);
8158 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace);
8159 verifyFormat("int f() throw(Deprecated);", NoSpace);
Anders Waldenborgb09075a2015-05-19 16:54:26 +00008160 verifyFormat("typedef void (*cb)(int);", NoSpace);
Alexander Kornienkofdca83d2013-12-10 10:18:34 +00008161
8162 FormatStyle Space = getLLVMStyle();
8163 Space.SpaceBeforeParens = FormatStyle::SBPO_Always;
8164
8165 verifyFormat("int f ();", Space);
8166 verifyFormat("void f (int a, T b) {\n"
8167 " while (true)\n"
8168 " continue;\n"
8169 "}",
8170 Space);
8171 verifyFormat("if (true)\n"
8172 " f ();\n"
8173 "else if (true)\n"
8174 " f ();",
8175 Space);
8176 verifyFormat("do {\n"
8177 " do_something ();\n"
8178 "} while (something ());",
8179 Space);
8180 verifyFormat("switch (x) {\n"
8181 "default:\n"
8182 " break;\n"
8183 "}",
8184 Space);
8185 verifyFormat("A::A () : a (1) {}", Space);
8186 verifyFormat("void f () __attribute__ ((asdf));", Space);
8187 verifyFormat("*(&a + 1);\n"
8188 "&((&a)[1]);\n"
8189 "a[(b + c) * d];\n"
8190 "(((a + 1) * 2) + 3) * 4;",
8191 Space);
8192 verifyFormat("#define A(x) x", Space);
8193 verifyFormat("#define A (x) x", Space);
8194 verifyFormat("#if defined(x)\n"
8195 "#endif",
8196 Space);
Chad Rosier0a84f172014-08-05 17:58:54 +00008197 verifyFormat("auto i = std::make_unique<int> (5);", Space);
Daniel Jasper78b194992014-08-06 14:15:41 +00008198 verifyFormat("size_t x = sizeof (x);", Space);
8199 verifyFormat("auto f (int x) -> decltype (x);", Space);
8200 verifyFormat("int f (T x) noexcept (x.create ());", Space);
8201 verifyFormat("alignas (128) char a[128];", Space);
8202 verifyFormat("size_t x = alignof (MyType);", Space);
8203 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space);
8204 verifyFormat("int f () throw (Deprecated);", Space);
Anders Waldenborgb09075a2015-05-19 16:54:26 +00008205 verifyFormat("typedef void (*cb) (int);", Space);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008206}
8207
8208TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
8209 FormatStyle Spaces = getLLVMStyle();
8210
8211 Spaces.SpacesInParentheses = true;
8212 verifyFormat("call( x, y, z );", Spaces);
Daniel Jasper92e09822015-03-18 12:59:19 +00008213 verifyFormat("call();", Spaces);
8214 verifyFormat("std::function<void( int, int )> callback;", Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008215 verifyFormat("while ( (bool)1 )\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008216 " continue;",
8217 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008218 verifyFormat("for ( ;; )\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008219 " continue;",
8220 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008221 verifyFormat("if ( true )\n"
8222 " f();\n"
8223 "else if ( true )\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008224 " f();",
8225 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008226 verifyFormat("do {\n"
8227 " do_something( (int)i );\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008228 "} while ( something() );",
8229 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008230 verifyFormat("switch ( x ) {\n"
8231 "default:\n"
8232 " break;\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008233 "}",
8234 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008235
8236 Spaces.SpacesInParentheses = false;
8237 Spaces.SpacesInCStyleCastParentheses = true;
8238 verifyFormat("Type *A = ( Type * )P;", Spaces);
8239 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
8240 verifyFormat("x = ( int32 )y;", Spaces);
8241 verifyFormat("int a = ( int )(2.0f);", Spaces);
8242 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
8243 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
8244 verifyFormat("#define x (( int )-1)", Spaces);
8245
Daniel Jasper92e09822015-03-18 12:59:19 +00008246 // Run the first set of tests again with:
Daniel Jaspera44991332015-04-29 13:06:49 +00008247 Spaces.SpacesInParentheses = false, Spaces.SpaceInEmptyParentheses = true;
Daniel Jasperb55acad2013-08-20 12:36:34 +00008248 Spaces.SpacesInCStyleCastParentheses = true;
8249 verifyFormat("call(x, y, z);", Spaces);
Daniel Jasper92e09822015-03-18 12:59:19 +00008250 verifyFormat("call( );", Spaces);
8251 verifyFormat("std::function<void(int, int)> callback;", Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008252 verifyFormat("while (( bool )1)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008253 " continue;",
8254 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008255 verifyFormat("for (;;)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008256 " continue;",
8257 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008258 verifyFormat("if (true)\n"
8259 " f( );\n"
8260 "else if (true)\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008261 " f( );",
8262 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008263 verifyFormat("do {\n"
8264 " do_something(( int )i);\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008265 "} while (something( ));",
8266 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008267 verifyFormat("switch (x) {\n"
8268 "default:\n"
8269 " break;\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00008270 "}",
8271 Spaces);
Daniel Jasperdb986eb2014-09-03 07:37:29 +00008272
Daniel Jasper92e09822015-03-18 12:59:19 +00008273 // Run the first set of tests again with:
Daniel Jasperdb986eb2014-09-03 07:37:29 +00008274 Spaces.SpaceAfterCStyleCast = true;
8275 verifyFormat("call(x, y, z);", Spaces);
Daniel Jasper92e09822015-03-18 12:59:19 +00008276 verifyFormat("call( );", Spaces);
8277 verifyFormat("std::function<void(int, int)> callback;", Spaces);
Daniel Jasperdb986eb2014-09-03 07:37:29 +00008278 verifyFormat("while (( bool ) 1)\n"
8279 " continue;",
8280 Spaces);
8281 verifyFormat("for (;;)\n"
8282 " continue;",
8283 Spaces);
8284 verifyFormat("if (true)\n"
8285 " f( );\n"
8286 "else if (true)\n"
8287 " f( );",
8288 Spaces);
8289 verifyFormat("do {\n"
8290 " do_something(( int ) i);\n"
8291 "} while (something( ));",
8292 Spaces);
8293 verifyFormat("switch (x) {\n"
8294 "default:\n"
8295 " break;\n"
8296 "}",
8297 Spaces);
Daniel Jasper92e09822015-03-18 12:59:19 +00008298
8299 // Run subset of tests again with:
Daniel Jasperdb986eb2014-09-03 07:37:29 +00008300 Spaces.SpacesInCStyleCastParentheses = false;
8301 Spaces.SpaceAfterCStyleCast = true;
8302 verifyFormat("while ((bool) 1)\n"
8303 " continue;",
8304 Spaces);
8305 verifyFormat("do {\n"
8306 " do_something((int) i);\n"
8307 "} while (something( ));",
8308 Spaces);
Daniel Jasperb55acad2013-08-20 12:36:34 +00008309}
8310
Daniel Jasperad981f82014-08-26 11:41:14 +00008311TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) {
8312 verifyFormat("int a[5];");
8313 verifyFormat("a[3] += 42;");
8314
8315 FormatStyle Spaces = getLLVMStyle();
8316 Spaces.SpacesInSquareBrackets = true;
8317 // Lambdas unchanged.
8318 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces);
8319 verifyFormat("return [i, args...] {};", Spaces);
8320
8321 // Not lambdas.
8322 verifyFormat("int a[ 5 ];", Spaces);
8323 verifyFormat("a[ 3 ] += 42;", Spaces);
8324 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces);
8325 verifyFormat("double &operator[](int i) { return 0; }\n"
8326 "int i;",
8327 Spaces);
8328 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces);
8329 verifyFormat("int i = a[ a ][ a ]->f();", Spaces);
8330 verifyFormat("int i = (*b)[ a ]->f();", Spaces);
8331}
8332
Daniel Jasperd94bff32013-09-25 15:15:02 +00008333TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
8334 verifyFormat("int a = 5;");
8335 verifyFormat("a += 42;");
8336 verifyFormat("a or_eq 8;");
8337
8338 FormatStyle Spaces = getLLVMStyle();
8339 Spaces.SpaceBeforeAssignmentOperators = false;
8340 verifyFormat("int a= 5;", Spaces);
8341 verifyFormat("a+= 42;", Spaces);
8342 verifyFormat("a or_eq 8;", Spaces);
8343}
8344
Daniel Jaspera44991332015-04-29 13:06:49 +00008345TEST_F(FormatTest, AlignConsecutiveAssignments) {
8346 FormatStyle Alignment = getLLVMStyle();
8347 Alignment.AlignConsecutiveAssignments = false;
8348 verifyFormat("int a = 5;\n"
8349 "int oneTwoThree = 123;",
8350 Alignment);
8351 verifyFormat("int a = 5;\n"
8352 "int oneTwoThree = 123;",
8353 Alignment);
8354
8355 Alignment.AlignConsecutiveAssignments = true;
8356 verifyFormat("int a = 5;\n"
8357 "int oneTwoThree = 123;",
8358 Alignment);
8359 verifyFormat("int a = method();\n"
8360 "int oneTwoThree = 133;",
8361 Alignment);
8362 verifyFormat("a &= 5;\n"
8363 "bcd *= 5;\n"
8364 "ghtyf += 5;\n"
8365 "dvfvdb -= 5;\n"
8366 "a /= 5;\n"
8367 "vdsvsv %= 5;\n"
8368 "sfdbddfbdfbb ^= 5;\n"
8369 "dvsdsv |= 5;\n"
8370 "int dsvvdvsdvvv = 123;",
8371 Alignment);
8372 verifyFormat("int i = 1, j = 10;\n"
8373 "something = 2000;",
8374 Alignment);
8375 verifyFormat("something = 2000;\n"
8376 "int i = 1, j = 10;\n",
8377 Alignment);
8378 verifyFormat("something = 2000;\n"
8379 "another = 911;\n"
8380 "int i = 1, j = 10;\n"
8381 "oneMore = 1;\n"
8382 "i = 2;",
8383 Alignment);
8384 verifyFormat("int a = 5;\n"
8385 "int one = 1;\n"
8386 "method();\n"
8387 "int oneTwoThree = 123;\n"
8388 "int oneTwo = 12;",
8389 Alignment);
8390 verifyFormat("int oneTwoThree = 123; // comment\n"
8391 "int oneTwo = 12; // comment",
8392 Alignment);
8393 EXPECT_EQ("int a = 5;\n"
8394 "\n"
8395 "int oneTwoThree = 123;",
8396 format("int a = 5;\n"
8397 "\n"
8398 "int oneTwoThree= 123;",
8399 Alignment));
8400 EXPECT_EQ("int a = 5;\n"
8401 "int one = 1;\n"
8402 "\n"
8403 "int oneTwoThree = 123;",
8404 format("int a = 5;\n"
8405 "int one = 1;\n"
8406 "\n"
8407 "int oneTwoThree = 123;",
8408 Alignment));
8409 EXPECT_EQ("int a = 5;\n"
8410 "int one = 1;\n"
8411 "\n"
8412 "int oneTwoThree = 123;\n"
8413 "int oneTwo = 12;",
8414 format("int a = 5;\n"
8415 "int one = 1;\n"
8416 "\n"
8417 "int oneTwoThree = 123;\n"
8418 "int oneTwo = 12;",
8419 Alignment));
8420 Alignment.AlignEscapedNewlinesLeft = true;
8421 verifyFormat("#define A \\\n"
8422 " int aaaa = 12; \\\n"
8423 " int b = 23; \\\n"
8424 " int ccc = 234; \\\n"
8425 " int dddddddddd = 2345;",
8426 Alignment);
8427 Alignment.AlignEscapedNewlinesLeft = false;
8428 verifyFormat("#define A "
8429 " \\\n"
8430 " int aaaa = 12; "
8431 " \\\n"
8432 " int b = 23; "
8433 " \\\n"
8434 " int ccc = 234; "
8435 " \\\n"
8436 " int dddddddddd = 2345;",
8437 Alignment);
8438 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
8439 "k = 4, int l = 5,\n"
8440 " int m = 6) {\n"
8441 " int j = 10;\n"
8442 " otherThing = 1;\n"
8443 "}",
8444 Alignment);
8445 verifyFormat("void SomeFunction(int parameter = 0) {\n"
8446 " int i = 1;\n"
8447 " int j = 2;\n"
8448 " int big = 10000;\n"
8449 "}",
8450 Alignment);
8451 verifyFormat("class C {\n"
8452 "public:\n"
8453 " int i = 1;\n"
8454 " virtual void f() = 0;\n"
8455 "};",
8456 Alignment);
8457 verifyFormat("int i = 1;\n"
8458 "if (SomeType t = getSomething()) {\n"
8459 "}\n"
8460 "int j = 2;\n"
8461 "int big = 10000;",
8462 Alignment);
8463 verifyFormat("int j = 7;\n"
8464 "for (int k = 0; k < N; ++k) {\n"
8465 "}\n"
8466 "int j = 2;\n"
8467 "int big = 10000;\n"
8468 "}",
8469 Alignment);
8470 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
8471 verifyFormat("int i = 1;\n"
8472 "LooooooooooongType loooooooooooooooooooooongVariable\n"
8473 " = someLooooooooooooooooongFunction();\n"
8474 "int j = 2;",
8475 Alignment);
8476 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
8477 verifyFormat("int i = 1;\n"
8478 "LooooooooooongType loooooooooooooooooooooongVariable =\n"
8479 " someLooooooooooooooooongFunction();\n"
8480 "int j = 2;",
8481 Alignment);
8482 // FIXME: Should align all three assignments
8483 verifyFormat(
8484 "int i = 1;\n"
8485 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
8486 " loooooooooooooooooooooongParameterB);\n"
8487 "int j = 2;",
8488 Alignment);
8489}
8490
Manuel Klimeka8eb9142013-05-13 12:51:40 +00008491TEST_F(FormatTest, LinuxBraceBreaking) {
Roman Kashitsyna043ced2014-08-11 12:18:01 +00008492 FormatStyle LinuxBraceStyle = getLLVMStyle();
8493 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
Manuel Klimeka8eb9142013-05-13 12:51:40 +00008494 verifyFormat("namespace a\n"
8495 "{\n"
8496 "class A\n"
8497 "{\n"
8498 " void f()\n"
8499 " {\n"
8500 " if (true) {\n"
8501 " a();\n"
8502 " b();\n"
8503 " }\n"
8504 " }\n"
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00008505 " void g() { return; }\n"
Roman Kashitsyna043ced2014-08-11 12:18:01 +00008506 "};\n"
8507 "struct B {\n"
8508 " int x;\n"
8509 "};\n"
8510 "}\n",
8511 LinuxBraceStyle);
8512 verifyFormat("enum X {\n"
8513 " Y = 0,\n"
8514 "}\n",
8515 LinuxBraceStyle);
8516 verifyFormat("struct S {\n"
8517 " int Type;\n"
8518 " union {\n"
8519 " int x;\n"
8520 " double y;\n"
8521 " } Value;\n"
8522 " class C\n"
8523 " {\n"
8524 " MyFavoriteType Value;\n"
8525 " } Class;\n"
8526 "}\n",
8527 LinuxBraceStyle);
Manuel Klimeka8eb9142013-05-13 12:51:40 +00008528}
8529
8530TEST_F(FormatTest, StroustrupBraceBreaking) {
Roman Kashitsyna043ced2014-08-11 12:18:01 +00008531 FormatStyle StroustrupBraceStyle = getLLVMStyle();
8532 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
Manuel Klimeka8eb9142013-05-13 12:51:40 +00008533 verifyFormat("namespace a {\n"
8534 "class A {\n"
8535 " void f()\n"
8536 " {\n"
8537 " if (true) {\n"
8538 " a();\n"
8539 " b();\n"
8540 " }\n"
8541 " }\n"
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00008542 " void g() { return; }\n"
Roman Kashitsyna043ced2014-08-11 12:18:01 +00008543 "};\n"
8544 "struct B {\n"
8545 " int x;\n"
8546 "};\n"
8547 "}\n",
8548 StroustrupBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00008549
Daniel Jasperd9670872014-08-05 12:06:20 +00008550 verifyFormat("void foo()\n"
8551 "{\n"
8552 " if (a) {\n"
8553 " a();\n"
8554 " }\n"
8555 " else {\n"
8556 " b();\n"
8557 " }\n"
8558 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00008559 StroustrupBraceStyle);
Daniel Jasperd9670872014-08-05 12:06:20 +00008560
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00008561 verifyFormat("#ifdef _DEBUG\n"
8562 "int foo(int i = 0)\n"
8563 "#else\n"
8564 "int foo(int i = 5)\n"
8565 "#endif\n"
8566 "{\n"
8567 " return i;\n"
8568 "}",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00008569 StroustrupBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00008570
8571 verifyFormat("void foo() {}\n"
8572 "void bar()\n"
8573 "#ifdef _DEBUG\n"
8574 "{\n"
8575 " foo();\n"
8576 "}\n"
8577 "#else\n"
8578 "{\n"
8579 "}\n"
8580 "#endif",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00008581 StroustrupBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00008582
8583 verifyFormat("void foobar() { int i = 5; }\n"
8584 "#ifdef _DEBUG\n"
8585 "void bar() {}\n"
8586 "#else\n"
8587 "void bar() { foobar(); }\n"
8588 "#endif",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00008589 StroustrupBraceStyle);
Manuel Klimeka8eb9142013-05-13 12:51:40 +00008590}
8591
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00008592TEST_F(FormatTest, AllmanBraceBreaking) {
Roman Kashitsyna043ced2014-08-11 12:18:01 +00008593 FormatStyle AllmanBraceStyle = getLLVMStyle();
8594 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00008595 verifyFormat("namespace a\n"
8596 "{\n"
8597 "class A\n"
8598 "{\n"
8599 " void f()\n"
8600 " {\n"
8601 " if (true)\n"
8602 " {\n"
8603 " a();\n"
8604 " b();\n"
8605 " }\n"
8606 " }\n"
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00008607 " void g() { return; }\n"
Roman Kashitsyna043ced2014-08-11 12:18:01 +00008608 "};\n"
8609 "struct B\n"
8610 "{\n"
8611 " int x;\n"
8612 "};\n"
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00008613 "}",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00008614 AllmanBraceStyle);
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00008615
8616 verifyFormat("void f()\n"
8617 "{\n"
8618 " if (true)\n"
8619 " {\n"
8620 " a();\n"
8621 " }\n"
8622 " else if (false)\n"
8623 " {\n"
8624 " b();\n"
8625 " }\n"
8626 " else\n"
8627 " {\n"
8628 " c();\n"
8629 " }\n"
8630 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00008631 AllmanBraceStyle);
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00008632
8633 verifyFormat("void f()\n"
8634 "{\n"
8635 " for (int i = 0; i < 10; ++i)\n"
8636 " {\n"
8637 " a();\n"
8638 " }\n"
8639 " while (false)\n"
8640 " {\n"
8641 " b();\n"
8642 " }\n"
8643 " do\n"
8644 " {\n"
8645 " c();\n"
8646 " } while (false)\n"
8647 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00008648 AllmanBraceStyle);
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00008649
8650 verifyFormat("void f(int a)\n"
8651 "{\n"
8652 " switch (a)\n"
8653 " {\n"
8654 " case 0:\n"
8655 " break;\n"
8656 " case 1:\n"
8657 " {\n"
8658 " break;\n"
8659 " }\n"
8660 " case 2:\n"
8661 " {\n"
8662 " }\n"
8663 " break;\n"
8664 " default:\n"
8665 " break;\n"
8666 " }\n"
8667 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00008668 AllmanBraceStyle);
Manuel Klimeka027f302013-08-07 19:20:45 +00008669
8670 verifyFormat("enum X\n"
8671 "{\n"
8672 " Y = 0,\n"
8673 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00008674 AllmanBraceStyle);
Daniel Jaspere18ff372014-06-02 10:17:32 +00008675 verifyFormat("enum X\n"
8676 "{\n"
8677 " Y = 0\n"
8678 "}\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00008679 AllmanBraceStyle);
Manuel Klimeka027f302013-08-07 19:20:45 +00008680
Dinesh Dwivediea3aca82014-05-02 17:01:46 +00008681 verifyFormat("@interface BSApplicationController ()\n"
8682 "{\n"
8683 "@private\n"
8684 " id _extraIvar;\n"
8685 "}\n"
8686 "@end\n",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00008687 AllmanBraceStyle);
Dinesh Dwivediea3aca82014-05-02 17:01:46 +00008688
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00008689 verifyFormat("#ifdef _DEBUG\n"
8690 "int foo(int i = 0)\n"
8691 "#else\n"
8692 "int foo(int i = 5)\n"
8693 "#endif\n"
8694 "{\n"
8695 " return i;\n"
8696 "}",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00008697 AllmanBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00008698
8699 verifyFormat("void foo() {}\n"
8700 "void bar()\n"
8701 "#ifdef _DEBUG\n"
8702 "{\n"
8703 " foo();\n"
8704 "}\n"
8705 "#else\n"
8706 "{\n"
8707 "}\n"
8708 "#endif",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00008709 AllmanBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00008710
8711 verifyFormat("void foobar() { int i = 5; }\n"
8712 "#ifdef _DEBUG\n"
8713 "void bar() {}\n"
8714 "#else\n"
8715 "void bar() { foobar(); }\n"
8716 "#endif",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00008717 AllmanBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00008718
Daniel Jasperba1b6bb2014-05-26 07:24:34 +00008719 // This shouldn't affect ObjC blocks..
Daniel Jasper565ed5e2014-05-22 13:53:55 +00008720 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +00008721 " // ...\n"
8722 " int i;\n"
Daniel Jasperba1b6bb2014-05-26 07:24:34 +00008723 "}];",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00008724 AllmanBraceStyle);
Daniel Jasper565ed5e2014-05-22 13:53:55 +00008725 verifyFormat("void (^block)(void) = ^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +00008726 " // ...\n"
8727 " int i;\n"
Daniel Jasperba1b6bb2014-05-26 07:24:34 +00008728 "};",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00008729 AllmanBraceStyle);
Daniel Jasperba1b6bb2014-05-26 07:24:34 +00008730 // .. or dict literals.
8731 verifyFormat("void f()\n"
8732 "{\n"
8733 " [object someMethod:@{ @\"a\" : @\"b\" }];\n"
8734 "}",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00008735 AllmanBraceStyle);
Daniel Jasper55aed672014-12-07 16:44:49 +00008736 verifyFormat("int f()\n"
8737 "{ // comment\n"
8738 " return 42;\n"
8739 "}",
8740 AllmanBraceStyle);
Daniel Jasper565ed5e2014-05-22 13:53:55 +00008741
Roman Kashitsyna043ced2014-08-11 12:18:01 +00008742 AllmanBraceStyle.ColumnLimit = 19;
8743 verifyFormat("void f() { int i; }", AllmanBraceStyle);
8744 AllmanBraceStyle.ColumnLimit = 18;
Daniel Jasper234379f2013-12-24 13:31:25 +00008745 verifyFormat("void f()\n"
8746 "{\n"
8747 " int i;\n"
8748 "}",
Roman Kashitsyna043ced2014-08-11 12:18:01 +00008749 AllmanBraceStyle);
8750 AllmanBraceStyle.ColumnLimit = 80;
Daniel Jasper234379f2013-12-24 13:31:25 +00008751
Roman Kashitsyna043ced2014-08-11 12:18:01 +00008752 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle;
Manuel Klimeka027f302013-08-07 19:20:45 +00008753 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = true;
8754 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
8755 verifyFormat("void f(bool b)\n"
8756 "{\n"
8757 " if (b)\n"
8758 " {\n"
8759 " return;\n"
8760 " }\n"
8761 "}\n",
8762 BreakBeforeBraceShortIfs);
8763 verifyFormat("void f(bool b)\n"
8764 "{\n"
8765 " if (b) return;\n"
8766 "}\n",
8767 BreakBeforeBraceShortIfs);
8768 verifyFormat("void f(bool b)\n"
8769 "{\n"
8770 " while (b)\n"
8771 " {\n"
8772 " return;\n"
8773 " }\n"
8774 "}\n",
8775 BreakBeforeBraceShortIfs);
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00008776}
8777
Alexander Kornienko3a33f022013-12-12 09:49:52 +00008778TEST_F(FormatTest, GNUBraceBreaking) {
8779 FormatStyle GNUBraceStyle = getLLVMStyle();
8780 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU;
8781 verifyFormat("namespace a\n"
8782 "{\n"
8783 "class A\n"
8784 "{\n"
8785 " void f()\n"
8786 " {\n"
8787 " int a;\n"
8788 " {\n"
8789 " int b;\n"
8790 " }\n"
8791 " if (true)\n"
8792 " {\n"
8793 " a();\n"
8794 " b();\n"
8795 " }\n"
8796 " }\n"
8797 " void g() { return; }\n"
8798 "}\n"
8799 "}",
8800 GNUBraceStyle);
8801
8802 verifyFormat("void f()\n"
8803 "{\n"
8804 " if (true)\n"
8805 " {\n"
8806 " a();\n"
8807 " }\n"
8808 " else if (false)\n"
8809 " {\n"
8810 " b();\n"
8811 " }\n"
8812 " else\n"
8813 " {\n"
8814 " c();\n"
8815 " }\n"
8816 "}\n",
8817 GNUBraceStyle);
8818
8819 verifyFormat("void f()\n"
8820 "{\n"
8821 " for (int i = 0; i < 10; ++i)\n"
8822 " {\n"
8823 " a();\n"
8824 " }\n"
8825 " while (false)\n"
8826 " {\n"
8827 " b();\n"
8828 " }\n"
8829 " do\n"
8830 " {\n"
8831 " c();\n"
8832 " }\n"
8833 " while (false);\n"
8834 "}\n",
8835 GNUBraceStyle);
8836
8837 verifyFormat("void f(int a)\n"
8838 "{\n"
8839 " switch (a)\n"
8840 " {\n"
8841 " case 0:\n"
8842 " break;\n"
8843 " case 1:\n"
8844 " {\n"
8845 " break;\n"
8846 " }\n"
8847 " case 2:\n"
8848 " {\n"
8849 " }\n"
8850 " break;\n"
8851 " default:\n"
8852 " break;\n"
8853 " }\n"
8854 "}\n",
8855 GNUBraceStyle);
8856
8857 verifyFormat("enum X\n"
8858 "{\n"
8859 " Y = 0,\n"
8860 "}\n",
8861 GNUBraceStyle);
Dinesh Dwivediea3aca82014-05-02 17:01:46 +00008862
8863 verifyFormat("@interface BSApplicationController ()\n"
8864 "{\n"
8865 "@private\n"
8866 " id _extraIvar;\n"
8867 "}\n"
8868 "@end\n",
8869 GNUBraceStyle);
Dinesh Dwivediafe6fb62014-05-05 11:36:35 +00008870
8871 verifyFormat("#ifdef _DEBUG\n"
8872 "int foo(int i = 0)\n"
8873 "#else\n"
8874 "int foo(int i = 5)\n"
8875 "#endif\n"
8876 "{\n"
8877 " return i;\n"
8878 "}",
8879 GNUBraceStyle);
8880
8881 verifyFormat("void foo() {}\n"
8882 "void bar()\n"
8883 "#ifdef _DEBUG\n"
8884 "{\n"
8885 " foo();\n"
8886 "}\n"
8887 "#else\n"
8888 "{\n"
8889 "}\n"
8890 "#endif",
8891 GNUBraceStyle);
8892
8893 verifyFormat("void foobar() { int i = 5; }\n"
8894 "#ifdef _DEBUG\n"
8895 "void bar() {}\n"
8896 "#else\n"
8897 "void bar() { foobar(); }\n"
8898 "#endif",
8899 GNUBraceStyle);
Alexander Kornienko3a33f022013-12-12 09:49:52 +00008900}
Manuel Klimekd5735502013-08-12 03:51:17 +00008901TEST_F(FormatTest, CatchExceptionReferenceBinding) {
8902 verifyFormat("void f() {\n"
8903 " try {\n"
Daniel Jasper04a71a42014-05-08 11:58:24 +00008904 " } catch (const Exception &e) {\n"
Manuel Klimekd5735502013-08-12 03:51:17 +00008905 " }\n"
8906 "}\n",
8907 getLLVMStyle());
8908}
8909
Daniel Jasper9613c812013-08-07 16:29:23 +00008910TEST_F(FormatTest, UnderstandsPragmas) {
8911 verifyFormat("#pragma omp reduction(| : var)");
8912 verifyFormat("#pragma omp reduction(+ : var)");
Daniel Jasperdc32c1b2014-01-09 13:56:49 +00008913
8914 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
8915 "(including parentheses).",
8916 format("#pragma mark Any non-hyphenated or hyphenated string "
8917 "(including parentheses)."));
Daniel Jasper9613c812013-08-07 16:29:23 +00008918}
8919
Daniel Jasperee4a8a12015-04-22 09:45:42 +00008920TEST_F(FormatTest, UnderstandPragmaOption) {
8921 verifyFormat("#pragma option -C -A");
8922
8923 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A"));
8924}
8925
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00008926#define EXPECT_ALL_STYLES_EQUAL(Styles) \
8927 for (size_t i = 1; i < Styles.size(); ++i) \
Daniel Jaspera44991332015-04-29 13:06:49 +00008928 EXPECT_EQ(Styles[0], Styles[i]) << "Style #" << i << " of " << Styles.size() \
8929 << " differs from Style #0"
Alexander Kornienkod6538332013-05-07 15:32:14 +00008930
8931TEST_F(FormatTest, GetsPredefinedStyleByName) {
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00008932 SmallVector<FormatStyle, 3> Styles;
8933 Styles.resize(3);
Alexander Kornienkod6538332013-05-07 15:32:14 +00008934
Alexander Kornienko006b5c82013-05-19 00:53:30 +00008935 Styles[0] = getLLVMStyle();
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00008936 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
8937 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
8938 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienkod6538332013-05-07 15:32:14 +00008939
Alexander Kornienko006b5c82013-05-19 00:53:30 +00008940 Styles[0] = getGoogleStyle();
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00008941 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
8942 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
8943 EXPECT_ALL_STYLES_EQUAL(Styles);
8944
Nico Weber514ecc82014-02-02 20:50:45 +00008945 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00008946 EXPECT_TRUE(
8947 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
8948 EXPECT_TRUE(
8949 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
8950 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienkod6538332013-05-07 15:32:14 +00008951
Nico Weber514ecc82014-02-02 20:50:45 +00008952 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00008953 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
8954 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
8955 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienko006b5c82013-05-19 00:53:30 +00008956
8957 Styles[0] = getMozillaStyle();
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00008958 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
8959 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
8960 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienko006b5c82013-05-19 00:53:30 +00008961
Daniel Jasperffefb3d2013-07-24 13:10:59 +00008962 Styles[0] = getWebKitStyle();
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00008963 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
8964 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
8965 EXPECT_ALL_STYLES_EQUAL(Styles);
Daniel Jasperffefb3d2013-07-24 13:10:59 +00008966
Alexander Kornienkofe7a57f2013-12-10 15:42:15 +00008967 Styles[0] = getGNUStyle();
8968 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
8969 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
8970 EXPECT_ALL_STYLES_EQUAL(Styles);
8971
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00008972 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
8973}
8974
8975TEST_F(FormatTest, GetsCorrectBasedOnStyle) {
8976 SmallVector<FormatStyle, 8> Styles;
8977 Styles.resize(2);
8978
8979 Styles[0] = getGoogleStyle();
8980 Styles[1] = getLLVMStyle();
8981 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
8982 EXPECT_ALL_STYLES_EQUAL(Styles);
8983
8984 Styles.resize(5);
Nico Weber514ecc82014-02-02 20:50:45 +00008985 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00008986 Styles[1] = getLLVMStyle();
8987 Styles[1].Language = FormatStyle::LK_JavaScript;
8988 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
8989
8990 Styles[2] = getLLVMStyle();
8991 Styles[2].Language = FormatStyle::LK_JavaScript;
8992 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
8993 "BasedOnStyle: Google",
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00008994 &Styles[2])
8995 .value());
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00008996
8997 Styles[3] = getLLVMStyle();
8998 Styles[3].Language = FormatStyle::LK_JavaScript;
8999 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
9000 "Language: JavaScript",
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00009001 &Styles[3])
9002 .value());
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009003
9004 Styles[4] = getLLVMStyle();
9005 Styles[4].Language = FormatStyle::LK_JavaScript;
9006 EXPECT_EQ(0, parseConfiguration("---\n"
9007 "BasedOnStyle: LLVM\n"
9008 "IndentWidth: 123\n"
9009 "---\n"
9010 "BasedOnStyle: Google\n"
9011 "Language: JavaScript",
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00009012 &Styles[4])
9013 .value());
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009014 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009015}
9016
Daniel Jasper91881d92014-09-29 08:07:46 +00009017#define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \
Alexander Kornienkod6538332013-05-07 15:32:14 +00009018 Style.FIELD = false; \
Daniel Jasper91881d92014-09-29 08:07:46 +00009019 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \
Alexander Kornienko006b5c82013-05-19 00:53:30 +00009020 EXPECT_TRUE(Style.FIELD); \
Daniel Jasper91881d92014-09-29 08:07:46 +00009021 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \
Patrik Hagglund76aca642013-05-14 07:53:53 +00009022 EXPECT_FALSE(Style.FIELD);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009023
Daniel Jasper91881d92014-09-29 08:07:46 +00009024#define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
9025
Daniel Jasper00853002014-09-16 16:22:30 +00009026#define CHECK_PARSE(TEXT, FIELD, VALUE) \
9027 EXPECT_NE(VALUE, Style.FIELD); \
9028 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \
9029 EXPECT_EQ(VALUE, Style.FIELD)
9030
Alexander Kornienkoc6221a52014-08-14 13:07:35 +00009031TEST_F(FormatTest, ParsesConfigurationBools) {
Alexander Kornienkocabdd732013-11-29 15:19:43 +00009032 FormatStyle Style = {};
9033 Style.Language = FormatStyle::LK_Cpp;
Daniel Jasper3219e432014-12-02 13:24:51 +00009034 CHECK_PARSE_BOOL(AlignAfterOpenBracket);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009035 CHECK_PARSE_BOOL(AlignEscapedNewlinesLeft);
Daniel Jasper3219e432014-12-02 13:24:51 +00009036 CHECK_PARSE_BOOL(AlignOperands);
Daniel Jasper552f4a72013-07-31 23:55:15 +00009037 CHECK_PARSE_BOOL(AlignTrailingComments);
Daniel Jaspera44991332015-04-29 13:06:49 +00009038 CHECK_PARSE_BOOL(AlignConsecutiveAssignments);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009039 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
Daniel Jasper17605d32014-05-14 09:33:35 +00009040 CHECK_PARSE_BOOL(AllowShortBlocksOnASingleLine);
Daniel Jasperb87899b2014-09-10 13:11:45 +00009041 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009042 CHECK_PARSE_BOOL(AllowShortIfStatementsOnASingleLine);
Daniel Jasper997af662013-05-16 12:16:23 +00009043 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
Daniel Jasperca4ea1c2014-08-05 12:16:31 +00009044 CHECK_PARSE_BOOL(AlwaysBreakAfterDefinitionReturnType);
Daniel Jasper61e6bbf2013-05-29 12:07:31 +00009045 CHECK_PARSE_BOOL(AlwaysBreakTemplateDeclarations);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009046 CHECK_PARSE_BOOL(BinPackParameters);
Daniel Jasper18210d72014-10-09 09:52:05 +00009047 CHECK_PARSE_BOOL(BinPackArguments);
Daniel Jasper165b29e2013-11-08 00:57:11 +00009048 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
Daniel Jaspere33d4af2013-07-26 16:56:36 +00009049 CHECK_PARSE_BOOL(BreakConstructorInitializersBeforeComma);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009050 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
Daniel Jasper553d4872014-06-17 12:40:34 +00009051 CHECK_PARSE_BOOL(DerivePointerAlignment);
Daniel Jasper91881d92014-09-29 08:07:46 +00009052 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
Alexander Kornienkod6538332013-05-07 15:32:14 +00009053 CHECK_PARSE_BOOL(IndentCaseLabels);
Daniel Jasperc75e1ef2014-07-09 08:42:42 +00009054 CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
Daniel Jaspera26fc5c2014-03-21 13:43:14 +00009055 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
Daniel Jaspere9beea22014-01-28 15:20:33 +00009056 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009057 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
Daniel Jasper6ab54682013-07-16 18:22:10 +00009058 CHECK_PARSE_BOOL(Cpp11BracedListStyle);
Daniel Jasperb55acad2013-08-20 12:36:34 +00009059 CHECK_PARSE_BOOL(SpacesInParentheses);
Daniel Jasperad981f82014-08-26 11:41:14 +00009060 CHECK_PARSE_BOOL(SpacesInSquareBrackets);
Daniel Jasperdd978ae2013-10-29 14:52:02 +00009061 CHECK_PARSE_BOOL(SpacesInAngles);
Daniel Jasperb55acad2013-08-20 12:36:34 +00009062 CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
Daniel Jasperb2e10a52014-01-15 15:09:08 +00009063 CHECK_PARSE_BOOL(SpacesInContainerLiterals);
Daniel Jasperb55acad2013-08-20 12:36:34 +00009064 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
Daniel Jasperdb986eb2014-09-03 07:37:29 +00009065 CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
Daniel Jasperd94bff32013-09-25 15:15:02 +00009066 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
Alexander Kornienkoc6221a52014-08-14 13:07:35 +00009067}
Alexander Kornienkod6538332013-05-07 15:32:14 +00009068
Alexander Kornienkoc6221a52014-08-14 13:07:35 +00009069#undef CHECK_PARSE_BOOL
9070
Alexander Kornienkoc6221a52014-08-14 13:07:35 +00009071TEST_F(FormatTest, ParsesConfiguration) {
9072 FormatStyle Style = {};
9073 Style.Language = FormatStyle::LK_Cpp;
Alexander Kornienkod6538332013-05-07 15:32:14 +00009074 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
Daniel Jaspercdaffa42013-08-13 10:58:30 +00009075 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
9076 ConstructorInitializerIndentWidth, 1234u);
Daniel Jasper50d634b2014-10-28 16:53:38 +00009077 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009078 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
9079 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
Daniel Jasper33b909c2013-10-25 14:29:37 +00009080 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
9081 PenaltyBreakBeforeFirstCallParameter, 1234u);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009082 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
9083 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
9084 PenaltyReturnTypeOnItsOwnLine, 1234u);
9085 CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
9086 SpacesBeforeTrailingComments, 1234u);
Manuel Klimek13b97d82013-05-13 08:42:42 +00009087 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
Daniel Jasper6633ab82013-10-18 10:38:14 +00009088 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009089
Daniel Jasper553d4872014-06-17 12:40:34 +00009090 Style.PointerAlignment = FormatStyle::PAS_Middle;
Daniel Jasperac043c92014-09-15 11:11:00 +00009091 CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
9092 FormatStyle::PAS_Left);
9093 CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
9094 FormatStyle::PAS_Right);
9095 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
9096 FormatStyle::PAS_Middle);
Daniel Jasper00853002014-09-16 16:22:30 +00009097 // For backward compatibility:
9098 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
9099 FormatStyle::PAS_Left);
9100 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
9101 FormatStyle::PAS_Right);
9102 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
9103 FormatStyle::PAS_Middle);
Daniel Jasper553d4872014-06-17 12:40:34 +00009104
Alexander Kornienkod6538332013-05-07 15:32:14 +00009105 Style.Standard = FormatStyle::LS_Auto;
Alexander Kornienkob40cfe42013-09-04 14:09:13 +00009106 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
9107 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Cpp11);
Alexander Kornienkod6538332013-05-07 15:32:14 +00009108 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
9109 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
9110 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
9111
Daniel Jasperac043c92014-09-15 11:11:00 +00009112 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
Daniel Jasperac043c92014-09-15 11:11:00 +00009113 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
9114 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
Daniel Jasperac043c92014-09-15 11:11:00 +00009115 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
9116 FormatStyle::BOS_None);
9117 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
9118 FormatStyle::BOS_All);
Daniel Jasper00853002014-09-16 16:22:30 +00009119 // For backward compatibility:
9120 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
9121 FormatStyle::BOS_None);
9122 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
9123 FormatStyle::BOS_All);
Daniel Jasperac043c92014-09-15 11:11:00 +00009124
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00009125 Style.UseTab = FormatStyle::UT_ForIndentation;
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00009126 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
9127 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
9128 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
Daniel Jasper00853002014-09-16 16:22:30 +00009129 // For backward compatibility:
9130 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
9131 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +00009132
Daniel Jasperd74cf402014-04-08 12:46:38 +00009133 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
Daniel Jasperd74cf402014-04-08 12:46:38 +00009134 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
9135 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
9136 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
9137 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
Daniel Jasper9e709352014-11-26 10:43:58 +00009138 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
9139 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
Daniel Jasperd74cf402014-04-08 12:46:38 +00009140 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
9141 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
Daniel Jasper00853002014-09-16 16:22:30 +00009142 // For backward compatibility:
9143 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
9144 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
9145 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
9146 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
Daniel Jasperd74cf402014-04-08 12:46:38 +00009147
Alexander Kornienkofdca83d2013-12-10 10:18:34 +00009148 Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
9149 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
9150 FormatStyle::SBPO_Never);
9151 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
9152 FormatStyle::SBPO_Always);
9153 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
9154 FormatStyle::SBPO_ControlStatements);
9155 // For backward compatibility:
9156 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
9157 FormatStyle::SBPO_Never);
9158 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
9159 FormatStyle::SBPO_ControlStatements);
9160
Alexander Kornienkod6538332013-05-07 15:32:14 +00009161 Style.ColumnLimit = 123;
9162 FormatStyle BaseStyle = getLLVMStyle();
9163 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
9164 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
9165
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009166 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
9167 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
9168 FormatStyle::BS_Attach);
9169 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
9170 FormatStyle::BS_Linux);
9171 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
9172 FormatStyle::BS_Stroustrup);
Alexander Kornienko3a33f022013-12-12 09:49:52 +00009173 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
9174 FormatStyle::BS_Allman);
9175 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
Manuel Klimeka8eb9142013-05-13 12:51:40 +00009176
Daniel Jasper65ee3472013-07-31 23:16:02 +00009177 Style.NamespaceIndentation = FormatStyle::NI_All;
9178 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
9179 FormatStyle::NI_None);
9180 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
9181 FormatStyle::NI_Inner);
9182 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
9183 FormatStyle::NI_All);
Daniel Jaspere1e43192014-04-01 12:55:11 +00009184
9185 Style.ForEachMacros.clear();
Aaron Ballman2b9036d2014-04-01 16:30:35 +00009186 std::vector<std::string> BoostForeach;
9187 BoostForeach.push_back("BOOST_FOREACH");
Daniel Jaspere1e43192014-04-01 12:55:11 +00009188 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
Aaron Ballman2b9036d2014-04-01 16:30:35 +00009189 std::vector<std::string> BoostAndQForeach;
9190 BoostAndQForeach.push_back("BOOST_FOREACH");
9191 BoostAndQForeach.push_back("Q_FOREACH");
Daniel Jaspere1e43192014-04-01 12:55:11 +00009192 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
9193 BoostAndQForeach);
Alexander Kornienkocabdd732013-11-29 15:19:43 +00009194}
9195
9196TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
9197 FormatStyle Style = {};
9198 Style.Language = FormatStyle::LK_Cpp;
9199 CHECK_PARSE("Language: Cpp\n"
9200 "IndentWidth: 12",
9201 IndentWidth, 12u);
Rafael Espindola1f243172014-06-12 11:35:17 +00009202 EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
9203 "IndentWidth: 34",
9204 &Style),
9205 ParseError::Unsuitable);
Alexander Kornienkocabdd732013-11-29 15:19:43 +00009206 EXPECT_EQ(12u, Style.IndentWidth);
9207 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
9208 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
9209
9210 Style.Language = FormatStyle::LK_JavaScript;
9211 CHECK_PARSE("Language: JavaScript\n"
9212 "IndentWidth: 12",
9213 IndentWidth, 12u);
9214 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
Rafael Espindola1f243172014-06-12 11:35:17 +00009215 EXPECT_EQ(parseConfiguration("Language: Cpp\n"
9216 "IndentWidth: 34",
9217 &Style),
9218 ParseError::Unsuitable);
Alexander Kornienkocabdd732013-11-29 15:19:43 +00009219 EXPECT_EQ(23u, Style.IndentWidth);
9220 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
9221 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
9222
9223 CHECK_PARSE("BasedOnStyle: LLVM\n"
9224 "IndentWidth: 67",
9225 IndentWidth, 67u);
9226
9227 CHECK_PARSE("---\n"
9228 "Language: JavaScript\n"
9229 "IndentWidth: 12\n"
9230 "---\n"
9231 "Language: Cpp\n"
9232 "IndentWidth: 34\n"
9233 "...\n",
9234 IndentWidth, 12u);
9235
9236 Style.Language = FormatStyle::LK_Cpp;
9237 CHECK_PARSE("---\n"
9238 "Language: JavaScript\n"
9239 "IndentWidth: 12\n"
9240 "---\n"
9241 "Language: Cpp\n"
9242 "IndentWidth: 34\n"
9243 "...\n",
9244 IndentWidth, 34u);
9245 CHECK_PARSE("---\n"
9246 "IndentWidth: 78\n"
9247 "---\n"
9248 "Language: JavaScript\n"
9249 "IndentWidth: 56\n"
9250 "...\n",
9251 IndentWidth, 78u);
9252
9253 Style.ColumnLimit = 123;
9254 Style.IndentWidth = 234;
9255 Style.BreakBeforeBraces = FormatStyle::BS_Linux;
9256 Style.TabWidth = 345;
Rafael Espindola3ae06202014-05-31 03:20:52 +00009257 EXPECT_FALSE(parseConfiguration("---\n"
9258 "IndentWidth: 456\n"
9259 "BreakBeforeBraces: Allman\n"
9260 "---\n"
9261 "Language: JavaScript\n"
9262 "IndentWidth: 111\n"
9263 "TabWidth: 111\n"
9264 "---\n"
9265 "Language: Cpp\n"
9266 "BreakBeforeBraces: Stroustrup\n"
9267 "TabWidth: 789\n"
9268 "...\n",
9269 &Style));
Alexander Kornienkocabdd732013-11-29 15:19:43 +00009270 EXPECT_EQ(123u, Style.ColumnLimit);
9271 EXPECT_EQ(456u, Style.IndentWidth);
9272 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
9273 EXPECT_EQ(789u, Style.TabWidth);
9274
Rafael Espindola1f243172014-06-12 11:35:17 +00009275 EXPECT_EQ(parseConfiguration("---\n"
9276 "Language: JavaScript\n"
9277 "IndentWidth: 56\n"
9278 "---\n"
9279 "IndentWidth: 78\n"
9280 "...\n",
9281 &Style),
9282 ParseError::Error);
9283 EXPECT_EQ(parseConfiguration("---\n"
9284 "Language: JavaScript\n"
9285 "IndentWidth: 56\n"
9286 "---\n"
9287 "Language: JavaScript\n"
9288 "IndentWidth: 78\n"
9289 "...\n",
9290 &Style),
9291 ParseError::Error);
Alexander Kornienkocabdd732013-11-29 15:19:43 +00009292
9293 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
9294}
Daniel Jasper65ee3472013-07-31 23:16:02 +00009295
Alexander Kornienkod6bd7472013-12-30 16:11:28 +00009296#undef CHECK_PARSE
Alexander Kornienkod6bd7472013-12-30 16:11:28 +00009297
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009298TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
9299 FormatStyle Style = {};
9300 Style.Language = FormatStyle::LK_JavaScript;
9301 Style.BreakBeforeTernaryOperators = true;
Alexander Kornienkod6bd7472013-12-30 16:11:28 +00009302 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
Daniel Jaspere551bb72014-11-05 17:22:31 +00009303 EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
Alexander Kornienkod6bd7472013-12-30 16:11:28 +00009304
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009305 Style.BreakBeforeTernaryOperators = true;
Alexander Kornienkod6bd7472013-12-30 16:11:28 +00009306 EXPECT_EQ(0, parseConfiguration("---\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00009307 "BasedOnStyle: Google\n"
9308 "---\n"
9309 "Language: JavaScript\n"
9310 "IndentWidth: 76\n"
9311 "...\n",
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00009312 &Style)
9313 .value());
Daniel Jaspere551bb72014-11-05 17:22:31 +00009314 EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00009315 EXPECT_EQ(76u, Style.IndentWidth);
9316 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
9317}
9318
Alexander Kornienkod6538332013-05-07 15:32:14 +00009319TEST_F(FormatTest, ConfigurationRoundTripTest) {
9320 FormatStyle Style = getLLVMStyle();
9321 std::string YAML = configurationAsText(Style);
9322 FormatStyle ParsedStyle = {};
Alexander Kornienkocabdd732013-11-29 15:19:43 +00009323 ParsedStyle.Language = FormatStyle::LK_Cpp;
Alexander Kornienkod6538332013-05-07 15:32:14 +00009324 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
9325 EXPECT_EQ(Style, ParsedStyle);
9326}
9327
Alexander Kornienkoffcc0102013-06-05 14:09:10 +00009328TEST_F(FormatTest, WorksFor8bitEncodings) {
9329 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
9330 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
9331 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
9332 "\"\xef\xee\xf0\xf3...\"",
9333 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
9334 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
9335 "\xef\xee\xf0\xf3...\"",
9336 getLLVMStyleWithColumns(12)));
9337}
9338
Alexander Kornienko393e3082013-11-13 14:04:17 +00009339TEST_F(FormatTest, HandlesUTF8BOM) {
9340 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
9341 EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
9342 format("\xef\xbb\xbf#include <iostream>"));
9343 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
9344 format("\xef\xbb\xbf\n#include <iostream>"));
9345}
9346
NAKAMURA Takumi5238eba2013-06-06 01:14:58 +00009347// FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
9348#if !defined(_MSC_VER)
9349
Alexander Kornienkoffcc0102013-06-05 14:09:10 +00009350TEST_F(FormatTest, CountsUTF8CharactersProperly) {
9351 verifyFormat("\"Однажды в студёную зимнюю пору...\"",
9352 getLLVMStyleWithColumns(35));
9353 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +00009354 getLLVMStyleWithColumns(31));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +00009355 verifyFormat("// Однажды в студёную зимнюю пору...",
9356 getLLVMStyleWithColumns(36));
Daniel Jaspera44991332015-04-29 13:06:49 +00009357 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +00009358 verifyFormat("/* Однажды в студёную зимнюю пору... */",
9359 getLLVMStyleWithColumns(39));
9360 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +00009361 getLLVMStyleWithColumns(35));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +00009362}
9363
9364TEST_F(FormatTest, SplitsUTF8Strings) {
Alexander Kornienko71d95d62013-11-26 10:38:53 +00009365 // Non-printable characters' width is currently considered to be the length in
9366 // bytes in UTF8. The characters can be displayed in very different manner
9367 // (zero-width, single width with a substitution glyph, expanded to their code
9368 // (e.g. "<8d>"), so there's no single correct way to handle them.
9369 EXPECT_EQ("\"aaaaÄ\"\n"
Alexander Kornienkofd1d7002013-11-26 13:31:46 +00009370 "\"\xc2\x8d\";",
9371 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
Alexander Kornienko71d95d62013-11-26 10:38:53 +00009372 EXPECT_EQ("\"aaaaaaaÄ\"\n"
Alexander Kornienkofd1d7002013-11-26 13:31:46 +00009373 "\"\xc2\x8d\";",
9374 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
Daniel Jaspera44991332015-04-29 13:06:49 +00009375 EXPECT_EQ("\"Однажды, в \"\n"
9376 "\"студёную \"\n"
9377 "\"зимнюю \"\n"
9378 "\"пору,\"",
9379 format("\"Однажды, в студёную зимнюю пору,\"",
9380 getLLVMStyleWithColumns(13)));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +00009381 EXPECT_EQ(
Daniel Jaspera44991332015-04-29 13:06:49 +00009382 "\"一 二 三 \"\n"
9383 "\"四 五六 \"\n"
9384 "\"七 八 九 \"\n"
9385 "\"十\"",
9386 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +00009387 EXPECT_EQ("\"一\t二 \"\n"
9388 "\"\t三 \"\n"
9389 "\"四 五\t六 \"\n"
9390 "\"\t七 \"\n"
9391 "\"八九十\tqq\"",
9392 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
9393 getLLVMStyleWithColumns(11)));
9394}
9395
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +00009396TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
9397 EXPECT_EQ("const char *sssss =\n"
9398 " \"一二三四五六七八\\\n"
9399 " 九 十\";",
9400 format("const char *sssss = \"一二三四五六七八\\\n"
9401 " 九 十\";",
9402 getLLVMStyleWithColumns(30)));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +00009403}
9404
9405TEST_F(FormatTest, SplitsUTF8LineComments) {
Alexander Kornienkofd1d7002013-11-26 13:31:46 +00009406 EXPECT_EQ("// aaaaÄ\xc2\x8d",
9407 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +00009408 EXPECT_EQ("// Я из лесу\n"
9409 "// вышел; был\n"
9410 "// сильный\n"
9411 "// мороз.",
9412 format("// Я из лесу вышел; был сильный мороз.",
9413 getLLVMStyleWithColumns(13)));
9414 EXPECT_EQ("// 一二三\n"
9415 "// 四五六七\n"
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +00009416 "// 八 九\n"
9417 "// 十",
9418 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9)));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +00009419}
9420
9421TEST_F(FormatTest, SplitsUTF8BlockComments) {
9422 EXPECT_EQ("/* Гляжу,\n"
9423 " * поднимается\n"
9424 " * медленно в\n"
9425 " * гору\n"
9426 " * Лошадка,\n"
9427 " * везущая\n"
9428 " * хворосту\n"
9429 " * воз. */",
9430 format("/* Гляжу, поднимается медленно в гору\n"
9431 " * Лошадка, везущая хворосту воз. */",
9432 getLLVMStyleWithColumns(13)));
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +00009433 EXPECT_EQ(
9434 "/* 一二三\n"
9435 " * 四五六七\n"
9436 " * 八 九\n"
9437 " * 十 */",
9438 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9)));
Alexander Kornienkoff73c202013-06-05 15:08:20 +00009439 EXPECT_EQ("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯\n"
9440 " * 𝕓𝕪𝕥𝕖\n"
9441 " * 𝖀𝕿𝕱-𝟠 */",
9442 format("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯 𝕓𝕪𝕥𝕖 𝖀𝕿𝕱-𝟠 */", getLLVMStyleWithColumns(12)));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +00009443}
9444
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +00009445#endif // _MSC_VER
9446
Daniel Jaspercdaffa42013-08-13 10:58:30 +00009447TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
9448 FormatStyle Style = getLLVMStyle();
9449
9450 Style.ConstructorInitializerIndentWidth = 4;
9451 verifyFormat(
9452 "SomeClass::Constructor()\n"
9453 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
9454 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
9455 Style);
9456
9457 Style.ConstructorInitializerIndentWidth = 2;
9458 verifyFormat(
9459 "SomeClass::Constructor()\n"
9460 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
9461 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
9462 Style);
9463
9464 Style.ConstructorInitializerIndentWidth = 0;
9465 verifyFormat(
9466 "SomeClass::Constructor()\n"
9467 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
9468 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
9469 Style);
Daniel Jasper00853002014-09-16 16:22:30 +00009470}
Daniel Jaspercdaffa42013-08-13 10:58:30 +00009471
Daniel Jasper00853002014-09-16 16:22:30 +00009472TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
9473 FormatStyle Style = getLLVMStyle();
Daniel Jaspercdaffa42013-08-13 10:58:30 +00009474 Style.BreakConstructorInitializersBeforeComma = true;
9475 Style.ConstructorInitializerIndentWidth = 4;
9476 verifyFormat("SomeClass::Constructor()\n"
9477 " : a(a)\n"
9478 " , b(b)\n"
9479 " , c(c) {}",
9480 Style);
Alexander Kornienkoa594ba82013-12-16 14:35:51 +00009481 verifyFormat("SomeClass::Constructor()\n"
9482 " : a(a) {}",
9483 Style);
Daniel Jaspercdaffa42013-08-13 10:58:30 +00009484
Alexander Kornienkoa594ba82013-12-16 14:35:51 +00009485 Style.ColumnLimit = 0;
9486 verifyFormat("SomeClass::Constructor()\n"
9487 " : a(a) {}",
9488 Style);
9489 verifyFormat("SomeClass::Constructor()\n"
9490 " : a(a)\n"
9491 " , b(b)\n"
9492 " , c(c) {}",
9493 Style);
9494 verifyFormat("SomeClass::Constructor()\n"
9495 " : a(a) {\n"
9496 " foo();\n"
9497 " bar();\n"
9498 "}",
9499 Style);
9500
Daniel Jasperd74cf402014-04-08 12:46:38 +00009501 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
Alexander Kornienkoa594ba82013-12-16 14:35:51 +00009502 verifyFormat("SomeClass::Constructor()\n"
9503 " : a(a)\n"
9504 " , b(b)\n"
9505 " , c(c) {\n}",
9506 Style);
9507 verifyFormat("SomeClass::Constructor()\n"
9508 " : a(a) {\n}",
9509 Style);
9510
9511 Style.ColumnLimit = 80;
Daniel Jasperd74cf402014-04-08 12:46:38 +00009512 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
Daniel Jaspercdaffa42013-08-13 10:58:30 +00009513 Style.ConstructorInitializerIndentWidth = 2;
9514 verifyFormat("SomeClass::Constructor()\n"
9515 " : a(a)\n"
9516 " , b(b)\n"
9517 " , c(c) {}",
9518 Style);
9519
9520 Style.ConstructorInitializerIndentWidth = 0;
9521 verifyFormat("SomeClass::Constructor()\n"
9522 ": a(a)\n"
9523 ", b(b)\n"
9524 ", c(c) {}",
9525 Style);
Daniel Jasperec01cd62013-10-08 05:11:18 +00009526
9527 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
9528 Style.ConstructorInitializerIndentWidth = 4;
Alexander Kornienkoa594ba82013-12-16 14:35:51 +00009529 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
9530 verifyFormat(
9531 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
9532 Style);
Daniel Jasperec01cd62013-10-08 05:11:18 +00009533 verifyFormat(
9534 "SomeClass::Constructor()\n"
9535 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
9536 Style);
9537 Style.ConstructorInitializerIndentWidth = 4;
9538 Style.ColumnLimit = 60;
9539 verifyFormat("SomeClass::Constructor()\n"
9540 " : aaaaaaaa(aaaaaaaa)\n"
9541 " , aaaaaaaa(aaaaaaaa)\n"
9542 " , aaaaaaaa(aaaaaaaa) {}",
9543 Style);
Daniel Jaspercdaffa42013-08-13 10:58:30 +00009544}
9545
Daniel Jasper38efc132014-10-21 07:51:54 +00009546TEST_F(FormatTest, Destructors) {
9547 verifyFormat("void F(int &i) { i.~int(); }");
9548 verifyFormat("void F(int &i) { i->~int(); }");
9549}
9550
Daniel Jasperffefb3d2013-07-24 13:10:59 +00009551TEST_F(FormatTest, FormatsWithWebKitStyle) {
9552 FormatStyle Style = getWebKitStyle();
9553
9554 // Don't indent in outer namespaces.
9555 verifyFormat("namespace outer {\n"
9556 "int i;\n"
9557 "namespace inner {\n"
Daniel Jasper65ee3472013-07-31 23:16:02 +00009558 " int i;\n"
Daniel Jasperffefb3d2013-07-24 13:10:59 +00009559 "} // namespace inner\n"
9560 "} // namespace outer\n"
9561 "namespace other_outer {\n"
9562 "int i;\n"
9563 "}",
9564 Style);
9565
9566 // Don't indent case labels.
9567 verifyFormat("switch (variable) {\n"
9568 "case 1:\n"
9569 "case 2:\n"
9570 " doSomething();\n"
9571 " break;\n"
9572 "default:\n"
9573 " ++variable;\n"
9574 "}",
9575 Style);
9576
9577 // Wrap before binary operators.
Daniel Jaspera44991332015-04-29 13:06:49 +00009578 EXPECT_EQ("void f()\n"
9579 "{\n"
9580 " if (aaaaaaaaaaaaaaaa\n"
9581 " && bbbbbbbbbbbbbbbbbbbbbbbb\n"
9582 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
9583 " return;\n"
9584 "}",
9585 format("void f() {\n"
9586 "if (aaaaaaaaaaaaaaaa\n"
9587 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
9588 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
9589 "return;\n"
9590 "}",
9591 Style));
Daniel Jasperffefb3d2013-07-24 13:10:59 +00009592
Daniel Jasper35995672014-04-29 14:05:20 +00009593 // Allow functions on a single line.
9594 verifyFormat("void f() { return; }", Style);
9595
Daniel Jasperffefb3d2013-07-24 13:10:59 +00009596 // Constructor initializers are formatted one per line with the "," on the
9597 // new line.
Alexander Kornienkoa594ba82013-12-16 14:35:51 +00009598 verifyFormat("Constructor()\n"
9599 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
9600 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
Daniel Jasper3aa9a6a2014-11-18 23:55:27 +00009601 " aaaaaaaaaaaaaa)\n"
Daniel Jasper234379f2013-12-24 13:31:25 +00009602 " , aaaaaaaaaaaaaaaaaaaaaaa()\n"
9603 "{\n"
9604 "}",
Alexander Kornienkoa594ba82013-12-16 14:35:51 +00009605 Style);
9606 verifyFormat("SomeClass::Constructor()\n"
9607 " : a(a)\n"
Daniel Jasper234379f2013-12-24 13:31:25 +00009608 "{\n"
9609 "}",
Alexander Kornienkoa594ba82013-12-16 14:35:51 +00009610 Style);
Daniel Jasper234379f2013-12-24 13:31:25 +00009611 EXPECT_EQ("SomeClass::Constructor()\n"
9612 " : a(a)\n"
9613 "{\n"
9614 "}",
9615 format("SomeClass::Constructor():a(a){}", Style));
9616 verifyFormat("SomeClass::Constructor()\n"
9617 " : a(a)\n"
9618 " , b(b)\n"
9619 " , c(c)\n"
9620 "{\n"
Daniel Jaspera44991332015-04-29 13:06:49 +00009621 "}",
9622 Style);
Alexander Kornienkoa594ba82013-12-16 14:35:51 +00009623 verifyFormat("SomeClass::Constructor()\n"
9624 " : a(a)\n"
9625 "{\n"
9626 " foo();\n"
9627 " bar();\n"
9628 "}",
9629 Style);
Daniel Jasperffefb3d2013-07-24 13:10:59 +00009630
Daniel Jasper65ee3472013-07-31 23:16:02 +00009631 // Access specifiers should be aligned left.
9632 verifyFormat("class C {\n"
9633 "public:\n"
9634 " int i;\n"
9635 "};",
9636 Style);
9637
Daniel Jasperffefb3d2013-07-24 13:10:59 +00009638 // Do not align comments.
Daniel Jasper552f4a72013-07-31 23:55:15 +00009639 verifyFormat("int a; // Do not\n"
9640 "double b; // align comments.",
9641 Style);
Daniel Jasperffefb3d2013-07-24 13:10:59 +00009642
Daniel Jasper3219e432014-12-02 13:24:51 +00009643 // Do not align operands.
9644 EXPECT_EQ("ASSERT(aaaa\n"
9645 " || bbbb);",
9646 format("ASSERT ( aaaa\n||bbbb);", Style));
9647
Daniel Jasperffefb3d2013-07-24 13:10:59 +00009648 // Accept input's line breaks.
9649 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
9650 " || bbbbbbbbbbbbbbb) {\n"
9651 " i++;\n"
9652 "}",
9653 format("if (aaaaaaaaaaaaaaa\n"
9654 "|| bbbbbbbbbbbbbbb) { i++; }",
9655 Style));
9656 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
9657 " i++;\n"
9658 "}",
9659 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
Daniel Jasper98fb6e12013-11-08 17:33:27 +00009660
9661 // Don't automatically break all macro definitions (llvm.org/PR17842).
9662 verifyFormat("#define aNumber 10", Style);
9663 // However, generally keep the line breaks that the user authored.
9664 EXPECT_EQ("#define aNumber \\\n"
9665 " 10",
9666 format("#define aNumber \\\n"
9667 " 10",
9668 Style));
Daniel Jasperaf4fee22014-04-14 12:05:05 +00009669
9670 // Keep empty and one-element array literals on a single line.
Daniel Jasper7f0c5172014-05-19 08:06:34 +00009671 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
9672 " copyItems:YES];",
9673 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
9674 "copyItems:YES];",
9675 Style));
9676 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
9677 " copyItems:YES];",
9678 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
9679 " copyItems:YES];",
9680 Style));
Daniel Jasper335ff262014-05-28 09:11:53 +00009681 // FIXME: This does not seem right, there should be more indentation before
9682 // the array literal's entries. Nested blocks have the same problem.
Daniel Jasperdb8804b2014-04-14 12:11:07 +00009683 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
Daniel Jasper335ff262014-05-28 09:11:53 +00009684 " @\"a\",\n"
9685 " @\"a\"\n"
9686 "]\n"
Daniel Jasperdb8804b2014-04-14 12:11:07 +00009687 " copyItems:YES];",
9688 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
9689 " @\"a\",\n"
9690 " @\"a\"\n"
9691 " ]\n"
9692 " copyItems:YES];",
9693 Style));
Daniel Jasper7f0c5172014-05-19 08:06:34 +00009694 EXPECT_EQ(
Daniel Jasperdb8804b2014-04-14 12:11:07 +00009695 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
9696 " copyItems:YES];",
Daniel Jasper7f0c5172014-05-19 08:06:34 +00009697 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
9698 " copyItems:YES];",
9699 Style));
9700
9701 verifyFormat("[self.a b:c c:d];", Style);
9702 EXPECT_EQ("[self.a b:c\n"
9703 " c:d];",
9704 format("[self.a b:c\n"
9705 "c:d];",
9706 Style));
Daniel Jasperffefb3d2013-07-24 13:10:59 +00009707}
9708
Manuel Klimekffdeb592013-09-03 15:10:01 +00009709TEST_F(FormatTest, FormatsLambdas) {
Daniel Jasper5f3ea472014-05-22 08:36:53 +00009710 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
9711 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
9712 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
9713 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
9714 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
Chandler Carruthf8b72662014-03-02 12:37:31 +00009715 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00009716 verifyFormat("void f() {\n"
9717 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
9718 "}\n");
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00009719 verifyFormat("void f() {\n"
9720 " other(x.begin(), //\n"
9721 " x.end(), //\n"
Daniel Jasper9a8d48b2013-09-05 10:04:31 +00009722 " [&](int, int) { return 1; });\n"
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00009723 "}\n");
Daniel Jasper21397a32014-04-09 12:21:48 +00009724 verifyFormat("SomeFunction([]() { // A cool function...\n"
9725 " return 43;\n"
9726 "});");
Daniel Jasper56346192014-10-27 16:31:46 +00009727 EXPECT_EQ("SomeFunction([]() {\n"
9728 "#define A a\n"
9729 " return 43;\n"
9730 "});",
9731 format("SomeFunction([](){\n"
9732 "#define A a\n"
9733 "return 43;\n"
9734 "});"));
Daniel Jasper0e6c51c2014-05-05 12:36:29 +00009735 verifyFormat("void f() {\n"
9736 " SomeFunction([](decltype(x), A *a) {});\n"
9737 "}");
Daniel Jaspera2fb50f2014-06-24 09:15:49 +00009738 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
9739 " [](const aaaaaaaaaa &a) { return a; });");
Daniel Jaspera5621202014-08-08 12:00:13 +00009740 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
9741 " SomeOtherFunctioooooooooooooooooooooooooon();\n"
9742 "});");
Daniel Jasperd6a1cab2015-01-12 10:23:24 +00009743 verifyFormat("Constructor()\n"
9744 " : Field([] { // comment\n"
9745 " int i;\n"
9746 " }) {}");
Daniel Jasper0ad28142015-05-13 08:47:16 +00009747 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
9748 " return some_parameter.size();\n"
9749 "};");
Daniel Jasperc4144ea2015-05-13 16:09:21 +00009750 verifyFormat("int i = aaaaaa ? 1 //\n"
9751 " : [] {\n"
9752 " return 2; //\n"
9753 " }();");
9754 verifyFormat("llvm::errs() << \"number of twos is \"\n"
9755 " << std::count_if(v.begin(), v.end(), [](int x) {\n"
9756 " return x == 2; // force break\n"
9757 " });");
Daniel Jasperbf02b2c12013-09-05 11:49:39 +00009758
Daniel Jaspercb51cf42014-01-16 09:11:55 +00009759 // Lambdas with return types.
Daniel Jasper81a20782014-03-10 10:02:02 +00009760 verifyFormat("int c = []() -> int { return 2; }();\n");
Daniel Jasper60ba32d2015-06-12 09:59:16 +00009761 verifyFormat("int c = []() -> int * { return 2; }();\n");
Daniel Jasper81a20782014-03-10 10:02:02 +00009762 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
9763 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
Daniel Jasperbcb55ee2014-11-21 14:08:38 +00009764 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};");
Daniel Jasper3431b752014-12-08 13:22:37 +00009765 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};");
Daniel Jasperbcb55ee2014-11-21 14:08:38 +00009766 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};");
9767 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};");
Daniel Jasper8f59ae52014-03-11 11:03:26 +00009768 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
9769 " int j) -> int {\n"
Daniel Jaspera2fb50f2014-06-24 09:15:49 +00009770 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n"
Daniel Jasper8f59ae52014-03-11 11:03:26 +00009771 "};");
Daniel Jaspere6623162015-03-02 10:35:13 +00009772 verifyFormat(
9773 "aaaaaaaaaaaaaaaaaaaaaa(\n"
9774 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n"
9775 " return aaaaaaaaaaaaaaaaa;\n"
9776 " });",
9777 getLLVMStyleWithColumns(70));
Daniel Jaspercb51cf42014-01-16 09:11:55 +00009778
Daniel Jasper3ae6f5a2014-04-09 12:08:39 +00009779 // Multiple lambdas in the same parentheses change indentation rules.
Daniel Jasper4b444492014-11-21 13:38:53 +00009780 verifyFormat("SomeFunction(\n"
9781 " []() {\n"
9782 " int i = 42;\n"
9783 " return i;\n"
9784 " },\n"
9785 " []() {\n"
9786 " int j = 43;\n"
9787 " return j;\n"
9788 " });");
Daniel Jasper3ae6f5a2014-04-09 12:08:39 +00009789
Daniel Jasperda18fd82014-06-10 06:39:03 +00009790 // More complex introducers.
9791 verifyFormat("return [i, args...] {};");
9792
Daniel Jasperbf02b2c12013-09-05 11:49:39 +00009793 // Not lambdas.
Chandler Carruthf8b72662014-03-02 12:37:31 +00009794 verifyFormat("constexpr char hello[]{\"hello\"};");
Daniel Jasperb4b99982013-09-06 21:25:51 +00009795 verifyFormat("double &operator[](int i) { return 0; }\n"
9796 "int i;");
Daniel Jasper6b70ec02014-01-22 17:01:47 +00009797 verifyFormat("std::unique_ptr<int[]> foo() {}");
Daniel Jasperd3c7ab92014-03-11 09:59:36 +00009798 verifyFormat("int i = a[a][a]->f();");
Daniel Jaspera58dd5d2014-03-11 10:03:33 +00009799 verifyFormat("int i = (*b)[a]->f();");
Daniel Jasper84a12e12014-03-10 15:06:25 +00009800
9801 // Other corner cases.
9802 verifyFormat("void f() {\n"
9803 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n"
9804 " );\n"
9805 "}");
Daniel Jasperc580af92014-03-11 09:29:46 +00009806
9807 // Lambdas created through weird macros.
9808 verifyFormat("void f() {\n"
9809 " MACRO((const AA &a) { return 1; });\n"
9810 "}");
Daniel Jasper11a0ac62014-12-12 09:40:58 +00009811
9812 verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
9813 " doo_dah();\n"
9814 " doo_dah();\n"
9815 " })) {\n"
9816 "}");
Daniel Jasper29d39d52015-02-08 09:34:49 +00009817 verifyFormat("auto lambda = []() {\n"
9818 " int a = 2\n"
9819 "#if A\n"
9820 " + 2\n"
9821 "#endif\n"
9822 " ;\n"
9823 "};");
Manuel Klimekffdeb592013-09-03 15:10:01 +00009824}
9825
Manuel Klimek516e0542013-09-04 13:25:30 +00009826TEST_F(FormatTest, FormatsBlocks) {
Daniel Jasper76284682014-10-22 09:12:44 +00009827 FormatStyle ShortBlocks = getLLVMStyle();
9828 ShortBlocks.AllowShortBlocksOnASingleLine = true;
9829 verifyFormat("int (^Block)(int, int);", ShortBlocks);
9830 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
9831 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
9832 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
9833 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
9834 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
Daniel Jasper31745732014-01-19 07:46:32 +00009835
Daniel Jasper76284682014-10-22 09:12:44 +00009836 verifyFormat("foo(^{ bar(); });", ShortBlocks);
9837 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
9838 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
Daniel Jasper31745732014-01-19 07:46:32 +00009839
Daniel Jasper76284682014-10-22 09:12:44 +00009840 verifyFormat("[operation setCompletionBlock:^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +00009841 " [self onOperationDone];\n"
Daniel Jasper76284682014-10-22 09:12:44 +00009842 "}];");
9843 verifyFormat("int i = {[operation setCompletionBlock:^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +00009844 " [self onOperationDone];\n"
Daniel Jasper76284682014-10-22 09:12:44 +00009845 "}]};");
9846 verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +00009847 " f();\n"
Daniel Jasper76284682014-10-22 09:12:44 +00009848 "}];");
9849 verifyFormat("int a = [operation block:^int(int *i) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +00009850 " return 1;\n"
Daniel Jasper76284682014-10-22 09:12:44 +00009851 "}];");
Daniel Jaspera225bce2014-01-16 19:14:34 +00009852 verifyFormat("[myObject doSomethingWith:arg1\n"
Daniel Jasper76284682014-10-22 09:12:44 +00009853 " aaa:^int(int *a) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +00009854 " return 1;\n"
Daniel Jasper76284682014-10-22 09:12:44 +00009855 " }\n"
Daniel Jasper5f3ea472014-05-22 08:36:53 +00009856 " bbb:f(a * bbbbbbbb)];");
Daniel Jasperb88b25f2013-12-23 07:29:06 +00009857
9858 verifyFormat("[operation setCompletionBlock:^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +00009859 " [self.delegate newDataAvailable];\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +00009860 "}];",
9861 getLLVMStyleWithColumns(60));
9862 verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +00009863 " NSString *path = [self sessionFilePath];\n"
9864 " if (path) {\n"
9865 " // ...\n"
9866 " }\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +00009867 "});");
9868 verifyFormat("[[SessionService sharedService]\n"
9869 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +00009870 " if (window) {\n"
9871 " [self windowDidLoad:window];\n"
9872 " } else {\n"
9873 " [self errorLoadingWindow];\n"
9874 " }\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +00009875 " }];");
9876 verifyFormat("void (^largeBlock)(void) = ^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +00009877 " // ...\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +00009878 "};\n",
9879 getLLVMStyleWithColumns(40));
9880 verifyFormat("[[SessionService sharedService]\n"
9881 " loadWindowWithCompletionBlock: //\n"
9882 " ^(SessionWindow *window) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +00009883 " if (window) {\n"
9884 " [self windowDidLoad:window];\n"
9885 " } else {\n"
9886 " [self errorLoadingWindow];\n"
9887 " }\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +00009888 " }];",
9889 getLLVMStyleWithColumns(60));
9890 verifyFormat("[myObject doSomethingWith:arg1\n"
9891 " firstBlock:^(Foo *a) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +00009892 " // ...\n"
9893 " int i;\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +00009894 " }\n"
9895 " secondBlock:^(Bar *b) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +00009896 " // ...\n"
9897 " int i;\n"
Daniel Jasperc13ee342014-03-27 09:43:54 +00009898 " }\n"
9899 " thirdBlock:^Foo(Bar *b) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +00009900 " // ...\n"
9901 " int i;\n"
Daniel Jasperb88b25f2013-12-23 07:29:06 +00009902 " }];");
Daniel Jasperb77105d2014-04-08 14:04:31 +00009903 verifyFormat("[myObject doSomethingWith:arg1\n"
9904 " firstBlock:-1\n"
9905 " secondBlock:^(Bar *b) {\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +00009906 " // ...\n"
9907 " int i;\n"
Daniel Jasperb77105d2014-04-08 14:04:31 +00009908 " }];");
Daniel Jasperac7e34e2014-03-13 10:11:17 +00009909
9910 verifyFormat("f(^{\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +00009911 " @autoreleasepool {\n"
9912 " if (a) {\n"
9913 " g();\n"
Daniel Jasperac7e34e2014-03-13 10:11:17 +00009914 " }\n"
Daniel Jasper50d634b2014-10-28 16:53:38 +00009915 " }\n"
Daniel Jasperac7e34e2014-03-13 10:11:17 +00009916 "});");
Daniel Jasperbb86d842014-11-23 19:15:35 +00009917 verifyFormat("Block b = ^int *(A *a, B *b) {}");
Daniel Jasper50d634b2014-10-28 16:53:38 +00009918
9919 FormatStyle FourIndent = getLLVMStyle();
9920 FourIndent.ObjCBlockIndentWidth = 4;
9921 verifyFormat("[operation setCompletionBlock:^{\n"
9922 " [self onOperationDone];\n"
9923 "}];",
9924 FourIndent);
Manuel Klimek516e0542013-09-04 13:25:30 +00009925}
9926
Daniel Jasper289afc02015-04-23 09:23:17 +00009927TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) {
9928 FormatStyle ZeroColumn = getLLVMStyle();
9929 ZeroColumn.ColumnLimit = 0;
9930
9931 verifyFormat("[[SessionService sharedService] "
9932 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
9933 " if (window) {\n"
9934 " [self windowDidLoad:window];\n"
9935 " } else {\n"
9936 " [self errorLoadingWindow];\n"
9937 " }\n"
9938 "}];",
9939 ZeroColumn);
9940 EXPECT_EQ("[[SessionService sharedService]\n"
9941 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
9942 " if (window) {\n"
9943 " [self windowDidLoad:window];\n"
9944 " } else {\n"
9945 " [self errorLoadingWindow];\n"
9946 " }\n"
9947 " }];",
9948 format("[[SessionService sharedService]\n"
9949 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
9950 " if (window) {\n"
9951 " [self windowDidLoad:window];\n"
9952 " } else {\n"
9953 " [self errorLoadingWindow];\n"
9954 " }\n"
9955 "}];",
9956 ZeroColumn));
9957 verifyFormat("[myObject doSomethingWith:arg1\n"
9958 " firstBlock:^(Foo *a) {\n"
9959 " // ...\n"
9960 " int i;\n"
9961 " }\n"
9962 " secondBlock:^(Bar *b) {\n"
9963 " // ...\n"
9964 " int i;\n"
9965 " }\n"
9966 " thirdBlock:^Foo(Bar *b) {\n"
9967 " // ...\n"
9968 " int i;\n"
9969 " }];",
9970 ZeroColumn);
9971 verifyFormat("f(^{\n"
9972 " @autoreleasepool {\n"
9973 " if (a) {\n"
9974 " g();\n"
9975 " }\n"
9976 " }\n"
9977 "});",
9978 ZeroColumn);
9979 verifyFormat("void (^largeBlock)(void) = ^{\n"
9980 " // ...\n"
9981 "};",
9982 ZeroColumn);
9983
9984 ZeroColumn.AllowShortBlocksOnASingleLine = true;
9985 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00009986 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn));
Daniel Jasper289afc02015-04-23 09:23:17 +00009987 ZeroColumn.AllowShortBlocksOnASingleLine = false;
9988 EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
9989 " int i;\n"
9990 "};",
9991 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn));
9992}
9993
Alexander Kornienko9e649af2013-09-11 12:25:57 +00009994TEST_F(FormatTest, SupportsCRLF) {
9995 EXPECT_EQ("int a;\r\n"
9996 "int b;\r\n"
9997 "int c;\r\n",
9998 format("int a;\r\n"
9999 " int b;\r\n"
10000 " int c;\r\n",
10001 getLLVMStyle()));
10002 EXPECT_EQ("int a;\r\n"
10003 "int b;\r\n"
10004 "int c;\r\n",
10005 format("int a;\r\n"
10006 " int b;\n"
10007 " int c;\r\n",
10008 getLLVMStyle()));
10009 EXPECT_EQ("int a;\n"
10010 "int b;\n"
10011 "int c;\n",
10012 format("int a;\r\n"
10013 " int b;\n"
10014 " int c;\n",
10015 getLLVMStyle()));
10016 EXPECT_EQ("\"aaaaaaa \"\r\n"
10017 "\"bbbbbbb\";\r\n",
10018 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
10019 EXPECT_EQ("#define A \\\r\n"
10020 " b; \\\r\n"
10021 " c; \\\r\n"
10022 " d;\r\n",
10023 format("#define A \\\r\n"
10024 " b; \\\r\n"
10025 " c; d; \r\n",
10026 getGoogleStyle()));
Daniel Jasper580da272013-10-30 07:36:40 +000010027
10028 EXPECT_EQ("/*\r\n"
10029 "multi line block comments\r\n"
10030 "should not introduce\r\n"
10031 "an extra carriage return\r\n"
10032 "*/\r\n",
10033 format("/*\r\n"
10034 "multi line block comments\r\n"
10035 "should not introduce\r\n"
10036 "an extra carriage return\r\n"
10037 "*/\r\n"));
Alexander Kornienko9e649af2013-09-11 12:25:57 +000010038}
10039
Manuel Klimekb212f3b2013-10-12 22:46:56 +000010040TEST_F(FormatTest, MunchSemicolonAfterBlocks) {
10041 verifyFormat("MY_CLASS(C) {\n"
10042 " int i;\n"
10043 " int j;\n"
10044 "};");
10045}
10046
Daniel Jasper6633ab82013-10-18 10:38:14 +000010047TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {
10048 FormatStyle TwoIndent = getLLVMStyleWithColumns(15);
10049 TwoIndent.ContinuationIndentWidth = 2;
10050
10051 EXPECT_EQ("int i =\n"
10052 " longFunction(\n"
10053 " arg);",
10054 format("int i = longFunction(arg);", TwoIndent));
10055
10056 FormatStyle SixIndent = getLLVMStyleWithColumns(20);
10057 SixIndent.ContinuationIndentWidth = 6;
10058
10059 EXPECT_EQ("int i =\n"
10060 " longFunction(\n"
10061 " arg);",
10062 format("int i = longFunction(arg);", SixIndent));
10063}
10064
Daniel Jasperdd978ae2013-10-29 14:52:02 +000010065TEST_F(FormatTest, SpacesInAngles) {
10066 FormatStyle Spaces = getLLVMStyle();
10067 Spaces.SpacesInAngles = true;
10068
10069 verifyFormat("static_cast< int >(arg);", Spaces);
10070 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
10071 verifyFormat("f< int, float >();", Spaces);
10072 verifyFormat("template <> g() {}", Spaces);
10073 verifyFormat("template < std::vector< int > > f() {}", Spaces);
10074
10075 Spaces.Standard = FormatStyle::LS_Cpp03;
10076 Spaces.SpacesInAngles = true;
10077 verifyFormat("A< A< int > >();", Spaces);
10078
10079 Spaces.SpacesInAngles = false;
10080 verifyFormat("A<A<int> >();", Spaces);
10081
10082 Spaces.Standard = FormatStyle::LS_Cpp11;
10083 Spaces.SpacesInAngles = true;
10084 verifyFormat("A< A< int > >();", Spaces);
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000010085
Daniel Jasperdd978ae2013-10-29 14:52:02 +000010086 Spaces.SpacesInAngles = false;
10087 verifyFormat("A<A<int>>();", Spaces);
10088}
10089
Jacques Pienaarfc275112015-02-18 23:48:37 +000010090TEST_F(FormatTest, TripleAngleBrackets) {
10091 verifyFormat("f<<<1, 1>>>();");
10092 verifyFormat("f<<<1, 1, 1, s>>>();");
10093 verifyFormat("f<<<a, b, c, d>>>();");
Daniel Jaspera44991332015-04-29 13:06:49 +000010094 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
Jacques Pienaarfc275112015-02-18 23:48:37 +000010095 verifyFormat("f<param><<<1, 1>>>();");
10096 verifyFormat("f<1><<<1, 1>>>();");
Daniel Jaspera44991332015-04-29 13:06:49 +000010097 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
Jacques Pienaarfc275112015-02-18 23:48:37 +000010098 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10099 "aaaaaaaaaaa<<<\n 1, 1>>>();");
10100}
10101
10102TEST_F(FormatTest, MergeLessLessAtEnd) {
Jacques Pienaar68a7dbf2015-02-20 21:09:01 +000010103 verifyFormat("<<");
Jacques Pienaar411b2512015-02-24 23:23:24 +000010104 EXPECT_EQ("< < <", format("\\\n<<<"));
Jacques Pienaarfc275112015-02-18 23:48:37 +000010105 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10106 "aaallvm::outs() <<");
10107 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10108 "aaaallvm::outs()\n <<");
10109}
10110
Manuel Klimek819788d2014-03-18 11:22:45 +000010111TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {
10112 std::string code = "#if A\n"
10113 "#if B\n"
10114 "a.\n"
10115 "#endif\n"
10116 " a = 1;\n"
10117 "#else\n"
10118 "#endif\n"
10119 "#if C\n"
10120 "#else\n"
10121 "#endif\n";
10122 EXPECT_EQ(code, format(code));
10123}
10124
Manuel Klimek68b03042014-04-14 09:14:11 +000010125TEST_F(FormatTest, HandleConflictMarkers) {
10126 // Git/SVN conflict markers.
10127 EXPECT_EQ("int a;\n"
10128 "void f() {\n"
10129 " callme(some(parameter1,\n"
10130 "<<<<<<< text by the vcs\n"
10131 " parameter2),\n"
10132 "||||||| text by the vcs\n"
10133 " parameter2),\n"
10134 " parameter3,\n"
10135 "======= text by the vcs\n"
10136 " parameter2, parameter3),\n"
10137 ">>>>>>> text by the vcs\n"
10138 " otherparameter);\n",
10139 format("int a;\n"
10140 "void f() {\n"
10141 " callme(some(parameter1,\n"
10142 "<<<<<<< text by the vcs\n"
10143 " parameter2),\n"
10144 "||||||| text by the vcs\n"
10145 " parameter2),\n"
10146 " parameter3,\n"
10147 "======= text by the vcs\n"
10148 " parameter2,\n"
10149 " parameter3),\n"
10150 ">>>>>>> text by the vcs\n"
10151 " otherparameter);\n"));
10152
10153 // Perforce markers.
10154 EXPECT_EQ("void f() {\n"
10155 " function(\n"
10156 ">>>> text by the vcs\n"
10157 " parameter,\n"
10158 "==== text by the vcs\n"
10159 " parameter,\n"
10160 "==== text by the vcs\n"
10161 " parameter,\n"
10162 "<<<< text by the vcs\n"
10163 " parameter);\n",
10164 format("void f() {\n"
10165 " function(\n"
10166 ">>>> text by the vcs\n"
10167 " parameter,\n"
10168 "==== text by the vcs\n"
10169 " parameter,\n"
10170 "==== text by the vcs\n"
10171 " parameter,\n"
10172 "<<<< text by the vcs\n"
10173 " parameter);\n"));
10174
10175 EXPECT_EQ("<<<<<<<\n"
10176 "|||||||\n"
10177 "=======\n"
10178 ">>>>>>>",
10179 format("<<<<<<<\n"
10180 "|||||||\n"
10181 "=======\n"
10182 ">>>>>>>"));
10183
10184 EXPECT_EQ("<<<<<<<\n"
10185 "|||||||\n"
10186 "int i;\n"
10187 "=======\n"
10188 ">>>>>>>",
10189 format("<<<<<<<\n"
10190 "|||||||\n"
10191 "int i;\n"
10192 "=======\n"
10193 ">>>>>>>"));
10194
10195 // FIXME: Handle parsing of macros around conflict markers correctly:
10196 EXPECT_EQ("#define Macro \\\n"
10197 "<<<<<<<\n"
10198 "Something \\\n"
10199 "|||||||\n"
10200 "Else \\\n"
10201 "=======\n"
10202 "Other \\\n"
10203 ">>>>>>>\n"
Daniel Jasper4355e7f2014-07-09 07:50:33 +000010204 " End int i;\n",
Manuel Klimek68b03042014-04-14 09:14:11 +000010205 format("#define Macro \\\n"
10206 "<<<<<<<\n"
10207 " Something \\\n"
10208 "|||||||\n"
10209 " Else \\\n"
10210 "=======\n"
10211 " Other \\\n"
10212 ">>>>>>>\n"
10213 " End\n"
10214 "int i;\n"));
10215}
10216
Daniel Jasper471894432014-08-06 13:40:26 +000010217TEST_F(FormatTest, DisableRegions) {
10218 EXPECT_EQ("int i;\n"
10219 "// clang-format off\n"
10220 " int j;\n"
10221 "// clang-format on\n"
10222 "int k;",
10223 format(" int i;\n"
10224 " // clang-format off\n"
10225 " int j;\n"
10226 " // clang-format on\n"
10227 " int k;"));
Roman Kashitsyn650ecb52014-09-11 14:47:20 +000010228 EXPECT_EQ("int i;\n"
10229 "/* clang-format off */\n"
10230 " int j;\n"
10231 "/* clang-format on */\n"
10232 "int k;",
10233 format(" int i;\n"
10234 " /* clang-format off */\n"
10235 " int j;\n"
10236 " /* clang-format on */\n"
10237 " int k;"));
Daniel Jasper471894432014-08-06 13:40:26 +000010238}
10239
Manuel Klimekf0c95b32015-06-11 10:14:13 +000010240TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
10241 format("? ) =");
10242 verifyNoCrash("#define a\\\n /**/}");
10243}
Manuel Klimek5f594f82014-08-13 14:00:41 +000010244
Daniel Jasperd246a5a2015-06-15 15:25:11 +000010245} // end namespace
10246} // end namespace format
Daniel Jasper8d1832e2013-01-07 13:26:07 +000010247} // end namespace clang