blob: 76062605f706028becd58fff5f5905aad2deaca4 [file] [log] [blame]
Daniel Jasperbac016b2012-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
Manuel Klimekca547db2013-01-16 14:55:28 +000010#define DEBUG_TYPE "format-test"
11
Stephen Hines651f13c2014-04-23 16:59:28 -070012#include "FormatTestUtils.h"
Chandler Carruth1050e8b2012-12-04 09:45:34 +000013#include "clang/Format/Format.h"
Chandler Carruthb1ba0ef2013-01-19 08:09:44 +000014#include "llvm/Support/Debug.h"
15#include "gtest/gtest.h"
Manuel Klimekca547db2013-01-16 14:55:28 +000016
Daniel Jasperbac016b2012-12-03 18:12:45 +000017namespace clang {
18namespace format {
19
Stephen Hines651f13c2014-04-23 16:59:28 -070020FormatStyle getGoogleStyle() {
21 return getGoogleStyle(FormatStyle::LK_Cpp);
22}
23
Daniel Jasperbac016b2012-12-03 18:12:45 +000024class FormatTest : public ::testing::Test {
25protected:
26 std::string format(llvm::StringRef Code, unsigned Offset, unsigned Length,
27 const FormatStyle &Style) {
Manuel Klimekca547db2013-01-16 14:55:28 +000028 DEBUG(llvm::errs() << "---\n");
Manuel Klimekae76f7f2013-10-11 21:25:45 +000029 DEBUG(llvm::errs() << Code << "\n\n");
Daniel Jasper8a999452013-05-16 10:40:07 +000030 std::vector<tooling::Range> Ranges(1, tooling::Range(Offset, Length));
31 tooling::Replacements Replaces = reformat(Style, Code, Ranges);
32 ReplacementCount = Replaces.size();
33 std::string Result = applyAllReplacements(Code, Replaces);
34 EXPECT_NE("", Result);
35 DEBUG(llvm::errs() << "\n" << Result << "\n\n");
36 return Result;
Daniel Jasperbac016b2012-12-03 18:12:45 +000037 }
38
Daniel Jasper66d19bd2013-02-18 11:59:17 +000039 std::string
40 format(llvm::StringRef Code, const FormatStyle &Style = getLLVMStyle()) {
Daniel Jasperbac016b2012-12-03 18:12:45 +000041 return format(Code, 0, Code.size(), Style);
42 }
43
Manuel Klimek060143e2013-01-02 18:33:23 +000044 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) {
45 FormatStyle Style = getLLVMStyle();
46 Style.ColumnLimit = ColumnLimit;
47 return Style;
48 }
49
Daniel Jasper6f5bb2c2013-01-14 16:24:39 +000050 FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) {
51 FormatStyle Style = getGoogleStyle();
52 Style.ColumnLimit = ColumnLimit;
53 return Style;
54 }
55
Manuel Klimek060143e2013-01-02 18:33:23 +000056 void verifyFormat(llvm::StringRef Code,
57 const FormatStyle &Style = getLLVMStyle()) {
Stephen Hines651f13c2014-04-23 16:59:28 -070058 EXPECT_EQ(Code.str(), format(test::messUp(Code), Style));
Daniel Jasperbac016b2012-12-03 18:12:45 +000059 }
60
61 void verifyGoogleFormat(llvm::StringRef Code) {
Manuel Klimek060143e2013-01-02 18:33:23 +000062 verifyFormat(Code, getGoogleStyle());
Daniel Jasperbac016b2012-12-03 18:12:45 +000063 }
Daniel Jasper4bfc65a2013-01-23 12:10:53 +000064
65 void verifyIndependentOfContext(llvm::StringRef text) {
66 verifyFormat(text);
67 verifyFormat(llvm::Twine("void f() { " + text + " }").str());
68 }
Daniel Jasperafcbd852013-01-30 09:46:12 +000069
70 int ReplacementCount;
Daniel Jasperbac016b2012-12-03 18:12:45 +000071};
72
Manuel Klimek526ed112013-01-09 15:25:02 +000073TEST_F(FormatTest, MessUp) {
Stephen Hines651f13c2014-04-23 16:59:28 -070074 EXPECT_EQ("1 2 3", test::messUp("1 2 3"));
75 EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n"));
76 EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc"));
77 EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc"));
78 EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne"));
Manuel Klimek526ed112013-01-09 15:25:02 +000079}
80
Alexander Kornienko15757312012-12-06 18:03:27 +000081//===----------------------------------------------------------------------===//
82// Basic function tests.
83//===----------------------------------------------------------------------===//
84
Daniel Jasper567dcf92013-09-05 09:29:45 +000085TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) {
Daniel Jasperbac016b2012-12-03 18:12:45 +000086 EXPECT_EQ(";", format(";"));
87}
88
89TEST_F(FormatTest, FormatsGlobalStatementsAt0) {
90 EXPECT_EQ("int i;", format(" int i;"));
Alexander Kornienko73d845c2013-09-11 12:25:57 +000091 EXPECT_EQ("\nint i;", format(" \n\t \v \f int i;"));
Daniel Jasperbac016b2012-12-03 18:12:45 +000092 EXPECT_EQ("int i;\nint j;", format(" int i; int j;"));
93 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;"));
94}
95
96TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) {
97 EXPECT_EQ("int i;", format("int\ni;"));
98}
99
100TEST_F(FormatTest, FormatsNestedBlockStatements) {
Manuel Klimek36fab8d2013-01-10 13:24:24 +0000101 EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}"));
Daniel Jasperbac016b2012-12-03 18:12:45 +0000102}
103
Alexander Kornienko15757312012-12-06 18:03:27 +0000104TEST_F(FormatTest, FormatsNestedCall) {
105 verifyFormat("Method(f1, f2(f3));");
106 verifyFormat("Method(f1(f2, f3()));");
Daniel Jasper4e9008a2013-01-13 08:19:51 +0000107 verifyFormat("Method(f1(f2, (f3())));");
Alexander Kornienko15757312012-12-06 18:03:27 +0000108}
109
Daniel Jasperdaf1a152013-02-07 21:08:36 +0000110TEST_F(FormatTest, NestedNameSpecifiers) {
Stephen Hines651f13c2014-04-23 16:59:28 -0700111 verifyFormat("vector<::Type> v;");
Daniel Jasperdaf1a152013-02-07 21:08:36 +0000112 verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())");
Daniel Jasper081fc172013-08-28 07:07:07 +0000113 verifyFormat("static constexpr bool Bar = decltype(bar())::value;");
Daniel Jasper6b825c22013-01-16 07:19:28 +0000114}
115
Daniel Jasperafcbd852013-01-30 09:46:12 +0000116TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) {
117 EXPECT_EQ("if (a) {\n"
118 " f();\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000119 "}",
120 format("if(a){f();}"));
Daniel Jasperafcbd852013-01-30 09:46:12 +0000121 EXPECT_EQ(4, ReplacementCount);
122 EXPECT_EQ("if (a) {\n"
123 " f();\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000124 "}",
125 format("if (a) {\n"
126 " f();\n"
127 "}"));
Daniel Jasperafcbd852013-01-30 09:46:12 +0000128 EXPECT_EQ(0, ReplacementCount);
129}
130
Daniel Jasperc78c6b32013-02-14 09:58:41 +0000131TEST_F(FormatTest, RemovesTrailingWhitespaceOfFormattedLine) {
132 EXPECT_EQ("int a;\nint b;", format("int a; \nint b;", 0, 0, getLLVMStyle()));
Daniel Jasper516fb312013-03-01 18:11:39 +0000133 EXPECT_EQ("int a;", format("int a; "));
134 EXPECT_EQ("int a;\n", format("int a; \n \n \n "));
135 EXPECT_EQ("int a;\nint b; ",
136 format("int a; \nint b; ", 0, 0, getLLVMStyle()));
Daniel Jasperc78c6b32013-02-14 09:58:41 +0000137}
138
Daniel Jasper1eee6c42013-03-04 13:43:19 +0000139TEST_F(FormatTest, FormatsCorrectRegionForLeadingWhitespace) {
140 EXPECT_EQ("int b;\nint a;",
141 format("int b;\n int a;", 7, 0, getLLVMStyle()));
142 EXPECT_EQ("int b;\n int a;",
143 format("int b;\n int a;", 6, 0, getLLVMStyle()));
144
145 EXPECT_EQ("#define A \\\n"
146 " int a; \\\n"
147 " int b;",
148 format("#define A \\\n"
149 " int a; \\\n"
150 " int b;",
151 26, 0, getLLVMStyleWithColumns(12)));
152 EXPECT_EQ("#define A \\\n"
153 " int a; \\\n"
Stephen Hines651f13c2014-04-23 16:59:28 -0700154 " int b;",
Daniel Jasper1eee6c42013-03-04 13:43:19 +0000155 format("#define A \\\n"
156 " int a; \\\n"
Stephen Hines651f13c2014-04-23 16:59:28 -0700157 " int b;",
Daniel Jasper1eee6c42013-03-04 13:43:19 +0000158 25, 0, getLLVMStyleWithColumns(12)));
159}
160
Daniel Jasperf3023542013-03-07 20:50:00 +0000161TEST_F(FormatTest, RemovesWhitespaceWhenTriggeredOnEmptyLine) {
162 EXPECT_EQ("int a;\n\n int b;",
163 format("int a;\n \n\n int b;", 7, 0, getLLVMStyle()));
164 EXPECT_EQ("int a;\n\n int b;",
165 format("int a;\n \n\n int b;", 9, 0, getLLVMStyle()));
166}
167
Daniel Jasper15f33f02013-06-03 16:16:41 +0000168TEST_F(FormatTest, RemovesEmptyLines) {
169 EXPECT_EQ("class C {\n"
170 " int i;\n"
171 "};",
172 format("class C {\n"
173 " int i;\n"
174 "\n"
175 "};"));
176
Stephen Hines651f13c2014-04-23 16:59:28 -0700177 // Don't remove empty lines at the start of namespaces.
178 EXPECT_EQ("namespace N {\n"
179 "\n"
180 "int i;\n"
181 "}",
182 format("namespace N {\n"
183 "\n"
184 "int i;\n"
185 "}",
186 getGoogleStyle()));
187
188 // Remove empty lines at the beginning and end of blocks.
189 EXPECT_EQ("void f() {\n"
190 "\n"
191 " if (a) {\n"
192 "\n"
193 " f();\n"
194 " }\n"
195 "}",
196 format("void f() {\n"
197 "\n"
198 " if (a) {\n"
199 "\n"
200 " f();\n"
201 "\n"
202 " }\n"
203 "\n"
204 "}",
205 getLLVMStyle()));
206 EXPECT_EQ("void f() {\n"
207 " if (a) {\n"
208 " f();\n"
209 " }\n"
210 "}",
211 format("void f() {\n"
212 "\n"
213 " if (a) {\n"
214 "\n"
215 " f();\n"
216 "\n"
217 " }\n"
218 "\n"
219 "}",
220 getGoogleStyle()));
221
Daniel Jasper15f33f02013-06-03 16:16:41 +0000222 // Don't remove empty lines in more complex control statements.
223 EXPECT_EQ("void f() {\n"
224 " if (a) {\n"
225 " f();\n"
226 "\n"
227 " } else if (b) {\n"
228 " f();\n"
229 " }\n"
230 "}",
231 format("void f() {\n"
232 " if (a) {\n"
233 " f();\n"
234 "\n"
235 " } else if (b) {\n"
236 " f();\n"
237 "\n"
238 " }\n"
239 "\n"
240 "}"));
241
242 // FIXME: This is slightly inconsistent.
243 EXPECT_EQ("namespace {\n"
244 "int i;\n"
245 "}",
246 format("namespace {\n"
247 "int i;\n"
248 "\n"
249 "}"));
250 EXPECT_EQ("namespace {\n"
251 "int i;\n"
252 "\n"
253 "} // namespace",
254 format("namespace {\n"
255 "int i;\n"
256 "\n"
257 "} // namespace"));
258}
259
Daniel Jasper29333162013-02-18 13:08:03 +0000260TEST_F(FormatTest, ReformatsMovedLines) {
261 EXPECT_EQ(
262 "template <typename T> T *getFETokenInfo() const {\n"
263 " return static_cast<T *>(FETokenInfo);\n"
264 "}\n"
265 " int a; // <- Should not be formatted",
266 format(
267 "template<typename T>\n"
268 "T *getFETokenInfo() const { return static_cast<T*>(FETokenInfo); }\n"
269 " int a; // <- Should not be formatted",
270 9, 5, getLLVMStyle()));
271}
272
Alexander Kornienko15757312012-12-06 18:03:27 +0000273//===----------------------------------------------------------------------===//
274// Tests for control statements.
275//===----------------------------------------------------------------------===//
276
Daniel Jasper84f5ddf2013-05-14 10:31:09 +0000277TEST_F(FormatTest, FormatIfWithoutCompoundStatement) {
Daniel Jasper6f5bb2c2013-01-14 16:24:39 +0000278 verifyFormat("if (true)\n f();\ng();");
279 verifyFormat("if (a)\n if (b)\n if (c)\n g();\nh();");
Alexander Kornienko15757312012-12-06 18:03:27 +0000280 verifyFormat("if (a)\n if (b) {\n f();\n }\ng();");
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000281
Daniel Jasperf11bbb92013-05-16 12:12:21 +0000282 FormatStyle AllowsMergedIf = getLLVMStyle();
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000283 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true;
284 verifyFormat("if (a)\n"
285 " // comment\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000286 " f();",
287 AllowsMergedIf);
Daniel Jasperf11bbb92013-05-16 12:12:21 +0000288 verifyFormat("if (a)\n"
289 " ;",
290 AllowsMergedIf);
291 verifyFormat("if (a)\n"
292 " if (b) return;",
293 AllowsMergedIf);
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000294
Daniel Jasperf11bbb92013-05-16 12:12:21 +0000295 verifyFormat("if (a) // Can't merge this\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000296 " f();\n",
297 AllowsMergedIf);
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000298 verifyFormat("if (a) /* still don't merge */\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000299 " f();",
300 AllowsMergedIf);
Daniel Jasperf11bbb92013-05-16 12:12:21 +0000301 verifyFormat("if (a) { // Never merge this\n"
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000302 " f();\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000303 "}",
304 AllowsMergedIf);
Stephen Hines651f13c2014-04-23 16:59:28 -0700305 verifyFormat("if (a) {/* Never merge this */\n"
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000306 " f();\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000307 "}",
308 AllowsMergedIf);
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000309
Daniel Jasper1fb8d882013-05-14 09:30:02 +0000310 EXPECT_EQ("if (a) return;", format("if(a)\nreturn;", 7, 1, AllowsMergedIf));
Daniel Jasperf11bbb92013-05-16 12:12:21 +0000311 EXPECT_EQ("if (a) return; // comment",
Daniel Jasper84f5ddf2013-05-14 10:31:09 +0000312 format("if(a)\nreturn; // comment", 20, 1, AllowsMergedIf));
Daniel Jasper1fb8d882013-05-14 09:30:02 +0000313
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000314 AllowsMergedIf.ColumnLimit = 14;
315 verifyFormat("if (a) return;", AllowsMergedIf);
Daniel Jasperfd0ca972013-01-14 16:02:06 +0000316 verifyFormat("if (aaaaaaaaa)\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000317 " return;",
318 AllowsMergedIf);
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000319
320 AllowsMergedIf.ColumnLimit = 13;
321 verifyFormat("if (a)\n return;", AllowsMergedIf);
Alexander Kornienko15757312012-12-06 18:03:27 +0000322}
323
Daniel Jasperf11bbb92013-05-16 12:12:21 +0000324TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) {
325 FormatStyle AllowsMergedLoops = getLLVMStyle();
326 AllowsMergedLoops.AllowShortLoopsOnASingleLine = true;
327 verifyFormat("while (true) continue;", AllowsMergedLoops);
328 verifyFormat("for (;;) continue;", AllowsMergedLoops);
329 verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops);
330 verifyFormat("while (true)\n"
331 " ;",
332 AllowsMergedLoops);
333 verifyFormat("for (;;)\n"
334 " ;",
335 AllowsMergedLoops);
336 verifyFormat("for (;;)\n"
337 " for (;;) continue;",
338 AllowsMergedLoops);
339 verifyFormat("for (;;) // Can't merge this\n"
340 " continue;",
341 AllowsMergedLoops);
342 verifyFormat("for (;;) /* still don't merge */\n"
343 " continue;",
344 AllowsMergedLoops);
345}
346
Alexander Kornienko15757312012-12-06 18:03:27 +0000347TEST_F(FormatTest, ParseIfElse) {
348 verifyFormat("if (true)\n"
349 " if (true)\n"
350 " if (true)\n"
351 " f();\n"
352 " else\n"
353 " g();\n"
354 " else\n"
355 " h();\n"
356 "else\n"
357 " i();");
358 verifyFormat("if (true)\n"
359 " if (true)\n"
360 " if (true) {\n"
Daniel Jasper6f5bb2c2013-01-14 16:24:39 +0000361 " if (true)\n"
362 " f();\n"
Alexander Kornienko15757312012-12-06 18:03:27 +0000363 " } else {\n"
364 " g();\n"
365 " }\n"
366 " else\n"
367 " h();\n"
368 "else {\n"
369 " i();\n"
370 "}");
Daniel Jaspere63a48a2013-09-17 08:28:05 +0000371 verifyFormat("void f() {\n"
372 " if (a) {\n"
373 " } else {\n"
374 " }\n"
375 "}");
Alexander Kornienko15757312012-12-06 18:03:27 +0000376}
377
378TEST_F(FormatTest, ElseIf) {
Manuel Klimek2f1ac412013-01-21 16:42:44 +0000379 verifyFormat("if (a) {\n} else if (b) {\n}");
Alexander Kornienko15757312012-12-06 18:03:27 +0000380 verifyFormat("if (a)\n"
381 " f();\n"
382 "else if (b)\n"
383 " g();\n"
384 "else\n"
385 " h();");
Daniel Jasperdc837b12013-10-30 14:04:10 +0000386 verifyFormat("if (a) {\n"
387 " f();\n"
388 "}\n"
389 "// or else ..\n"
390 "else {\n"
391 " g()\n"
392 "}");
Alexander Kornienko15757312012-12-06 18:03:27 +0000393}
394
Daniel Jasperbac016b2012-12-03 18:12:45 +0000395TEST_F(FormatTest, FormatsForLoop) {
396 verifyFormat(
397 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n"
Alexander Kornienko2e97cfc2012-12-05 15:06:06 +0000398 " ++VeryVeryLongLoopVariable)\n"
399 " ;");
400 verifyFormat("for (;;)\n"
401 " f();");
Manuel Klimek2f1ac412013-01-21 16:42:44 +0000402 verifyFormat("for (;;) {\n}");
Alexander Kornienko2e97cfc2012-12-05 15:06:06 +0000403 verifyFormat("for (;;) {\n"
404 " f();\n"
405 "}");
Daniel Jasper454cb702013-05-03 14:50:50 +0000406 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}");
Daniel Jaspera324a0e2012-12-21 14:37:20 +0000407
408 verifyFormat(
409 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
410 " E = UnwrappedLines.end();\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +0000411 " I != E; ++I) {\n}");
Daniel Jaspera324a0e2012-12-21 14:37:20 +0000412
413 verifyFormat(
414 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +0000415 " ++IIIII) {\n}");
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +0000416 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n"
417 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000418 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}");
Daniel Jasper7d812812013-02-21 15:00:29 +0000419 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n"
420 " I = FD->getDeclsInPrototypeScope().begin(),\n"
421 " E = FD->getDeclsInPrototypeScope().end();\n"
422 " I != E; ++I) {\n}");
Daniel Jasper75223182013-01-28 17:30:17 +0000423
424 // FIXME: Not sure whether we want extra identation in line 3 here:
425 verifyFormat(
426 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
427 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n"
Daniel Jasperf9955d32013-03-20 12:37:50 +0000428 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
429 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
Daniel Jasper75223182013-01-28 17:30:17 +0000430 " ++aaaaaaaaaaa) {\n}");
Daniel Jasperfaab0d32013-02-27 09:47:53 +0000431 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n"
432 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
433 "}");
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +0000434 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n"
435 " aaaaaaaaaa);\n"
436 " iter; ++iter) {\n"
437 "}");
Daniel Jasper8159d2f2013-02-04 07:30:30 +0000438
Daniel Jasperfaab0d32013-02-27 09:47:53 +0000439 FormatStyle NoBinPacking = getLLVMStyle();
440 NoBinPacking.BinPackParameters = false;
441 verifyFormat("for (int aaaaaaaaaaa = 1;\n"
442 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n"
443 " aaaaaaaaaaaaaaaa,\n"
444 " aaaaaaaaaaaaaaaa,\n"
445 " aaaaaaaaaaaaaaaa);\n"
446 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
447 "}",
448 NoBinPacking);
449 verifyFormat(
Daniel Jasper237d4c12013-02-23 21:01:55 +0000450 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
451 " E = UnwrappedLines.end();\n"
452 " I != E;\n"
Daniel Jasperfaab0d32013-02-27 09:47:53 +0000453 " ++I) {\n}",
454 NoBinPacking);
Daniel Jasperbac016b2012-12-03 18:12:45 +0000455}
456
Daniel Jasper3b9a8fc2013-01-28 13:21:16 +0000457TEST_F(FormatTest, RangeBasedForLoops) {
458 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
459 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
460 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n"
461 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}");
Daniel Jasper84a1a632013-02-26 13:18:08 +0000462 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n"
463 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Stephen Hines651f13c2014-04-23 16:59:28 -0700464 verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n"
465 " aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}");
466}
467
468TEST_F(FormatTest, ForEachLoops) {
469 verifyFormat("void f() {\n"
470 " foreach (Item *item, itemlist) {}\n"
471 " Q_FOREACH (Item *item, itemlist) {}\n"
472 " BOOST_FOREACH (Item *item, itemlist) {}\n"
473 " UNKNOWN_FORACH(Item * item, itemlist) {}\n"
474 "}");
Daniel Jasper3b9a8fc2013-01-28 13:21:16 +0000475}
476
Daniel Jasperbac016b2012-12-03 18:12:45 +0000477TEST_F(FormatTest, FormatsWhileLoop) {
Manuel Klimek2f1ac412013-01-21 16:42:44 +0000478 verifyFormat("while (true) {\n}");
Alexander Kornienko2e97cfc2012-12-05 15:06:06 +0000479 verifyFormat("while (true)\n"
480 " f();");
Manuel Klimek2f1ac412013-01-21 16:42:44 +0000481 verifyFormat("while () {\n}");
Alexander Kornienko2e97cfc2012-12-05 15:06:06 +0000482 verifyFormat("while () {\n"
483 " f();\n"
484 "}");
Daniel Jasperbac016b2012-12-03 18:12:45 +0000485}
486
Alexander Kornienko15757312012-12-06 18:03:27 +0000487TEST_F(FormatTest, FormatsDoWhile) {
488 verifyFormat("do {\n"
489 " do_something();\n"
490 "} while (something());");
491 verifyFormat("do\n"
492 " do_something();\n"
493 "while (something());");
Daniel Jasperbac016b2012-12-03 18:12:45 +0000494}
495
Alexander Kornienko15757312012-12-06 18:03:27 +0000496TEST_F(FormatTest, FormatsSwitchStatement) {
Daniel Jasperbac016b2012-12-03 18:12:45 +0000497 verifyFormat("switch (x) {\n"
498 "case 1:\n"
499 " f();\n"
500 " break;\n"
501 "case kFoo:\n"
502 "case ns::kBar:\n"
503 "case kBaz:\n"
504 " break;\n"
505 "default:\n"
506 " g();\n"
507 " break;\n"
508 "}");
509 verifyFormat("switch (x) {\n"
510 "case 1: {\n"
511 " f();\n"
512 " break;\n"
513 "}\n"
514 "}");
Nico Weber94fb7292013-01-18 05:50:57 +0000515 verifyFormat("switch (x) {\n"
516 "case 1: {\n"
517 " f();\n"
518 " {\n"
519 " g();\n"
520 " h();\n"
521 " }\n"
522 " break;\n"
523 "}\n"
524 "}");
525 verifyFormat("switch (x) {\n"
526 "case 1: {\n"
527 " f();\n"
528 " if (foo) {\n"
529 " g();\n"
530 " h();\n"
531 " }\n"
532 " break;\n"
533 "}\n"
534 "}");
535 verifyFormat("switch (x) {\n"
536 "case 1: {\n"
537 " f();\n"
538 " g();\n"
539 "} break;\n"
540 "}");
Daniel Jasperbac016b2012-12-03 18:12:45 +0000541 verifyFormat("switch (test)\n"
542 " ;");
Daniel Jasper4ba9bfd2013-03-12 12:26:55 +0000543 verifyFormat("switch (x) {\n"
544 "default: {\n"
545 " // Do nothing.\n"
Manuel Klimek67d080d2013-04-12 14:13:36 +0000546 "}\n"
Daniel Jasper4ba9bfd2013-03-12 12:26:55 +0000547 "}");
Daniel Jasper6050a1e2013-03-13 15:53:12 +0000548 verifyFormat("switch (x) {\n"
Daniel Jasper5999f762013-04-09 17:46:55 +0000549 "// comment\n"
Daniel Jasper6050a1e2013-03-13 15:53:12 +0000550 "// if 1, do f()\n"
551 "case 1:\n"
552 " f();\n"
553 "}");
Daniel Jasperc30eb512013-03-19 18:33:58 +0000554 verifyFormat("switch (x) {\n"
555 "case 1:\n"
556 " // Do amazing stuff\n"
557 " {\n"
558 " f();\n"
559 " g();\n"
560 " }\n"
561 " break;\n"
562 "}");
Daniel Jasperbcca7e42013-03-20 10:23:53 +0000563 verifyFormat("#define A \\\n"
564 " switch (x) { \\\n"
565 " case a: \\\n"
566 " foo = b; \\\n"
567 " }", getLLVMStyleWithColumns(20));
Daniel Jasper67cf1db2013-09-02 08:26:29 +0000568 verifyFormat("#define OPERATION_CASE(name) \\\n"
569 " case OP_name: \\\n"
570 " return operations::Operation##name\n",
571 getLLVMStyleWithColumns(40));
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000572
Alexander Kornienko15757312012-12-06 18:03:27 +0000573 verifyGoogleFormat("switch (x) {\n"
574 " case 1:\n"
575 " f();\n"
576 " break;\n"
577 " case kFoo:\n"
578 " case ns::kBar:\n"
579 " case kBaz:\n"
580 " break;\n"
581 " default:\n"
582 " g();\n"
583 " break;\n"
584 "}");
585 verifyGoogleFormat("switch (x) {\n"
586 " case 1: {\n"
587 " f();\n"
588 " break;\n"
589 " }\n"
590 "}");
591 verifyGoogleFormat("switch (test)\n"
Daniel Jaspere865cc52013-07-25 11:31:57 +0000592 " ;");
593
594 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n"
595 " case OP_name: \\\n"
596 " return operations::Operation##name\n");
597 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n"
598 " // Get the correction operation class.\n"
599 " switch (OpCode) {\n"
600 " CASE(Add);\n"
601 " CASE(Subtract);\n"
602 " default:\n"
603 " return operations::Unknown;\n"
604 " }\n"
605 "#undef OPERATION_CASE\n"
606 "}");
Daniel Jasperb77d7412013-09-06 07:54:20 +0000607 verifyFormat("DEBUG({\n"
608 " switch (x) {\n"
609 " case A:\n"
610 " f();\n"
611 " break;\n"
612 " // On B:\n"
613 " case B:\n"
614 " g();\n"
615 " break;\n"
616 " }\n"
617 "});");
Daniel Jasperbac016b2012-12-03 18:12:45 +0000618}
619
Daniel Jasperb3c887d2013-10-20 16:56:16 +0000620TEST_F(FormatTest, CaseRanges) {
621 verifyFormat("switch (x) {\n"
622 "case 'A' ... 'Z':\n"
623 "case 1 ... 5:\n"
624 " break;\n"
625 "}");
626}
627
Alexander Kornienko15757312012-12-06 18:03:27 +0000628TEST_F(FormatTest, FormatsLabels) {
Daniel Jasperbac016b2012-12-03 18:12:45 +0000629 verifyFormat("void f() {\n"
630 " some_code();\n"
631 "test_label:\n"
632 " some_other_code();\n"
633 " {\n"
634 " some_more_code();\n"
635 " another_label:\n"
636 " some_more_code();\n"
637 " }\n"
638 "}");
639 verifyFormat("some_code();\n"
640 "test_label:\n"
641 "some_other_code();");
642}
643
Alexander Kornienko15757312012-12-06 18:03:27 +0000644//===----------------------------------------------------------------------===//
645// Tests for comments.
646//===----------------------------------------------------------------------===//
647
648TEST_F(FormatTest, UnderstandsSingleLineComments) {
Daniel Jasperb64eca02013-03-22 10:01:29 +0000649 verifyFormat("//* */");
Daniel Jaspere35ec2b2012-12-18 19:56:56 +0000650 verifyFormat("// line 1\n"
651 "// line 2\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +0000652 "void f() {}\n");
Alexander Kornienko15757312012-12-06 18:03:27 +0000653
Daniel Jaspere35ec2b2012-12-18 19:56:56 +0000654 verifyFormat("void f() {\n"
655 " // Doesn't do anything\n"
656 "}");
Daniel Jaspere1f9a8e2013-07-11 13:48:16 +0000657 verifyFormat("SomeObject\n"
658 " // Calling someFunction on SomeObject\n"
659 " .someFunction();");
Stephen Hines651f13c2014-04-23 16:59:28 -0700660 verifyFormat("auto result = SomeObject\n"
661 " // Calling someFunction on SomeObject\n"
662 " .someFunction();");
Daniel Jasperdcc2a622013-01-18 08:44:07 +0000663 verifyFormat("void f(int i, // some comment (probably for i)\n"
664 " int j, // some comment (probably for j)\n"
Daniel Jasper487f64b2013-01-13 16:10:20 +0000665 " int k); // some comment (probably for k)");
666 verifyFormat("void f(int i,\n"
667 " // some comment (probably for j)\n"
668 " int j,\n"
669 " // some comment (probably for k)\n"
670 " int k);");
Alexander Kornienko15757312012-12-06 18:03:27 +0000671
Daniel Jasperdcc2a622013-01-18 08:44:07 +0000672 verifyFormat("int i // This is a fancy variable\n"
673 " = 5; // with nicely aligned comment.");
674
675 verifyFormat("// Leading comment.\n"
676 "int a; // Trailing comment.");
677 verifyFormat("int a; // Trailing comment\n"
678 " // on 2\n"
679 " // or 3 lines.\n"
680 "int b;");
681 verifyFormat("int a; // Trailing comment\n"
682 "\n"
683 "// Leading comment.\n"
684 "int b;");
685 verifyFormat("int a; // Comment.\n"
686 " // More details.\n"
687 "int bbbb; // Another comment.");
688 verifyFormat(
689 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; // comment\n"
690 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; // comment\n"
691 "int cccccccccccccccccccccccccccccc; // comment\n"
692 "int ddd; // looooooooooooooooooooooooong comment\n"
693 "int aaaaaaaaaaaaaaaaaaaaaaa; // comment\n"
694 "int bbbbbbbbbbbbbbbbbbbbb; // comment\n"
695 "int ccccccccccccccccccc; // comment");
696
Daniel Jasper7d1185d2013-01-18 09:19:33 +0000697 verifyFormat("#include \"a\" // comment\n"
698 "#include \"a/b/c\" // comment");
699 verifyFormat("#include <a> // comment\n"
700 "#include <a/b/c> // comment");
Daniel Jasper84379572013-10-30 13:54:53 +0000701 EXPECT_EQ("#include \"a\" // comment\n"
Manuel Klimekad3094b2013-05-23 10:56:37 +0000702 "#include \"a/b/c\" // comment",
703 format("#include \\\n"
704 " \"a\" // comment\n"
705 "#include \"a/b/c\" // comment"));
Alexander Kornienko15757312012-12-06 18:03:27 +0000706
Daniel Jaspere35ec2b2012-12-18 19:56:56 +0000707 verifyFormat("enum E {\n"
708 " // comment\n"
Daniel Jasper7ad4eff2013-01-07 11:09:06 +0000709 " VAL_A, // comment\n"
Daniel Jaspere35ec2b2012-12-18 19:56:56 +0000710 " VAL_B\n"
711 "};");
Daniel Jasper05b1ac82012-12-17 11:29:41 +0000712
713 verifyFormat(
714 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Daniel Jasper7ad4eff2013-01-07 11:09:06 +0000715 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; // Trailing comment");
Daniel Jasper043835a2013-01-09 09:33:39 +0000716 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
717 " // Comment inside a statement.\n"
718 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
Daniel Jasper36ba0ff2013-02-06 15:23:09 +0000719 verifyFormat(
720 "bool aaaaaaaaaaaaa = // comment\n"
721 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
722 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Manuel Klimek6cf58142013-01-07 08:54:53 +0000723
Daniel Jasper42f458d2013-02-13 19:25:54 +0000724 verifyFormat("int aaaa; // aaaaa\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000725 "int aa; // aaaaaaa",
726 getLLVMStyleWithColumns(20));
Daniel Jasper42f458d2013-02-13 19:25:54 +0000727
Daniel Jasper821627e2013-01-21 22:49:20 +0000728 EXPECT_EQ("void f() { // This does something ..\n"
729 "}\n"
730 "int a; // This is unrelated",
731 format("void f() { // This does something ..\n"
732 " }\n"
733 "int a; // This is unrelated"));
Daniel Jaspercbe86cc2013-07-01 11:22:57 +0000734 EXPECT_EQ("class C {\n"
735 " void f() { // This does something ..\n"
736 " } // awesome..\n"
Daniel Jasper821627e2013-01-21 22:49:20 +0000737 "\n"
Daniel Jaspercbe86cc2013-07-01 11:22:57 +0000738 " int a; // This is unrelated\n"
739 "};",
740 format("class C{void f() { // This does something ..\n"
Daniel Jasper821627e2013-01-21 22:49:20 +0000741 " } // awesome..\n"
742 " \n"
Daniel Jaspercbe86cc2013-07-01 11:22:57 +0000743 "int a; // This is unrelated\n"
744 "};"));
Daniel Jasper821627e2013-01-21 22:49:20 +0000745
Daniel Jasper7ad4eff2013-01-07 11:09:06 +0000746 EXPECT_EQ("int i; // single line trailing comment",
Manuel Klimek6cf58142013-01-07 08:54:53 +0000747 format("int i;\\\n// single line trailing comment"));
Daniel Jasper7ad4eff2013-01-07 11:09:06 +0000748
749 verifyGoogleFormat("int a; // Trailing comment.");
Daniel Jasperd4f2c2e2013-01-29 19:41:55 +0000750
751 verifyFormat("someFunction(anotherFunction( // Force break.\n"
752 " parameter));");
Daniel Jasper5b7e7b02013-02-05 09:34:14 +0000753
754 verifyGoogleFormat("#endif // HEADER_GUARD");
Daniel Jasper474e4622013-02-06 22:04:05 +0000755
756 verifyFormat("const char *test[] = {\n"
Stephen Hines651f13c2014-04-23 16:59:28 -0700757 " // A\n"
758 " \"aaaa\",\n"
759 " // B\n"
760 " \"aaaaa\"};");
Daniel Jasper729a7432013-02-11 12:36:37 +0000761 verifyGoogleFormat(
762 "aaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Alexander Kornienko2785b9a2013-06-07 16:02:52 +0000763 " aaaaaaaaaaaaaaaaaaaaaa); // 81_cols_with_this_comment");
Alexander Kornienko4128e192013-04-03 12:38:53 +0000764 EXPECT_EQ("D(a, {\n"
765 " // test\n"
766 " int a;\n"
767 "});",
768 format("D(a, {\n"
769 "// test\n"
770 "int a;\n"
771 "});"));
Manuel Klimekebfb88c2013-05-23 11:42:52 +0000772
773 EXPECT_EQ("lineWith(); // comment\n"
774 "// at start\n"
775 "otherLine();",
776 format("lineWith(); // comment\n"
777 "// at start\n"
778 "otherLine();"));
779 EXPECT_EQ("lineWith(); // comment\n"
780 " // at start\n"
781 "otherLine();",
782 format("lineWith(); // comment\n"
783 " // at start\n"
784 "otherLine();"));
Manuel Klimek23ad3392013-05-23 19:54:43 +0000785
786 EXPECT_EQ("lineWith(); // comment\n"
787 "// at start\n"
788 "otherLine(); // comment",
789 format("lineWith(); // comment\n"
790 "// at start\n"
791 "otherLine(); // comment"));
Manuel Klimek854ca792013-05-23 20:46:07 +0000792 EXPECT_EQ("lineWith();\n"
793 "// at start\n"
794 "otherLine(); // comment",
795 format("lineWith();\n"
796 " // at start\n"
797 "otherLine(); // comment"));
798 EXPECT_EQ("// first\n"
799 "// at start\n"
800 "otherLine(); // comment",
801 format("// first\n"
802 " // at start\n"
803 "otherLine(); // comment"));
804 EXPECT_EQ("f();\n"
805 "// first\n"
806 "// at start\n"
807 "otherLine(); // comment",
808 format("f();\n"
809 "// first\n"
810 " // at start\n"
811 "otherLine(); // comment"));
Daniel Jasper0ce1c9a2013-11-08 23:31:14 +0000812 verifyFormat("f(); // comment\n"
813 "// first\n"
814 "// at start\n"
815 "otherLine();");
816 EXPECT_EQ("f(); // comment\n"
817 "// first\n"
818 "// at start\n"
819 "otherLine();",
820 format("f(); // comment\n"
821 "// first\n"
822 " // at start\n"
823 "otherLine();"));
824 EXPECT_EQ("f(); // comment\n"
825 " // first\n"
826 "// at start\n"
827 "otherLine();",
828 format("f(); // comment\n"
829 " // first\n"
830 "// at start\n"
831 "otherLine();"));
Daniel Jasper05b1ac82012-12-17 11:29:41 +0000832}
833
Stephen Hines651f13c2014-04-23 16:59:28 -0700834TEST_F(FormatTest, KeepsParameterWithTrailingCommentsOnTheirOwnLine) {
835 EXPECT_EQ("SomeFunction(a,\n"
836 " b, // comment\n"
837 " c);",
838 format("SomeFunction(a,\n"
839 " b, // comment\n"
840 " c);"));
841 EXPECT_EQ("SomeFunction(a, b,\n"
842 " // comment\n"
843 " c);",
844 format("SomeFunction(a,\n"
845 " b,\n"
846 " // comment\n"
847 " c);"));
848 EXPECT_EQ("SomeFunction(a, b, // comment (unclear relation)\n"
849 " c);",
850 format("SomeFunction(a, b, // comment (unclear relation)\n"
851 " c);"));
852 EXPECT_EQ("SomeFunction(a, // comment\n"
853 " b,\n"
854 " c); // comment",
855 format("SomeFunction(a, // comment\n"
856 " b,\n"
857 " c); // comment"));
858}
859
Daniel Jasperc363dbb2013-03-22 16:25:51 +0000860TEST_F(FormatTest, CanFormatCommentsLocally) {
861 EXPECT_EQ("int a; // comment\n"
862 "int b; // comment",
863 format("int a; // comment\n"
864 "int b; // comment",
865 0, 0, getLLVMStyle()));
866 EXPECT_EQ("int a; // comment\n"
867 " // line 2\n"
868 "int b;",
869 format("int a; // comment\n"
870 " // line 2\n"
871 "int b;",
872 28, 0, getLLVMStyle()));
Daniel Jasperaf849762013-04-24 06:33:59 +0000873 EXPECT_EQ("int aaaaaa; // comment\n"
874 "int b;\n"
875 "int c; // unrelated comment",
876 format("int aaaaaa; // comment\n"
877 "int b;\n"
878 "int c; // unrelated comment",
879 31, 0, getLLVMStyle()));
Stephen Hines651f13c2014-04-23 16:59:28 -0700880
881 EXPECT_EQ("int a; // This\n"
882 " // is\n"
883 " // a",
884 format("int a; // This\n"
885 " // is\n"
886 " // a",
887 0, 0, getLLVMStyle()));
888 EXPECT_EQ("int a; // This\n"
889 " // is\n"
890 " // a\n"
891 "// This is b\n"
892 "int b;",
893 format("int a; // This\n"
894 " // is\n"
895 " // a\n"
896 "// This is b\n"
897 "int b;",
898 0, 0, getLLVMStyle()));
899 EXPECT_EQ("int a; // This\n"
900 " // is\n"
901 " // a\n"
902 "\n"
903 " // This is unrelated",
904 format("int a; // This\n"
905 " // is\n"
906 " // a\n"
907 "\n"
908 " // This is unrelated",
909 0, 0, getLLVMStyle()));
910 EXPECT_EQ("int a;\n"
911 "// This is\n"
912 "// not formatted. ",
913 format("int a;\n"
914 "// This is\n"
915 "// not formatted. ",
916 0, 0, getLLVMStyle()));
Daniel Jasperc363dbb2013-03-22 16:25:51 +0000917}
918
Daniel Jasper812c0452013-03-01 16:45:59 +0000919TEST_F(FormatTest, RemovesTrailingWhitespaceOfComments) {
920 EXPECT_EQ("// comment", format("// comment "));
921 EXPECT_EQ("int aaaaaaa, bbbbbbb; // comment",
922 format("int aaaaaaa, bbbbbbb; // comment ",
923 getLLVMStyleWithColumns(33)));
Alexander Kornienko51bb5d92013-09-06 17:24:54 +0000924 EXPECT_EQ("// comment\\\n", format("// comment\\\n \t \v \f "));
925 EXPECT_EQ("// comment \\\n", format("// comment \\\n \t \v \f "));
Daniel Jasper812c0452013-03-01 16:45:59 +0000926}
927
Alexander Kornienkoc36c5c22013-06-19 19:50:11 +0000928TEST_F(FormatTest, UnderstandsBlockComments) {
Nico Weber861576b2013-06-26 00:15:19 +0000929 verifyFormat("f(/*noSpaceAfterParameterNamingComment=*/true);");
Stephen Hines651f13c2014-04-23 16:59:28 -0700930 verifyFormat("void f() { g(/*aaa=*/x, /*bbb=*/!y); }");
931 EXPECT_EQ("f(aaaaaaaaaaaaaaaaaaaaaaaaa, /* Trailing comment for aa... */\n"
932 " bbbbbbbbbbbbbbbbbbbbbbbbb);",
933 format("f(aaaaaaaaaaaaaaaaaaaaaaaaa , \\\n"
934 "/* Trailing comment for aa... */\n"
935 " bbbbbbbbbbbbbbbbbbbbbbbbb);"));
Daniel Jasper2c6cc482013-01-17 12:53:34 +0000936 EXPECT_EQ(
937 "f(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
938 " /* Leading comment for bb... */ bbbbbbbbbbbbbbbbbbbbbbbbb);",
939 format("f(aaaaaaaaaaaaaaaaaaaaaaaaa , \n"
940 "/* Leading comment for bb... */ bbbbbbbbbbbbbbbbbbbbbbbbb);"));
Daniel Jasper65d2c382013-06-06 16:08:57 +0000941 EXPECT_EQ(
942 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
943 " aaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper88cc5622013-07-08 14:25:23 +0000944 " aaaaaaaaaaaaaaaaaa) { /*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*/\n"
Daniel Jasper65d2c382013-06-06 16:08:57 +0000945 "}",
946 format("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
947 " aaaaaaaaaaaaaaaaaa ,\n"
Daniel Jasper88cc5622013-07-08 14:25:23 +0000948 " aaaaaaaaaaaaaaaaaa) { /*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*/\n"
Daniel Jasper65d2c382013-06-06 16:08:57 +0000949 "}"));
Daniel Jasperd4f2c2e2013-01-29 19:41:55 +0000950
Daniel Jasperfaab0d32013-02-27 09:47:53 +0000951 FormatStyle NoBinPacking = getLLVMStyle();
952 NoBinPacking.BinPackParameters = false;
953 verifyFormat("aaaaaaaa(/* parameter 1 */ aaaaaa,\n"
954 " /* parameter 2 */ aaaaaa,\n"
955 " /* parameter 3 */ aaaaaa,\n"
956 " /* parameter 4 */ aaaaaa);",
957 NoBinPacking);
Stephen Hines651f13c2014-04-23 16:59:28 -0700958
959 // Aligning block comments in macros.
960 verifyGoogleFormat("#define A \\\n"
961 " int i; /*a*/ \\\n"
962 " int jjj; /*b*/");
Daniel Jasper2c6cc482013-01-17 12:53:34 +0000963}
964
Alexander Kornienkoc36c5c22013-06-19 19:50:11 +0000965TEST_F(FormatTest, AlignsBlockComments) {
Alexander Kornienkof7536152013-03-14 16:10:54 +0000966 EXPECT_EQ("/*\n"
967 " * Really multi-line\n"
968 " * comment.\n"
969 " */\n"
970 "void f() {}",
971 format(" /*\n"
972 " * Really multi-line\n"
973 " * comment.\n"
974 " */\n"
975 " void f() {}"));
Alexander Kornienkof7536152013-03-14 16:10:54 +0000976 EXPECT_EQ("class C {\n"
977 " /*\n"
978 " * Another multi-line\n"
979 " * comment.\n"
980 " */\n"
981 " void f() {}\n"
982 "};",
983 format("class C {\n"
984 "/*\n"
985 " * Another multi-line\n"
986 " * comment.\n"
987 " */\n"
988 "void f() {}\n"
989 "};"));
Alexander Kornienko1fdd8b32013-03-15 13:42:02 +0000990 EXPECT_EQ("/*\n"
991 " 1. This is a comment with non-trivial formatting.\n"
992 " 1.1. We have to indent/outdent all lines equally\n"
993 " 1.1.1. to keep the formatting.\n"
994 " */",
995 format(" /*\n"
996 " 1. This is a comment with non-trivial formatting.\n"
997 " 1.1. We have to indent/outdent all lines equally\n"
998 " 1.1.1. to keep the formatting.\n"
999 " */"));
1000 EXPECT_EQ("/*\n"
Daniel Jaspereff18b92013-07-31 23:16:02 +00001001 "Don't try to outdent if there's not enough indentation.\n"
Manuel Klimekde008c02013-05-27 15:23:34 +00001002 "*/",
Alexander Kornienko1fdd8b32013-03-15 13:42:02 +00001003 format(" /*\n"
Daniel Jaspereff18b92013-07-31 23:16:02 +00001004 " Don't try to outdent if there's not enough indentation.\n"
Alexander Kornienko1fdd8b32013-03-15 13:42:02 +00001005 " */"));
Manuel Klimekc5cc4bf2013-05-28 08:55:01 +00001006
1007 EXPECT_EQ("int i; /* Comment with empty...\n"
1008 " *\n"
1009 " * line. */",
1010 format("int i; /* Comment with empty...\n"
1011 " *\n"
1012 " * line. */"));
Alexander Kornienkof7536152013-03-14 16:10:54 +00001013}
1014
Alexander Kornienkoc36c5c22013-06-19 19:50:11 +00001015TEST_F(FormatTest, CorrectlyHandlesLengthOfBlockComments) {
1016 EXPECT_EQ("double *x; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
1017 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */",
1018 format("double *x; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
1019 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */"));
Alexander Kornienkod446f732013-07-01 13:42:42 +00001020 EXPECT_EQ(
1021 "void ffffffffffff(\n"
1022 " int aaaaaaaa, int bbbbbbbb,\n"
1023 " int cccccccccccc) { /*\n"
1024 " aaaaaaaaaa\n"
1025 " aaaaaaaaaaaaa\n"
1026 " bbbbbbbbbbbbbb\n"
1027 " bbbbbbbbbb\n"
1028 " */\n"
1029 "}",
1030 format("void ffffffffffff(int aaaaaaaa, int bbbbbbbb, int cccccccccccc)\n"
1031 "{ /*\n"
1032 " aaaaaaaaaa aaaaaaaaaaaaa\n"
1033 " bbbbbbbbbbbbbb bbbbbbbbbb\n"
1034 " */\n"
1035 "}",
1036 getLLVMStyleWithColumns(40)));
Alexander Kornienkoc36c5c22013-06-19 19:50:11 +00001037}
1038
Alexander Kornienkob4b4a522013-07-16 23:47:22 +00001039TEST_F(FormatTest, DontBreakNonTrailingBlockComments) {
1040 EXPECT_EQ("void\n"
1041 "ffffffffff(int aaaaa /* test */);",
1042 format("void ffffffffff(int aaaaa /* test */);",
1043 getLLVMStyleWithColumns(35)));
1044}
1045
Alexander Kornienko5262dd92013-03-27 11:52:18 +00001046TEST_F(FormatTest, SplitsLongCxxComments) {
1047 EXPECT_EQ("// A comment that\n"
1048 "// doesn't fit on\n"
1049 "// one line",
1050 format("// A comment that doesn't fit on one line",
1051 getLLVMStyleWithColumns(20)));
Alexander Kornienko919398b2013-04-17 17:34:05 +00001052 EXPECT_EQ("// a b c d\n"
1053 "// e f g\n"
1054 "// h i j k",
1055 format("// a b c d e f g h i j k",
1056 getLLVMStyleWithColumns(10)));
1057 EXPECT_EQ("// a b c d\n"
1058 "// e f g\n"
1059 "// h i j k",
1060 format("\\\n// a b c d e f g h i j k",
1061 getLLVMStyleWithColumns(10)));
Alexander Kornienko5262dd92013-03-27 11:52:18 +00001062 EXPECT_EQ("if (true) // A comment that\n"
1063 " // doesn't fit on\n"
1064 " // one line",
1065 format("if (true) // A comment that doesn't fit on one line ",
1066 getLLVMStyleWithColumns(30)));
1067 EXPECT_EQ("// Don't_touch_leading_whitespace",
1068 format("// Don't_touch_leading_whitespace",
1069 getLLVMStyleWithColumns(20)));
Alexander Kornienko2b2faa52013-06-11 16:01:49 +00001070 EXPECT_EQ("// Add leading\n"
1071 "// whitespace",
1072 format("//Add leading whitespace", getLLVMStyleWithColumns(20)));
1073 EXPECT_EQ("// whitespace", format("//whitespace", getLLVMStyle()));
1074 EXPECT_EQ("// Even if it makes the line exceed the column\n"
1075 "// limit",
1076 format("//Even if it makes the line exceed the column limit",
1077 getLLVMStyleWithColumns(51)));
1078 EXPECT_EQ("//--But not here", format("//--But not here", getLLVMStyle()));
Alexander Kornienkoa7462b82013-11-12 17:50:13 +00001079
1080 EXPECT_EQ("// aa bb cc dd",
1081 format("// aa bb cc dd ",
1082 getLLVMStyleWithColumns(15)));
1083
Alexander Kornienko9fdc00a2013-03-28 18:40:55 +00001084 EXPECT_EQ("// A comment before\n"
1085 "// a macro\n"
1086 "// definition\n"
1087 "#define a b",
1088 format("// A comment before a macro definition\n"
1089 "#define a b",
1090 getLLVMStyleWithColumns(20)));
Stephen Hines651f13c2014-04-23 16:59:28 -07001091 EXPECT_EQ("void\n"
1092 "ffffff(int aaaaaaaaa, // wwww\n"
1093 " int bbbbbbbbbb, // xxxxxxx\n"
1094 " // yyyyyyyyyy\n"
1095 " int c, int d, int e) {}",
Alexander Kornienko22d0e292013-06-17 12:59:44 +00001096 format("void ffffff(\n"
1097 " int aaaaaaaaa, // wwww\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07001098 " int bbbbbbbbbb, // xxxxxxx yyyyyyyyyy\n"
Alexander Kornienko22d0e292013-06-17 12:59:44 +00001099 " int c, int d, int e) {}",
1100 getLLVMStyleWithColumns(40)));
Alexander Kornienko8afa39b2013-06-20 13:58:37 +00001101 EXPECT_EQ("//\t aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
1102 format("//\t aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
1103 getLLVMStyleWithColumns(20)));
Alexander Kornienko5486a422013-11-12 17:30:49 +00001104 EXPECT_EQ(
1105 "#define XXX // a b c d\n"
1106 " // e f g h",
1107 format("#define XXX // a b c d e f g h", getLLVMStyleWithColumns(22)));
1108 EXPECT_EQ(
1109 "#define XXX // q w e r\n"
1110 " // t y u i",
1111 format("#define XXX //q w e r t y u i", getLLVMStyleWithColumns(22)));
Alexander Kornienko2785b9a2013-06-07 16:02:52 +00001112}
Manuel Klimekde008c02013-05-27 15:23:34 +00001113
Stephen Hines651f13c2014-04-23 16:59:28 -07001114TEST_F(FormatTest, PreservesHangingIndentInCxxComments) {
1115 EXPECT_EQ("// A comment\n"
1116 "// that doesn't\n"
1117 "// fit on one\n"
1118 "// line",
1119 format("// A comment that doesn't fit on one line",
1120 getLLVMStyleWithColumns(20)));
1121 EXPECT_EQ("/// A comment\n"
1122 "/// that doesn't\n"
1123 "/// fit on one\n"
1124 "/// line",
1125 format("/// A comment that doesn't fit on one line",
1126 getLLVMStyleWithColumns(20)));
1127}
1128
Alexander Kornienko10c26b22013-07-16 21:06:13 +00001129TEST_F(FormatTest, DontSplitLineCommentsWithEscapedNewlines) {
1130 EXPECT_EQ("// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
1131 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
1132 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
1133 format("// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
1134 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
1135 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
1136 EXPECT_EQ("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
1137 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
1138 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
1139 format("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
1140 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
1141 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
1142 getLLVMStyleWithColumns(50)));
1143 // FIXME: One day we might want to implement adjustment of leading whitespace
1144 // of the consecutive lines in this kind of comment:
1145 EXPECT_EQ("int\n"
1146 "a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
1147 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
1148 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
1149 format("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
1150 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
1151 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
1152 getLLVMStyleWithColumns(49)));
1153}
1154
Stephen Hines651f13c2014-04-23 16:59:28 -07001155TEST_F(FormatTest, DontSplitLineCommentsWithPragmas) {
1156 FormatStyle Pragmas = getLLVMStyleWithColumns(30);
1157 Pragmas.CommentPragmas = "^ IWYU pragma:";
1158 EXPECT_EQ(
1159 "// IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb",
1160 format("// IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb", Pragmas));
1161 EXPECT_EQ(
1162 "/* IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb */",
1163 format("/* IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb */", Pragmas));
1164}
1165
Alexander Kornienko2785b9a2013-06-07 16:02:52 +00001166TEST_F(FormatTest, PriorityOfCommentBreaking) {
Daniel Jasperf5461782013-08-28 10:03:58 +00001167 EXPECT_EQ("if (xxx ==\n"
1168 " yyy && // aaaaaaaaaaaa bbbbbbbbb\n"
Alexander Kornienko2785b9a2013-06-07 16:02:52 +00001169 " zzz)\n"
1170 " q();",
1171 format("if (xxx == yyy && // aaaaaaaaaaaa bbbbbbbbb\n"
1172 " zzz) q();",
1173 getLLVMStyleWithColumns(40)));
1174 EXPECT_EQ("if (xxxxxxxxxx ==\n"
1175 " yyy && // aaaaaa bbbbbbbb cccc\n"
1176 " zzz)\n"
1177 " q();",
1178 format("if (xxxxxxxxxx == yyy && // aaaaaa bbbbbbbb cccc\n"
1179 " zzz) q();",
1180 getLLVMStyleWithColumns(40)));
1181 EXPECT_EQ("if (xxxxxxxxxx &&\n"
1182 " yyy || // aaaaaa bbbbbbbb cccc\n"
1183 " zzz)\n"
1184 " q();",
1185 format("if (xxxxxxxxxx && yyy || // aaaaaa bbbbbbbb cccc\n"
1186 " zzz) q();",
1187 getLLVMStyleWithColumns(40)));
Stephen Hines651f13c2014-04-23 16:59:28 -07001188 EXPECT_EQ("fffffffff(\n"
1189 " &xxx, // aaaaaaaaaaaa bbbbbbbbbbb\n"
1190 " zzz);",
Alexander Kornienko2785b9a2013-06-07 16:02:52 +00001191 format("fffffffff(&xxx, // aaaaaaaaaaaa bbbbbbbbbbb\n"
1192 " zzz);",
1193 getLLVMStyleWithColumns(40)));
Manuel Klimekde008c02013-05-27 15:23:34 +00001194}
1195
1196TEST_F(FormatTest, MultiLineCommentsInDefines) {
Alexander Kornienkoc36c5c22013-06-19 19:50:11 +00001197 EXPECT_EQ("#define A(x) /* \\\n"
1198 " a comment \\\n"
1199 " inside */ \\\n"
Manuel Klimekde008c02013-05-27 15:23:34 +00001200 " f();",
1201 format("#define A(x) /* \\\n"
1202 " a comment \\\n"
1203 " inside */ \\\n"
1204 " f();",
1205 getLLVMStyleWithColumns(17)));
Alexander Kornienkoc36c5c22013-06-19 19:50:11 +00001206 EXPECT_EQ("#define A( \\\n"
1207 " x) /* \\\n"
1208 " a comment \\\n"
1209 " inside */ \\\n"
Manuel Klimekde008c02013-05-27 15:23:34 +00001210 " f();",
1211 format("#define A( \\\n"
1212 " x) /* \\\n"
1213 " a comment \\\n"
1214 " inside */ \\\n"
1215 " f();",
1216 getLLVMStyleWithColumns(17)));
Alexander Kornienko5262dd92013-03-27 11:52:18 +00001217}
1218
Alexander Kornienkof52d5272013-04-02 13:04:06 +00001219TEST_F(FormatTest, ParsesCommentsAdjacentToPPDirectives) {
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001220 EXPECT_EQ("namespace {}\n// Test\n#define A",
Alexander Kornienkof52d5272013-04-02 13:04:06 +00001221 format("namespace {}\n // Test\n#define A"));
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001222 EXPECT_EQ("namespace {}\n/* Test */\n#define A",
Alexander Kornienkof52d5272013-04-02 13:04:06 +00001223 format("namespace {}\n /* Test */\n#define A"));
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001224 EXPECT_EQ("namespace {}\n/* Test */ #define A",
Alexander Kornienkof52d5272013-04-02 13:04:06 +00001225 format("namespace {}\n /* Test */ #define A"));
1226}
1227
Alexander Kornienko052685c2013-03-19 17:41:36 +00001228TEST_F(FormatTest, SplitsLongLinesInComments) {
1229 EXPECT_EQ("/* This is a long\n"
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001230 " * comment that\n"
1231 " * doesn't\n"
1232 " * fit on one line.\n"
1233 " */",
Alexander Kornienko052685c2013-03-19 17:41:36 +00001234 format("/* "
1235 "This is a long "
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001236 "comment that "
1237 "doesn't "
Alexander Kornienko052685c2013-03-19 17:41:36 +00001238 "fit on one line. */",
1239 getLLVMStyleWithColumns(20)));
Alexander Kornienko919398b2013-04-17 17:34:05 +00001240 EXPECT_EQ("/* a b c d\n"
1241 " * e f g\n"
1242 " * h i j k\n"
1243 " */",
1244 format("/* a b c d e f g h i j k */",
1245 getLLVMStyleWithColumns(10)));
1246 EXPECT_EQ("/* a b c d\n"
1247 " * e f g\n"
1248 " * h i j k\n"
1249 " */",
1250 format("\\\n/* a b c d e f g h i j k */",
1251 getLLVMStyleWithColumns(10)));
Alexander Kornienko052685c2013-03-19 17:41:36 +00001252 EXPECT_EQ("/*\n"
1253 "This is a long\n"
1254 "comment that doesn't\n"
1255 "fit on one line.\n"
1256 "*/",
1257 format("/*\n"
1258 "This is a long "
1259 "comment that doesn't "
1260 "fit on one line. \n"
1261 "*/", getLLVMStyleWithColumns(20)));
1262 EXPECT_EQ("/*\n"
1263 " * This is a long\n"
1264 " * comment that\n"
1265 " * doesn't fit on\n"
1266 " * one line.\n"
1267 " */",
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001268 format("/* \n"
Alexander Kornienko052685c2013-03-19 17:41:36 +00001269 " * This is a long "
1270 " comment that "
1271 " doesn't fit on "
1272 " one line. \n"
1273 " */", getLLVMStyleWithColumns(20)));
1274 EXPECT_EQ("/*\n"
1275 " * This_is_a_comment_with_words_that_dont_fit_on_one_line\n"
1276 " * so_it_should_be_broken\n"
1277 " * wherever_a_space_occurs\n"
1278 " */",
1279 format("/*\n"
1280 " * This_is_a_comment_with_words_that_dont_fit_on_one_line "
1281 " so_it_should_be_broken "
1282 " wherever_a_space_occurs \n"
1283 " */",
1284 getLLVMStyleWithColumns(20)));
1285 EXPECT_EQ("/*\n"
Alexander Kornienko5262dd92013-03-27 11:52:18 +00001286 " * This_comment_can_not_be_broken_into_lines\n"
Alexander Kornienko052685c2013-03-19 17:41:36 +00001287 " */",
1288 format("/*\n"
Alexander Kornienko5262dd92013-03-27 11:52:18 +00001289 " * This_comment_can_not_be_broken_into_lines\n"
Alexander Kornienko052685c2013-03-19 17:41:36 +00001290 " */",
1291 getLLVMStyleWithColumns(20)));
1292 EXPECT_EQ("{\n"
1293 " /*\n"
1294 " This is another\n"
1295 " long comment that\n"
1296 " doesn't fit on one\n"
1297 " line 1234567890\n"
1298 " */\n"
1299 "}",
1300 format("{\n"
1301 "/*\n"
1302 "This is another "
1303 " long comment that "
1304 " doesn't fit on one"
1305 " line 1234567890\n"
1306 "*/\n"
1307 "}", getLLVMStyleWithColumns(20)));
1308 EXPECT_EQ("{\n"
1309 " /*\n"
1310 " * This i s\n"
1311 " * another comment\n"
1312 " * t hat doesn' t\n"
1313 " * fit on one l i\n"
1314 " * n e\n"
1315 " */\n"
1316 "}",
1317 format("{\n"
1318 "/*\n"
1319 " * This i s"
1320 " another comment"
1321 " t hat doesn' t"
1322 " fit on one l i"
1323 " n e\n"
1324 " */\n"
1325 "}", getLLVMStyleWithColumns(20)));
1326 EXPECT_EQ("/*\n"
1327 " * This is a long\n"
1328 " * comment that\n"
1329 " * doesn't fit on\n"
1330 " * one line\n"
1331 " */",
1332 format(" /*\n"
1333 " * This is a long comment that doesn't fit on one line\n"
1334 " */", getLLVMStyleWithColumns(20)));
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001335 EXPECT_EQ("{\n"
1336 " if (something) /* This is a\n"
Manuel Klimekde008c02013-05-27 15:23:34 +00001337 " long\n"
1338 " comment */\n"
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001339 " ;\n"
1340 "}",
1341 format("{\n"
1342 " if (something) /* This is a long comment */\n"
1343 " ;\n"
1344 "}",
1345 getLLVMStyleWithColumns(30)));
Alexander Kornienko2785b9a2013-06-07 16:02:52 +00001346
1347 EXPECT_EQ("/* A comment before\n"
1348 " * a macro\n"
1349 " * definition */\n"
1350 "#define a b",
1351 format("/* A comment before a macro definition */\n"
1352 "#define a b",
1353 getLLVMStyleWithColumns(20)));
1354
1355 EXPECT_EQ("/* some comment\n"
1356 " * a comment\n"
1357 "* that we break\n"
1358 " * another comment\n"
1359 "* we have to break\n"
1360 "* a left comment\n"
1361 " */",
1362 format(" /* some comment\n"
1363 " * a comment that we break\n"
1364 " * another comment we have to break\n"
1365 "* a left comment\n"
1366 " */",
1367 getLLVMStyleWithColumns(20)));
1368
1369 EXPECT_EQ("/*\n"
1370 "\n"
1371 "\n"
1372 " */\n",
1373 format(" /* \n"
1374 " \n"
1375 " \n"
1376 " */\n"));
Alexander Kornienkoa7462b82013-11-12 17:50:13 +00001377
1378 EXPECT_EQ("/* a a */",
1379 format("/* a a */", getLLVMStyleWithColumns(15)));
1380 EXPECT_EQ("/* a a bc */",
1381 format("/* a a bc */", getLLVMStyleWithColumns(15)));
1382 EXPECT_EQ("/* aaa aaa\n"
1383 " * aaaaa */",
1384 format("/* aaa aaa aaaaa */", getLLVMStyleWithColumns(15)));
1385 EXPECT_EQ("/* aaa aaa\n"
1386 " * aaaaa */",
1387 format("/* aaa aaa aaaaa */", getLLVMStyleWithColumns(15)));
Alexander Kornienko052685c2013-03-19 17:41:36 +00001388}
1389
1390TEST_F(FormatTest, SplitsLongLinesInCommentsInPreprocessor) {
1391 EXPECT_EQ("#define X \\\n"
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001392 " /* \\\n"
1393 " Test \\\n"
Alexander Kornienko052685c2013-03-19 17:41:36 +00001394 " Macro comment \\\n"
1395 " with a long \\\n"
1396 " line \\\n"
Alexander Kornienko70ce7882013-04-15 14:28:00 +00001397 " */ \\\n"
Alexander Kornienko052685c2013-03-19 17:41:36 +00001398 " A + B",
1399 format("#define X \\\n"
1400 " /*\n"
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001401 " Test\n"
Alexander Kornienko052685c2013-03-19 17:41:36 +00001402 " Macro comment with a long line\n"
1403 " */ \\\n"
1404 " A + B",
1405 getLLVMStyleWithColumns(20)));
1406 EXPECT_EQ("#define X \\\n"
1407 " /* Macro comment \\\n"
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001408 " with a long \\\n"
Alexander Kornienko70ce7882013-04-15 14:28:00 +00001409 " line */ \\\n"
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001410 " A + B",
1411 format("#define X \\\n"
1412 " /* Macro comment with a long\n"
1413 " line */ \\\n"
1414 " A + B",
1415 getLLVMStyleWithColumns(20)));
1416 EXPECT_EQ("#define X \\\n"
1417 " /* Macro comment \\\n"
1418 " * with a long \\\n"
Alexander Kornienko70ce7882013-04-15 14:28:00 +00001419 " * line */ \\\n"
Alexander Kornienko052685c2013-03-19 17:41:36 +00001420 " A + B",
1421 format("#define X \\\n"
1422 " /* Macro comment with a long line */ \\\n"
1423 " A + B",
1424 getLLVMStyleWithColumns(20)));
1425}
1426
Daniel Jasper2c6cc482013-01-17 12:53:34 +00001427TEST_F(FormatTest, CommentsInStaticInitializers) {
1428 EXPECT_EQ(
Stephen Hines651f13c2014-04-23 16:59:28 -07001429 "static SomeType type = {aaaaaaaaaaaaaaaaaaaa, /* comment */\n"
1430 " aaaaaaaaaaaaaaaaaaaa /* comment */,\n"
1431 " /* comment */ aaaaaaaaaaaaaaaaaaaa,\n"
1432 " aaaaaaaaaaaaaaaaaaaa, // comment\n"
1433 " aaaaaaaaaaaaaaaaaaaa};",
Daniel Jasper2c6cc482013-01-17 12:53:34 +00001434 format("static SomeType type = { aaaaaaaaaaaaaaaaaaaa , /* comment */\n"
1435 " aaaaaaaaaaaaaaaaaaaa /* comment */ ,\n"
1436 " /* comment */ aaaaaaaaaaaaaaaaaaaa ,\n"
1437 " aaaaaaaaaaaaaaaaaaaa , // comment\n"
1438 " aaaaaaaaaaaaaaaaaaaa };"));
Stephen Hines651f13c2014-04-23 16:59:28 -07001439 verifyFormat("static SomeType type = {aaaaaaaaaaa, // comment for aa...\n"
1440 " bbbbbbbbbbb, ccccccccccc};");
1441 verifyFormat("static SomeType type = {aaaaaaaaaaa,\n"
1442 " // comment for bb....\n"
1443 " bbbbbbbbbbb, ccccccccccc};");
Daniel Jasper2c6cc482013-01-17 12:53:34 +00001444 verifyGoogleFormat(
Daniel Jasper2424eef2013-05-23 10:15:45 +00001445 "static SomeType type = {aaaaaaaaaaa, // comment for aa...\n"
1446 " bbbbbbbbbbb, ccccccccccc};");
1447 verifyGoogleFormat("static SomeType type = {aaaaaaaaaaa,\n"
1448 " // comment for bb....\n"
1449 " bbbbbbbbbbb, ccccccccccc};");
Daniel Jasper2c6cc482013-01-17 12:53:34 +00001450
Stephen Hines651f13c2014-04-23 16:59:28 -07001451 verifyFormat("S s = {{a, b, c}, // Group #1\n"
1452 " {d, e, f}, // Group #2\n"
1453 " {g, h, i}}; // Group #3");
1454 verifyFormat("S s = {{// Group #1\n"
1455 " a, b, c},\n"
1456 " {// Group #2\n"
1457 " d, e, f},\n"
1458 " {// Group #3\n"
1459 " g, h, i}};");
Daniel Jasperc4615b72013-02-20 12:56:39 +00001460
1461 EXPECT_EQ("S s = {\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07001462 " // Some comment\n"
1463 " a,\n"
Daniel Jasperc4615b72013-02-20 12:56:39 +00001464 "\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07001465 " // Comment after empty line\n"
1466 " b}",
Daniel Jasper1ef81d52013-02-26 13:10:34 +00001467 format("S s = {\n"
1468 " // Some comment\n"
1469 " a,\n"
1470 " \n"
1471 " // Comment after empty line\n"
1472 " b\n"
1473 "}"));
Alexander Kornienkoe3f11972013-06-12 19:04:12 +00001474 EXPECT_EQ("S s = {\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07001475 " /* Some comment */\n"
1476 " a,\n"
Alexander Kornienkoe3f11972013-06-12 19:04:12 +00001477 "\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07001478 " /* Comment after empty line */\n"
1479 " b}",
Alexander Kornienkoe3f11972013-06-12 19:04:12 +00001480 format("S s = {\n"
1481 " /* Some comment */\n"
1482 " a,\n"
1483 " \n"
1484 " /* Comment after empty line */\n"
1485 " b\n"
1486 "}"));
Daniel Jasper25e81b22013-02-28 15:04:12 +00001487 verifyFormat("const uint8_t aaaaaaaaaaaaaaaaaaaaaa[0] = {\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07001488 " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n"
1489 " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n"
1490 " 0x00, 0x00, 0x00, 0x00}; // comment\n");
Alexander Kornienko15757312012-12-06 18:03:27 +00001491}
1492
Alexander Kornienko6fb46b02013-05-24 18:24:24 +00001493TEST_F(FormatTest, IgnoresIf0Contents) {
1494 EXPECT_EQ("#if 0\n"
1495 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n"
1496 "#endif\n"
1497 "void f() {}",
1498 format("#if 0\n"
1499 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n"
1500 "#endif\n"
1501 "void f( ) { }"));
1502 EXPECT_EQ("#if false\n"
1503 "void f( ) { }\n"
1504 "#endif\n"
1505 "void g() {}\n",
1506 format("#if false\n"
1507 "void f( ) { }\n"
1508 "#endif\n"
1509 "void g( ) { }\n"));
1510 EXPECT_EQ("enum E {\n"
1511 " One,\n"
1512 " Two,\n"
1513 "#if 0\n"
1514 "Three,\n"
1515 " Four,\n"
1516 "#endif\n"
1517 " Five\n"
1518 "};",
1519 format("enum E {\n"
1520 " One,Two,\n"
1521 "#if 0\n"
1522 "Three,\n"
1523 " Four,\n"
1524 "#endif\n"
1525 " Five};"));
1526 EXPECT_EQ("enum F {\n"
1527 " One,\n"
1528 "#if 1\n"
1529 " Two,\n"
1530 "#if 0\n"
1531 "Three,\n"
1532 " Four,\n"
1533 "#endif\n"
1534 " Five\n"
1535 "#endif\n"
1536 "};",
1537 format("enum F {\n"
1538 "One,\n"
1539 "#if 1\n"
1540 "Two,\n"
1541 "#if 0\n"
1542 "Three,\n"
1543 " Four,\n"
1544 "#endif\n"
1545 "Five\n"
1546 "#endif\n"
1547 "};"));
1548 EXPECT_EQ("enum G {\n"
1549 " One,\n"
1550 "#if 0\n"
1551 "Two,\n"
1552 "#else\n"
1553 " Three,\n"
1554 "#endif\n"
1555 " Four\n"
1556 "};",
1557 format("enum G {\n"
1558 "One,\n"
1559 "#if 0\n"
1560 "Two,\n"
1561 "#else\n"
1562 "Three,\n"
1563 "#endif\n"
1564 "Four\n"
1565 "};"));
1566 EXPECT_EQ("enum H {\n"
1567 " One,\n"
1568 "#if 0\n"
1569 "#ifdef Q\n"
1570 "Two,\n"
1571 "#else\n"
1572 "Three,\n"
1573 "#endif\n"
1574 "#endif\n"
1575 " Four\n"
1576 "};",
1577 format("enum H {\n"
1578 "One,\n"
1579 "#if 0\n"
1580 "#ifdef Q\n"
1581 "Two,\n"
1582 "#else\n"
1583 "Three,\n"
1584 "#endif\n"
1585 "#endif\n"
1586 "Four\n"
1587 "};"));
1588 EXPECT_EQ("enum I {\n"
1589 " One,\n"
1590 "#if /* test */ 0 || 1\n"
1591 "Two,\n"
1592 "Three,\n"
1593 "#endif\n"
1594 " Four\n"
1595 "};",
1596 format("enum I {\n"
1597 "One,\n"
1598 "#if /* test */ 0 || 1\n"
1599 "Two,\n"
1600 "Three,\n"
1601 "#endif\n"
1602 "Four\n"
1603 "};"));
1604 EXPECT_EQ("enum J {\n"
1605 " One,\n"
1606 "#if 0\n"
1607 "#if 0\n"
1608 "Two,\n"
1609 "#else\n"
1610 "Three,\n"
1611 "#endif\n"
1612 "Four,\n"
1613 "#endif\n"
1614 " Five\n"
1615 "};",
1616 format("enum J {\n"
1617 "One,\n"
1618 "#if 0\n"
1619 "#if 0\n"
1620 "Two,\n"
1621 "#else\n"
1622 "Three,\n"
1623 "#endif\n"
1624 "Four,\n"
1625 "#endif\n"
1626 "Five\n"
1627 "};"));
1628
1629}
1630
Alexander Kornienko15757312012-12-06 18:03:27 +00001631//===----------------------------------------------------------------------===//
1632// Tests for classes, namespaces, etc.
1633//===----------------------------------------------------------------------===//
1634
1635TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) {
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001636 verifyFormat("class A {};");
Alexander Kornienko15757312012-12-06 18:03:27 +00001637}
1638
1639TEST_F(FormatTest, UnderstandsAccessSpecifiers) {
1640 verifyFormat("class A {\n"
1641 "public:\n"
Daniel Jasperac3223e2013-04-10 09:49:49 +00001642 "public: // comment\n"
Alexander Kornienko15757312012-12-06 18:03:27 +00001643 "protected:\n"
1644 "private:\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +00001645 " void f() {}\n"
Alexander Kornienko15757312012-12-06 18:03:27 +00001646 "};");
1647 verifyGoogleFormat("class A {\n"
1648 " public:\n"
1649 " protected:\n"
1650 " private:\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +00001651 " void f() {}\n"
Alexander Kornienko15757312012-12-06 18:03:27 +00001652 "};");
Stephen Hines651f13c2014-04-23 16:59:28 -07001653 verifyFormat("class A {\n"
1654 "public slots:\n"
1655 " void f() {}\n"
1656 "public Q_SLOTS:\n"
1657 " void f() {}\n"
1658 "};");
Alexander Kornienko15757312012-12-06 18:03:27 +00001659}
1660
Alexander Kornienko94b748f2013-03-27 17:08:02 +00001661TEST_F(FormatTest, SeparatesLogicalBlocks) {
1662 EXPECT_EQ("class A {\n"
1663 "public:\n"
1664 " void f();\n"
1665 "\n"
1666 "private:\n"
1667 " void g() {}\n"
1668 " // test\n"
1669 "protected:\n"
1670 " int h;\n"
1671 "};",
1672 format("class A {\n"
1673 "public:\n"
1674 "void f();\n"
1675 "private:\n"
1676 "void g() {}\n"
1677 "// test\n"
1678 "protected:\n"
1679 "int h;\n"
1680 "};"));
Daniel Jasper63cfb892013-10-06 11:40:08 +00001681 EXPECT_EQ("class A {\n"
1682 "protected:\n"
1683 "public:\n"
1684 " void f();\n"
1685 "};",
1686 format("class A {\n"
1687 "protected:\n"
1688 "\n"
1689 "public:\n"
1690 "\n"
1691 " void f();\n"
1692 "};"));
Alexander Kornienko94b748f2013-03-27 17:08:02 +00001693}
1694
Daniel Jasper6b119d62013-04-05 17:22:09 +00001695TEST_F(FormatTest, FormatsClasses) {
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001696 verifyFormat("class A : public B {};");
1697 verifyFormat("class A : public ::B {};");
Daniel Jasper6cabab42013-02-14 08:42:54 +00001698
1699 verifyFormat(
1700 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001701 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
Daniel Jasperc194c952013-05-06 06:45:09 +00001702 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
1703 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001704 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
Daniel Jasper6cabab42013-02-14 08:42:54 +00001705 verifyFormat(
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001706 "class A : public B, public C, public D, public E, public F {};");
Daniel Jasper6cabab42013-02-14 08:42:54 +00001707 verifyFormat("class AAAAAAAAAAAA : public B,\n"
1708 " public C,\n"
1709 " public D,\n"
1710 " public E,\n"
1711 " public F,\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001712 " public G {};");
Daniel Jasper6b119d62013-04-05 17:22:09 +00001713
1714 verifyFormat("class\n"
Daniel Jasper567dcf92013-09-05 09:29:45 +00001715 " ReallyReallyLongClassName {\n"
1716 " int i;\n"
1717 "};",
Daniel Jasper6b119d62013-04-05 17:22:09 +00001718 getLLVMStyleWithColumns(32));
Daniel Jaspercea014b2013-10-08 16:24:07 +00001719 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n"
1720 " aaaaaaaaaaaaaaaa> {};");
1721 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n"
1722 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n"
1723 " aaaaaaaaaaaaaaaaaaaaaa> {};");
Stephen Hines651f13c2014-04-23 16:59:28 -07001724 verifyFormat("template <class R, class C>\n"
1725 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n"
1726 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};");
Daniel Jasperbac016b2012-12-03 18:12:45 +00001727}
1728
Manuel Klimekde768542013-01-07 18:10:23 +00001729TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) {
Manuel Klimek2f1ac412013-01-21 16:42:44 +00001730 verifyFormat("class A {\n} a, b;");
1731 verifyFormat("struct A {\n} a, b;");
1732 verifyFormat("union A {\n} a;");
Manuel Klimekde768542013-01-07 18:10:23 +00001733}
1734
Alexander Kornienko15757312012-12-06 18:03:27 +00001735TEST_F(FormatTest, FormatsEnum) {
Alexander Kornienkoa166e732012-12-04 14:46:19 +00001736 verifyFormat("enum {\n"
1737 " Zero,\n"
1738 " One = 1,\n"
1739 " Two = One + 1,\n"
1740 " Three = (One + Two),\n"
1741 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1742 " Five = (One, Two, Three, Four, 5)\n"
1743 "};");
Daniel Jasper57981202013-09-13 09:20:45 +00001744 verifyGoogleFormat("enum {\n"
1745 " Zero,\n"
1746 " One = 1,\n"
1747 " Two = One + 1,\n"
1748 " Three = (One + Two),\n"
1749 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1750 " Five = (One, Two, Three, Four, 5)\n"
1751 "};");
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001752 verifyFormat("enum Enum {};");
1753 verifyFormat("enum {};");
Daniel Jasper57981202013-09-13 09:20:45 +00001754 verifyFormat("enum X E {} d;");
1755 verifyFormat("enum __attribute__((...)) E {} d;");
1756 verifyFormat("enum __declspec__((...)) E {} d;");
Manuel Klimek308232c2013-01-21 19:17:52 +00001757 verifyFormat("enum X f() {\n a();\n return 42;\n}");
Daniel Jasper57981202013-09-13 09:20:45 +00001758 verifyFormat("enum {\n"
1759 " Bar = Foo<int, int>::value\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07001760 "};",
1761 getLLVMStyleWithColumns(30));
1762
1763 verifyFormat("enum ShortEnum { A, B, C };");
1764 verifyGoogleFormat("enum ShortEnum { A, B, C };");
Alexander Kornienkoa166e732012-12-04 14:46:19 +00001765}
1766
Daniel Jasper4b434cf2013-08-30 10:10:19 +00001767TEST_F(FormatTest, FormatsEnumsWithErrors) {
1768 verifyFormat("enum Type {\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07001769 " One = 0; // These semicolons should be commas.\n"
Daniel Jasper4b434cf2013-08-30 10:10:19 +00001770 " Two = 1;\n"
1771 "};");
1772 verifyFormat("namespace n {\n"
1773 "enum Type {\n"
1774 " One,\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07001775 " Two, // missing };\n"
Daniel Jasper4b434cf2013-08-30 10:10:19 +00001776 " int i;\n"
1777 "}\n"
1778 "void g() {}");
1779}
1780
Daniel Jaspercbeb1c62013-08-20 12:42:50 +00001781TEST_F(FormatTest, FormatsEnumStruct) {
1782 verifyFormat("enum struct {\n"
1783 " Zero,\n"
1784 " One = 1,\n"
1785 " Two = One + 1,\n"
1786 " Three = (One + Two),\n"
1787 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1788 " Five = (One, Two, Three, Four, 5)\n"
1789 "};");
1790 verifyFormat("enum struct Enum {};");
1791 verifyFormat("enum struct {};");
Daniel Jasper57981202013-09-13 09:20:45 +00001792 verifyFormat("enum struct X E {} d;");
1793 verifyFormat("enum struct __attribute__((...)) E {} d;");
1794 verifyFormat("enum struct __declspec__((...)) E {} d;");
Daniel Jaspercbeb1c62013-08-20 12:42:50 +00001795 verifyFormat("enum struct X f() {\n a();\n return 42;\n}");
1796}
1797
1798TEST_F(FormatTest, FormatsEnumClass) {
1799 verifyFormat("enum class {\n"
1800 " Zero,\n"
1801 " One = 1,\n"
1802 " Two = One + 1,\n"
1803 " Three = (One + Two),\n"
1804 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1805 " Five = (One, Two, Three, Four, 5)\n"
1806 "};");
1807 verifyFormat("enum class Enum {};");
1808 verifyFormat("enum class {};");
Daniel Jasper57981202013-09-13 09:20:45 +00001809 verifyFormat("enum class X E {} d;");
1810 verifyFormat("enum class __attribute__((...)) E {} d;");
1811 verifyFormat("enum class __declspec__((...)) E {} d;");
Daniel Jaspercbeb1c62013-08-20 12:42:50 +00001812 verifyFormat("enum class X f() {\n a();\n return 42;\n}");
1813}
1814
Manuel Klimeke11e45f2013-09-05 15:34:55 +00001815TEST_F(FormatTest, FormatsEnumTypes) {
1816 verifyFormat("enum X : int {\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07001817 " A, // Force multiple lines.\n"
Manuel Klimeke11e45f2013-09-05 15:34:55 +00001818 " B\n"
1819 "};");
Stephen Hines651f13c2014-04-23 16:59:28 -07001820 verifyFormat("enum X : int { A, B };");
1821 verifyFormat("enum X : std::uint32_t { A, B };");
1822}
1823
1824TEST_F(FormatTest, FormatsNSEnums) {
1825 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }");
1826 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n"
1827 " // Information about someDecentlyLongValue.\n"
1828 " someDecentlyLongValue,\n"
1829 " // Information about anotherDecentlyLongValue.\n"
1830 " anotherDecentlyLongValue,\n"
1831 " // Information about aThirdDecentlyLongValue.\n"
1832 " aThirdDecentlyLongValue\n"
1833 "};");
Manuel Klimeke11e45f2013-09-05 15:34:55 +00001834}
1835
Nico Weberefaddc02013-01-14 05:49:49 +00001836TEST_F(FormatTest, FormatsBitfields) {
1837 verifyFormat("struct Bitfields {\n"
1838 " unsigned sClass : 8;\n"
1839 " unsigned ValueKind : 2;\n"
1840 "};");
Alexander Kornienko01fe9f92013-10-10 13:36:20 +00001841 verifyFormat("struct A {\n"
1842 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n"
1843 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n"
1844 "};");
Nico Weberefaddc02013-01-14 05:49:49 +00001845}
1846
Alexander Kornienko15757312012-12-06 18:03:27 +00001847TEST_F(FormatTest, FormatsNamespaces) {
1848 verifyFormat("namespace some_namespace {\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001849 "class A {};\n"
Manuel Klimek517e8942013-01-11 17:54:10 +00001850 "void f() { f(); }\n"
Alexander Kornienko15757312012-12-06 18:03:27 +00001851 "}");
1852 verifyFormat("namespace {\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001853 "class A {};\n"
Manuel Klimek517e8942013-01-11 17:54:10 +00001854 "void f() { f(); }\n"
Alexander Kornienko15757312012-12-06 18:03:27 +00001855 "}");
Dmitri Gribenko1f94f2b2012-12-30 21:27:25 +00001856 verifyFormat("inline namespace X {\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001857 "class A {};\n"
Manuel Klimek517e8942013-01-11 17:54:10 +00001858 "void f() { f(); }\n"
Dmitri Gribenko1f94f2b2012-12-30 21:27:25 +00001859 "}");
Alexander Kornienko15757312012-12-06 18:03:27 +00001860 verifyFormat("using namespace some_namespace;\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001861 "class A {};\n"
Manuel Klimek517e8942013-01-11 17:54:10 +00001862 "void f() { f(); }");
Manuel Klimek7fc2db02013-02-06 16:08:09 +00001863
1864 // This code is more common than we thought; if we
1865 // layout this correctly the semicolon will go into
Stephen Hines651f13c2014-04-23 16:59:28 -07001866 // its own line, which is undesirable.
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001867 verifyFormat("namespace {};");
Manuel Klimek7fc2db02013-02-06 16:08:09 +00001868 verifyFormat("namespace {\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001869 "class A {};\n"
Manuel Klimek7fc2db02013-02-06 16:08:09 +00001870 "};");
Daniel Jaspercbe86cc2013-07-01 11:22:57 +00001871
1872 verifyFormat("namespace {\n"
1873 "int SomeVariable = 0; // comment\n"
1874 "} // namespace");
1875 EXPECT_EQ("#ifndef HEADER_GUARD\n"
1876 "#define HEADER_GUARD\n"
1877 "namespace my_namespace {\n"
1878 "int i;\n"
1879 "} // my_namespace\n"
1880 "#endif // HEADER_GUARD",
1881 format("#ifndef HEADER_GUARD\n"
1882 " #define HEADER_GUARD\n"
1883 " namespace my_namespace {\n"
1884 "int i;\n"
1885 "} // my_namespace\n"
1886 "#endif // HEADER_GUARD"));
Daniel Jaspereff18b92013-07-31 23:16:02 +00001887
1888 FormatStyle Style = getLLVMStyle();
1889 Style.NamespaceIndentation = FormatStyle::NI_All;
1890 EXPECT_EQ("namespace out {\n"
1891 " int i;\n"
1892 " namespace in {\n"
1893 " int i;\n"
1894 " } // namespace\n"
1895 "} // namespace",
1896 format("namespace out {\n"
1897 "int i;\n"
1898 "namespace in {\n"
1899 "int i;\n"
1900 "} // namespace\n"
1901 "} // namespace",
1902 Style));
1903
1904 Style.NamespaceIndentation = FormatStyle::NI_Inner;
1905 EXPECT_EQ("namespace out {\n"
1906 "int i;\n"
1907 "namespace in {\n"
1908 " int i;\n"
1909 "} // namespace\n"
1910 "} // namespace",
1911 format("namespace out {\n"
1912 "int i;\n"
1913 "namespace in {\n"
1914 "int i;\n"
1915 "} // namespace\n"
1916 "} // namespace",
1917 Style));
Alexander Kornienko15757312012-12-06 18:03:27 +00001918}
1919
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001920TEST_F(FormatTest, FormatsExternC) { verifyFormat("extern \"C\" {\nint a;"); }
Manuel Klimekd19dc2d2013-01-21 14:32:05 +00001921
Daniel Jasper923ebef2013-03-14 13:45:21 +00001922TEST_F(FormatTest, FormatsInlineASM) {
1923 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));");
1924 verifyFormat(
1925 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
1926 " \"cpuid\\n\\t\"\n"
1927 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
Daniel Jaspera8fda852013-05-15 07:51:51 +00001928 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n"
Daniel Jasper923ebef2013-03-14 13:45:21 +00001929 " : \"a\"(value));");
1930}
1931
Nico Webera9ccdd12013-01-07 16:36:17 +00001932TEST_F(FormatTest, FormatTryCatch) {
Manuel Klimek517e8942013-01-11 17:54:10 +00001933 // FIXME: Handle try-catch explicitly in the UnwrappedLineParser, then we'll
1934 // also not create single-line-blocks.
Nico Webera9ccdd12013-01-07 16:36:17 +00001935 verifyFormat("try {\n"
1936 " throw a * b;\n"
1937 "}\n"
1938 "catch (int a) {\n"
1939 " // Do nothing.\n"
1940 "}\n"
1941 "catch (...) {\n"
1942 " exit(42);\n"
1943 "}");
1944
1945 // Function-level try statements.
Manuel Klimek517e8942013-01-11 17:54:10 +00001946 verifyFormat("int f() try { return 4; }\n"
Nico Webera9ccdd12013-01-07 16:36:17 +00001947 "catch (...) {\n"
1948 " return 5;\n"
1949 "}");
1950 verifyFormat("class A {\n"
1951 " int a;\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +00001952 " A() try : a(0) {}\n"
Nico Webera9ccdd12013-01-07 16:36:17 +00001953 " catch (...) {\n"
1954 " throw;\n"
1955 " }\n"
1956 "};\n");
1957}
1958
1959TEST_F(FormatTest, FormatObjCTryCatch) {
Manuel Klimekd5688cf2013-01-11 19:17:44 +00001960 verifyFormat("@try {\n"
1961 " f();\n"
1962 "}\n"
1963 "@catch (NSException e) {\n"
1964 " @throw;\n"
1965 "}\n"
1966 "@finally {\n"
1967 " exit(42);\n"
1968 "}");
Nico Webera9ccdd12013-01-07 16:36:17 +00001969}
1970
Daniel Jasper05b1ac82012-12-17 11:29:41 +00001971TEST_F(FormatTest, StaticInitializers) {
Stephen Hines651f13c2014-04-23 16:59:28 -07001972 verifyFormat("static SomeClass SC = {1, 'a'};");
Daniel Jasper05b1ac82012-12-17 11:29:41 +00001973
Daniel Jasper05b1ac82012-12-17 11:29:41 +00001974 verifyFormat(
Daniel Jasper9cda8002013-01-07 13:08:40 +00001975 "static SomeClass WithALoooooooooooooooooooongName = {\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07001976 " 100000000, \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};");
Manuel Klimekc8c8a472013-01-10 15:58:26 +00001977
Daniel Jasper399914b2013-05-17 09:35:01 +00001978 // Here, everything other than the "}" would fit on a line.
1979 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07001980 " 10000000000000000000000000};");
1981 EXPECT_EQ("S s = {a, b};", format("S s = {\n"
1982 " a,\n"
1983 "\n"
1984 " b\n"
1985 "};"));
Daniel Jasper399914b2013-05-17 09:35:01 +00001986
1987 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first
1988 // line. However, the formatting looks a bit off and this probably doesn't
1989 // happen often in practice.
1990 verifyFormat("static int Variable[1] = {\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07001991 " {1000000000000000000000000000000000000}};",
Daniel Jasper399914b2013-05-17 09:35:01 +00001992 getLLVMStyleWithColumns(40));
Daniel Jasper05b1ac82012-12-17 11:29:41 +00001993}
1994
Daniel Jasper5ad390d2013-05-28 11:30:49 +00001995TEST_F(FormatTest, DesignatedInitializers) {
Stephen Hines651f13c2014-04-23 16:59:28 -07001996 verifyFormat("const struct A a = {.a = 1, .b = 2};");
1997 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n"
1998 " .bbbbbbbbbb = 2,\n"
1999 " .cccccccccc = 3,\n"
2000 " .dddddddddd = 4,\n"
2001 " .eeeeeeeeee = 5};");
Daniel Jasper5ad390d2013-05-28 11:30:49 +00002002 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07002003 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n"
2004 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n"
2005 " .ccccccccccccccccccccccccccc = 3,\n"
2006 " .ddddddddddddddddddddddddddd = 4,\n"
2007 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};");
Daniel Jasper5ad390d2013-05-28 11:30:49 +00002008
2009 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};");
2010}
2011
Manuel Klimek2c7739e2013-01-14 16:41:43 +00002012TEST_F(FormatTest, NestedStaticInitializers) {
Stephen Hines651f13c2014-04-23 16:59:28 -07002013 verifyFormat("static A x = {{{}}};\n");
2014 verifyFormat("static A x = {{{init1, init2, init3, init4},\n"
2015 " {init1, init2, init3, init4}}};",
2016 getLLVMStyleWithColumns(50));
Daniel Jasper0df6acd2013-01-16 14:59:02 +00002017
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002018 verifyFormat("somes Status::global_reps[3] = {\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07002019 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2020 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2021 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};",
2022 getLLVMStyleWithColumns(60));
Daniel Jasper2424eef2013-05-23 10:15:45 +00002023 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n"
Daniel Jasperb5dc3f42013-07-16 18:22:10 +00002024 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2025 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2026 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};");
Manuel Klimek2c7739e2013-01-14 16:41:43 +00002027 verifyFormat(
Stephen Hines651f13c2014-04-23 16:59:28 -07002028 "CGRect cg_rect = {{rect.fLeft, rect.fTop},\n"
2029 " {rect.fRight - rect.fLeft, rect.fBottom - rect.fTop}};");
Manuel Klimek2c7739e2013-01-14 16:41:43 +00002030
Daniel Jasperf343cab2013-01-31 14:59:26 +00002031 verifyFormat(
Daniel Jasperb5dc3f42013-07-16 18:22:10 +00002032 "SomeArrayOfSomeType a = {\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07002033 " {{1, 2, 3},\n"
2034 " {1, 2, 3},\n"
2035 " {111111111111111111111111111111, 222222222222222222222222222222,\n"
2036 " 333333333333333333333333333333},\n"
2037 " {1, 2, 3},\n"
2038 " {1, 2, 3}}};");
2039 verifyFormat(
2040 "SomeArrayOfSomeType a = {\n"
2041 " {{1, 2, 3}},\n"
2042 " {{1, 2, 3}},\n"
Daniel Jasperb5dc3f42013-07-16 18:22:10 +00002043 " {{111111111111111111111111111111, 222222222222222222222222222222,\n"
2044 " 333333333333333333333333333333}},\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07002045 " {{1, 2, 3}},\n"
2046 " {{1, 2, 3}}};");
Daniel Jasperf343cab2013-01-31 14:59:26 +00002047
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002048 verifyFormat(
2049 "struct {\n"
2050 " unsigned bit;\n"
2051 " const char *const name;\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07002052 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n"
2053 " {kOsWin, \"Windows\"},\n"
2054 " {kOsLinux, \"Linux\"},\n"
2055 " {kOsCrOS, \"Chrome OS\"}};");
Manuel Klimek2c7739e2013-01-14 16:41:43 +00002056}
2057
Manuel Klimeka080a182013-01-02 16:30:12 +00002058TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) {
2059 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("
2060 " \\\n"
2061 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)");
2062}
2063
Daniel Jasper71607512013-01-07 10:48:50 +00002064TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) {
Alexander Kornienkob18c2582013-10-11 21:43:05 +00002065 verifyFormat("virtual void write(ELFWriter *writerrr,\n"
2066 " OwningPtr<FileOutputBuffer> &buffer) = 0;");
2067}
2068
2069TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) {
2070 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3",
2071 getLLVMStyleWithColumns(40));
2072 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
2073 getLLVMStyleWithColumns(40));
2074 EXPECT_EQ("#define Q \\\n"
2075 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n"
2076 " \"aaaaaaaa.cpp\"",
2077 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
2078 getLLVMStyleWithColumns(40)));
2079}
2080
2081TEST_F(FormatTest, UnderstandsLinePPDirective) {
2082 EXPECT_EQ("# 123 \"A string literal\"",
2083 format(" # 123 \"A string literal\""));
Daniel Jasper71607512013-01-07 10:48:50 +00002084}
2085
Manuel Klimekbd04f2a2013-01-31 15:58:48 +00002086TEST_F(FormatTest, LayoutUnknownPPDirective) {
Manuel Klimekbd04f2a2013-01-31 15:58:48 +00002087 EXPECT_EQ("#;", format("#;"));
Manuel Klimekdd5b1012013-01-07 10:03:37 +00002088 verifyFormat("#\n;\n;\n;");
Manuel Klimeka080a182013-01-02 16:30:12 +00002089}
2090
2091TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) {
2092 EXPECT_EQ("#line 42 \"test\"\n",
2093 format("# \\\n line \\\n 42 \\\n \"test\"\n"));
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002094 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n",
2095 getLLVMStyleWithColumns(12)));
Manuel Klimeka080a182013-01-02 16:30:12 +00002096}
2097
2098TEST_F(FormatTest, EndOfFileEndsPPDirective) {
2099 EXPECT_EQ("#line 42 \"test\"",
2100 format("# \\\n line \\\n 42 \\\n \"test\""));
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002101 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B"));
Manuel Klimeka080a182013-01-02 16:30:12 +00002102}
2103
Daniel Jasper1d82b1a2013-10-11 19:45:02 +00002104TEST_F(FormatTest, DoesntRemoveUnknownTokens) {
2105 verifyFormat("#define A \\x20");
2106 verifyFormat("#define A \\ x20");
2107 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20"));
2108 verifyFormat("#define A ''");
2109 verifyFormat("#define A ''qqq");
2110 verifyFormat("#define A `qqq");
2111 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");
Stephen Hines651f13c2014-04-23 16:59:28 -07002112 EXPECT_EQ("const char *c = STRINGIFY(\n"
2113 "\\na : b);",
2114 format("const char * c = STRINGIFY(\n"
2115 "\\na : b);"));
Daniel Jasper1d82b1a2013-10-11 19:45:02 +00002116}
2117
Manuel Klimek060143e2013-01-02 18:33:23 +00002118TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {
Daniel Jaspera4d46212013-02-28 11:05:57 +00002119 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
2120 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12));
Manuel Klimek060143e2013-01-02 18:33:23 +00002121 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12));
Daniel Jaspera4d46212013-02-28 11:05:57 +00002122 // FIXME: We never break before the macro name.
Daniel Jasperc9346c92013-08-28 09:07:32 +00002123 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12));
Daniel Jaspere0b15ea2013-01-14 15:40:57 +00002124
2125 verifyFormat("#define A A\n#define A A");
2126 verifyFormat("#define A(X) A\n#define A A");
2127
Daniel Jaspera4d46212013-02-28 11:05:57 +00002128 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
2129 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22));
Manuel Klimek060143e2013-01-02 18:33:23 +00002130}
2131
2132TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {
Alexander Kornienko9fdc00a2013-03-28 18:40:55 +00002133 EXPECT_EQ("// somecomment\n"
Manuel Klimekd4397b92013-01-04 23:34:14 +00002134 "#include \"a.h\"\n"
Daniel Jaspera4d46212013-02-28 11:05:57 +00002135 "#define A( \\\n"
2136 " A, B)\n"
Manuel Klimekd4397b92013-01-04 23:34:14 +00002137 "#include \"b.h\"\n"
Alexander Kornienko5262dd92013-03-27 11:52:18 +00002138 "// somecomment\n",
Alexander Kornienko9fdc00a2013-03-28 18:40:55 +00002139 format(" // somecomment\n"
Manuel Klimekd4397b92013-01-04 23:34:14 +00002140 " #include \"a.h\"\n"
2141 "#define A(A,\\\n"
2142 " B)\n"
2143 " #include \"b.h\"\n"
Alexander Kornienko5262dd92013-03-27 11:52:18 +00002144 " // somecomment\n",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002145 getLLVMStyleWithColumns(13)));
Manuel Klimek060143e2013-01-02 18:33:23 +00002146}
2147
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002148TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
Manuel Klimekd4397b92013-01-04 23:34:14 +00002149
2150TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
2151 EXPECT_EQ("#define A \\\n"
2152 " c; \\\n"
2153 " e;\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002154 "f;",
2155 format("#define A c; e;\n"
2156 "f;",
2157 getLLVMStyleWithColumns(14)));
Manuel Klimekd4397b92013-01-04 23:34:14 +00002158}
2159
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002160TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
Manuel Klimekd4397b92013-01-04 23:34:14 +00002161
Daniel Jasper89b3a7f2013-05-10 13:00:49 +00002162TEST_F(FormatTest, AlwaysFormatsEntireMacroDefinitions) {
2163 EXPECT_EQ("int i;\n"
2164 "#define A \\\n"
2165 " int i; \\\n"
2166 " int j\n"
2167 "int k;",
2168 format("int i;\n"
2169 "#define A \\\n"
2170 " int i ; \\\n"
2171 " int j\n"
2172 "int k;",
2173 8, 0, getGoogleStyle())); // 8: position of "#define".
2174 EXPECT_EQ("int i;\n"
2175 "#define A \\\n"
2176 " int i; \\\n"
2177 " int j\n"
2178 "int k;",
2179 format("int i;\n"
2180 "#define A \\\n"
2181 " int i ; \\\n"
2182 " int j\n"
2183 "int k;",
2184 45, 0, getGoogleStyle())); // 45: position of "j".
Manuel Klimekd4397b92013-01-04 23:34:14 +00002185}
2186
2187TEST_F(FormatTest, MacroDefinitionInsideStatement) {
Manuel Klimek526ed112013-01-09 15:25:02 +00002188 EXPECT_EQ("int x,\n"
2189 "#define A\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002190 " y;",
2191 format("int x,\n#define A\ny;"));
Manuel Klimekd4397b92013-01-04 23:34:14 +00002192}
2193
Manuel Klimek6f8424b2013-01-05 21:34:55 +00002194TEST_F(FormatTest, HashInMacroDefinition) {
Alexander Kornienkodaa07e92013-09-10 13:41:43 +00002195 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle()));
Manuel Klimek6f8424b2013-01-05 21:34:55 +00002196 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11));
Daniel Jasperc9346c92013-08-28 09:07:32 +00002197 verifyFormat("#define A \\\n"
2198 " { \\\n"
2199 " f(#c); \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002200 " }",
2201 getLLVMStyleWithColumns(11));
Daniel Jasper765561f2013-01-08 16:17:54 +00002202
2203 verifyFormat("#define A(X) \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002204 " void function##X()",
2205 getLLVMStyleWithColumns(22));
Daniel Jasper765561f2013-01-08 16:17:54 +00002206
2207 verifyFormat("#define A(a, b, c) \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002208 " void a##b##c()",
2209 getLLVMStyleWithColumns(22));
Daniel Jasper765561f2013-01-08 16:17:54 +00002210
Daniel Jaspere0b15ea2013-01-14 15:40:57 +00002211 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
Manuel Klimek6f8424b2013-01-05 21:34:55 +00002212}
2213
Manuel Klimek7ccbc212013-01-23 14:37:36 +00002214TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) {
Stephen Hines651f13c2014-04-23 16:59:28 -07002215 EXPECT_EQ("#define A (x)", format("#define A (x)"));
2216 EXPECT_EQ("#define A(x)", format("#define A(x)"));
Manuel Klimek7ccbc212013-01-23 14:37:36 +00002217}
2218
Manuel Klimeka28fc062013-02-11 12:33:24 +00002219TEST_F(FormatTest, EmptyLinesInMacroDefinitions) {
2220 EXPECT_EQ("#define A b;", format("#define A \\\n"
2221 " \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002222 " b;",
2223 getLLVMStyleWithColumns(25)));
Manuel Klimeka28fc062013-02-11 12:33:24 +00002224 EXPECT_EQ("#define A \\\n"
2225 " \\\n"
2226 " a; \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002227 " b;",
2228 format("#define A \\\n"
2229 " \\\n"
2230 " a; \\\n"
2231 " b;",
2232 getLLVMStyleWithColumns(11)));
Manuel Klimeka28fc062013-02-11 12:33:24 +00002233 EXPECT_EQ("#define A \\\n"
2234 " a; \\\n"
2235 " \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002236 " b;",
2237 format("#define A \\\n"
2238 " a; \\\n"
2239 " \\\n"
2240 " b;",
2241 getLLVMStyleWithColumns(11)));
Manuel Klimeka28fc062013-02-11 12:33:24 +00002242}
2243
Daniel Jasper34511fb2013-02-19 17:14:38 +00002244TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
Daniel Jaspercf6d76a2013-03-18 12:50:26 +00002245 verifyFormat("#define A :");
Daniel Jasper34511fb2013-02-19 17:14:38 +00002246 verifyFormat("#define SOMECASES \\\n"
Daniel Jasperbcca7e42013-03-20 10:23:53 +00002247 " case 1: \\\n"
Daniel Jasper34511fb2013-02-19 17:14:38 +00002248 " case 2\n",
2249 getLLVMStyleWithColumns(20));
Daniel Jasper34511fb2013-02-19 17:14:38 +00002250 verifyFormat("#define A template <typename T>");
Daniel Jasper03628b82013-02-19 20:05:41 +00002251 verifyFormat("#define STR(x) #x\n"
2252 "f(STR(this_is_a_string_literal{));");
Daniel Jasper7143a212013-08-28 09:17:37 +00002253 verifyFormat("#pragma omp threadprivate( \\\n"
2254 " y)), // expected-warning",
2255 getLLVMStyleWithColumns(28));
Daniel Jasper34511fb2013-02-19 17:14:38 +00002256}
2257
Daniel Jasper7e70f4c2013-05-29 13:16:10 +00002258TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) {
2259 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
2260 EXPECT_EQ("class A : public QObject {\n"
2261 " Q_OBJECT\n"
2262 "\n"
2263 " A() {}\n"
2264 "};",
2265 format("class A : public QObject {\n"
2266 " Q_OBJECT\n"
2267 "\n"
2268 " A() {\n}\n"
2269 "} ;"));
Daniel Jasperc76d59d2013-05-29 14:09:17 +00002270 EXPECT_EQ("SOME_MACRO\n"
2271 "namespace {\n"
2272 "void f();\n"
2273 "}",
2274 format("SOME_MACRO\n"
2275 " namespace {\n"
2276 "void f( );\n"
2277 "}"));
Daniel Jasper7e70f4c2013-05-29 13:16:10 +00002278 // Only if the identifier contains at least 5 characters.
2279 EXPECT_EQ("HTTP f();",
2280 format("HTTP\nf();"));
2281 EXPECT_EQ("MACRO\nf();",
2282 format("MACRO\nf();"));
2283 // Only if everything is upper case.
2284 EXPECT_EQ("class A : public QObject {\n"
2285 " Q_Object A() {}\n"
2286 "};",
2287 format("class A : public QObject {\n"
2288 " Q_Object\n"
2289 "\n"
2290 " A() {\n}\n"
2291 "} ;"));
2292}
2293
Alexander Kornienko3d713a72013-04-08 22:16:06 +00002294TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) {
2295 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
2296 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
2297 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00002298 "class X {};\n"
Alexander Kornienko3d713a72013-04-08 22:16:06 +00002299 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
2300 "int *createScopDetectionPass() { return 0; }",
2301 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
2302 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
2303 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
2304 " class X {};\n"
2305 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
2306 " int *createScopDetectionPass() { return 0; }"));
Alexander Kornienko99b0e142013-04-09 16:15:19 +00002307 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as
2308 // braces, so that inner block is indented one level more.
2309 EXPECT_EQ("int q() {\n"
2310 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
2311 " IPC_MESSAGE_HANDLER(xxx, qqq)\n"
2312 " IPC_END_MESSAGE_MAP()\n"
2313 "}",
2314 format("int q() {\n"
2315 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
2316 " IPC_MESSAGE_HANDLER(xxx, qqq)\n"
2317 " IPC_END_MESSAGE_MAP()\n"
2318 "}"));
Daniel Jasper42ff2632013-09-17 09:26:07 +00002319
Stephen Hines651f13c2014-04-23 16:59:28 -07002320 // Same inside macros.
2321 EXPECT_EQ("#define LIST(L) \\\n"
2322 " L(A) \\\n"
2323 " L(B) \\\n"
2324 " L(C)",
2325 format("#define LIST(L) \\\n"
2326 " L(A) \\\n"
2327 " L(B) \\\n"
2328 " L(C)",
2329 getGoogleStyle()));
2330
Daniel Jasper42ff2632013-09-17 09:26:07 +00002331 // These must not be recognized as macros.
Alexander Kornienko99b0e142013-04-09 16:15:19 +00002332 EXPECT_EQ("int q() {\n"
2333 " f(x);\n"
2334 " f(x) {}\n"
2335 " f(x)->g();\n"
2336 " f(x)->*g();\n"
2337 " f(x).g();\n"
2338 " f(x) = x;\n"
2339 " f(x) += x;\n"
2340 " f(x) -= x;\n"
2341 " f(x) *= x;\n"
2342 " f(x) /= x;\n"
2343 " f(x) %= x;\n"
2344 " f(x) &= x;\n"
2345 " f(x) |= x;\n"
2346 " f(x) ^= x;\n"
2347 " f(x) >>= x;\n"
2348 " f(x) <<= x;\n"
2349 " f(x)[y].z();\n"
2350 " LOG(INFO) << x;\n"
2351 " ifstream(x) >> x;\n"
2352 "}\n",
2353 format("int q() {\n"
2354 " f(x)\n;\n"
2355 " f(x)\n {}\n"
2356 " f(x)\n->g();\n"
2357 " f(x)\n->*g();\n"
2358 " f(x)\n.g();\n"
2359 " f(x)\n = x;\n"
2360 " f(x)\n += x;\n"
2361 " f(x)\n -= x;\n"
2362 " f(x)\n *= x;\n"
2363 " f(x)\n /= x;\n"
2364 " f(x)\n %= x;\n"
2365 " f(x)\n &= x;\n"
2366 " f(x)\n |= x;\n"
2367 " f(x)\n ^= x;\n"
2368 " f(x)\n >>= x;\n"
2369 " f(x)\n <<= x;\n"
2370 " f(x)\n[y].z();\n"
2371 " LOG(INFO)\n << x;\n"
2372 " ifstream(x)\n >> x;\n"
2373 "}\n"));
2374 EXPECT_EQ("int q() {\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07002375 " F(x)\n"
Alexander Kornienko99b0e142013-04-09 16:15:19 +00002376 " if (1) {\n"
2377 " }\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07002378 " F(x)\n"
Alexander Kornienko99b0e142013-04-09 16:15:19 +00002379 " while (1) {\n"
2380 " }\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07002381 " F(x)\n"
2382 " G(x);\n"
2383 " F(x)\n"
Alexander Kornienko99b0e142013-04-09 16:15:19 +00002384 " try {\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07002385 " Q();\n"
Alexander Kornienko99b0e142013-04-09 16:15:19 +00002386 " }\n"
2387 " catch (...) {\n"
2388 " }\n"
2389 "}\n",
2390 format("int q() {\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07002391 "F(x)\n"
Alexander Kornienko99b0e142013-04-09 16:15:19 +00002392 "if (1) {}\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07002393 "F(x)\n"
Alexander Kornienko99b0e142013-04-09 16:15:19 +00002394 "while (1) {}\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07002395 "F(x)\n"
2396 "G(x);\n"
2397 "F(x)\n"
2398 "try { Q(); } catch (...) {}\n"
Alexander Kornienko99b0e142013-04-09 16:15:19 +00002399 "}\n"));
2400 EXPECT_EQ("class A {\n"
2401 " A() : t(0) {}\n"
2402 " A(X x)\n" // FIXME: function-level try blocks are broken.
2403 " try : t(0) {\n"
2404 " }\n"
2405 " catch (...) {\n"
2406 " }\n"
2407 "};",
2408 format("class A {\n"
2409 " A()\n : t(0) {}\n"
2410 " A(X x)\n"
2411 " try : t(0) {} catch (...) {}\n"
2412 "};"));
Stephen Hines651f13c2014-04-23 16:59:28 -07002413 EXPECT_EQ(
2414 "class SomeClass {\n"
2415 "public:\n"
2416 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
2417 "};",
2418 format("class SomeClass {\n"
2419 "public:\n"
2420 " SomeClass()\n"
2421 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
2422 "};"));
2423 EXPECT_EQ(
2424 "class SomeClass {\n"
2425 "public:\n"
2426 " SomeClass()\n"
2427 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
2428 "};",
2429 format("class SomeClass {\n"
2430 "public:\n"
2431 " SomeClass()\n"
2432 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
2433 "};", getLLVMStyleWithColumns(40)));
Alexander Kornienko3d713a72013-04-08 22:16:06 +00002434}
2435
Manuel Klimeke573c3f2013-05-22 12:51:29 +00002436TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) {
2437 verifyFormat("#define A \\\n"
2438 " f({ \\\n"
2439 " g(); \\\n"
2440 " });", getLLVMStyleWithColumns(11));
2441}
2442
Manuel Klimekc37b4d62013-01-05 22:14:16 +00002443TEST_F(FormatTest, IndentPreprocessorDirectivesAtZero) {
2444 EXPECT_EQ("{\n {\n#define A\n }\n}", format("{{\n#define A\n}}"));
2445}
2446
Manuel Klimekf6fd00b2013-01-05 22:56:06 +00002447TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) {
Manuel Klimek517e8942013-01-11 17:54:10 +00002448 verifyFormat("{\n { a #c; }\n}");
Manuel Klimekf6fd00b2013-01-05 22:56:06 +00002449}
2450
Manuel Klimeka5342db2013-01-06 20:07:31 +00002451TEST_F(FormatTest, FormatUnbalancedStructuralElements) {
2452 EXPECT_EQ("#define A \\\n { \\\n {\nint i;",
2453 format("#define A { {\nint i;", getLLVMStyleWithColumns(11)));
2454 EXPECT_EQ("#define A \\\n } \\\n }\nint i;",
2455 format("#define A } }\nint i;", getLLVMStyleWithColumns(11)));
2456}
Manuel Klimekd4397b92013-01-04 23:34:14 +00002457
Alexander Kornienko54e6c9d2013-06-07 17:45:07 +00002458TEST_F(FormatTest, EscapedNewlineAtStartOfToken) {
Daniel Jaspercd162382013-01-07 13:26:07 +00002459 EXPECT_EQ(
2460 "#define A \\\n int i; \\\n int j;",
2461 format("#define A \\\nint i;\\\n int j;", getLLVMStyleWithColumns(11)));
Alexander Kornienko54e6c9d2013-06-07 17:45:07 +00002462 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
Manuel Klimek95419382013-01-07 07:56:50 +00002463}
2464
Alexander Kornienko16a0ec62013-06-14 11:46:10 +00002465TEST_F(FormatTest, NoEscapedNewlineHandlingInBlockComments) {
2466 EXPECT_EQ("/* \\ \\ \\\n*/", format("\\\n/* \\ \\ \\\n*/"));
2467}
2468
Manuel Klimekd544c572013-01-07 09:24:17 +00002469TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) {
2470 verifyFormat("#define A \\\n"
2471 " int v( \\\n"
2472 " a); \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002473 " int i;",
2474 getLLVMStyleWithColumns(11));
Manuel Klimekd544c572013-01-07 09:24:17 +00002475}
2476
Manuel Klimeka080a182013-01-02 16:30:12 +00002477TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) {
Manuel Klimekd4397b92013-01-04 23:34:14 +00002478 EXPECT_EQ(
2479 "#define ALooooooooooooooooooooooooooooooooooooooongMacro("
2480 " \\\n"
2481 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
2482 "\n"
2483 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
2484 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n",
2485 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro("
2486 "\\\n"
2487 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
2488 " \n"
2489 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
2490 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n"));
Manuel Klimeka080a182013-01-02 16:30:12 +00002491}
2492
Manuel Klimek526ed112013-01-09 15:25:02 +00002493TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {
2494 EXPECT_EQ("int\n"
2495 "#define A\n"
Daniel Jasper53e72cd2013-05-06 08:27:33 +00002496 " a;",
Manuel Klimeka9a7f102013-06-21 17:25:42 +00002497 format("int\n#define A\na;", getGoogleStyle()));
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002498 verifyFormat("functionCallTo(\n"
2499 " someOtherFunction(\n"
2500 " withSomeParameters, whichInSequence,\n"
2501 " areLongerThanALine(andAnotherCall,\n"
2502 "#define A B\n"
2503 " withMoreParamters,\n"
2504 " whichStronglyInfluenceTheLayout),\n"
Daniel Jasper7d812812013-02-21 15:00:29 +00002505 " andMoreParameters),\n"
2506 " trailing);",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002507 getLLVMStyleWithColumns(69));
Daniel Jasperebaa1712013-09-17 09:52:48 +00002508 verifyFormat("Foo::Foo()\n"
2509 "#ifdef BAR\n"
2510 " : baz(0)\n"
2511 "#endif\n"
2512 "{\n"
2513 "}");
Manuel Klimekae76f7f2013-10-11 21:25:45 +00002514 verifyFormat("void f() {\n"
2515 " if (true)\n"
2516 "#ifdef A\n"
2517 " f(42);\n"
2518 " x();\n"
2519 "#else\n"
2520 " g();\n"
2521 " x();\n"
2522 "#endif\n"
2523 "}");
2524 verifyFormat("void f(param1, param2,\n"
2525 " param3,\n"
2526 "#ifdef A\n"
2527 " param4(param5,\n"
2528 "#ifdef A1\n"
2529 " param6,\n"
2530 "#ifdef A2\n"
2531 " param7),\n"
2532 "#else\n"
2533 " param8),\n"
2534 " param9,\n"
2535 "#endif\n"
2536 " param10,\n"
2537 "#endif\n"
2538 " param11)\n"
2539 "#else\n"
2540 " param12)\n"
2541 "#endif\n"
2542 "{\n"
2543 " x();\n"
2544 "}",
2545 getLLVMStyleWithColumns(28));
Daniel Jasperac4d0182013-10-12 13:32:56 +00002546 verifyFormat("#if 1\n"
2547 "int i;");
Manuel Klimek45206ca2013-10-22 08:27:19 +00002548 verifyFormat(
2549 "#if 1\n"
2550 "#endif\n"
2551 "#if 1\n"
2552 "#else\n"
2553 "#endif\n");
Daniel Jasper852bce42013-10-24 15:23:11 +00002554 verifyFormat("DEBUG({\n"
2555 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2556 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
2557 "});\n"
2558 "#if a\n"
2559 "#else\n"
2560 "#endif");
Manuel Klimek526ed112013-01-09 15:25:02 +00002561}
2562
Stephen Hines651f13c2014-04-23 16:59:28 -07002563TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) {
2564 verifyFormat("#endif\n"
2565 "#if B");
2566}
2567
Manuel Klimekd186f0b2013-10-21 08:11:15 +00002568TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) {
2569 FormatStyle SingleLine = getLLVMStyle();
2570 SingleLine.AllowShortIfStatementsOnASingleLine = true;
2571 verifyFormat(
2572 "#if 0\n"
2573 "#elif 1\n"
2574 "#endif\n"
2575 "void foo() {\n"
2576 " if (test) foo2();\n"
2577 "}",
2578 SingleLine);
2579}
2580
Manuel Klimekbb42bf12013-01-10 11:52:21 +00002581TEST_F(FormatTest, LayoutBlockInsideParens) {
Daniel Jasper567dcf92013-09-05 09:29:45 +00002582 EXPECT_EQ("functionCall({ int i; });", format(" functionCall ( {int i;} );"));
Manuel Klimekbb42bf12013-01-10 11:52:21 +00002583 EXPECT_EQ("functionCall({\n"
2584 " int i;\n"
Daniel Jasper567dcf92013-09-05 09:29:45 +00002585 " int j;\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002586 "});",
Daniel Jasper567dcf92013-09-05 09:29:45 +00002587 format(" functionCall ( {int i;int j;} );"));
Daniel Jasperf7ec1cc2013-05-31 14:56:29 +00002588 EXPECT_EQ("functionCall({\n"
Daniel Jasper567dcf92013-09-05 09:29:45 +00002589 " int i;\n"
2590 " int j;\n"
2591 " },\n"
Daniel Jasperf7ec1cc2013-05-31 14:56:29 +00002592 " aaaa, bbbb, cccc);",
Daniel Jasper567dcf92013-09-05 09:29:45 +00002593 format(" functionCall ( {int i;int j;}, aaaa, bbbb, cccc);"));
2594 EXPECT_EQ("functionCall(aaaa, bbbb, { int i; });",
2595 format(" functionCall (aaaa, bbbb, {int i;});"));
2596 EXPECT_EQ("functionCall(aaaa, bbbb, {\n"
2597 " int i;\n"
2598 " int j;\n"
2599 "});",
2600 format(" functionCall (aaaa, bbbb, {int i;int j;});"));
2601 EXPECT_EQ("functionCall(aaaa, bbbb, { int i; });",
2602 format(" functionCall (aaaa, bbbb, {int i;});"));
Daniel Jasperf7ec1cc2013-05-31 14:56:29 +00002603 verifyFormat(
2604 "Aaa({\n"
Daniel Jasper567dcf92013-09-05 09:29:45 +00002605 " int i; // break\n"
2606 " },\n"
Daniel Jasperf7ec1cc2013-05-31 14:56:29 +00002607 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
2608 " ccccccccccccccccc));");
Daniel Jasper567dcf92013-09-05 09:29:45 +00002609 verifyFormat("DEBUG({\n"
2610 " if (a)\n"
2611 " f();\n"
2612 "});");
Manuel Klimekbb42bf12013-01-10 11:52:21 +00002613}
2614
2615TEST_F(FormatTest, LayoutBlockInsideStatement) {
Manuel Klimek517e8942013-01-11 17:54:10 +00002616 EXPECT_EQ("SOME_MACRO { int i; }\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002617 "int i;",
2618 format(" SOME_MACRO {int i;} int i;"));
Manuel Klimekbb42bf12013-01-10 11:52:21 +00002619}
2620
2621TEST_F(FormatTest, LayoutNestedBlocks) {
2622 verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
2623 " struct s {\n"
2624 " int i;\n"
2625 " };\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07002626 " s kBitsToOs[] = {{10}};\n"
Manuel Klimekbb42bf12013-01-10 11:52:21 +00002627 " for (int i = 0; i < 10; ++i)\n"
2628 " return;\n"
2629 "}");
Daniel Jasperb77d7412013-09-06 07:54:20 +00002630 verifyFormat("call(parameter, {\n"
2631 " something();\n"
2632 " // Comment using all columns.\n"
2633 " somethingelse();\n"
2634 "});",
2635 getLLVMStyleWithColumns(40));
Stephen Hines651f13c2014-04-23 16:59:28 -07002636 verifyFormat("DEBUG( //\n"
2637 " { f(); }, a);");
2638 verifyFormat("DEBUG( //\n"
2639 " {\n"
2640 " f(); //\n"
2641 " },\n"
2642 " a);");
2643
Daniel Jasperb77d7412013-09-06 07:54:20 +00002644 EXPECT_EQ("call(parameter, {\n"
2645 " something();\n"
2646 " // Comment too\n"
2647 " // looooooooooong.\n"
2648 " somethingElse();\n"
2649 "});",
2650 format("call(parameter, {\n"
2651 " something();\n"
2652 " // Comment too looooooooooong.\n"
2653 " somethingElse();\n"
2654 "});",
2655 getLLVMStyleWithColumns(29)));
Daniel Jasper14e25c02013-09-08 14:07:57 +00002656 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });"));
Daniel Jasper15eef852013-10-20 17:28:32 +00002657 EXPECT_EQ("DEBUG({ // comment\n"
2658 " int i;\n"
2659 "});",
2660 format("DEBUG({ // comment\n"
2661 "int i;\n"
2662 "});"));
Daniel Jasper14e25c02013-09-08 14:07:57 +00002663 EXPECT_EQ("DEBUG({\n"
2664 " int i;\n"
2665 "\n"
2666 " // comment\n"
2667 " int j;\n"
2668 "});",
2669 format("DEBUG({\n"
2670 " int i;\n"
2671 "\n"
2672 " // comment\n"
2673 " int j;\n"
2674 "});"));
Daniel Jasper2a80ad62013-11-05 19:10:03 +00002675
2676 verifyFormat("DEBUG({\n"
2677 " if (a)\n"
2678 " return;\n"
2679 "});");
2680 verifyGoogleFormat("DEBUG({\n"
2681 " if (a) return;\n"
2682 "});");
2683 FormatStyle Style = getGoogleStyle();
2684 Style.ColumnLimit = 45;
2685 verifyFormat("Debug(aaaaa, {\n"
2686 " if (aaaaaaaaaaaaaaaaaaaaaaaa)\n"
2687 " return;\n"
2688 " },\n"
2689 " a);", Style);
Stephen Hines651f13c2014-04-23 16:59:28 -07002690}
2691
2692TEST_F(FormatTest, IndividualStatementsOfNestedBlocks) {
2693 EXPECT_EQ("DEBUG({\n"
2694 " int i;\n"
2695 " int j;\n"
2696 "});",
2697 format("DEBUG( {\n"
2698 " int i;\n"
2699 " int j;\n"
2700 "} ) ;",
2701 20, 1, getLLVMStyle()));
2702 EXPECT_EQ("DEBUG( {\n"
2703 " int i;\n"
2704 " int j;\n"
2705 "} ) ;",
2706 format("DEBUG( {\n"
2707 " int i;\n"
2708 " int j;\n"
2709 "} ) ;",
2710 41, 1, getLLVMStyle()));
2711 EXPECT_EQ("DEBUG( {\n"
2712 " int i;\n"
2713 " int j;\n"
2714 "} ) ;",
2715 format("DEBUG( {\n"
2716 " int i;\n"
2717 " int j;\n"
2718 "} ) ;",
2719 41, 1, getLLVMStyle()));
2720 EXPECT_EQ("DEBUG({\n"
2721 " int i;\n"
2722 " int j;\n"
2723 "});",
2724 format("DEBUG( {\n"
2725 " int i;\n"
2726 " int j;\n"
2727 "} ) ;",
2728 20, 1, getLLVMStyle()));
Daniel Jasper2a80ad62013-11-05 19:10:03 +00002729
2730 EXPECT_EQ("Debug({\n"
2731 " if (aaaaaaaaaaaaaaaaaaaaaaaa)\n"
2732 " return;\n"
2733 " },\n"
2734 " a);",
2735 format("Debug({\n"
2736 " if (aaaaaaaaaaaaaaaaaaaaaaaa)\n"
2737 " return;\n"
2738 " },\n"
2739 " a);",
2740 50, 1, getLLVMStyle()));
Daniel Jasper2a80ad62013-11-05 19:10:03 +00002741 EXPECT_EQ("DEBUG({\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07002742 " DEBUG({\n"
2743 " int a;\n"
2744 " int b;\n"
2745 " }) ;\n"
Daniel Jasper2a80ad62013-11-05 19:10:03 +00002746 "});",
Stephen Hines651f13c2014-04-23 16:59:28 -07002747 format("DEBUG({\n"
2748 " DEBUG({\n"
2749 " int a;\n"
2750 " int b;\n" // Format this line only.
2751 " }) ;\n" // Don't touch this line.
2752 "});",
2753 35, 0, getLLVMStyle()));
2754 EXPECT_EQ("DEBUG({\n"
2755 " int a; //\n"
2756 "});",
2757 format("DEBUG({\n"
2758 " int a; //\n"
2759 "});",
2760 0, 0, getLLVMStyle()));
Manuel Klimekbb42bf12013-01-10 11:52:21 +00002761}
2762
Manuel Klimek36fab8d2013-01-10 13:24:24 +00002763TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) {
2764 EXPECT_EQ("{}", format("{}"));
Daniel Jasper8893b8a2013-05-31 14:56:20 +00002765 verifyFormat("enum E {};");
Manuel Klimek2f1ac412013-01-21 16:42:44 +00002766 verifyFormat("enum E {}");
Manuel Klimek36fab8d2013-01-10 13:24:24 +00002767}
2768
Alexander Kornienko15757312012-12-06 18:03:27 +00002769//===----------------------------------------------------------------------===//
2770// Line break tests.
2771//===----------------------------------------------------------------------===//
2772
Daniel Jasper13d2aa52013-08-30 08:29:25 +00002773TEST_F(FormatTest, PreventConfusingIndents) {
Alexander Kornienko15757312012-12-06 18:03:27 +00002774 verifyFormat(
Daniel Jasper59875ac2013-11-07 17:43:07 +00002775 "void f() {\n"
2776 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n"
2777 " parameter, parameter, parameter)),\n"
2778 " SecondLongCall(parameter));\n"
2779 "}");
Daniel Jasper986e17f2013-01-28 07:35:34 +00002780 verifyFormat(
2781 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2782 " aaaaaaaaaaaaaaaaaaaaaaaa(\n"
2783 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
2784 " aaaaaaaaaaaaaaaaaaaaaaaa);");
2785 verifyFormat(
Daniel Jasper011c35d2013-07-12 11:19:37 +00002786 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2787 " [aaaaaaaaaaaaaaaaaaaaaaaa\n"
2788 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
2789 " [aaaaaaaaaaaaaaaaaaaaaaaa]];");
Daniel Jasper986e17f2013-01-28 07:35:34 +00002790 verifyFormat(
2791 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
2792 " aaaaaaaaaaaaaaaaaaaaaaaa<\n"
2793 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n"
2794 " aaaaaaaaaaaaaaaaaaaaaaaa>;");
Daniel Jasperae8699b2013-01-28 09:35:24 +00002795 verifyFormat("int a = bbbb && ccc && fffff(\n"
2796 "#define A Just forcing a new line\n"
2797 " ddd);");
Daniel Jasper986e17f2013-01-28 07:35:34 +00002798}
2799
Daniel Jasper11e13802013-05-08 14:12:04 +00002800TEST_F(FormatTest, LineBreakingInBinaryExpressions) {
2801 verifyFormat(
2802 "bool aaaaaaa =\n"
2803 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n"
2804 " bbbbbbbb();");
2805 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
2806 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n"
2807 " ccccccccc == ddddddddddd;");
2808
2809 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
2810 " aaaaaa) &&\n"
2811 " bbbbbb && cccccc;");
Daniel Jasper69c43712013-05-28 07:42:44 +00002812 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
2813 " aaaaaa) >>\n"
2814 " bbbbbb;");
Daniel Jasper11e13802013-05-08 14:12:04 +00002815 verifyFormat("Whitespaces.addUntouchableComment(\n"
2816 " SourceMgr.getSpellingColumnNumber(\n"
2817 " TheLine.Last->FormatTok.Tok.getLocation()) -\n"
2818 " 1);");
Daniel Jasperd741f022013-05-14 20:39:56 +00002819
Daniel Jasper5ef8aac2013-06-03 08:42:05 +00002820 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
2821 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n"
2822 " cccccc) {\n}");
2823
Daniel Jasper6df7a2d2013-07-03 10:34:47 +00002824 // If the LHS of a comparison is not a binary expression itself, the
2825 // additional linebreak confuses many people.
2826 verifyFormat(
2827 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2828 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n"
2829 "}");
2830 verifyFormat(
2831 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2832 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
2833 "}");
Daniel Jasperdb4813a2013-09-06 08:08:14 +00002834 verifyFormat(
2835 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n"
2836 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
2837 "}");
Daniel Jasper6df7a2d2013-07-03 10:34:47 +00002838 // Even explicit parentheses stress the precedence enough to make the
2839 // additional break unnecessary.
2840 verifyFormat(
2841 "if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2842 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
2843 "}");
2844 // This cases is borderline, but with the indentation it is still readable.
2845 verifyFormat(
2846 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2847 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2848 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
2849 "}",
2850 getLLVMStyleWithColumns(75));
2851
2852 // If the LHS is a binary expression, we should still use the additional break
2853 // as otherwise the formatting hides the operator precedence.
2854 verifyFormat(
2855 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2856 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2857 " 5) {\n"
2858 "}");
2859
Daniel Jasperd741f022013-05-14 20:39:56 +00002860 FormatStyle OnePerLine = getLLVMStyle();
2861 OnePerLine.BinPackParameters = false;
2862 verifyFormat(
2863 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
2864 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
2865 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}",
2866 OnePerLine);
Daniel Jasper11e13802013-05-08 14:12:04 +00002867}
2868
Daniel Jasperbf71ba22013-04-08 20:33:42 +00002869TEST_F(FormatTest, ExpressionIndentation) {
2870 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2871 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2872 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2873 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2874 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
2875 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n"
2876 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2877 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n"
2878 " ccccccccccccccccccccccccccccccccccccccccc;");
2879 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2880 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2881 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2882 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
2883 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2884 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2885 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2886 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
2887 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2888 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2889 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2890 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
Daniel Jasper9acb8b42013-06-06 09:11:58 +00002891 verifyFormat("if () {\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07002892 "} else if (aaaaa &&\n"
2893 " bbbbb > // break\n"
2894 " ccccc) {\n"
Daniel Jasper9acb8b42013-06-06 09:11:58 +00002895 "}");
Alexander Kornienkod71b15b2013-06-17 13:19:53 +00002896
2897 // Presence of a trailing comment used to change indentation of b.
2898 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
2899 " b;\n"
2900 "return aaaaaaaaaaaaaaaaaaa +\n"
2901 " b; //",
2902 getLLVMStyleWithColumns(30));
Daniel Jasperbf71ba22013-04-08 20:33:42 +00002903}
2904
Daniel Jaspere8b10d32013-07-26 16:56:36 +00002905TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) {
2906 // Not sure what the best system is here. Like this, the LHS can be found
2907 // immediately above an operator (everything with the same or a higher
2908 // indent). The RHS is aligned right of the operator and so compasses
2909 // everything until something with the same indent as the operator is found.
2910 // FIXME: Is this a good system?
2911 FormatStyle Style = getLLVMStyle();
2912 Style.BreakBeforeBinaryOperators = true;
2913 verifyFormat(
2914 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2915 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2916 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2917 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2918 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
2919 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
2920 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2921 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2922 " > ccccccccccccccccccccccccccccccccccccccccc;",
2923 Style);
2924 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2925 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2926 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2927 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
2928 Style);
2929 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2930 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2931 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2932 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
2933 Style);
2934 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2935 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2936 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2937 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
2938 Style);
2939 verifyFormat("if () {\n"
2940 "} else if (aaaaa && bbbbb // break\n"
2941 " > ccccc) {\n"
2942 "}",
2943 Style);
Daniel Jasper8b156e22013-11-08 19:56:28 +00002944
2945 // Forced by comments.
2946 verifyFormat(
2947 "unsigned ContentSize =\n"
2948 " sizeof(int16_t) // DWARF ARange version number\n"
2949 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
2950 " + sizeof(int8_t) // Pointer Size (in bytes)\n"
2951 " + sizeof(int8_t); // Segment Size (in bytes)");
Stephen Hines651f13c2014-04-23 16:59:28 -07002952
2953 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
2954 " == boost::fusion::at_c<1>(iiii).second;",
2955 Style);
Daniel Jaspere8b10d32013-07-26 16:56:36 +00002956}
2957
Daniel Jasper1321eb52012-12-18 21:05:13 +00002958TEST_F(FormatTest, ConstructorInitializers) {
Manuel Klimek36fab8d2013-01-10 13:24:24 +00002959 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
Daniel Jasper7e9bf8c2013-01-11 11:37:55 +00002960 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
2961 getLLVMStyleWithColumns(45));
Daniel Jasperf11a7052013-02-21 21:33:55 +00002962 verifyFormat("Constructor()\n"
2963 " : Inttializer(FitsOnTheLine) {}",
Daniel Jasper7e9bf8c2013-01-11 11:37:55 +00002964 getLLVMStyleWithColumns(44));
Manuel Klimek2f1ac412013-01-21 16:42:44 +00002965 verifyFormat("Constructor()\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002966 " : Inttializer(FitsOnTheLine) {}",
Manuel Klimek2f1ac412013-01-21 16:42:44 +00002967 getLLVMStyleWithColumns(43));
Daniel Jasper1321eb52012-12-18 21:05:13 +00002968
2969 verifyFormat(
2970 "SomeClass::Constructor()\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002971 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
Daniel Jasper1321eb52012-12-18 21:05:13 +00002972
2973 verifyFormat(
2974 "SomeClass::Constructor()\n"
Daniel Jasper7e9bf8c2013-01-11 11:37:55 +00002975 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002976 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}");
Daniel Jasper7e9bf8c2013-01-11 11:37:55 +00002977 verifyFormat(
2978 "SomeClass::Constructor()\n"
Daniel Jasper1321eb52012-12-18 21:05:13 +00002979 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002980 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
Daniel Jasper1321eb52012-12-18 21:05:13 +00002981
2982 verifyFormat("Constructor()\n"
2983 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
2984 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2985 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002986 " aaaaaaaaaaaaaaaaaaaaaaa() {}");
Daniel Jasper1321eb52012-12-18 21:05:13 +00002987
Daniel Jasper02b771e2013-01-28 13:31:35 +00002988 verifyFormat("Constructor()\n"
2989 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002990 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasper02b771e2013-01-28 13:31:35 +00002991
Daniel Jasper9c3e71a2013-02-25 15:59:54 +00002992 verifyFormat("Constructor(int Parameter = 0)\n"
2993 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
2994 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}");
Daniel Jasper00e0f432013-09-06 21:46:41 +00002995 verifyFormat("Constructor()\n"
2996 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
2997 "}",
2998 getLLVMStyleWithColumns(60));
Daniel Jasperdbfb5f32013-11-07 17:52:51 +00002999 verifyFormat("Constructor()\n"
3000 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3001 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}");
Daniel Jasper9c3e71a2013-02-25 15:59:54 +00003002
Daniel Jasper1321eb52012-12-18 21:05:13 +00003003 // Here a line could be saved by splitting the second initializer onto two
Stephen Hines651f13c2014-04-23 16:59:28 -07003004 // lines, but that is not desirable.
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003005 verifyFormat("Constructor()\n"
3006 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
3007 " aaaaaaaaaaa(aaaaaaaaaaa),\n"
3008 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasper1321eb52012-12-18 21:05:13 +00003009
Daniel Jasperb130a542013-02-15 16:49:44 +00003010 FormatStyle OnePerLine = getLLVMStyle();
3011 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
3012 verifyFormat("SomeClass::Constructor()\n"
3013 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
3014 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00003015 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003016 OnePerLine);
Daniel Jasperb130a542013-02-15 16:49:44 +00003017 verifyFormat("SomeClass::Constructor()\n"
3018 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
3019 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00003020 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003021 OnePerLine);
Daniel Jasperb130a542013-02-15 16:49:44 +00003022 verifyFormat("MyClass::MyClass(int var)\n"
3023 " : some_var_(var), // 4 space indent\n"
3024 " some_other_var_(var + 1) { // lined up\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003025 "}",
3026 OnePerLine);
Daniel Jasper3a39ac72013-02-28 09:39:12 +00003027 verifyFormat("Constructor()\n"
3028 " : aaaaa(aaaaaa),\n"
3029 " aaaaa(aaaaaa),\n"
3030 " aaaaa(aaaaaa),\n"
3031 " aaaaa(aaaaaa),\n"
3032 " aaaaa(aaaaaa) {}",
3033 OnePerLine);
Daniel Jasper001bf4e2013-04-22 07:59:53 +00003034 verifyFormat("Constructor()\n"
3035 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
3036 " aaaaaaaaaaaaaaaaaaaaaa) {}",
3037 OnePerLine);
Stephen Hines651f13c2014-04-23 16:59:28 -07003038
3039 EXPECT_EQ("Constructor()\n"
3040 " : // Comment forcing unwanted break.\n"
3041 " aaaa(aaaa) {}",
3042 format("Constructor() :\n"
3043 " // Comment forcing unwanted break.\n"
3044 " aaaa(aaaa) {}"));
Daniel Jasperfca24bc2013-04-25 13:31:51 +00003045}
3046
3047TEST_F(FormatTest, MemoizationTests) {
3048 // This breaks if the memoization lookup does not take \c Indent and
3049 // \c LastSpace into account.
3050 verifyFormat(
3051 "extern CFRunLoopTimerRef\n"
3052 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
3053 " CFTimeInterval interval, CFOptionFlags flags,\n"
3054 " CFIndex order, CFRunLoopTimerCallBack callout,\n"
Daniel Jasper53e72cd2013-05-06 08:27:33 +00003055 " CFRunLoopTimerContext *context) {}");
Daniel Jasperfca24bc2013-04-25 13:31:51 +00003056
3057 // Deep nesting somewhat works around our memoization.
3058 verifyFormat(
3059 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
3060 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
3061 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
3062 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
3063 " aaaaa())))))))))))))))))))))))))))))))))))))));",
3064 getLLVMStyleWithColumns(65));
Daniel Jasperc3df5ff2013-05-13 09:19:24 +00003065 verifyFormat(
3066 "aaaaa(\n"
3067 " aaaaa,\n"
3068 " aaaaa(\n"
3069 " aaaaa,\n"
3070 " aaaaa(\n"
3071 " aaaaa,\n"
3072 " aaaaa(\n"
3073 " aaaaa,\n"
3074 " aaaaa(\n"
3075 " aaaaa,\n"
3076 " aaaaa(\n"
3077 " aaaaa,\n"
3078 " aaaaa(\n"
3079 " aaaaa,\n"
3080 " aaaaa(\n"
3081 " aaaaa,\n"
3082 " aaaaa(\n"
3083 " aaaaa,\n"
3084 " aaaaa(\n"
3085 " aaaaa,\n"
3086 " aaaaa(\n"
3087 " aaaaa,\n"
3088 " aaaaa(\n"
3089 " aaaaa,\n"
3090 " aaaaa))))))))))));",
3091 getLLVMStyleWithColumns(65));
Daniel Jasper54b4e442013-05-22 05:27:42 +00003092 verifyFormat(
3093 "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"
3094 " a),\n"
3095 " a),\n"
3096 " a),\n"
3097 " a),\n"
3098 " a),\n"
3099 " a),\n"
3100 " a),\n"
3101 " a),\n"
3102 " a),\n"
3103 " a),\n"
3104 " a),\n"
3105 " a),\n"
3106 " a),\n"
3107 " a),\n"
3108 " a),\n"
3109 " a),\n"
3110 " a)",
3111 getLLVMStyleWithColumns(65));
Daniel Jasperb3123142013-01-12 07:36:22 +00003112
3113 // This test takes VERY long when memoization is broken.
Daniel Jasperfca24bc2013-04-25 13:31:51 +00003114 FormatStyle OnePerLine = getLLVMStyle();
3115 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003116 OnePerLine.BinPackParameters = false;
Daniel Jasper0df6acd2013-01-16 14:59:02 +00003117 std::string input = "Constructor()\n"
Daniel Jasper3499dda2013-01-25 15:43:32 +00003118 " : aaaa(a,\n";
Daniel Jasper0df6acd2013-01-16 14:59:02 +00003119 for (unsigned i = 0, e = 80; i != e; ++i) {
3120 input += " a,\n";
3121 }
Daniel Jasperf11a7052013-02-21 21:33:55 +00003122 input += " a) {}";
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003123 verifyFormat(input, OnePerLine);
Daniel Jasper1321eb52012-12-18 21:05:13 +00003124}
3125
Alexander Kornienko15757312012-12-06 18:03:27 +00003126TEST_F(FormatTest, BreaksAsHighAsPossible) {
3127 verifyFormat(
Alexander Kornienko3fd9ccd2013-03-12 16:28:18 +00003128 "void f() {\n"
3129 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
3130 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
3131 " f();\n"
3132 "}");
Daniel Jasper518ee342013-02-26 13:59:14 +00003133 verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
Daniel Jasperbf71ba22013-04-08 20:33:42 +00003134 " Intervals[i - 1].getRange().getLast()) {\n}");
Alexander Kornienko15757312012-12-06 18:03:27 +00003135}
3136
Daniel Jasper1407bee2013-04-11 14:29:13 +00003137TEST_F(FormatTest, BreaksFunctionDeclarations) {
3138 // Principially, we break function declarations in a certain order:
3139 // 1) break amongst arguments.
3140 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
3141 " Cccccccccccccc cccccccccccccc);");
Daniel Jasper92495a82013-08-19 10:16:18 +00003142 verifyFormat(
3143 "template <class TemplateIt>\n"
3144 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n"
3145 " TemplateIt *stop) {}");
Daniel Jasper1407bee2013-04-11 14:29:13 +00003146
3147 // 2) break after return type.
Daniel Jasper53e72cd2013-05-06 08:27:33 +00003148 verifyFormat(
Manuel Klimeka9a7f102013-06-21 17:25:42 +00003149 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3150 " bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);",
3151 getGoogleStyle());
Daniel Jasper1407bee2013-04-11 14:29:13 +00003152
3153 // 3) break after (.
3154 verifyFormat(
3155 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00003156 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);",
3157 getGoogleStyle());
Daniel Jasper1407bee2013-04-11 14:29:13 +00003158
3159 // 4) break before after nested name specifiers.
3160 verifyFormat(
3161 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper53e72cd2013-05-06 08:27:33 +00003162 " SomeClasssssssssssssssssssssssssssssssssssssss::\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00003163 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);",
3164 getGoogleStyle());
Daniel Jasper1407bee2013-04-11 14:29:13 +00003165
3166 // However, there are exceptions, if a sufficient amount of lines can be
3167 // saved.
3168 // FIXME: The precise cut-offs wrt. the number of saved lines might need some
3169 // more adjusting.
3170 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
3171 " Cccccccccccccc cccccccccc,\n"
3172 " Cccccccccccccc cccccccccc,\n"
3173 " Cccccccccccccc cccccccccc,\n"
3174 " Cccccccccccccc cccccccccc);");
3175 verifyFormat(
Manuel Klimeka9a7f102013-06-21 17:25:42 +00003176 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper53e72cd2013-05-06 08:27:33 +00003177 " bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3178 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00003179 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);",
3180 getGoogleStyle());
Daniel Jasper1407bee2013-04-11 14:29:13 +00003181 verifyFormat(
3182 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
3183 " Cccccccccccccc cccccccccc,\n"
3184 " Cccccccccccccc cccccccccc,\n"
3185 " Cccccccccccccc cccccccccc,\n"
3186 " Cccccccccccccc cccccccccc,\n"
3187 " Cccccccccccccc cccccccccc,\n"
3188 " Cccccccccccccc cccccccccc);");
3189 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
3190 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3191 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3192 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
3193 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
Daniel Jasper01218ff2013-04-15 22:36:37 +00003194
3195 // Break after multi-line parameters.
3196 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3197 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3198 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3199 " bbbb bbbb);");
Daniel Jasper6561f6a2013-07-09 07:43:55 +00003200
3201 // Treat overloaded operators like other functions.
3202 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
3203 "operator>(const SomeLoooooooooooooooooooooooooogType &other);");
Daniel Jasperc476ea92013-08-28 07:27:35 +00003204 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
3205 "operator>>(const SomeLooooooooooooooooooooooooogType &other);");
Stephen Hines651f13c2014-04-23 16:59:28 -07003206 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
3207 "operator<<(const SomeLooooooooooooooooooooooooogType &other);");
3208 verifyGoogleFormat(
3209 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n"
3210 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
Daniel Jasper6561f6a2013-07-09 07:43:55 +00003211 verifyGoogleFormat(
3212 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n"
3213 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
Stephen Hines651f13c2014-04-23 16:59:28 -07003214 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3215 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);");
3216 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n"
3217 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);");
Daniel Jasper1407bee2013-04-11 14:29:13 +00003218}
3219
Daniel Jasper2ca37412013-07-09 14:36:48 +00003220TEST_F(FormatTest, TrailingReturnType) {
3221 verifyFormat("auto foo() -> int;\n");
3222 verifyFormat("struct S {\n"
3223 " auto bar() const -> int;\n"
3224 "};");
3225 verifyFormat("template <size_t Order, typename T>\n"
3226 "auto load_img(const std::string &filename)\n"
3227 " -> alias::tensor<Order, T, mem::tag::cpu> {}");
Daniel Jasper3262f4c2013-07-11 14:33:06 +00003228
3229 // Not trailing return types.
3230 verifyFormat("void f() { auto a = b->c(); }");
Daniel Jasper2ca37412013-07-09 14:36:48 +00003231}
3232
Daniel Jaspere033e872013-05-21 09:16:31 +00003233TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) {
Daniel Jasper53eb05a2013-10-18 16:34:40 +00003234 // Avoid breaking before trailing 'const' or other trailing annotations, if
3235 // they are not function-like.
Daniel Jasper5ad72bb2013-05-22 08:28:26 +00003236 FormatStyle Style = getGoogleStyle();
3237 Style.ColumnLimit = 47;
3238 verifyFormat("void\n"
3239 "someLongFunction(int someLongParameter) const {\n}",
3240 getLLVMStyleWithColumns(47));
Daniel Jasper5ad72bb2013-05-22 08:28:26 +00003241 verifyFormat("LoooooongReturnType\n"
3242 "someLoooooooongFunction() const {}",
3243 getLLVMStyleWithColumns(47));
3244 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
3245 " const {}",
3246 Style);
Daniel Jasper53eb05a2013-10-18 16:34:40 +00003247 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
3248 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;");
3249 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
3250 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;");
3251 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
3252 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;");
Stephen Hines651f13c2014-04-23 16:59:28 -07003253 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n"
3254 " aaaaaaaaaaa aaaaa) const override;");
3255 verifyGoogleFormat(
3256 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
3257 " const override;");
Daniel Jaspere033e872013-05-21 09:16:31 +00003258
Stephen Hines651f13c2014-04-23 16:59:28 -07003259 // Even if the first parameter has to be wrapped.
3260 verifyFormat("void someLongFunction(\n"
3261 " int someLongParameter) const {}",
Daniel Jasper53eb05a2013-10-18 16:34:40 +00003262 getLLVMStyleWithColumns(46));
Stephen Hines651f13c2014-04-23 16:59:28 -07003263 verifyFormat("void someLongFunction(\n"
3264 " int someLongParameter) const {}",
Daniel Jasper53eb05a2013-10-18 16:34:40 +00003265 Style);
Stephen Hines651f13c2014-04-23 16:59:28 -07003266 verifyFormat("void someLongFunction(\n"
3267 " int someLongParameter) override {}",
3268 Style);
3269 verifyFormat("void someLongFunction(\n"
3270 " int someLongParameter) final {}",
3271 Style);
3272 verifyFormat("void someLongFunction(\n"
3273 " int parameter) const override {}",
3274 Style);
3275
3276 // Unless these are unknown annotations.
Daniel Jasper53eb05a2013-10-18 16:34:40 +00003277 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n"
3278 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3279 " LONG_AND_UGLY_ANNOTATION;");
Daniel Jasper20a0f8c2013-07-11 21:02:56 +00003280
3281 // Breaking before function-like trailing annotations is fine to keep them
3282 // close to their arguments.
Daniel Jaspere033e872013-05-21 09:16:31 +00003283 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3284 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
3285 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
3286 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
3287 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
3288 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}");
3289
3290 verifyFormat(
3291 "void aaaaaaaaaaaaaaaaaa()\n"
3292 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
3293 " aaaaaaaaaaaaaaaaaaaaaaaaa));");
3294 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3295 " __attribute__((unused));");
3296 verifyFormat(
Manuel Klimeka9a7f102013-06-21 17:25:42 +00003297 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3298 " GUARDED_BY(aaaaaaaaaaaa);",
3299 getGoogleStyle());
Daniel Jasperc18cff32013-07-11 12:34:23 +00003300 verifyFormat(
3301 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3302 " GUARDED_BY(aaaaaaaaaaaa);",
3303 getGoogleStyle());
Daniel Jaspere033e872013-05-21 09:16:31 +00003304}
3305
Daniel Jasperbac016b2012-12-03 18:12:45 +00003306TEST_F(FormatTest, BreaksDesireably) {
3307 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
3308 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003309 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
Daniel Jaspere438bac2013-01-23 20:41:06 +00003310 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3311 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
3312 "}");
Daniel Jasperbac016b2012-12-03 18:12:45 +00003313
3314 verifyFormat(
3315 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00003316 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasperbac016b2012-12-03 18:12:45 +00003317
3318 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3319 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3320 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jaspera88bb452012-12-04 10:50:12 +00003321
3322 verifyFormat(
3323 "aaaaaaaa(aaaaaaaaaaaaa, aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3324 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
3325 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3326 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));");
Daniel Jasper33182dd2012-12-05 14:57:28 +00003327
3328 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3329 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
3330
Daniel Jasper723f0302013-01-02 14:40:02 +00003331 verifyFormat(
Alexander Kornienko3fd9ccd2013-03-12 16:28:18 +00003332 "void f() {\n"
3333 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
3334 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
3335 "}");
Daniel Jasper3499dda2013-01-25 15:43:32 +00003336 verifyFormat(
3337 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3338 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
3339 verifyFormat(
3340 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3341 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jasper64f09282013-03-20 13:53:11 +00003342 verifyFormat(
Daniel Jasper47066e42013-10-25 14:29:37 +00003343 "aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3344 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3345 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper723f0302013-01-02 14:40:02 +00003346
Stephen Hines651f13c2014-04-23 16:59:28 -07003347 // Indent consistently independent of call expression.
Daniel Jasper13d2aa52013-08-30 08:29:25 +00003348 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
3349 " dddddddddddddddddddddddddddddd));\n"
3350 "aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
3351 " dddddddddddddddddddddddddddddd));");
3352
Daniel Jasper33182dd2012-12-05 14:57:28 +00003353 // This test case breaks on an incorrect memoization, i.e. an optimization not
3354 // taking into account the StopAt value.
3355 verifyFormat(
3356 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
Daniel Jaspercf225b62012-12-24 13:43:52 +00003357 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
3358 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
3359 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jaspera4974cf2012-12-24 16:43:00 +00003360
Daniel Jaspercd162382013-01-07 13:26:07 +00003361 verifyFormat("{\n {\n {\n"
3362 " Annotation.SpaceRequiredBefore =\n"
3363 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
3364 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
3365 " }\n }\n}");
Alexander Kornienko22d0e292013-06-17 12:59:44 +00003366
3367 // Break on an outer level if there was a break on an inner level.
3368 EXPECT_EQ("f(g(h(a, // comment\n"
3369 " b, c),\n"
3370 " d, e),\n"
3371 " x, y);",
3372 format("f(g(h(a, // comment\n"
3373 " b, c), d, e), x, y);"));
Daniel Jasper88cc5622013-07-08 14:25:23 +00003374
3375 // Prefer breaking similar line breaks.
3376 verifyFormat(
3377 "const int kTrackingOptions = NSTrackingMouseMoved |\n"
3378 " NSTrackingMouseEnteredAndExited |\n"
3379 " NSTrackingActiveAlways;");
Daniel Jasperbac016b2012-12-03 18:12:45 +00003380}
3381
Daniel Jasper0df6acd2013-01-16 14:59:02 +00003382TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +00003383 FormatStyle NoBinPacking = getGoogleStyle();
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003384 NoBinPacking.BinPackParameters = false;
3385 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
3386 " aaaaaaaaaaaaaaaaaaaa,\n"
3387 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);",
3388 NoBinPacking);
3389 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
3390 " aaaaaaaaaaaaa,\n"
3391 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));",
3392 NoBinPacking);
3393 verifyFormat(
Daniel Jasper0df6acd2013-01-16 14:59:02 +00003394 "aaaaaaaa(aaaaaaaaaaaaa,\n"
3395 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3396 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
3397 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003398 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));",
3399 NoBinPacking);
3400 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
3401 " .aaaaaaaaaaaaaaaaaa();",
3402 NoBinPacking);
Daniel Jasper59875ac2013-11-07 17:43:07 +00003403 verifyFormat("void f() {\n"
3404 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3405 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n"
3406 "}",
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003407 NoBinPacking);
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003408
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003409 verifyFormat(
Daniel Jasper8f4bd7a2013-01-23 10:08:28 +00003410 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3411 " aaaaaaaaaaaa,\n"
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003412 " aaaaaaaaaaaa);",
3413 NoBinPacking);
3414 verifyFormat(
Daniel Jasper0df6acd2013-01-16 14:59:02 +00003415 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
3416 " ddddddddddddddddddddddddddddd),\n"
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003417 " test);",
3418 NoBinPacking);
Daniel Jasper0df6acd2013-01-16 14:59:02 +00003419
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003420 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
3421 " aaaaaaaaaaaaaaaaaaaaaaa,\n"
3422 " aaaaaaaaaaaaaaaaaaaaaaa> aaaaaaaaaaaaaaaaaa;",
3423 NoBinPacking);
3424 verifyFormat("a(\"a\"\n"
3425 " \"a\",\n"
3426 " a);");
Daniel Jasper8f4bd7a2013-01-23 10:08:28 +00003427
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003428 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
Daniel Jasperf1579602013-01-29 16:03:49 +00003429 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
Daniel Jasper8f4bd7a2013-01-23 10:08:28 +00003430 " aaaaaaaaa,\n"
Daniel Jasperf1579602013-01-29 16:03:49 +00003431 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003432 NoBinPacking);
Daniel Jasperfc759082013-02-14 14:26:07 +00003433 verifyFormat(
3434 "void f() {\n"
3435 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
3436 " .aaaaaaa();\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003437 "}",
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003438 NoBinPacking);
Daniel Jasper24e19e42013-05-22 08:55:55 +00003439 verifyFormat(
3440 "template <class SomeType, class SomeOtherType>\n"
3441 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
3442 NoBinPacking);
Daniel Jasper0df6acd2013-01-16 14:59:02 +00003443}
3444
Daniel Jasperc7bd68f2013-07-10 14:02:49 +00003445TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
3446 FormatStyle Style = getLLVMStyleWithColumns(15);
3447 Style.ExperimentalAutoDetectBinPacking = true;
3448 EXPECT_EQ("aaa(aaaa,\n"
3449 " aaaa,\n"
3450 " aaaa);\n"
3451 "aaa(aaaa,\n"
3452 " aaaa,\n"
3453 " aaaa);",
3454 format("aaa(aaaa,\n" // one-per-line
3455 " aaaa,\n"
3456 " aaaa );\n"
3457 "aaa(aaaa, aaaa, aaaa);", // inconclusive
3458 Style));
3459 EXPECT_EQ("aaa(aaaa, aaaa,\n"
3460 " aaaa);\n"
3461 "aaa(aaaa, aaaa,\n"
3462 " aaaa);",
3463 format("aaa(aaaa, aaaa,\n" // bin-packed
3464 " aaaa );\n"
3465 "aaa(aaaa, aaaa, aaaa);", // inconclusive
3466 Style));
3467}
3468
Daniel Jasperc79afda2013-01-18 10:56:38 +00003469TEST_F(FormatTest, FormatsBuilderPattern) {
3470 verifyFormat(
3471 "return llvm::StringSwitch<Reference::Kind>(name)\n"
Daniel Jasper29082452013-08-30 07:27:13 +00003472 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
3473 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
3474 " .StartsWith(\".init\", ORDER_INIT)\n"
3475 " .StartsWith(\".fini\", ORDER_FINI)\n"
3476 " .StartsWith(\".hash\", ORDER_HASH)\n"
3477 " .Default(ORDER_TEXT);\n");
Daniel Jasper33f4b902013-05-15 09:35:08 +00003478
Daniel Jasper4a544e52013-02-15 20:33:06 +00003479 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
Daniel Jasperbf71ba22013-04-08 20:33:42 +00003480 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
Daniel Jasper515f65d2013-02-18 13:24:21 +00003481 verifyFormat(
Daniel Jasperefed6872013-08-07 05:34:02 +00003482 "aaaaaaa->aaaaaaa->aaaaaaaaaaaaaaaa(\n"
3483 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
Daniel Jasper515f65d2013-02-18 13:24:21 +00003484 " ->aaaaaaaa(aaaaaaaaaaaaaaa);");
Daniel Jasper82282dc2013-02-18 13:52:06 +00003485 verifyFormat(
3486 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
Daniel Jasper24849712013-03-01 16:48:32 +00003487 " aaaaaaaaaaaaaa);");
Daniel Jasper82282dc2013-02-18 13:52:06 +00003488 verifyFormat(
Daniel Jasperd489f8c2013-08-27 11:09:05 +00003489 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n"
3490 " aaaaaa->aaaaaaaaaaaa()\n"
3491 " ->aaaaaaaaaaaaaaaa(\n"
3492 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3493 " ->aaaaaaaaaaaaaaaaa();");
Daniel Jasper47066e42013-10-25 14:29:37 +00003494 verifyGoogleFormat(
Daniel Jasper59875ac2013-11-07 17:43:07 +00003495 "void f() {\n"
3496 " someo->Add((new util::filetools::Handler(dir))\n"
Daniel Jasperd489f8c2013-08-27 11:09:05 +00003497 " ->OnEvent1(NewPermanentCallback(\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07003498 " this, &HandlerHolderClass::EventHandlerCBA))\n"
Daniel Jasperd489f8c2013-08-27 11:09:05 +00003499 " ->OnEvent2(NewPermanentCallback(\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07003500 " this, &HandlerHolderClass::EventHandlerCBB))\n"
Daniel Jasperd489f8c2013-08-27 11:09:05 +00003501 " ->OnEvent3(NewPermanentCallback(\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07003502 " this, &HandlerHolderClass::EventHandlerCBC))\n"
Daniel Jasperd489f8c2013-08-27 11:09:05 +00003503 " ->OnEvent5(NewPermanentCallback(\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07003504 " this, &HandlerHolderClass::EventHandlerCBD))\n"
Daniel Jasperd489f8c2013-08-27 11:09:05 +00003505 " ->OnEvent6(NewPermanentCallback(\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07003506 " this, &HandlerHolderClass::EventHandlerCBE)));\n"
Daniel Jasper59875ac2013-11-07 17:43:07 +00003507 "}");
Daniel Jasperd3fef0f2013-08-27 14:24:43 +00003508
3509 verifyFormat(
3510 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();");
3511 verifyFormat("aaaaaaaaaaaaaaa()\n"
3512 " .aaaaaaaaaaaaaaa()\n"
3513 " .aaaaaaaaaaaaaaa()\n"
3514 " .aaaaaaaaaaaaaaa()\n"
3515 " .aaaaaaaaaaaaaaa();");
3516 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
3517 " .aaaaaaaaaaaaaaa()\n"
3518 " .aaaaaaaaaaaaaaa()\n"
3519 " .aaaaaaaaaaaaaaa();");
3520 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
3521 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
3522 " .aaaaaaaaaaaaaaa();");
Daniel Jaspereb331832013-08-30 07:12:40 +00003523 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
3524 " ->aaaaaaaaaaaaaae(0)\n"
3525 " ->aaaaaaaaaaaaaaa();");
Daniel Jasper2f0a0202013-09-06 08:54:24 +00003526
Daniel Jasper9b3cb442013-10-18 15:23:06 +00003527 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
3528 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
3529 " .has<bbbbbbbbbbbbbbbbbbbbb>();");
3530 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
3531 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07003532 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();");
Daniel Jasper9b3cb442013-10-18 15:23:06 +00003533
Daniel Jasper2f0a0202013-09-06 08:54:24 +00003534 // Prefer not to break after empty parentheses.
3535 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
3536 " First->LastNewlineOffset);");
Daniel Jasperc79afda2013-01-18 10:56:38 +00003537}
3538
Daniel Jaspere2c7acf2012-12-24 00:13:23 +00003539TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) {
3540 verifyFormat(
3541 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003542 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
Daniel Jaspercd162382013-01-07 13:26:07 +00003543 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003544 " ccccccccccccccccccccccccc) {\n}");
Daniel Jaspercd162382013-01-07 13:26:07 +00003545 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003546 " ccccccccccccccccccccccccc) {\n}");
Daniel Jaspere2c7acf2012-12-24 00:13:23 +00003547 verifyFormat(
3548 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003549 " ccccccccccccccccccccccccc) {\n}");
Daniel Jasper29f123b2013-02-08 15:28:42 +00003550 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
3551 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
3552 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
3553 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
3554 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
3555 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
3556 " aaaaaaaaaaaaaaa != aa) {\n}");
Daniel Jaspere2c7acf2012-12-24 00:13:23 +00003557}
3558
Daniel Jasper7006e7e2013-01-23 12:27:43 +00003559TEST_F(FormatTest, BreaksAfterAssignments) {
Daniel Jasper9cda8002013-01-07 13:08:40 +00003560 verifyFormat(
Daniel Jasper7006e7e2013-01-23 12:27:43 +00003561 "unsigned Cost =\n"
3562 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
3563 " SI->getPointerAddressSpaceee());\n");
Daniel Jasper9cda8002013-01-07 13:08:40 +00003564 verifyFormat(
Daniel Jasper13cb7c22013-01-23 15:55:19 +00003565 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
3566 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
Daniel Jasperf39c8852013-01-23 16:58:21 +00003567
3568 verifyFormat(
Daniel Jasperd489f8c2013-08-27 11:09:05 +00003569 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
3570 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper512843a2013-05-27 12:45:09 +00003571 verifyFormat("unsigned OriginalStartColumn =\n"
3572 " SourceMgr.getSpellingColumnNumber(\n"
3573 " Current.FormatTok.getStartOfNonWhitespace()) -\n"
3574 " 1;");
Daniel Jasper9cda8002013-01-07 13:08:40 +00003575}
3576
Daniel Jaspercf225b62012-12-24 13:43:52 +00003577TEST_F(FormatTest, AlignsAfterAssignments) {
3578 verifyFormat(
3579 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper9cda8002013-01-07 13:08:40 +00003580 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jaspercf225b62012-12-24 13:43:52 +00003581 verifyFormat(
3582 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper9cda8002013-01-07 13:08:40 +00003583 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jaspercf225b62012-12-24 13:43:52 +00003584 verifyFormat(
3585 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper9cda8002013-01-07 13:08:40 +00003586 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jaspercf225b62012-12-24 13:43:52 +00003587 verifyFormat(
3588 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper9cda8002013-01-07 13:08:40 +00003589 " aaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper88cc5622013-07-08 14:25:23 +00003590 verifyFormat(
3591 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n"
3592 " aaaaaaaaaaaaaaaaaaaaaaaa +\n"
3593 " aaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jaspercf225b62012-12-24 13:43:52 +00003594}
3595
3596TEST_F(FormatTest, AlignsAfterReturn) {
3597 verifyFormat(
3598 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3599 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
3600 verifyFormat(
3601 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3602 " aaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper37911302013-04-02 14:33:13 +00003603 verifyFormat(
3604 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
Daniel Jasperbf71ba22013-04-08 20:33:42 +00003605 " aaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper37911302013-04-02 14:33:13 +00003606 verifyFormat(
3607 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
Daniel Jasperbf71ba22013-04-08 20:33:42 +00003608 " aaaaaaaaaaaaaaaaaaaaaa());");
3609 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3610 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
3611 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3612 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
3613 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasperf78bf4a2013-09-30 08:29:03 +00003614 verifyFormat("return\n"
3615 " // true if code is one of a or b.\n"
3616 " code == a || code == b;");
Daniel Jaspercf225b62012-12-24 13:43:52 +00003617}
3618
Daniel Jasper9c837d02013-01-09 07:06:56 +00003619TEST_F(FormatTest, BreaksConditionalExpressions) {
3620 verifyFormat(
Daniel Jasper88cc5622013-07-08 14:25:23 +00003621 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3622 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3623 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper1f2b0782013-01-16 16:23:19 +00003624 verifyFormat(
Daniel Jasperbfe6fd42013-01-28 12:45:14 +00003625 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3626 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
3627 verifyFormat(
3628 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
3629 " : aaaaaaaaaaaaa);");
3630 verifyFormat(
3631 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper64f09282013-03-20 13:53:11 +00003632 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasperbfe6fd42013-01-28 12:45:14 +00003633 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3634 " aaaaaaaaaaaaa);");
Daniel Jasperab3ce592013-08-01 22:05:00 +00003635 verifyFormat(
3636 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3637 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3638 " aaaaaaaaaaaaa);");
Daniel Jasperbfe6fd42013-01-28 12:45:14 +00003639 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3640 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3641 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3642 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3643 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
3644 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3645 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3646 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3647 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3648 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3649 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3650 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperab3ce592013-08-01 22:05:00 +00003651 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3652 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3653 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3654 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3655 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper7878a7b2013-02-15 11:07:25 +00003656 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3657 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3658 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper37911302013-04-02 14:33:13 +00003659 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
3660 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3661 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3662 " : aaaaaaaaaaaaaaaa;");
Daniel Jasper237d4c12013-02-23 21:01:55 +00003663 verifyFormat(
3664 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3665 " ? aaaaaaaaaaaaaaa\n"
3666 " : aaaaaaaaaaaaaaa;");
3667 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
Daniel Jasperbf71ba22013-04-08 20:33:42 +00003668 " aaaaaaaaa\n"
Daniel Jasper65622aa2013-04-08 10:45:44 +00003669 " ? b\n"
3670 " : c);");
Daniel Jasper087387a2013-02-08 16:49:27 +00003671 verifyFormat(
Daniel Jasper7878a7b2013-02-15 11:07:25 +00003672 "unsigned Indent =\n"
3673 " format(TheLine.First, IndentForLevel[TheLine.Level] >= 0\n"
3674 " ? IndentForLevel[TheLine.Level]\n"
Daniel Jasper7d812812013-02-21 15:00:29 +00003675 " : TheLine * 2,\n"
3676 " TheLine.InPPDirective, PreviousEndOfLineColumn);",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003677 getLLVMStyleWithColumns(70));
Daniel Jasperc01897c2013-05-31 14:56:12 +00003678 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
3679 " ? aaaaaaaaaaaaaaa\n"
3680 " : bbbbbbbbbbbbbbb //\n"
3681 " ? ccccccccccccccc\n"
3682 " : ddddddddddddddd;");
3683 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
3684 " ? aaaaaaaaaaaaaaa\n"
3685 " : (bbbbbbbbbbbbbbb //\n"
3686 " ? ccccccccccccccc\n"
3687 " : ddddddddddddddd);");
Daniel Jasper7878a7b2013-02-15 11:07:25 +00003688
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003689 FormatStyle NoBinPacking = getLLVMStyle();
3690 NoBinPacking.BinPackParameters = false;
3691 verifyFormat(
Daniel Jasper237d4c12013-02-23 21:01:55 +00003692 "void f() {\n"
3693 " g(aaa,\n"
3694 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
3695 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3696 " ? aaaaaaaaaaaaaaa\n"
3697 " : aaaaaaaaaaaaaaa);\n"
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003698 "}",
3699 NoBinPacking);
Daniel Jasperab3ce592013-08-01 22:05:00 +00003700 verifyFormat(
3701 "void f() {\n"
3702 " g(aaa,\n"
3703 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
3704 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3705 " ?: aaaaaaaaaaaaaaa);\n"
3706 "}",
3707 NoBinPacking);
Daniel Jasper9c837d02013-01-09 07:06:56 +00003708}
3709
Daniel Jasper1a896a52013-11-08 00:57:11 +00003710TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) {
3711 FormatStyle Style = getLLVMStyle();
3712 Style.BreakBeforeTernaryOperators = false;
3713 Style.ColumnLimit = 70;
3714 verifyFormat(
3715 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
3716 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
3717 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
3718 Style);
3719 verifyFormat(
3720 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
3721 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
3722 Style);
3723 verifyFormat(
3724 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n"
3725 " aaaaaaaaaaaaa);",
3726 Style);
3727 verifyFormat(
3728 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3729 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
3730 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3731 " aaaaaaaaaaaaa);",
3732 Style);
3733 verifyFormat(
3734 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3735 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3736 " aaaaaaaaaaaaa);",
3737 Style);
3738 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
3739 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3740 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
3741 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3742 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
3743 Style);
3744 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3745 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
3746 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3747 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
3748 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3749 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3750 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
3751 Style);
3752 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3753 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n"
3754 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3755 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3756 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
3757 Style);
3758 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
3759 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
3760 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;",
3761 Style);
3762 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07003763 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
Daniel Jasper1a896a52013-11-08 00:57:11 +00003764 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
3765 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
3766 Style);
3767 verifyFormat(
3768 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
3769 " aaaaaaaaaaaaaaa :\n"
3770 " aaaaaaaaaaaaaaa;",
3771 Style);
3772 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
3773 " aaaaaaaaa ?\n"
3774 " b :\n"
3775 " c);",
3776 Style);
3777 verifyFormat(
3778 "unsigned Indent =\n"
3779 " format(TheLine.First, IndentForLevel[TheLine.Level] >= 0 ?\n"
3780 " IndentForLevel[TheLine.Level] :\n"
3781 " TheLine * 2,\n"
3782 " TheLine.InPPDirective, PreviousEndOfLineColumn);",
3783 Style);
3784 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
3785 " aaaaaaaaaaaaaaa :\n"
3786 " bbbbbbbbbbbbbbb ? //\n"
3787 " ccccccccccccccc :\n"
3788 " ddddddddddddddd;",
3789 Style);
3790 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
3791 " aaaaaaaaaaaaaaa :\n"
3792 " (bbbbbbbbbbbbbbb ? //\n"
3793 " ccccccccccccccc :\n"
3794 " ddddddddddddddd);",
3795 Style);
3796}
3797
Daniel Jasper2e603772013-01-29 11:21:01 +00003798TEST_F(FormatTest, DeclarationsOfMultipleVariables) {
3799 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
3800 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();");
3801 verifyFormat("bool a = true, b = false;");
3802
Daniel Jasper2e603772013-01-29 11:21:01 +00003803 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +00003804 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
Daniel Jasper2e603772013-01-29 11:21:01 +00003805 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
Daniel Jasper37911302013-04-02 14:33:13 +00003806 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);");
Daniel Jasper2e603772013-01-29 11:21:01 +00003807 verifyFormat(
Daniel Jasper7d812812013-02-21 15:00:29 +00003808 "bool aaaaaaaaaaaaaaaaaaaaa =\n"
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +00003809 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
Daniel Jasper7d812812013-02-21 15:00:29 +00003810 " d = e && f;");
Daniel Jasperadc0f092013-04-05 09:38:50 +00003811 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
3812 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;");
3813 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
3814 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;");
3815 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
3816 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;");
3817 // FIXME: If multiple variables are defined, the "*" needs to move to the new
3818 // line. Also fix indent for breaking after the type, this looks bad.
Manuel Klimeka9a7f102013-06-21 17:25:42 +00003819 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
Daniel Jasper53e72cd2013-05-06 08:27:33 +00003820 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00003821 " *b = bbbbbbbbbbbbbbbbbbb;",
3822 getGoogleStyle());
Daniel Jasper2e603772013-01-29 11:21:01 +00003823
Daniel Jasperadc0f092013-04-05 09:38:50 +00003824 // Not ideal, but pointer-with-type does not allow much here.
3825 verifyGoogleFormat(
3826 "aaaaaaaaa* a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
3827 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;");
Daniel Jasper2e603772013-01-29 11:21:01 +00003828}
3829
Nico Weber7d37b8b2013-01-12 01:28:06 +00003830TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
3831 verifyFormat("arr[foo ? bar : baz];");
3832 verifyFormat("f()[foo ? bar : baz];");
3833 verifyFormat("(a + b)[foo ? bar : baz];");
3834 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
3835}
3836
Daniel Jasperbac016b2012-12-03 18:12:45 +00003837TEST_F(FormatTest, AlignsStringLiterals) {
3838 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
3839 " \"short literal\");");
3840 verifyFormat(
3841 "looooooooooooooooooooooooongFunction(\n"
3842 " \"short literal\"\n"
3843 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003844 verifyFormat("someFunction(\"Always break between multi-line\"\n"
3845 " \" string literals\",\n"
3846 " and, other, parameters);");
Manuel Klimekb56b6d12013-02-20 15:25:48 +00003847 EXPECT_EQ("fun + \"1243\" /* comment */\n"
3848 " \"5678\";",
3849 format("fun + \"1243\" /* comment */\n"
3850 " \"5678\";",
3851 getLLVMStyleWithColumns(28)));
3852 EXPECT_EQ(
3853 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
3854 " \"aaaaaaaaaaaaaaaaaaaaa\"\n"
3855 " \"aaaaaaaaaaaaaaaa\";",
3856 format("aaaaaa ="
3857 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
3858 "aaaaaaaaaaaaaaaaaaaaa\" "
3859 "\"aaaaaaaaaaaaaaaa\";"));
Manuel Klimeke9a62262013-02-20 15:32:58 +00003860 verifyFormat("a = a + \"a\"\n"
3861 " \"a\"\n"
3862 " \"a\";");
Daniel Jasper9a2f8d02013-05-16 04:26:02 +00003863 verifyFormat("f(\"a\", \"b\"\n"
3864 " \"c\");");
Daniel Jasper3a204412013-02-23 07:46:38 +00003865
3866 verifyFormat(
3867 "#define LL_FORMAT \"ll\"\n"
3868 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
3869 " \"d, ddddddddd: %\" LL_FORMAT \"d\");");
Daniel Jasper27c7f542013-05-13 20:50:15 +00003870
3871 verifyFormat("#define A(X) \\\n"
3872 " \"aaaaa\" #X \"bbbbbb\" \\\n"
3873 " \"ccccc\"",
3874 getLLVMStyleWithColumns(23));
3875 verifyFormat("#define A \"def\"\n"
3876 "f(\"abc\" A \"ghi\"\n"
3877 " \"jkl\");");
Stephen Hines651f13c2014-04-23 16:59:28 -07003878
3879 verifyFormat("f(L\"a\"\n"
3880 " L\"b\")");
3881 verifyFormat("#define A(X) \\\n"
3882 " L\"aaaaa\" #X L\"bbbbbb\" \\\n"
3883 " L\"ccccc\"",
3884 getLLVMStyleWithColumns(25));
Daniel Jasperbac016b2012-12-03 18:12:45 +00003885}
3886
Alexander Kornienko56312022013-07-04 12:02:44 +00003887TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) {
3888 FormatStyle NoBreak = getLLVMStyle();
3889 NoBreak.AlwaysBreakBeforeMultilineStrings = false;
3890 FormatStyle Break = getLLVMStyle();
3891 Break.AlwaysBreakBeforeMultilineStrings = true;
Daniel Jasper215c57f2013-07-17 15:38:19 +00003892 verifyFormat("aaaa = \"bbbb\"\n"
3893 " \"cccc\";",
3894 NoBreak);
3895 verifyFormat("aaaa =\n"
3896 " \"bbbb\"\n"
3897 " \"cccc\";",
3898 Break);
3899 verifyFormat("aaaa(\"bbbb\"\n"
3900 " \"cccc\");",
3901 NoBreak);
3902 verifyFormat("aaaa(\n"
3903 " \"bbbb\"\n"
3904 " \"cccc\");",
3905 Break);
3906 verifyFormat("aaaa(qqq, \"bbbb\"\n"
3907 " \"cccc\");",
3908 NoBreak);
3909 verifyFormat("aaaa(qqq,\n"
3910 " \"bbbb\"\n"
3911 " \"cccc\");",
3912 Break);
Stephen Hines651f13c2014-04-23 16:59:28 -07003913 verifyFormat("aaaa(qqq,\n"
3914 " L\"bbbb\"\n"
3915 " L\"cccc\");",
3916 Break);
Daniel Jasper215c57f2013-07-17 15:38:19 +00003917
3918 // Don't break if there is no column gain.
3919 verifyFormat("f(\"aaaa\"\n"
3920 " \"bbbb\");",
3921 Break);
3922
3923 // Treat literals with escaped newlines like multi-line string literals.
Alexander Kornienko10c26b22013-07-16 21:06:13 +00003924 EXPECT_EQ("x = \"a\\\n"
3925 "b\\\n"
3926 "c\";",
3927 format("x = \"a\\\n"
3928 "b\\\n"
3929 "c\";",
3930 NoBreak));
3931 EXPECT_EQ("x =\n"
3932 " \"a\\\n"
3933 "b\\\n"
3934 "c\";",
3935 format("x = \"a\\\n"
3936 "b\\\n"
3937 "c\";",
3938 Break));
Daniel Jaspera7856d02013-11-09 03:08:25 +00003939
3940 // Exempt ObjC strings for now.
3941 EXPECT_EQ("NSString *const kString = @\"aaaa\"\n"
3942 " \"bbbb\";",
3943 format("NSString *const kString = @\"aaaa\"\n"
3944 "\"bbbb\";",
3945 Break));
Alexander Kornienko56312022013-07-04 12:02:44 +00003946}
3947
Alexander Kornienko15757312012-12-06 18:03:27 +00003948TEST_F(FormatTest, AlignsPipes) {
3949 verifyFormat(
3950 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3951 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3952 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
3953 verifyFormat(
3954 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
3955 " << aaaaaaaaaaaaaaaaaaaa;");
3956 verifyFormat(
3957 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3958 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
3959 verifyFormat(
3960 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
3961 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
3962 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";");
3963 verifyFormat(
3964 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3965 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3966 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasperfa543ac2013-02-04 07:34:48 +00003967
3968 verifyFormat("return out << \"somepacket = {\\n\"\n"
Manuel Klimekae76f7f2013-10-11 21:25:45 +00003969 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
3970 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
3971 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
3972 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
Daniel Jasperfa543ac2013-02-04 07:34:48 +00003973 " << \"}\";");
Daniel Jasper4e8a7b42013-02-06 21:04:05 +00003974
Daniel Jasper3e12e872013-07-15 14:12:30 +00003975 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
3976 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
3977 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;");
Daniel Jasper4e8a7b42013-02-06 21:04:05 +00003978 verifyFormat(
3979 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
3980 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
3981 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
3982 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
3983 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;");
Daniel Jasperbfa1edd2013-03-14 14:00:17 +00003984 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
3985 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
Daniel Jasper9637dda2013-07-15 14:33:14 +00003986 verifyFormat(
3987 "void f() {\n"
3988 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n"
3989 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
3990 "}");
Daniel Jasper37911302013-04-02 14:33:13 +00003991
Daniel Jasperfaec47b2013-07-11 20:41:21 +00003992 // Breaking before the first "<<" is generally not desirable.
3993 verifyFormat(
3994 "llvm::errs()\n"
3995 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3996 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3997 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3998 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
3999 getLLVMStyleWithColumns(70));
4000 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
4001 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4002 " << \"aaaaaaaaaaaaaaaaaaa: \"\n"
4003 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4004 " << \"aaaaaaaaaaaaaaaaaaa: \"\n"
4005 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4006 getLLVMStyleWithColumns(70));
4007
Daniel Jasperb349a782013-08-12 12:58:05 +00004008 // But sometimes, breaking before the first "<<" is desirable.
Stephen Hines651f13c2014-04-23 16:59:28 -07004009 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
4010 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);");
Daniel Jaspera0740f52013-07-12 15:14:05 +00004011 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
4012 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4013 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasperb349a782013-08-12 12:58:05 +00004014 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
4015 " << BEF << IsTemplate << Description << E->getType();");
Daniel Jaspera0740f52013-07-12 15:14:05 +00004016
Daniel Jasper37911302013-04-02 14:33:13 +00004017 verifyFormat(
4018 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4019 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper20376982013-09-29 12:02:57 +00004020
4021 // Incomplete string literal.
4022 EXPECT_EQ("llvm::errs() << \"\n"
4023 " << a;",
4024 format("llvm::errs() << \"\n<<a;"));
Stephen Hines651f13c2014-04-23 16:59:28 -07004025
4026 verifyFormat("void f() {\n"
4027 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n"
4028 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n"
4029 "}");
Alexander Kornienko15757312012-12-06 18:03:27 +00004030}
4031
Daniel Jasperbac016b2012-12-03 18:12:45 +00004032TEST_F(FormatTest, UnderstandsEquals) {
4033 verifyFormat(
4034 "aaaaaaaaaaaaaaaaa =\n"
4035 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
4036 verifyFormat(
4037 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004038 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasperbac016b2012-12-03 18:12:45 +00004039 verifyFormat(
4040 "if (a) {\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +00004041 " f();\n"
Daniel Jasperbac016b2012-12-03 18:12:45 +00004042 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004043 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
4044 "}");
Daniel Jasperbac016b2012-12-03 18:12:45 +00004045
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004046 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
4047 " 100000000 + 10000000) {\n}");
Daniel Jasperbac016b2012-12-03 18:12:45 +00004048}
4049
Daniel Jasper9a0b4942012-12-17 14:34:14 +00004050TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
Daniel Jasper1321eb52012-12-18 21:05:13 +00004051 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
4052 " .looooooooooooooooooooooooooooooooooooooongFunction();");
Daniel Jasper9a0b4942012-12-17 14:34:14 +00004053
Daniel Jasper1321eb52012-12-18 21:05:13 +00004054 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
4055 " ->looooooooooooooooooooooooooooooooooooooongFunction();");
Daniel Jasper9a0b4942012-12-17 14:34:14 +00004056
4057 verifyFormat(
4058 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
4059 " Parameter2);");
4060
4061 verifyFormat(
4062 "ShortObject->shortFunction(\n"
4063 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
4064 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);");
4065
4066 verifyFormat("loooooooooooooongFunction(\n"
4067 " LoooooooooooooongObject->looooooooooooooooongFunction());");
4068
4069 verifyFormat(
4070 "function(LoooooooooooooooooooooooooooooooooooongObject\n"
4071 " ->loooooooooooooooooooooooooooooooooooooooongFunction());");
4072
Daniel Jasperfc759082013-02-14 14:26:07 +00004073 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
4074 " .WillRepeatedly(Return(SomeValue));");
Stephen Hines651f13c2014-04-23 16:59:28 -07004075 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n"
4076 " ccccccccccccccccccccccc);");
Daniel Jasper259a0382013-05-27 11:50:16 +00004077 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4078 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa).aaaaa(aaaaa),\n"
4079 " aaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper59875ac2013-11-07 17:43:07 +00004080 verifyFormat("void f() {\n"
4081 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4082 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n"
4083 "}");
Daniel Jasper3af59ce2013-03-15 14:57:30 +00004084 verifyFormat(
4085 "aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4086 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
Daniel Jasper88cc5622013-07-08 14:25:23 +00004087 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4088 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4089 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jasper37911302013-04-02 14:33:13 +00004090 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4091 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4092 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4093 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
4094 "}");
Daniel Jasperfc759082013-02-14 14:26:07 +00004095
Daniel Jasper46a46a22013-01-07 07:13:20 +00004096 // Here, it is not necessary to wrap at "." or "->".
Daniel Jasper1321eb52012-12-18 21:05:13 +00004097 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004098 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasper46a46a22013-01-07 07:13:20 +00004099 verifyFormat(
4100 "aaaaaaaaaaa->aaaaaaaaa(\n"
4101 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4102 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
Daniel Jasper9fc56f22013-02-14 15:01:34 +00004103
4104 verifyFormat(
4105 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4106 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
Daniel Jasper8d0d19a2013-03-13 15:37:48 +00004107 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
4108 " aaaaaaaaa()->aaaaaa()->aaaaa());");
4109 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
4110 " aaaaaaaaa()->aaaaaa()->aaaaa());");
Daniel Jasperfaab0d32013-02-27 09:47:53 +00004111
Daniel Jasper3af59ce2013-03-15 14:57:30 +00004112 // FIXME: Should we break before .a()?
4113 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4114 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa).a();");
4115
Daniel Jasperfaab0d32013-02-27 09:47:53 +00004116 FormatStyle NoBinPacking = getLLVMStyle();
4117 NoBinPacking.BinPackParameters = false;
4118 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
4119 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
4120 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
4121 " aaaaaaaaaaaaaaaaaaa,\n"
4122 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4123 NoBinPacking);
Daniel Jasperb1491792013-07-09 11:57:27 +00004124
4125 // If there is a subsequent call, change to hanging indentation.
4126 verifyFormat(
4127 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4128 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n"
4129 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
4130 verifyFormat(
4131 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4132 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));");
Stephen Hines651f13c2014-04-23 16:59:28 -07004133 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4134 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4135 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
4136 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4137 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4138 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
Daniel Jasper9a0b4942012-12-17 14:34:14 +00004139}
4140
Daniel Jasper9a64fb52013-01-02 15:08:56 +00004141TEST_F(FormatTest, WrapsTemplateDeclarations) {
4142 verifyFormat("template <typename T>\n"
4143 "virtual void loooooooooooongFunction(int Param1, int Param2);");
Daniel Jasper48c099f2013-09-27 07:49:08 +00004144 verifyFormat("template <typename T>\n"
4145 "// T should be one of {A, B}.\n"
4146 "virtual void loooooooooooongFunction(int Param1, int Param2);");
Daniel Jasper9a64fb52013-01-02 15:08:56 +00004147 verifyFormat(
Daniel Jasperc79afda2013-01-18 10:56:38 +00004148 "template <typename T>\n"
Daniel Jasper29f123b2013-02-08 15:28:42 +00004149 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;");
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004150 verifyFormat("template <typename T>\n"
4151 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
4152 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);");
Daniel Jasper9a64fb52013-01-02 15:08:56 +00004153 verifyFormat(
4154 "template <typename T>\n"
4155 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
4156 " int Paaaaaaaaaaaaaaaaaaaaram2);");
Daniel Jasper5eda31e2013-01-02 18:30:06 +00004157 verifyFormat(
4158 "template <typename T>\n"
4159 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
4160 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
4161 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperd64f7382013-01-09 09:50:48 +00004162 verifyFormat("template <typename T>\n"
4163 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +00004164 " int aaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper3fc0bb72013-01-09 10:40:23 +00004165 verifyFormat(
4166 "template <typename T1, typename T2 = char, typename T3 = char,\n"
4167 " typename T4 = char>\n"
4168 "void f();");
Stephen Hines651f13c2014-04-23 16:59:28 -07004169 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n"
4170 " template <typename> class cccccccccccccccccccccc,\n"
4171 " typename ddddddddddddd>\n"
4172 "class C {};");
Daniel Jasper3499dda2013-01-25 15:43:32 +00004173 verifyFormat(
4174 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
4175 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper01786732013-02-04 07:21:18 +00004176
Daniel Jasper59875ac2013-11-07 17:43:07 +00004177 verifyFormat("void f() {\n"
4178 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
4179 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n"
4180 "}");
Daniel Jasperbbc87762013-05-29 12:07:31 +00004181
Daniel Jasper8893b8a2013-05-31 14:56:20 +00004182 verifyFormat("template <typename T> class C {};");
Daniel Jasperbbc87762013-05-29 12:07:31 +00004183 verifyFormat("template <typename T> void f();");
4184 verifyFormat("template <typename T> void f() {}");
Daniel Jasper07ca5472013-07-05 09:14:35 +00004185 verifyFormat(
4186 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
4187 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4188 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
4189 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
4190 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4191 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
4192 " bbbbbbbbbbbbbbbbbbbbbbbb);",
4193 getLLVMStyleWithColumns(72));
Daniel Jasperd3d9e0f2013-09-14 08:13:22 +00004194
4195 FormatStyle AlwaysBreak = getLLVMStyle();
4196 AlwaysBreak.AlwaysBreakTemplateDeclarations = true;
4197 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
4198 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
4199 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
4200 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4201 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
4202 " ccccccccccccccccccccccccccccccccccccccccccccccc);");
4203 verifyFormat("template <template <typename> class Fooooooo,\n"
4204 " template <typename> class Baaaaaaar>\n"
4205 "struct C {};",
4206 AlwaysBreak);
Daniel Jasper6e7f1932013-10-09 15:06:17 +00004207 verifyFormat("template <typename T> // T can be A, B or C.\n"
4208 "struct C {};",
4209 AlwaysBreak);
Daniel Jasper9a64fb52013-01-02 15:08:56 +00004210}
4211
Daniel Jasper63f00362013-01-25 10:57:27 +00004212TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
4213 verifyFormat(
4214 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
4215 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
4216 verifyFormat(
4217 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
4218 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4219 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
4220
Daniel Jasperb2f063a2013-05-08 10:00:18 +00004221 // FIXME: Should we have the extra indent after the second break?
Daniel Jasper63f00362013-01-25 10:57:27 +00004222 verifyFormat(
4223 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
4224 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
Daniel Jasperb2f063a2013-05-08 10:00:18 +00004225 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper63f00362013-01-25 10:57:27 +00004226
Daniel Jasper63f00362013-01-25 10:57:27 +00004227 verifyFormat(
4228 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
Daniel Jasper5f2173e2013-01-28 07:43:15 +00004229 " cccccccccccccccccccccccccccccccccccccccccccccc());");
Daniel Jasper63f00362013-01-25 10:57:27 +00004230
4231 // Breaking at nested name specifiers is generally not desirable.
4232 verifyFormat(
4233 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4234 " aaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperbfe6fd42013-01-28 12:45:14 +00004235
4236 verifyFormat(
4237 "aaaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
4238 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4239 " aaaaaaaaaaaaaaaaaaaaa);",
4240 getLLVMStyleWithColumns(74));
Daniel Jasper37911302013-04-02 14:33:13 +00004241
4242 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
4243 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4244 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper63f00362013-01-25 10:57:27 +00004245}
4246
Daniel Jasperbac016b2012-12-03 18:12:45 +00004247TEST_F(FormatTest, UnderstandsTemplateParameters) {
4248 verifyFormat("A<int> a;");
Stephen Hines651f13c2014-04-23 16:59:28 -07004249 verifyFormat("A<A<A<int>>> a;");
Daniel Jasperbac016b2012-12-03 18:12:45 +00004250 verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
4251 verifyFormat("bool x = a < 1 || 2 > a;");
4252 verifyFormat("bool x = 5 < f<int>();");
4253 verifyFormat("bool x = f<int>() > 5;");
4254 verifyFormat("bool x = 5 < a<int>::x;");
4255 verifyFormat("bool x = a < 4 ? a > 2 : false;");
4256 verifyFormat("bool x = f() ? a < 2 : a > 2;");
4257
4258 verifyGoogleFormat("A<A<int>> a;");
4259 verifyGoogleFormat("A<A<A<int>>> a;");
4260 verifyGoogleFormat("A<A<A<A<int>>>> a;");
Daniel Jasper8ff690a2013-02-06 14:22:40 +00004261 verifyGoogleFormat("A<A<int> > a;");
4262 verifyGoogleFormat("A<A<A<int> > > a;");
4263 verifyGoogleFormat("A<A<A<A<int> > > > a;");
Daniel Jasper78a4e612013-10-12 05:16:06 +00004264 verifyGoogleFormat("A<::A<int>> a;");
4265 verifyGoogleFormat("A<::A> a;");
4266 verifyGoogleFormat("A< ::A> a;");
4267 verifyGoogleFormat("A< ::A<int> > a;");
Daniel Jasper8ff690a2013-02-06 14:22:40 +00004268 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
4269 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
Daniel Jasper78a4e612013-10-12 05:16:06 +00004270 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle()));
4271 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle()));
Daniel Jasperbac016b2012-12-03 18:12:45 +00004272
4273 verifyFormat("test >> a >> b;");
4274 verifyFormat("test << a >> b;");
4275
4276 verifyFormat("f<int>();");
Manuel Klimek36fab8d2013-01-10 13:24:24 +00004277 verifyFormat("template <typename T> void f() {}");
Daniel Jasper0348be02013-06-01 18:56:00 +00004278
4279 // Not template parameters.
4280 verifyFormat("return a < b && c > d;");
4281 verifyFormat("void f() {\n"
4282 " while (a < b && c > d) {\n"
4283 " }\n"
4284 "}");
Daniel Jasper0236dd02013-07-30 22:37:19 +00004285 verifyFormat("template <typename... Types>\n"
4286 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}");
Daniel Jasper26356cc2013-09-17 08:15:46 +00004287
4288 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4289 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);",
4290 getLLVMStyleWithColumns(60));
Daniel Jasperbac016b2012-12-03 18:12:45 +00004291}
4292
Daniel Jasper807809c2013-02-28 09:21:10 +00004293TEST_F(FormatTest, UnderstandsBinaryOperators) {
4294 verifyFormat("COMPARE(a, ==, b);");
Alexander Kornienko54a38bd2013-03-20 16:41:56 +00004295}
4296
4297TEST_F(FormatTest, UnderstandsPointersToMembers) {
4298 verifyFormat("int A::*x;");
Daniel Jasper395228f2013-05-08 14:58:20 +00004299 verifyFormat("int (S::*func)(void *);");
Daniel Jasper431f5912013-05-28 08:33:00 +00004300 verifyFormat("void f() { int (S::*func)(void *); }");
Daniel Jasper4b7b1042013-05-08 15:06:58 +00004301 verifyFormat("typedef bool *(Class::*Member)() const;");
Daniel Jasper395228f2013-05-08 14:58:20 +00004302 verifyFormat("void f() {\n"
4303 " (a->*f)();\n"
4304 " a->*x;\n"
4305 " (a.*f)();\n"
4306 " ((*a).*f)();\n"
4307 " a.*x;\n"
4308 "}");
Daniel Jasper5e2169f2013-07-18 14:46:07 +00004309 verifyFormat("void f() {\n"
4310 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
4311 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n"
4312 "}");
Daniel Jasper4b7b1042013-05-08 15:06:58 +00004313 FormatStyle Style = getLLVMStyle();
4314 Style.PointerBindsToType = true;
4315 verifyFormat("typedef bool* (Class::*Member)() const;", Style);
Daniel Jasper807809c2013-02-28 09:21:10 +00004316}
4317
Daniel Jasper98e6b4a2012-12-21 09:41:31 +00004318TEST_F(FormatTest, UnderstandsUnaryOperators) {
Daniel Jasperbac016b2012-12-03 18:12:45 +00004319 verifyFormat("int a = -2;");
Daniel Jasper8822d3a2012-12-04 13:02:32 +00004320 verifyFormat("f(-1, -2, -3);");
4321 verifyFormat("a[-1] = 5;");
4322 verifyFormat("int a = 5 + -2;");
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004323 verifyFormat("if (i == -1) {\n}");
4324 verifyFormat("if (i != -1) {\n}");
4325 verifyFormat("if (i > -1) {\n}");
4326 verifyFormat("if (i < -1) {\n}");
Daniel Jasperd56a7372012-12-06 13:16:39 +00004327 verifyFormat("++(a->f());");
4328 verifyFormat("--(a->f());");
Daniel Jasper4abbb532013-01-14 12:18:19 +00004329 verifyFormat("(a->f())++;");
4330 verifyFormat("a[42]++;");
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004331 verifyFormat("if (!(a->f())) {\n}");
Daniel Jasper98e6b4a2012-12-21 09:41:31 +00004332
4333 verifyFormat("a-- > b;");
4334 verifyFormat("b ? -a : c;");
4335 verifyFormat("n * sizeof char16;");
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00004336 verifyFormat("n * alignof char16;", getGoogleStyle());
Daniel Jasper98e6b4a2012-12-21 09:41:31 +00004337 verifyFormat("sizeof(char);");
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00004338 verifyFormat("alignof(char);", getGoogleStyle());
Daniel Jasper1f0754b2013-01-02 15:26:16 +00004339
4340 verifyFormat("return -1;");
4341 verifyFormat("switch (a) {\n"
4342 "case -1:\n"
4343 " break;\n"
4344 "}");
Daniel Jasperb5985422013-03-22 10:44:43 +00004345 verifyFormat("#define X -1");
4346 verifyFormat("#define X -kConstant");
Nico Webercc191d12013-01-12 05:41:23 +00004347
Stephen Hines651f13c2014-04-23 16:59:28 -07004348 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};");
4349 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};");
Daniel Jasperb369c2c2013-01-15 14:27:39 +00004350
4351 verifyFormat("int a = /* confusing comment */ -1;");
4352 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case.
4353 verifyFormat("int a = i /* confusing comment */++;");
Daniel Jasperbac016b2012-12-03 18:12:45 +00004354}
4355
Stephen Hines651f13c2014-04-23 16:59:28 -07004356TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) {
Daniel Jasper34f3d052013-08-21 08:39:01 +00004357 verifyFormat("if (!aaaaaaaaaa( // break\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07004358 " aaaaa)) {\n"
Daniel Jasper34f3d052013-08-21 08:39:01 +00004359 "}");
4360 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07004361 " aaaaa));");
Daniel Jasper3618e6f2013-08-23 15:14:03 +00004362 verifyFormat("*aaa = aaaaaaa( // break\n"
4363 " bbbbbb);");
Daniel Jasper34f3d052013-08-21 08:39:01 +00004364}
4365
Daniel Jasper332c6772013-08-26 08:10:17 +00004366TEST_F(FormatTest, UnderstandsOverloadedOperators) {
Daniel Jasperf6aef6a2012-12-24 10:56:04 +00004367 verifyFormat("bool operator<();");
4368 verifyFormat("bool operator>();");
4369 verifyFormat("bool operator=();");
4370 verifyFormat("bool operator==();");
4371 verifyFormat("bool operator!=();");
4372 verifyFormat("int operator+();");
4373 verifyFormat("int operator++();");
4374 verifyFormat("bool operator();");
4375 verifyFormat("bool operator()();");
4376 verifyFormat("bool operator[]();");
4377 verifyFormat("operator bool();");
Daniel Jasper2b4c9242013-02-11 08:01:18 +00004378 verifyFormat("operator int();");
4379 verifyFormat("operator void *();");
Daniel Jasperf6aef6a2012-12-24 10:56:04 +00004380 verifyFormat("operator SomeType<int>();");
Daniel Jasper2b4c9242013-02-11 08:01:18 +00004381 verifyFormat("operator SomeType<int, int>();");
Stephen Hines651f13c2014-04-23 16:59:28 -07004382 verifyFormat("operator SomeType<SomeType<int>>();");
Daniel Jasperf6aef6a2012-12-24 10:56:04 +00004383 verifyFormat("void *operator new(std::size_t size);");
4384 verifyFormat("void *operator new[](std::size_t size);");
4385 verifyFormat("void operator delete(void *ptr);");
4386 verifyFormat("void operator delete[](void *ptr);");
Daniel Jasper6ea933c2013-05-10 07:59:58 +00004387 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
4388 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);");
Daniel Jasper2b4c9242013-02-11 08:01:18 +00004389
Daniel Jasperdc2efa12013-02-15 19:24:08 +00004390 verifyFormat(
4391 "ostream &operator<<(ostream &OutputStream,\n"
4392 " SomeReallyLongType WithSomeReallyLongValue);");
Daniel Jasper27b91cc2013-04-05 17:21:59 +00004393 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
4394 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
4395 " return left.group < right.group;\n"
4396 "}");
Daniel Jasper2eb23b72013-04-11 08:48:20 +00004397 verifyFormat("SomeType &operator=(const SomeType &S);");
Daniel Jasperdc2efa12013-02-15 19:24:08 +00004398
Daniel Jasper2b4c9242013-02-11 08:01:18 +00004399 verifyGoogleFormat("operator void*();");
4400 verifyGoogleFormat("operator SomeType<SomeType<int>>();");
Daniel Jasper52af9442013-10-29 12:24:23 +00004401 verifyGoogleFormat("operator ::A();");
Daniel Jasper174f60f2013-09-02 09:20:39 +00004402
4403 verifyFormat("using A::operator+;");
Stephen Hines651f13c2014-04-23 16:59:28 -07004404
4405 verifyFormat("Deleted &operator=(const Deleted &)& = default;");
4406 verifyFormat("Deleted &operator=(const Deleted &)&& = delete;");
4407 verifyGoogleFormat("Deleted& operator=(const Deleted&)& = default;");
4408 verifyGoogleFormat("Deleted& operator=(const Deleted&)&& = delete;");
Daniel Jasperbac016b2012-12-03 18:12:45 +00004409}
4410
Daniel Jasper088dab52013-01-11 16:09:04 +00004411TEST_F(FormatTest, UnderstandsNewAndDelete) {
Daniel Jasper37eff832013-02-23 08:07:18 +00004412 verifyFormat("void f() {\n"
4413 " A *a = new A;\n"
4414 " A *a = new (placement) A;\n"
4415 " delete a;\n"
4416 " delete (A *)a;\n"
4417 "}");
Daniel Jasper088dab52013-01-11 16:09:04 +00004418}
4419
Daniel Jasper5d334402013-01-02 08:57:10 +00004420TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
Manuel Klimek36fab8d2013-01-10 13:24:24 +00004421 verifyFormat("int *f(int *a) {}");
Manuel Klimek36fab8d2013-01-10 13:24:24 +00004422 verifyFormat("int main(int argc, char **argv) {}");
Daniel Jasperd0f349b2013-02-18 12:44:35 +00004423 verifyFormat("Test::Test(int b) : a(b * b) {}");
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00004424 verifyIndependentOfContext("f(a, *a);");
Daniel Jasper8a5d7cd2013-03-01 17:13:29 +00004425 verifyFormat("void g() { f(*a); }");
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00004426 verifyIndependentOfContext("int a = b * 10;");
4427 verifyIndependentOfContext("int a = 10 * b;");
4428 verifyIndependentOfContext("int a = b * c;");
4429 verifyIndependentOfContext("int a += b * c;");
4430 verifyIndependentOfContext("int a -= b * c;");
4431 verifyIndependentOfContext("int a *= b * c;");
4432 verifyIndependentOfContext("int a /= b * c;");
4433 verifyIndependentOfContext("int a = *b;");
4434 verifyIndependentOfContext("int a = *b * c;");
4435 verifyIndependentOfContext("int a = b * *c;");
4436 verifyIndependentOfContext("return 10 * b;");
4437 verifyIndependentOfContext("return *b * *c;");
4438 verifyIndependentOfContext("return a & ~b;");
4439 verifyIndependentOfContext("f(b ? *c : *d);");
4440 verifyIndependentOfContext("int a = b ? *c : *d;");
4441 verifyIndependentOfContext("*b = a;");
4442 verifyIndependentOfContext("a * ~b;");
4443 verifyIndependentOfContext("a * !b;");
4444 verifyIndependentOfContext("a * +b;");
4445 verifyIndependentOfContext("a * -b;");
4446 verifyIndependentOfContext("a * ++b;");
4447 verifyIndependentOfContext("a * --b;");
4448 verifyIndependentOfContext("a[4] * b;");
Daniel Jasper9c65b062013-02-27 11:43:50 +00004449 verifyIndependentOfContext("a[a * a] = 1;");
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00004450 verifyIndependentOfContext("f() * b;");
4451 verifyIndependentOfContext("a * [self dostuff];");
Daniel Jasper81d2d382013-04-01 17:13:26 +00004452 verifyIndependentOfContext("int x = a * (a + b);");
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00004453 verifyIndependentOfContext("(a *)(a + b);");
4454 verifyIndependentOfContext("int *pa = (int *)&a;");
Nico Weber95e8e462013-02-12 16:17:07 +00004455 verifyIndependentOfContext("return sizeof(int **);");
4456 verifyIndependentOfContext("return sizeof(int ******);");
4457 verifyIndependentOfContext("return (int **&)a;");
Daniel Jasper3ff4a2f2013-05-28 15:27:10 +00004458 verifyIndependentOfContext("f((*PointerToArray)[10]);");
Daniel Jasper8a5d7cd2013-03-01 17:13:29 +00004459 verifyFormat("void f(Type (*parameter)[10]) {}");
Nico Weber95e8e462013-02-12 16:17:07 +00004460 verifyGoogleFormat("return sizeof(int**);");
4461 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);");
4462 verifyGoogleFormat("Type** A = static_cast<Type**>(P);");
Daniel Jasper567dcf92013-09-05 09:29:45 +00004463 verifyFormat("auto a = [](int **&, int ***) {};");
Daniel Jasper363193b2013-10-20 18:15:30 +00004464 verifyFormat("auto PointerBinding = [](const char *S) {};");
Daniel Jasperdb8afe42013-09-10 10:26:38 +00004465 verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
Stephen Hines651f13c2014-04-23 16:59:28 -07004466 verifyIndependentOfContext("typedef void (*f)(int *a);");
Daniel Jasperc74e2792012-12-07 09:52:15 +00004467
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00004468 verifyIndependentOfContext("InvalidRegions[*R] = 0;");
Daniel Jasper9bb0d282013-01-04 20:46:38 +00004469
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00004470 verifyIndependentOfContext("A<int *> a;");
4471 verifyIndependentOfContext("A<int **> a;");
4472 verifyIndependentOfContext("A<int *, int *> a;");
Daniel Jasper4e778092013-02-06 10:05:46 +00004473 verifyIndependentOfContext(
4474 "const char *const p = reinterpret_cast<const char *const>(q);");
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00004475 verifyIndependentOfContext("A<int **, int **> a;");
Daniel Jasper6b5ba8b2013-02-06 10:57:42 +00004476 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);");
Daniel Jasperd3cf17b2013-03-14 10:50:25 +00004477 verifyFormat("for (char **a = b; *a; ++a) {\n}");
Daniel Jasper16a69ef2013-05-03 14:41:24 +00004478 verifyFormat("for (; a && b;) {\n}");
Daniel Jasper8b39c662012-12-10 18:59:13 +00004479
Daniel Jasper2db356d2013-01-08 20:03:18 +00004480 verifyFormat(
4481 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4482 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
4483
Manuel Klimek36fab8d2013-01-10 13:24:24 +00004484 verifyGoogleFormat("int main(int argc, char** argv) {}");
Daniel Jasper8b39c662012-12-10 18:59:13 +00004485 verifyGoogleFormat("A<int*> a;");
4486 verifyGoogleFormat("A<int**> a;");
4487 verifyGoogleFormat("A<int*, int*> a;");
4488 verifyGoogleFormat("A<int**, int**> a;");
Daniel Jasper5d334402013-01-02 08:57:10 +00004489 verifyGoogleFormat("f(b ? *c : *d);");
4490 verifyGoogleFormat("int a = b ? *c : *d;");
Daniel Jasper48bd7b72013-01-16 16:04:06 +00004491 verifyGoogleFormat("Type* t = **x;");
4492 verifyGoogleFormat("Type* t = *++*x;");
4493 verifyGoogleFormat("*++*x;");
4494 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);");
4495 verifyGoogleFormat("Type* t = x++ * y;");
Daniel Jasper4e778092013-02-06 10:05:46 +00004496 verifyGoogleFormat(
4497 "const char* const p = reinterpret_cast<const char* const>(q);");
Manuel Klimek1b6f4bd2013-01-14 10:58:01 +00004498
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00004499 verifyIndependentOfContext("a = *(x + y);");
4500 verifyIndependentOfContext("a = &(x + y);");
4501 verifyIndependentOfContext("*(x + y).call();");
4502 verifyIndependentOfContext("&(x + y)->call();");
Daniel Jasper8a5d7cd2013-03-01 17:13:29 +00004503 verifyFormat("void f() { &(*I).first; }");
Daniel Jasperb369c2c2013-01-15 14:27:39 +00004504
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00004505 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
Daniel Jasperb369c2c2013-01-15 14:27:39 +00004506 verifyFormat(
Stephen Hines651f13c2014-04-23 16:59:28 -07004507 "int *MyValues = {*A, // Operator detection might be confused by the '{'\n"
4508 " *BB // Operator detection might be confused by previous comment\n"
Daniel Jasperb369c2c2013-01-15 14:27:39 +00004509 "};");
Nico Weber5096a442013-01-17 17:17:19 +00004510
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00004511 verifyIndependentOfContext("if (int *a = &b)");
4512 verifyIndependentOfContext("if (int &a = *b)");
4513 verifyIndependentOfContext("if (a & b[i])");
4514 verifyIndependentOfContext("if (a::b::c::d & b[i])");
4515 verifyIndependentOfContext("if (*b[i])");
4516 verifyIndependentOfContext("if (int *a = (&b))");
4517 verifyIndependentOfContext("while (int *a = &b)");
Daniel Jasper65da8e92013-09-21 17:31:51 +00004518 verifyIndependentOfContext("size = sizeof *a;");
Daniel Jasper20d35832013-01-23 12:58:14 +00004519 verifyFormat("void f() {\n"
4520 " for (const int &v : Values) {\n"
4521 " }\n"
4522 "}");
Daniel Jasperd0f349b2013-02-18 12:44:35 +00004523 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
4524 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
Daniel Jasper7e274002013-09-11 20:37:10 +00004525 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}");
Daniel Jasperffee1712013-01-22 11:46:26 +00004526
Daniel Jasperf9504aa2013-11-07 19:56:07 +00004527 verifyFormat("#define A (!a * b)");
Daniel Jasper378d93d2013-05-13 07:14:40 +00004528 verifyFormat("#define MACRO \\\n"
4529 " int *i = a * b; \\\n"
4530 " void f(a *b);",
4531 getLLVMStyleWithColumns(19));
4532
Daniel Jasper6f21a982013-03-13 07:49:51 +00004533 verifyIndependentOfContext("A = new SomeType *[Length];");
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00004534 verifyIndependentOfContext("A = new SomeType *[Length]();");
Daniel Jasperd6104f62013-07-05 13:30:40 +00004535 verifyIndependentOfContext("T **t = new T *;");
4536 verifyIndependentOfContext("T **t = new T *();");
Daniel Jasperffee1712013-01-22 11:46:26 +00004537 verifyGoogleFormat("A = new SomeType* [Length]();");
Daniel Jasper6f21a982013-03-13 07:49:51 +00004538 verifyGoogleFormat("A = new SomeType* [Length];");
Daniel Jasperd6104f62013-07-05 13:30:40 +00004539 verifyGoogleFormat("T** t = new T*;");
4540 verifyGoogleFormat("T** t = new T*();");
Daniel Jasper378d93d2013-05-13 07:14:40 +00004541
Daniel Jasperdbef71e2013-05-07 14:17:18 +00004542 FormatStyle PointerLeft = getLLVMStyle();
4543 PointerLeft.PointerBindsToType = true;
4544 verifyFormat("delete *x;", PointerLeft);
Stephen Hines651f13c2014-04-23 16:59:28 -07004545 verifyFormat("STATIC_ASSERT((a & b) == 0);");
4546 verifyFormat("STATIC_ASSERT(0 == (a & b));");
4547 verifyFormat("template <bool a, bool b> "
4548 "typename t::if<x && y>::type f() {};");
4549 verifyFormat("template <int *y> f() {};");
4550 verifyFormat("vector<int *> v;");
4551 verifyFormat("vector<int *const> v;");
4552 verifyFormat("vector<int *const **const *> v;");
4553 verifyFormat("vector<int *volatile> v;");
4554 verifyFormat("vector<a * b> v;");
4555 verifyFormat("foo<b && false>();");
4556 verifyFormat("foo<b & 1>();");
4557
4558 verifyIndependentOfContext("MACRO(int *i);");
4559 verifyIndependentOfContext("MACRO(auto *a);");
4560 verifyIndependentOfContext("MACRO(const A *a);");
4561 // FIXME: Is there a way to make this work?
4562 // verifyIndependentOfContext("MACRO(A *a);");
4563
4564 // FIXME: We cannot handle this case yet; we might be able to figure out that
4565 // foo<x> d > v; doesn't make sense.
4566 verifyFormat("foo<a < b && c> d > v;");
Daniel Jasper8a5d7cd2013-03-01 17:13:29 +00004567}
Daniel Jasper8ff690a2013-02-06 14:22:40 +00004568
Daniel Jaspere0fa4c52013-07-17 20:25:02 +00004569TEST_F(FormatTest, UnderstandsAttributes) {
4570 verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
Stephen Hines651f13c2014-04-23 16:59:28 -07004571 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
4572 "aaaaaaaaaaaaaaaaaaaaaaa(int i);");
Daniel Jaspere0fa4c52013-07-17 20:25:02 +00004573}
4574
Daniel Jasperf0220182013-05-06 06:35:44 +00004575TEST_F(FormatTest, UnderstandsEllipsis) {
4576 verifyFormat("int printf(const char *fmt, ...);");
4577 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
Daniel Jasperc47d7f12013-07-01 09:47:25 +00004578 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}");
4579
4580 FormatStyle PointersLeft = getLLVMStyle();
4581 PointersLeft.PointerBindsToType = true;
4582 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft);
Daniel Jasperf0220182013-05-06 06:35:44 +00004583}
4584
Daniel Jasper8a5d7cd2013-03-01 17:13:29 +00004585TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
Daniel Jasper8ff690a2013-02-06 14:22:40 +00004586 EXPECT_EQ("int *a;\n"
4587 "int *a;\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004588 "int *a;",
4589 format("int *a;\n"
4590 "int* a;\n"
4591 "int *a;",
4592 getGoogleStyle()));
Daniel Jasper8ff690a2013-02-06 14:22:40 +00004593 EXPECT_EQ("int* a;\n"
4594 "int* a;\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004595 "int* a;",
4596 format("int* a;\n"
4597 "int* a;\n"
4598 "int *a;",
4599 getGoogleStyle()));
Daniel Jasper8ff690a2013-02-06 14:22:40 +00004600 EXPECT_EQ("int *a;\n"
4601 "int *a;\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004602 "int *a;",
4603 format("int *a;\n"
4604 "int * a;\n"
4605 "int * a;",
4606 getGoogleStyle()));
Daniel Jasperbac016b2012-12-03 18:12:45 +00004607}
4608
Alexander Kornienko3fd9ccd2013-03-12 16:28:18 +00004609TEST_F(FormatTest, UnderstandsRvalueReferences) {
4610 verifyFormat("int f(int &&a) {}");
4611 verifyFormat("int f(int a, char &&b) {}");
4612 verifyFormat("void f() { int &&a = b; }");
4613 verifyGoogleFormat("int f(int a, char&& b) {}");
4614 verifyGoogleFormat("void f() { int&& a = b; }");
4615
Daniel Jasper131884a2013-05-27 16:36:33 +00004616 verifyIndependentOfContext("A<int &&> a;");
4617 verifyIndependentOfContext("A<int &&, int &&> a;");
4618 verifyGoogleFormat("A<int&&> a;");
4619 verifyGoogleFormat("A<int&&, int&&> a;");
Daniel Jasperb7000ca2013-08-01 17:58:23 +00004620
4621 // Not rvalue references:
4622 verifyFormat("template <bool B, bool C> class A {\n"
4623 " static_assert(B && C, \"Something is wrong\");\n"
4624 "};");
Daniel Jasperb644dd62013-08-13 09:09:09 +00004625 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))");
4626 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))");
Alexander Kornienko3fd9ccd2013-03-12 16:28:18 +00004627}
4628
Manuel Klimeka32a7fd2013-01-23 14:08:21 +00004629TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
4630 verifyFormat("void f() {\n"
4631 " x[aaaaaaaaa -\n"
Daniel Jasperbf71ba22013-04-08 20:33:42 +00004632 " b] = 23;\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004633 "}",
4634 getLLVMStyleWithColumns(15));
Manuel Klimeka32a7fd2013-01-23 14:08:21 +00004635}
4636
Daniel Jasper4981bd02013-01-13 08:01:36 +00004637TEST_F(FormatTest, FormatsCasts) {
4638 verifyFormat("Type *A = static_cast<Type *>(P);");
4639 verifyFormat("Type *A = (Type *)P;");
4640 verifyFormat("Type *A = (vector<Type *, int *>)P;");
4641 verifyFormat("int a = (int)(2.0f);");
Daniel Jasperb8b42952013-05-31 16:14:28 +00004642 verifyFormat("int a = (int)2.0f;");
4643 verifyFormat("x[(int32)y];");
4644 verifyFormat("x = (int32)y;");
4645 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
4646 verifyFormat("int a = (int)*b;");
4647 verifyFormat("int a = (int)2.0f;");
4648 verifyFormat("int a = (int)~0;");
4649 verifyFormat("int a = (int)++a;");
4650 verifyFormat("int a = (int)sizeof(int);");
4651 verifyFormat("int a = (int)+2;");
4652 verifyFormat("my_int a = (my_int)2.0f;");
4653 verifyFormat("my_int a = (my_int)sizeof(int);");
Daniel Jasperff1a2e52013-06-06 08:20:20 +00004654 verifyFormat("return (my_int)aaa;");
Daniel Jasper0c368782013-07-15 15:04:42 +00004655 verifyFormat("#define x ((int)-1)");
4656 verifyFormat("#define p(q) ((int *)&q)");
Daniel Jasper4981bd02013-01-13 08:01:36 +00004657
Daniel Jasperb8b42952013-05-31 16:14:28 +00004658 // FIXME: Without type knowledge, this can still fall apart miserably.
4659 verifyFormat("void f() { my_int a = (my_int) * b; }");
Alexander Kornienko2785b9a2013-06-07 16:02:52 +00004660 verifyFormat("void f() { return P ? (my_int) * P : (my_int)0; }");
Daniel Jasperb8b42952013-05-31 16:14:28 +00004661 verifyFormat("my_int a = (my_int) ~0;");
4662 verifyFormat("my_int a = (my_int)++ a;");
4663 verifyFormat("my_int a = (my_int) + 2;");
Daniel Jasper4981bd02013-01-13 08:01:36 +00004664
Daniel Jasper5e2169f2013-07-18 14:46:07 +00004665 // Don't break after a cast's
4666 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
4667 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
4668 " bbbbbbbbbbbbbbbbbbbbbb);");
4669
Daniel Jasper4981bd02013-01-13 08:01:36 +00004670 // These are not casts.
4671 verifyFormat("void f(int *) {}");
Nico Weber6fa7e742013-02-13 04:32:57 +00004672 verifyFormat("f(foo)->b;");
4673 verifyFormat("f(foo).b;");
4674 verifyFormat("f(foo)(b);");
4675 verifyFormat("f(foo)[b];");
Daniel Jasper567dcf92013-09-05 09:29:45 +00004676 verifyFormat("[](foo) { return 4; }(bar);");
Nico Weber6fa7e742013-02-13 04:32:57 +00004677 verifyFormat("(*funptr)(foo)[4];");
4678 verifyFormat("funptrs[4](foo)[4];");
Daniel Jasper4981bd02013-01-13 08:01:36 +00004679 verifyFormat("void f(int *);");
4680 verifyFormat("void f(int *) = 0;");
4681 verifyFormat("void f(SmallVector<int>) {}");
4682 verifyFormat("void f(SmallVector<int>);");
4683 verifyFormat("void f(SmallVector<int>) = 0;");
Nico Weber77280572013-02-09 18:02:07 +00004684 verifyFormat("void f(int i = (kValue) * kMask) {}");
4685 verifyFormat("void f(int i = (kA * kB) & kMask) {}");
Nico Weber6fa7e742013-02-13 04:32:57 +00004686 verifyFormat("int a = sizeof(int) * b;");
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00004687 verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
Daniel Jasperff1a2e52013-06-06 08:20:20 +00004688 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
4689 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
Daniel Jasper526df0f2013-07-08 14:58:01 +00004690 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
Daniel Jasperfaab0d32013-02-27 09:47:53 +00004691
Daniel Jasper37eff832013-02-23 08:07:18 +00004692 // These are not casts, but at some point were confused with casts.
4693 verifyFormat("virtual void foo(int *) override;");
4694 verifyFormat("virtual void foo(char &) const;");
4695 verifyFormat("virtual void foo(int *a, char *) const;");
Daniel Jasper6a365aa2013-03-13 17:13:53 +00004696 verifyFormat("int a = sizeof(int *) + b;");
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00004697 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
Daniel Jasper198c8bf2013-07-05 07:58:34 +00004698
4699 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
4700 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
Daniel Jasper011c35d2013-07-12 11:19:37 +00004701 // FIXME: The indentation here is not ideal.
Daniel Jasper07ca5472013-07-05 09:14:35 +00004702 verifyFormat(
Daniel Jasper011c35d2013-07-12 11:19:37 +00004703 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4704 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
4705 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];");
Daniel Jasper4981bd02013-01-13 08:01:36 +00004706}
4707
Daniel Jasper46ef8522013-01-10 13:08:12 +00004708TEST_F(FormatTest, FormatsFunctionTypes) {
Daniel Jasper46ef8522013-01-10 13:08:12 +00004709 verifyFormat("A<bool()> a;");
4710 verifyFormat("A<SomeType()> a;");
Daniel Jasper431f5912013-05-28 08:33:00 +00004711 verifyFormat("A<void (*)(int, std::string)> a;");
Daniel Jasper9322aae2013-03-20 09:53:18 +00004712 verifyFormat("A<void *(int)>;");
Daniel Jasper81d2d382013-04-01 17:13:26 +00004713 verifyFormat("void *(*a)(int *, SomeType *);");
Daniel Jasper8a5d7cd2013-03-01 17:13:29 +00004714 verifyFormat("int (*func)(void *);");
Daniel Jasper431f5912013-05-28 08:33:00 +00004715 verifyFormat("void f() { int (*func)(void *); }");
Daniel Jasper53352602013-08-12 12:16:34 +00004716 verifyFormat("template <class CallbackClass>\n"
4717 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);");
Daniel Jasper9322aae2013-03-20 09:53:18 +00004718
Daniel Jasper81d2d382013-04-01 17:13:26 +00004719 verifyGoogleFormat("A<void*(int*, SomeType*)>;");
4720 verifyGoogleFormat("void* (*a)(int);");
Daniel Jasper53352602013-08-12 12:16:34 +00004721 verifyGoogleFormat(
4722 "template <class CallbackClass>\n"
4723 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);");
Daniel Jasper7424d792013-05-14 08:34:47 +00004724
Daniel Jaspera8fda852013-05-15 07:51:51 +00004725 // Other constructs can look somewhat like function types:
Daniel Jasper7424d792013-05-14 08:34:47 +00004726 verifyFormat("A<sizeof(*x)> a;");
Daniel Jaspera8fda852013-05-15 07:51:51 +00004727 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
Daniel Jaspere7d3bff2013-07-16 11:37:21 +00004728 verifyFormat("some_var = function(*some_pointer_var)[0];");
4729 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
Daniel Jasper46ef8522013-01-10 13:08:12 +00004730}
4731
Daniel Jasper3c08a812013-02-24 18:54:32 +00004732TEST_F(FormatTest, BreaksLongDeclarations) {
Daniel Jasper53e72cd2013-05-06 08:27:33 +00004733 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00004734 " AnotherNameForTheLongType;",
4735 getGoogleStyle());
Daniel Jasper59875ac2013-11-07 17:43:07 +00004736 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n"
4737 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4738 getGoogleStyle());
Daniel Jasper53e72cd2013-05-06 08:27:33 +00004739 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00004740 " LoooooooooooooooooooooooooooooooooooooooongVariable;",
4741 getGoogleStyle());
Daniel Jasper6ac431c2013-07-02 09:47:29 +00004742 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
4743 " LoooooooooooooooooooooooooooooooooooooooongVariable;",
4744 getGoogleStyle());
Daniel Jasper53e72cd2013-05-06 08:27:33 +00004745 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00004746 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();",
4747 getGoogleStyle());
Daniel Jasper53e72cd2013-05-06 08:27:33 +00004748 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
4749 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasper6ac431c2013-07-02 09:47:29 +00004750 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
4751 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasper53e72cd2013-05-06 08:27:33 +00004752
4753 // FIXME: Without the comment, this breaks after "(".
Manuel Klimeka9a7f102013-06-21 17:25:42 +00004754 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n"
4755 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();",
4756 getGoogleStyle());
Daniel Jasper53e72cd2013-05-06 08:27:33 +00004757
Daniel Jasper83f25ba2013-01-28 15:16:31 +00004758 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00004759 " int LoooooooooooooooooooongParam2) {}");
Daniel Jasper4dc41de2013-01-02 08:44:14 +00004760 verifyFormat(
Daniel Jasper1407bee2013-04-11 14:29:13 +00004761 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
4762 " SourceLocation L, IdentifierIn *II,\n"
4763 " Type *T) {}");
Daniel Jasper3c08a812013-02-24 18:54:32 +00004764 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
4765 "ReallyReallyLongFunctionName(\n"
4766 " const std::string &SomeParameter,\n"
4767 " const SomeType<string, SomeOtherTemplateParameter> &\n"
4768 " ReallyReallyLongParameterName,\n"
4769 " const SomeType<string, SomeOtherTemplateParameter> &\n"
4770 " AnotherLongParameterName) {}");
Daniel Jasper33f4b902013-05-15 09:35:08 +00004771 verifyFormat("template <typename A>\n"
4772 "SomeLoooooooooooooooooooooongType<\n"
4773 " typename some_namespace::SomeOtherType<A>::Type>\n"
4774 "Function() {}");
Daniel Jasper3c08a812013-02-24 18:54:32 +00004775
Daniel Jasperd75ff642013-01-28 15:40:20 +00004776 verifyGoogleFormat(
Daniel Jasper92495a82013-08-19 10:16:18 +00004777 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
4778 " aaaaaaaaaaaaaaaaaaaaaaa;");
4779 verifyGoogleFormat(
Daniel Jasperfaab0d32013-02-27 09:47:53 +00004780 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
4781 " SourceLocation L) {}");
Daniel Jaspera03ab102013-02-13 20:33:44 +00004782 verifyGoogleFormat(
4783 "some_namespace::LongReturnType\n"
4784 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00004785 " int first_long_parameter, int second_parameter) {}");
Daniel Jaspera03ab102013-02-13 20:33:44 +00004786
4787 verifyGoogleFormat("template <typename T>\n"
4788 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00004789 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
Daniel Jasperb6f02f32013-02-28 10:06:05 +00004790 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4791 " int aaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper4dc41de2013-01-02 08:44:14 +00004792}
4793
Daniel Jasper011c35d2013-07-12 11:19:37 +00004794TEST_F(FormatTest, FormatsArrays) {
4795 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
4796 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
4797 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4798 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
4799 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4800 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
4801 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4802 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
4803 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
4804 verifyFormat(
4805 "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
4806 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
4807 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
Stephen Hines651f13c2014-04-23 16:59:28 -07004808
4809 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n"
4810 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];");
Daniel Jasper011c35d2013-07-12 11:19:37 +00004811}
4812
Daniel Jasper3b5943f2012-12-06 09:56:08 +00004813TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
4814 verifyFormat("(a)->b();");
4815 verifyFormat("--a;");
4816}
4817
Daniel Jasper8822d3a2012-12-04 13:02:32 +00004818TEST_F(FormatTest, HandlesIncludeDirectives) {
Daniel Jasper2b9c10b2013-01-14 15:52:06 +00004819 verifyFormat("#include <string>\n"
4820 "#include <a/b/c.h>\n"
4821 "#include \"a/b/string\"\n"
4822 "#include \"string.h\"\n"
4823 "#include \"string.h\"\n"
Manuel Klimek407a31a2013-01-15 15:50:27 +00004824 "#include <a-a>\n"
Daniel Jasper3a204412013-02-23 07:46:38 +00004825 "#include < path with space >\n"
Daniel Jasper7ff96ed2013-05-06 10:24:51 +00004826 "#include \"abc.h\" // this is included for ABC\n"
Daniel Jasper5d5b4242013-05-16 12:59:13 +00004827 "#include \"some long include\" // with a comment\n"
Daniel Jasper3a204412013-02-23 07:46:38 +00004828 "#include \"some very long include paaaaaaaaaaaaaaaaaaaaaaath\"",
4829 getLLVMStyleWithColumns(35));
Daniel Jasper84379572013-10-30 13:54:53 +00004830 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\""));
4831 EXPECT_EQ("#include <a>", format("#include<a>"));
Nico Weberb23ae0c2012-12-21 18:21:56 +00004832
Daniel Jasper8134e1e2013-01-13 08:12:18 +00004833 verifyFormat("#import <string>");
4834 verifyFormat("#import <a/b/c.h>");
4835 verifyFormat("#import \"a/b/string\"");
4836 verifyFormat("#import \"string.h\"");
4837 verifyFormat("#import \"string.h\"");
Daniel Jaspera4dd9822013-08-28 08:24:04 +00004838 verifyFormat("#if __has_include(<strstream>)\n"
4839 "#include <strstream>\n"
4840 "#endif");
Stephen Hines651f13c2014-04-23 16:59:28 -07004841
4842 // Protocol buffer definition or missing "#".
4843 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";",
4844 getLLVMStyleWithColumns(30));
Daniel Jasper8822d3a2012-12-04 13:02:32 +00004845}
4846
Alexander Kornienko15757312012-12-06 18:03:27 +00004847//===----------------------------------------------------------------------===//
4848// Error recovery tests.
4849//===----------------------------------------------------------------------===//
4850
Daniel Jasperc5cfa492013-02-14 09:19:04 +00004851TEST_F(FormatTest, IncompleteParameterLists) {
Daniel Jasperfaab0d32013-02-27 09:47:53 +00004852 FormatStyle NoBinPacking = getLLVMStyle();
4853 NoBinPacking.BinPackParameters = false;
4854 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
4855 " double *min_x,\n"
4856 " double *max_x,\n"
4857 " double *min_y,\n"
4858 " double *max_y,\n"
4859 " double *min_z,\n"
4860 " double *max_z, ) {}",
4861 NoBinPacking);
Daniel Jasperc5cfa492013-02-14 09:19:04 +00004862}
4863
Daniel Jasper700e7102013-01-10 09:26:47 +00004864TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
Alexander Kornienko51c23fa2013-01-16 11:45:16 +00004865 verifyFormat("void f() { return; }\n42");
4866 verifyFormat("void f() {\n"
4867 " if (0)\n"
4868 " return;\n"
4869 "}\n"
4870 "42");
Alexander Kornienkod8818752013-01-16 11:43:46 +00004871 verifyFormat("void f() { return }\n42");
4872 verifyFormat("void f() {\n"
4873 " if (0)\n"
4874 " return\n"
4875 "}\n"
4876 "42");
4877}
4878
4879TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
4880 EXPECT_EQ("void f() { return }", format("void f ( ) { return }"));
4881 EXPECT_EQ("void f() {\n"
4882 " if (a)\n"
4883 " return\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004884 "}",
4885 format("void f ( ) { if ( a ) return }"));
Daniel Jasper5be59ba2013-05-15 14:09:55 +00004886 EXPECT_EQ("namespace N {\n"
4887 "void f()\n"
4888 "}",
4889 format("namespace N { void f() }"));
Alexander Kornienkod8818752013-01-16 11:43:46 +00004890 EXPECT_EQ("namespace N {\n"
4891 "void f() {}\n"
4892 "void g()\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004893 "}",
4894 format("namespace N { void f( ) { } void g( ) }"));
Daniel Jasper700e7102013-01-10 09:26:47 +00004895}
4896
Daniel Jasperceb99ab2013-01-09 10:16:05 +00004897TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
4898 verifyFormat("int aaaaaaaa =\n"
Alexander Kornienko5262dd92013-03-27 11:52:18 +00004899 " // Overlylongcomment\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004900 " b;",
4901 getLLVMStyleWithColumns(20));
Daniel Jasperceb99ab2013-01-09 10:16:05 +00004902 verifyFormat("function(\n"
4903 " ShortArgument,\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004904 " LoooooooooooongArgument);\n",
4905 getLLVMStyleWithColumns(20));
Daniel Jasperceb99ab2013-01-09 10:16:05 +00004906}
4907
Alexander Kornienko56e49c52012-12-10 16:34:48 +00004908TEST_F(FormatTest, IncorrectAccessSpecifier) {
4909 verifyFormat("public:");
4910 verifyFormat("class A {\n"
4911 "public\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +00004912 " void f() {}\n"
Alexander Kornienko56e49c52012-12-10 16:34:48 +00004913 "};");
4914 verifyFormat("public\n"
4915 "int qwerty;");
4916 verifyFormat("public\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +00004917 "B {}");
Alexander Kornienko56e49c52012-12-10 16:34:48 +00004918 verifyFormat("public\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +00004919 "{}");
Alexander Kornienko56e49c52012-12-10 16:34:48 +00004920 verifyFormat("public\n"
Manuel Klimek517e8942013-01-11 17:54:10 +00004921 "B { int x; }");
Alexander Kornienko56e49c52012-12-10 16:34:48 +00004922}
Daniel Jasperbac016b2012-12-03 18:12:45 +00004923
Daniel Jasper92f9faf2013-03-20 15:58:10 +00004924TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
4925 verifyFormat("{");
4926 verifyFormat("#})");
4927}
Alexander Kornienko393b0082012-12-04 15:40:36 +00004928
4929TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004930 verifyFormat("do {\n}");
4931 verifyFormat("do {\n}\n"
Alexander Kornienko393b0082012-12-04 15:40:36 +00004932 "f();");
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004933 verifyFormat("do {\n}\n"
Alexander Kornienko393b0082012-12-04 15:40:36 +00004934 "wheeee(fun);");
4935 verifyFormat("do {\n"
4936 " f();\n"
Manuel Klimekde768542013-01-07 18:10:23 +00004937 "}");
Alexander Kornienko393b0082012-12-04 15:40:36 +00004938}
4939
Manuel Klimek6eca03f2013-01-11 19:23:05 +00004940TEST_F(FormatTest, IncorrectCodeMissingParens) {
Manuel Klimekd4658432013-01-11 18:28:36 +00004941 verifyFormat("if {\n foo;\n foo();\n}");
Manuel Klimek6eca03f2013-01-11 19:23:05 +00004942 verifyFormat("switch {\n foo;\n foo();\n}");
4943 verifyFormat("for {\n foo;\n foo();\n}");
4944 verifyFormat("while {\n foo;\n foo();\n}");
4945 verifyFormat("do {\n foo;\n foo();\n} while;");
Manuel Klimekd4658432013-01-11 18:28:36 +00004946}
4947
Daniel Jasper1f42f112013-01-04 18:52:56 +00004948TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
4949 verifyFormat("namespace {\n"
Manuel Klimekae76f7f2013-10-11 21:25:45 +00004950 "class Foo { Foo (\n"
Daniel Jasperf7ec1cc2013-05-31 14:56:29 +00004951 "};\n"
4952 "} // comment");
Daniel Jasper1f42f112013-01-04 18:52:56 +00004953}
4954
Alexander Kornienkocff563c2012-12-04 17:27:50 +00004955TEST_F(FormatTest, IncorrectCodeErrorDetection) {
Daniel Jasper0baf33b2013-10-18 17:20:57 +00004956 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n"));
Manuel Klimek36fab8d2013-01-10 13:24:24 +00004957 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n"));
4958 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n"));
Daniel Jasper0baf33b2013-10-18 17:20:57 +00004959 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n"));
Alexander Kornienkocff563c2012-12-04 17:27:50 +00004960
Alexander Kornienkocff563c2012-12-04 17:27:50 +00004961 EXPECT_EQ("{\n"
Daniel Jasper0baf33b2013-10-18 17:20:57 +00004962 " {\n"
4963 " breakme(\n"
4964 " qwe);\n"
4965 " }\n",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004966 format("{\n"
4967 " {\n"
4968 " breakme(qwe);\n"
4969 "}\n",
4970 getLLVMStyleWithColumns(10)));
Alexander Kornienkocff563c2012-12-04 17:27:50 +00004971}
4972
Manuel Klimek2851c162013-01-10 14:36:46 +00004973TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004974 verifyFormat("int x = {\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07004975 " avariable,\n"
4976 " b(alongervariable)};",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004977 getLLVMStyleWithColumns(25));
Manuel Klimek2851c162013-01-10 14:36:46 +00004978}
4979
Manuel Klimekc44ee892013-01-21 10:07:49 +00004980TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
Stephen Hines651f13c2014-04-23 16:59:28 -07004981 verifyFormat("return (a)(b) {1, 2, 3};");
Manuel Klimekc44ee892013-01-21 10:07:49 +00004982}
4983
Manuel Klimek80829bd2013-05-23 09:41:43 +00004984TEST_F(FormatTest, LayoutCxx11ConstructorBraceInitializers) {
Stephen Hines651f13c2014-04-23 16:59:28 -07004985 verifyFormat("vector<int> x{1, 2, 3, 4};");
4986 verifyFormat("vector<int> x{\n"
4987 " 1, 2, 3, 4,\n"
4988 "};");
4989 verifyFormat("vector<T> x{{}, {}, {}, {}};");
4990 verifyFormat("f({1, 2});");
4991 verifyFormat("auto v = Foo{-1};");
4992 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});");
4993 verifyFormat("Class::Class : member{1, 2, 3} {}");
4994 verifyFormat("new vector<int>{1, 2, 3};");
4995 verifyFormat("new int[3]{1, 2, 3};");
4996 verifyFormat("return {arg1, arg2};");
4997 verifyFormat("return {arg1, SomeType{parameter}};");
4998 verifyFormat("int count = set<int>{f(), g(), h()}.size();");
4999 verifyFormat("new T{arg1, arg2};");
5000 verifyFormat("f(MyMap[{composite, key}]);");
5001 verifyFormat("class Class {\n"
5002 " T member = {arg1, arg2};\n"
5003 "};");
5004 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};");
Daniel Jasper2424eef2013-05-23 10:15:45 +00005005
Stephen Hines651f13c2014-04-23 16:59:28 -07005006 // FIXME: The alignment of these trailing comments might be bad. Then again,
5007 // this might be utterly useless in real code.
5008 verifyFormat("Constructor::Constructor()\n"
5009 " : some_value{ //\n"
5010 " aaaaaaa //\n"
5011 " } {}");
5012
5013 // In braced lists, the first comment is always assumed to belong to the
5014 // first element. Thus, it can be moved to the next or previous line as
5015 // appropriate.
5016 EXPECT_EQ("function({// First element:\n"
5017 " 1,\n"
5018 " // Second element:\n"
5019 " 2});",
5020 format("function({\n"
5021 " // First element:\n"
5022 " 1,\n"
5023 " // Second element:\n"
5024 " 2});"));
5025 EXPECT_EQ("std::vector<int> MyNumbers{\n"
5026 " // First element:\n"
5027 " 1,\n"
5028 " // Second element:\n"
5029 " 2};",
5030 format("std::vector<int> MyNumbers{// First element:\n"
5031 " 1,\n"
5032 " // Second element:\n"
5033 " 2};",
5034 getLLVMStyleWithColumns(30)));
5035
5036 FormatStyle ExtraSpaces = getLLVMStyle();
5037 ExtraSpaces.Cpp11BracedListStyle = false;
5038 ExtraSpaces.ColumnLimit = 75;
5039 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces);
5040 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces);
5041 verifyFormat("f({ 1, 2 });", ExtraSpaces);
5042 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces);
5043 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces);
5044 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces);
5045 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces);
5046 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces);
5047 verifyFormat("return { arg1, arg2 };", ExtraSpaces);
5048 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces);
5049 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces);
5050 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces);
5051 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces);
5052 verifyFormat("class Class {\n"
5053 " T member = { arg1, arg2 };\n"
5054 "};",
5055 ExtraSpaces);
5056 verifyFormat(
5057 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5058 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
5059 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
5060 " bbbbbbbbbbbbbbbbbbbb, bbbbb };",
5061 ExtraSpaces);
5062 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces);
5063 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });",
5064 ExtraSpaces);
5065 verifyFormat(
5066 "someFunction(OtherParam,\n"
5067 " BracedList{ // comment 1 (Forcing interesting break)\n"
5068 " param1, param2,\n"
5069 " // comment 2\n"
5070 " param3, param4 });",
5071 ExtraSpaces);
5072 verifyFormat(
5073 "std::this_thread::sleep_for(\n"
5074 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);",
5075 ExtraSpaces);
5076 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaa{\n"
5077 " aaaaaaa, aaaaaaaaaa,\n"
5078 " aaaaa, aaaaaaaaaaaaaaa,\n"
5079 " aaa, aaaaaaaaaa,\n"
5080 " a, aaaaaaaaaaaaaaaaaaaaa,\n"
5081 " aaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n"
5082 " aaaaaaa, a\n"
5083 "};",
5084 ExtraSpaces);
5085 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces);
Manuel Klimek80829bd2013-05-23 09:41:43 +00005086}
5087
Daniel Jasper47066e42013-10-25 14:29:37 +00005088TEST_F(FormatTest, FormatsBracedListsInColumnLayout) {
Stephen Hines651f13c2014-04-23 16:59:28 -07005089 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
5090 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
5091 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
5092 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
5093 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
5094 " 1, 22, 333, 4444, 55555, 666666, 7777777};");
5095 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
5096 " // line comment\n"
5097 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
5098 " 1, 22, 333, 4444, 55555,\n"
5099 " // line comment\n"
5100 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
5101 " 1, 22, 333, 4444, 55555, 666666, 7777777};");
Daniel Jasperd4a03db2013-08-22 15:00:41 +00005102 verifyFormat(
Stephen Hines651f13c2014-04-23 16:59:28 -07005103 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
5104 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
5105 " 1, 22, 333, 4444, 55555, 666666, // comment\n"
5106 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
5107 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
5108 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
5109 " 7777777};");
Daniel Jasperd4a03db2013-08-22 15:00:41 +00005110 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07005111 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
5112 " X86::R8, X86::R9, X86::R10, X86::R11, 0};");
5113 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
5114 " 1, 1, 1, 1};",
Daniel Jasperd4a03db2013-08-22 15:00:41 +00005115 getLLVMStyleWithColumns(39));
Stephen Hines651f13c2014-04-23 16:59:28 -07005116 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
5117 " 1, 1, 1, 1};",
Daniel Jasperd4a03db2013-08-22 15:00:41 +00005118 getLLVMStyleWithColumns(38));
5119 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07005120 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};",
5121 getLLVMStyleWithColumns(43));
Daniel Jaspered51c022013-08-23 10:05:49 +00005122
5123 // Trailing commas.
Stephen Hines651f13c2014-04-23 16:59:28 -07005124 verifyFormat("vector<int> x = {\n"
5125 " 1, 1, 1, 1, 1, 1, 1, 1,\n"
Daniel Jaspered51c022013-08-23 10:05:49 +00005126 "};",
5127 getLLVMStyleWithColumns(39));
Stephen Hines651f13c2014-04-23 16:59:28 -07005128 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
5129 " 1, 1, 1, 1, //\n"
5130 "};",
Daniel Jasper332c6772013-08-26 08:10:17 +00005131 getLLVMStyleWithColumns(39));
Stephen Hines651f13c2014-04-23 16:59:28 -07005132 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
5133 " 1, 1, 1, 1,\n"
5134 " /**/ /**/};",
5135 getLLVMStyleWithColumns(39));
5136 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
5137 " {aaaaaaaaaaaaaaaaaaa},\n"
5138 " {aaaaaaaaaaaaaaaaaaaaa},\n"
5139 " {aaaaaaaaaaaaaaaaa}};",
Daniel Jasper451f1e02013-08-27 08:43:47 +00005140 getLLVMStyleWithColumns(60));
Stephen Hines651f13c2014-04-23 16:59:28 -07005141
5142 // With nested lists, we should either format one item per line or all nested
5143 // lists one one line.
5144 // FIXME: For some nested lists, we can do better.
5145 verifyFormat(
5146 "SomeStruct my_struct_array = {\n"
5147 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n"
5148 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n"
5149 " {aaa, aaa},\n"
5150 " {aaa, aaa},\n"
5151 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n"
5152 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n"
5153 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};");
5154
5155 // No column layout should be used here.
5156 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
5157 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};");
Daniel Jasperd4a03db2013-08-22 15:00:41 +00005158}
5159
Manuel Klimek517e8942013-01-11 17:54:10 +00005160TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
Stephen Hines651f13c2014-04-23 16:59:28 -07005161 FormatStyle DoNotMerge = getLLVMStyle();
5162 DoNotMerge.AllowShortFunctionsOnASingleLine = false;
5163
Manuel Klimek517e8942013-01-11 17:54:10 +00005164 verifyFormat("void f() { return 42; }");
5165 verifyFormat("void f() {\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07005166 " return 42;\n"
5167 "}",
5168 DoNotMerge);
5169 verifyFormat("void f() {\n"
Manuel Klimek517e8942013-01-11 17:54:10 +00005170 " // Comment\n"
5171 "}");
5172 verifyFormat("{\n"
5173 "#error {\n"
5174 " int a;\n"
5175 "}");
5176 verifyFormat("{\n"
5177 " int a;\n"
5178 "#error {\n"
5179 "}");
Daniel Jasper058f6f82013-05-16 10:17:39 +00005180 verifyFormat("void f() {} // comment");
5181 verifyFormat("void f() { int a; } // comment");
Daniel Jasper9e5b6c32013-05-16 16:54:34 +00005182 verifyFormat("void f() {\n"
5183 "} // comment",
Stephen Hines651f13c2014-04-23 16:59:28 -07005184 DoNotMerge);
5185 verifyFormat("void f() {\n"
5186 " int a;\n"
5187 "} // comment",
5188 DoNotMerge);
5189 verifyFormat("void f() {\n"
5190 "} // comment",
Daniel Jasper9e5b6c32013-05-16 16:54:34 +00005191 getLLVMStyleWithColumns(15));
Manuel Klimek2f1ac412013-01-21 16:42:44 +00005192
5193 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
5194 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22));
5195
5196 verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
5197 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
Stephen Hines651f13c2014-04-23 16:59:28 -07005198 verifyFormat("class C {\n"
5199 " C()\n"
5200 " : iiiiiiii(nullptr),\n"
5201 " kkkkkkk(nullptr),\n"
5202 " mmmmmmm(nullptr),\n"
5203 " nnnnnnn(nullptr) {}\n"
5204 "};",
5205 getGoogleStyle());
5206
5207 FormatStyle NoColumnLimit = getLLVMStyle();
5208 NoColumnLimit.ColumnLimit = 0;
5209 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));
5210 EXPECT_EQ("class C {\n"
5211 " A() : b(0) {}\n"
5212 "};", format("class C{A():b(0){}};", NoColumnLimit));
5213 EXPECT_EQ("A()\n"
5214 " : b(0) {\n"
5215 "}",
5216 format("A()\n:b(0)\n{\n}", NoColumnLimit));
5217
5218 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit;
5219 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine = false;
5220 EXPECT_EQ("A()\n"
5221 " : b(0) {\n"
5222 "}",
5223 format("A():b(0){}", DoNotMergeNoColumnLimit));
5224 EXPECT_EQ("A()\n"
5225 " : b(0) {\n"
5226 "}",
5227 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit));
5228
5229 verifyFormat("#define A \\\n"
5230 " void f() { \\\n"
5231 " int i; \\\n"
5232 " }",
5233 getLLVMStyleWithColumns(20));
5234 verifyFormat("#define A \\\n"
5235 " void f() { int i; }",
5236 getLLVMStyleWithColumns(21));
5237 verifyFormat("#define A \\\n"
5238 " void f() { \\\n"
5239 " int i; \\\n"
5240 " } \\\n"
5241 " int j;",
5242 getLLVMStyleWithColumns(22));
5243 verifyFormat("#define A \\\n"
5244 " void f() { int i; } \\\n"
5245 " int j;",
5246 getLLVMStyleWithColumns(23));
Manuel Klimek517e8942013-01-11 17:54:10 +00005247}
5248
Manuel Klimek47ea7f62013-01-15 13:38:33 +00005249TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
5250 // Elaborate type variable declarations.
Stephen Hines651f13c2014-04-23 16:59:28 -07005251 verifyFormat("struct foo a = {bar};\nint n;");
5252 verifyFormat("class foo a = {bar};\nint n;");
5253 verifyFormat("union foo a = {bar};\nint n;");
Manuel Klimek47ea7f62013-01-15 13:38:33 +00005254
5255 // Elaborate types inside function definitions.
5256 verifyFormat("struct foo f() {}\nint n;");
5257 verifyFormat("class foo f() {}\nint n;");
5258 verifyFormat("union foo f() {}\nint n;");
5259
5260 // Templates.
5261 verifyFormat("template <class X> void f() {}\nint n;");
5262 verifyFormat("template <struct X> void f() {}\nint n;");
5263 verifyFormat("template <union X> void f() {}\nint n;");
5264
5265 // Actual definitions...
Manuel Klimek2f1ac412013-01-21 16:42:44 +00005266 verifyFormat("struct {\n} n;");
5267 verifyFormat(
5268 "template <template <class T, class Y>, class Z> class X {\n} n;");
Manuel Klimek47ea7f62013-01-15 13:38:33 +00005269 verifyFormat("union Z {\n int n;\n} x;");
Manuel Klimek2f1ac412013-01-21 16:42:44 +00005270 verifyFormat("class MACRO Z {\n} n;");
5271 verifyFormat("class MACRO(X) Z {\n} n;");
5272 verifyFormat("class __attribute__(X) Z {\n} n;");
5273 verifyFormat("class __declspec(X) Z {\n} n;");
Manuel Klimekb8b1ce12013-02-06 15:57:54 +00005274 verifyFormat("class A##B##C {\n} n;");
Manuel Klimek3d712892013-10-07 09:15:41 +00005275 verifyFormat("class alignas(16) Z {\n} n;");
Manuel Klimek47ea7f62013-01-15 13:38:33 +00005276
Manuel Klimek7f5b0252013-01-21 10:17:14 +00005277 // Redefinition from nested context:
Manuel Klimek2f1ac412013-01-21 16:42:44 +00005278 verifyFormat("class A::B::C {\n} n;");
Manuel Klimek7f5b0252013-01-21 10:17:14 +00005279
Manuel Klimek3a3408c2013-01-21 13:58:54 +00005280 // Template definitions.
Daniel Jasper5d823e32013-05-15 13:46:48 +00005281 verifyFormat(
5282 "template <typename F>\n"
5283 "Matcher(const Matcher<F> &Other,\n"
5284 " typename enable_if_c<is_base_of<F, T>::value &&\n"
5285 " !is_same<F, T>::value>::type * = 0)\n"
5286 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
5287
Manuel Klimek3a3408c2013-01-21 13:58:54 +00005288 // FIXME: This is still incorrectly handled at the formatter side.
Daniel Jasper0236dd02013-07-30 22:37:19 +00005289 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
Manuel Klimek3a3408c2013-01-21 13:58:54 +00005290
5291 // FIXME:
5292 // This now gets parsed incorrectly as class definition.
Manuel Klimek2f1ac412013-01-21 16:42:44 +00005293 // verifyFormat("class A<int> f() {\n}\nint n;");
Manuel Klimek3a3408c2013-01-21 13:58:54 +00005294
Manuel Klimek47ea7f62013-01-15 13:38:33 +00005295 // Elaborate types where incorrectly parsing the structural element would
5296 // break the indent.
5297 verifyFormat("if (true)\n"
5298 " class X x;\n"
5299 "else\n"
5300 " f();\n");
Daniel Jasper6fe554e2013-03-20 15:12:38 +00005301
5302 // This is simply incomplete. Formatting is not important, but must not crash.
Daniel Jasper6315fec2013-08-13 10:58:30 +00005303 verifyFormat("class A:");
Manuel Klimek606e07e2013-01-11 18:13:04 +00005304}
5305
Manuel Klimek407a31a2013-01-15 15:50:27 +00005306TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
Manuel Klimekae76f7f2013-10-11 21:25:45 +00005307 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n",
5308 format("#error Leave all white!!!!! space* alone!\n"));
5309 EXPECT_EQ(
5310 "#warning Leave all white!!!!! space* alone!\n",
5311 format("#warning Leave all white!!!!! space* alone!\n"));
Manuel Klimek407a31a2013-01-15 15:50:27 +00005312 EXPECT_EQ("#error 1", format(" # error 1"));
5313 EXPECT_EQ("#warning 1", format(" # warning 1"));
5314}
5315
Daniel Jasperaae7bad2013-04-23 13:54:04 +00005316TEST_F(FormatTest, FormatHashIfExpressions) {
Stephen Hines651f13c2014-04-23 16:59:28 -07005317 verifyFormat("#if AAAA && BBBB");
Daniel Jasperaae7bad2013-04-23 13:54:04 +00005318 // FIXME: Come up with a better indentation for #elif.
5319 verifyFormat(
5320 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n"
5321 " defined(BBBBBBBB)\n"
5322 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n"
5323 " defined(BBBBBBBB)\n"
5324 "#endif",
5325 getLLVMStyleWithColumns(65));
5326}
5327
Manuel Klimek525fe162013-01-18 14:04:34 +00005328TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
5329 FormatStyle AllowsMergedIf = getGoogleStyle();
5330 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true;
5331 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
5332 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
Manuel Klimek4c128122013-01-18 14:46:43 +00005333 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf);
5334 EXPECT_EQ("if (true) return 42;",
5335 format("if (true)\nreturn 42;", AllowsMergedIf));
5336 FormatStyle ShortMergedIf = AllowsMergedIf;
5337 ShortMergedIf.ColumnLimit = 25;
Daniel Jasper2972d042013-04-25 08:56:26 +00005338 verifyFormat("#define A \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005339 " if (true) return 42;",
5340 ShortMergedIf);
Daniel Jasper2972d042013-04-25 08:56:26 +00005341 verifyFormat("#define A \\\n"
5342 " f(); \\\n"
Manuel Klimek4c128122013-01-18 14:46:43 +00005343 " if (true)\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005344 "#define B",
5345 ShortMergedIf);
Daniel Jasper2972d042013-04-25 08:56:26 +00005346 verifyFormat("#define A \\\n"
5347 " f(); \\\n"
Manuel Klimek4c128122013-01-18 14:46:43 +00005348 " if (true)\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005349 "g();",
5350 ShortMergedIf);
Manuel Klimek0fbe0082013-01-21 14:16:56 +00005351 verifyFormat("{\n"
5352 "#ifdef A\n"
5353 " // Comment\n"
5354 " if (true) continue;\n"
5355 "#endif\n"
5356 " // Comment\n"
Manuel Klimekae76f7f2013-10-11 21:25:45 +00005357 " if (true) continue;\n"
5358 "}",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005359 ShortMergedIf);
Stephen Hines651f13c2014-04-23 16:59:28 -07005360 ShortMergedIf.ColumnLimit = 29;
5361 verifyFormat("#define A \\\n"
5362 " if (aaaaaaaaaa) return 1; \\\n"
5363 " return 2;",
5364 ShortMergedIf);
5365 ShortMergedIf.ColumnLimit = 28;
5366 verifyFormat("#define A \\\n"
5367 " if (aaaaaaaaaa) \\\n"
5368 " return 1; \\\n"
5369 " return 2;",
5370 ShortMergedIf);
Manuel Klimek525fe162013-01-18 14:04:34 +00005371}
5372
Manuel Klimek86721d22013-01-22 16:31:55 +00005373TEST_F(FormatTest, BlockCommentsInControlLoops) {
5374 verifyFormat("if (0) /* a comment in a strange place */ {\n"
5375 " f();\n"
5376 "}");
5377 verifyFormat("if (0) /* a comment in a strange place */ {\n"
5378 " f();\n"
5379 "} /* another comment */ else /* comment #3 */ {\n"
5380 " g();\n"
5381 "}");
5382 verifyFormat("while (0) /* a comment in a strange place */ {\n"
5383 " f();\n"
5384 "}");
5385 verifyFormat("for (;;) /* a comment in a strange place */ {\n"
5386 " f();\n"
5387 "}");
5388 verifyFormat("do /* a comment in a strange place */ {\n"
5389 " f();\n"
5390 "} /* another comment */ while (0);");
5391}
5392
5393TEST_F(FormatTest, BlockComments) {
5394 EXPECT_EQ("/* */ /* */ /* */\n/* */ /* */ /* */",
5395 format("/* *//* */ /* */\n/* *//* */ /* */"));
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005396 EXPECT_EQ("/* */ a /* */ b;", format(" /* */ a/* */ b;"));
Daniel Jasperc9346c92013-08-28 09:07:32 +00005397 EXPECT_EQ("#define A /*123*/ \\\n"
Manuel Klimek86721d22013-01-22 16:31:55 +00005398 " b\n"
5399 "/* */\n"
5400 "someCall(\n"
5401 " parameter);",
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00005402 format("#define A /*123*/ b\n"
Manuel Klimek86721d22013-01-22 16:31:55 +00005403 "/* */\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005404 "someCall(parameter);",
5405 getLLVMStyleWithColumns(15)));
Manuel Klimek86721d22013-01-22 16:31:55 +00005406
5407 EXPECT_EQ("#define A\n"
5408 "/* */ someCall(\n"
5409 " parameter);",
5410 format("#define A\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005411 "/* */someCall(parameter);",
5412 getLLVMStyleWithColumns(15)));
Daniel Jaspere2c482f2013-05-30 06:40:07 +00005413 EXPECT_EQ("/*\n**\n*/", format("/*\n**\n*/"));
Daniel Jasper92092702013-05-30 15:20:29 +00005414 EXPECT_EQ("/*\n"
5415 "*\n"
5416 " * aaaaaa\n"
Alexander Kornienko1659ded2013-07-08 14:12:07 +00005417 "*aaaaaa\n"
Daniel Jasper92092702013-05-30 15:20:29 +00005418 "*/",
5419 format("/*\n"
5420 "*\n"
5421 " * aaaaaa aaaaaa\n"
5422 "*/",
5423 getLLVMStyleWithColumns(10)));
Daniel Jaspercb4b40b2013-05-30 17:27:48 +00005424 EXPECT_EQ("/*\n"
5425 "**\n"
5426 "* aaaaaa\n"
Alexander Kornienko1659ded2013-07-08 14:12:07 +00005427 "*aaaaaa\n"
Daniel Jaspercb4b40b2013-05-30 17:27:48 +00005428 "*/",
5429 format("/*\n"
5430 "**\n"
5431 "* aaaaaa aaaaaa\n"
5432 "*/",
5433 getLLVMStyleWithColumns(10)));
Daniel Jasper2752ff32013-02-04 07:32:14 +00005434
Daniel Jasperfaab0d32013-02-27 09:47:53 +00005435 FormatStyle NoBinPacking = getLLVMStyle();
5436 NoBinPacking.BinPackParameters = false;
Daniel Jasper2752ff32013-02-04 07:32:14 +00005437 EXPECT_EQ("someFunction(1, /* comment 1 */\n"
5438 " 2, /* comment 2 */\n"
5439 " 3, /* comment 3 */\n"
Daniel Jaspercda16502013-02-04 08:34:57 +00005440 " aaaa,\n"
5441 " bbbb);",
Daniel Jasper2752ff32013-02-04 07:32:14 +00005442 format("someFunction (1, /* comment 1 */\n"
5443 " 2, /* comment 2 */ \n"
5444 " 3, /* comment 3 */\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005445 "aaaa, bbbb );",
Daniel Jasperfaab0d32013-02-27 09:47:53 +00005446 NoBinPacking));
Daniel Jasper36ba0ff2013-02-06 15:23:09 +00005447 verifyFormat(
5448 "bool aaaaaaaaaaaaa = /* comment: */ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5449 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5450 EXPECT_EQ(
5451 "bool aaaaaaaaaaaaa = /* trailing comment */\n"
5452 " aaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5453 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;",
5454 format(
5455 "bool aaaaaaaaaaaaa = /* trailing comment */\n"
5456 " aaaaaaaaaaaaaaaaaaaaaaaaaaa||aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5457 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;"));
Daniel Jasper15417ef2013-02-06 20:07:35 +00005458 EXPECT_EQ(
5459 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n"
5460 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n"
5461 "int cccccccccccccccccccccccccccccc; /* comment */\n",
5462 format("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n"
5463 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n"
5464 "int cccccccccccccccccccccccccccccc; /* comment */\n"));
Daniel Jasper3a1847e2013-07-01 09:34:09 +00005465
5466 verifyFormat("void f(int * /* unused */) {}");
Alexander Kornienko1659ded2013-07-08 14:12:07 +00005467
5468 EXPECT_EQ("/*\n"
5469 " **\n"
5470 " */",
5471 format("/*\n"
5472 " **\n"
5473 " */"));
5474 EXPECT_EQ("/*\n"
5475 " *q\n"
5476 " */",
5477 format("/*\n"
5478 " *q\n"
5479 " */"));
5480 EXPECT_EQ("/*\n"
5481 " * q\n"
5482 " */",
5483 format("/*\n"
5484 " * q\n"
5485 " */"));
5486 EXPECT_EQ("/*\n"
5487 " **/",
5488 format("/*\n"
5489 " **/"));
5490 EXPECT_EQ("/*\n"
5491 " ***/",
5492 format("/*\n"
5493 " ***/"));
Manuel Klimek86721d22013-01-22 16:31:55 +00005494}
5495
Manuel Klimekb3507cd2013-02-06 16:40:56 +00005496TEST_F(FormatTest, BlockCommentsInMacros) {
5497 EXPECT_EQ("#define A \\\n"
5498 " { \\\n"
5499 " /* one line */ \\\n"
5500 " someCall();",
5501 format("#define A { \\\n"
5502 " /* one line */ \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005503 " someCall();",
5504 getLLVMStyleWithColumns(20)));
Manuel Klimekb3507cd2013-02-06 16:40:56 +00005505 EXPECT_EQ("#define A \\\n"
5506 " { \\\n"
5507 " /* previous */ \\\n"
5508 " /* one line */ \\\n"
5509 " someCall();",
5510 format("#define A { \\\n"
5511 " /* previous */ \\\n"
5512 " /* one line */ \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005513 " someCall();",
5514 getLLVMStyleWithColumns(20)));
Manuel Klimekb3507cd2013-02-06 16:40:56 +00005515}
5516
Manuel Klimekbe9ed772013-05-29 22:06:18 +00005517TEST_F(FormatTest, BlockCommentsAtEndOfLine) {
5518 EXPECT_EQ("a = {\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07005519 " 1111 /* */\n"
Manuel Klimekbe9ed772013-05-29 22:06:18 +00005520 "};",
Alexander Kornienkoe3f11972013-06-12 19:04:12 +00005521 format("a = {1111 /* */\n"
Manuel Klimekbe9ed772013-05-29 22:06:18 +00005522 "};",
5523 getLLVMStyleWithColumns(15)));
5524 EXPECT_EQ("a = {\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07005525 " 1111 /* */\n"
Manuel Klimekbe9ed772013-05-29 22:06:18 +00005526 "};",
Alexander Kornienkoe3f11972013-06-12 19:04:12 +00005527 format("a = {1111 /* */\n"
Manuel Klimekbe9ed772013-05-29 22:06:18 +00005528 "};",
5529 getLLVMStyleWithColumns(15)));
5530
5531 // FIXME: The formatting is still wrong here.
5532 EXPECT_EQ("a = {\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07005533 " 1111 /* a\n"
5534 " */\n"
Manuel Klimekbe9ed772013-05-29 22:06:18 +00005535 "};",
Alexander Kornienkoe3f11972013-06-12 19:04:12 +00005536 format("a = {1111 /* a */\n"
Manuel Klimekbe9ed772013-05-29 22:06:18 +00005537 "};",
5538 getLLVMStyleWithColumns(15)));
5539}
5540
Manuel Klimekb3507cd2013-02-06 16:40:56 +00005541TEST_F(FormatTest, IndentLineCommentsInStartOfBlockAtEndOfFile) {
5542 // FIXME: This is not what we want...
5543 verifyFormat("{\n"
5544 "// a"
5545 "// b");
5546}
5547
Manuel Klimek092a2c72013-01-23 10:09:28 +00005548TEST_F(FormatTest, FormatStarDependingOnContext) {
Manuel Klimek70b03f42013-01-23 09:32:48 +00005549 verifyFormat("void f(int *a);");
5550 verifyFormat("void f() { f(fint * b); }");
Manuel Klimek836b58f2013-01-23 11:03:04 +00005551 verifyFormat("class A {\n void f(int *a);\n};");
5552 verifyFormat("class A {\n int *a;\n};");
5553 verifyFormat("namespace a {\n"
5554 "namespace b {\n"
5555 "class A {\n"
5556 " void f() {}\n"
5557 " int *a;\n"
5558 "};\n"
5559 "}\n"
5560 "}");
Manuel Klimek70b03f42013-01-23 09:32:48 +00005561}
5562
Manuel Klimek092a2c72013-01-23 10:09:28 +00005563TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
5564 verifyFormat("while");
5565 verifyFormat("operator");
5566}
5567
Nico Webercf4a79c2013-01-08 17:56:31 +00005568//===----------------------------------------------------------------------===//
5569// Objective-C tests.
5570//===----------------------------------------------------------------------===//
5571
Fariborz Jahanian154120c2012-12-20 19:54:13 +00005572TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
5573 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
5574 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
5575 format("-(NSUInteger)indexOfObject:(id)anObject;"));
Daniel Jaspercd162382013-01-07 13:26:07 +00005576 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
Fariborz Jahanian154120c2012-12-20 19:54:13 +00005577 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
5578 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
5579 format("-(NSInteger)Method3:(id)anObject;"));
5580 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
5581 format("-(NSInteger)Method4:(id)anObject;"));
5582 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
5583 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
5584 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
5585 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
Daniel Jaspercd162382013-01-07 13:26:07 +00005586 EXPECT_EQ(
5587 "- (void)sendAction:(SEL)aSelector to:(id)anObject forAllCells:(BOOL)flag;",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005588 format(
5589 "- (void)sendAction:(SEL)aSelector to:(id)anObject forAllCells:(BOOL)flag;"));
Fariborz Jahanian9b3f02c2012-12-21 22:51:18 +00005590
5591 // Very long objectiveC method declaration.
Daniel Jasper63d7ced2013-02-05 10:07:47 +00005592 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
5593 " inRange:(NSRange)range\n"
5594 " outRange:(NSRange)out_range\n"
5595 " outRange1:(NSRange)out_range1\n"
5596 " outRange2:(NSRange)out_range2\n"
5597 " outRange3:(NSRange)out_range3\n"
5598 " outRange4:(NSRange)out_range4\n"
5599 " outRange5:(NSRange)out_range5\n"
5600 " outRange6:(NSRange)out_range6\n"
5601 " outRange7:(NSRange)out_range7\n"
5602 " outRange8:(NSRange)out_range8\n"
5603 " outRange9:(NSRange)out_range9;");
Nico Webere0fd4292013-01-10 20:18:33 +00005604
5605 verifyFormat("- (int)sum:(vector<int>)numbers;");
Nico Weberaab60052013-01-17 06:14:50 +00005606 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
Nico Webere0fd4292013-01-10 20:18:33 +00005607 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
5608 // protocol lists (but not for template classes):
5609 //verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
Nico Webercd52bda2013-01-10 23:11:41 +00005610
Daniel Jasper431f5912013-05-28 08:33:00 +00005611 verifyFormat("- (int (*)())foo:(int (*)())f;");
5612 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
Nico Webercd52bda2013-01-10 23:11:41 +00005613
5614 // If there's no return type (very rare in practice!), LLVM and Google style
5615 // agree.
Daniel Jasper627707b2013-03-22 16:55:40 +00005616 verifyFormat("- foo;");
Nico Webercd52bda2013-01-10 23:11:41 +00005617 verifyFormat("- foo:(int)f;");
5618 verifyGoogleFormat("- foo:(int)foo;");
Fariborz Jahanian154120c2012-12-20 19:54:13 +00005619}
5620
Nico Weber27d13672013-01-09 20:25:35 +00005621TEST_F(FormatTest, FormatObjCInterface) {
Nico Weber5f500df2013-01-10 20:12:55 +00005622 verifyFormat("@interface Foo : NSObject <NSSomeDelegate> {\n"
Nico Weber27d13672013-01-09 20:25:35 +00005623 "@public\n"
5624 " int field1;\n"
5625 "@protected\n"
5626 " int field2;\n"
5627 "@private\n"
5628 " int field3;\n"
5629 "@package\n"
5630 " int field4;\n"
5631 "}\n"
5632 "+ (id)init;\n"
5633 "@end");
5634
Nico Weber27d13672013-01-09 20:25:35 +00005635 verifyGoogleFormat("@interface Foo : NSObject<NSSomeDelegate> {\n"
5636 " @public\n"
5637 " int field1;\n"
5638 " @protected\n"
5639 " int field2;\n"
5640 " @private\n"
5641 " int field3;\n"
5642 " @package\n"
5643 " int field4;\n"
5644 "}\n"
Nico Weberaab60052013-01-17 06:14:50 +00005645 "+ (id)init;\n"
Nico Weber27d13672013-01-09 20:25:35 +00005646 "@end");
5647
Nico Weberf5ecfa52013-01-22 16:53:59 +00005648 verifyFormat("@interface /* wait for it */ Foo\n"
Nico Weber27d13672013-01-09 20:25:35 +00005649 "+ (id)init;\n"
5650 "// Look, a comment!\n"
5651 "- (int)answerWith:(int)i;\n"
5652 "@end");
5653
5654 verifyFormat("@interface Foo\n"
Nico Weber049c4472013-01-09 21:42:32 +00005655 "@end\n"
5656 "@interface Bar\n"
Nico Weber27d13672013-01-09 20:25:35 +00005657 "@end");
5658
5659 verifyFormat("@interface Foo : Bar\n"
5660 "+ (id)init;\n"
5661 "@end");
5662
Nico Weberf5ecfa52013-01-22 16:53:59 +00005663 verifyFormat("@interface Foo : /**/ Bar /**/ <Baz, /**/ Quux>\n"
Nico Weber27d13672013-01-09 20:25:35 +00005664 "+ (id)init;\n"
5665 "@end");
5666
Nico Weber5f500df2013-01-10 20:12:55 +00005667 verifyGoogleFormat("@interface Foo : Bar<Baz, Quux>\n"
Nico Weberaab60052013-01-17 06:14:50 +00005668 "+ (id)init;\n"
Nico Weber5f500df2013-01-10 20:12:55 +00005669 "@end");
5670
Nico Webered91bba2013-01-10 19:19:14 +00005671 verifyFormat("@interface Foo (HackStuff)\n"
Nico Weber27d13672013-01-09 20:25:35 +00005672 "+ (id)init;\n"
5673 "@end");
5674
Nico Webered91bba2013-01-10 19:19:14 +00005675 verifyFormat("@interface Foo ()\n"
Nico Weber27d13672013-01-09 20:25:35 +00005676 "+ (id)init;\n"
5677 "@end");
5678
Nico Weber5f500df2013-01-10 20:12:55 +00005679 verifyFormat("@interface Foo (HackStuff) <MyProtocol>\n"
Nico Weber27d13672013-01-09 20:25:35 +00005680 "+ (id)init;\n"
5681 "@end");
5682
Nico Weber5f500df2013-01-10 20:12:55 +00005683 verifyGoogleFormat("@interface Foo (HackStuff)<MyProtocol>\n"
Nico Weberaab60052013-01-17 06:14:50 +00005684 "+ (id)init;\n"
Nico Weber5f500df2013-01-10 20:12:55 +00005685 "@end");
5686
Manuel Klimekd5688cf2013-01-11 19:17:44 +00005687 verifyFormat("@interface Foo {\n"
5688 " int _i;\n"
5689 "}\n"
Nico Weber27d13672013-01-09 20:25:35 +00005690 "+ (id)init;\n"
5691 "@end");
5692
Manuel Klimekd5688cf2013-01-11 19:17:44 +00005693 verifyFormat("@interface Foo : Bar {\n"
5694 " int _i;\n"
5695 "}\n"
Nico Weber27d13672013-01-09 20:25:35 +00005696 "+ (id)init;\n"
5697 "@end");
5698
Manuel Klimekd5688cf2013-01-11 19:17:44 +00005699 verifyFormat("@interface Foo : Bar <Baz, Quux> {\n"
5700 " int _i;\n"
5701 "}\n"
Nico Weber27d13672013-01-09 20:25:35 +00005702 "+ (id)init;\n"
5703 "@end");
5704
Manuel Klimekd5688cf2013-01-11 19:17:44 +00005705 verifyFormat("@interface Foo (HackStuff) {\n"
5706 " int _i;\n"
5707 "}\n"
Nico Weber27d13672013-01-09 20:25:35 +00005708 "+ (id)init;\n"
5709 "@end");
5710
Manuel Klimekd5688cf2013-01-11 19:17:44 +00005711 verifyFormat("@interface Foo () {\n"
5712 " int _i;\n"
5713 "}\n"
Nico Weber27d13672013-01-09 20:25:35 +00005714 "+ (id)init;\n"
5715 "@end");
5716
Manuel Klimekd5688cf2013-01-11 19:17:44 +00005717 verifyFormat("@interface Foo (HackStuff) <MyProtocol> {\n"
5718 " int _i;\n"
5719 "}\n"
Nico Weber27d13672013-01-09 20:25:35 +00005720 "+ (id)init;\n"
5721 "@end");
5722}
5723
Nico Weber50767d82013-01-09 23:25:37 +00005724TEST_F(FormatTest, FormatObjCImplementation) {
5725 verifyFormat("@implementation Foo : NSObject {\n"
5726 "@public\n"
5727 " int field1;\n"
5728 "@protected\n"
5729 " int field2;\n"
5730 "@private\n"
5731 " int field3;\n"
5732 "@package\n"
5733 " int field4;\n"
5734 "}\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00005735 "+ (id)init {\n}\n"
Nico Weber50767d82013-01-09 23:25:37 +00005736 "@end");
5737
5738 verifyGoogleFormat("@implementation Foo : NSObject {\n"
5739 " @public\n"
5740 " int field1;\n"
5741 " @protected\n"
5742 " int field2;\n"
5743 " @private\n"
5744 " int field3;\n"
5745 " @package\n"
5746 " int field4;\n"
5747 "}\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00005748 "+ (id)init {\n}\n"
Nico Weber50767d82013-01-09 23:25:37 +00005749 "@end");
5750
5751 verifyFormat("@implementation Foo\n"
5752 "+ (id)init {\n"
Daniel Jasper6f5bb2c2013-01-14 16:24:39 +00005753 " if (true)\n"
5754 " return nil;\n"
Nico Weber50767d82013-01-09 23:25:37 +00005755 "}\n"
5756 "// Look, a comment!\n"
Manuel Klimekd5688cf2013-01-11 19:17:44 +00005757 "- (int)answerWith:(int)i {\n"
5758 " return i;\n"
5759 "}\n"
Nico Weber67015ed2013-01-11 21:14:08 +00005760 "+ (int)answerWith:(int)i {\n"
5761 " return i;\n"
5762 "}\n"
Nico Weber50767d82013-01-09 23:25:37 +00005763 "@end");
5764
5765 verifyFormat("@implementation Foo\n"
5766 "@end\n"
5767 "@implementation Bar\n"
5768 "@end");
5769
5770 verifyFormat("@implementation Foo : Bar\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00005771 "+ (id)init {\n}\n"
5772 "- (void)foo {\n}\n"
Nico Weber50767d82013-01-09 23:25:37 +00005773 "@end");
5774
Manuel Klimekd5688cf2013-01-11 19:17:44 +00005775 verifyFormat("@implementation Foo {\n"
5776 " int _i;\n"
5777 "}\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00005778 "+ (id)init {\n}\n"
Nico Weber50767d82013-01-09 23:25:37 +00005779 "@end");
5780
Manuel Klimekd5688cf2013-01-11 19:17:44 +00005781 verifyFormat("@implementation Foo : Bar {\n"
5782 " int _i;\n"
5783 "}\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00005784 "+ (id)init {\n}\n"
Nico Weber50767d82013-01-09 23:25:37 +00005785 "@end");
5786
Nico Webered91bba2013-01-10 19:19:14 +00005787 verifyFormat("@implementation Foo (HackStuff)\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00005788 "+ (id)init {\n}\n"
Nico Weber50767d82013-01-09 23:25:37 +00005789 "@end");
Daniel Jasper7186ccc2013-08-28 08:04:23 +00005790 verifyFormat("@implementation ObjcClass\n"
5791 "- (void)method;\n"
5792 "{}\n"
5793 "@end");
Nico Weber50767d82013-01-09 23:25:37 +00005794}
5795
Nico Weber1abe6ea2013-01-09 21:15:03 +00005796TEST_F(FormatTest, FormatObjCProtocol) {
5797 verifyFormat("@protocol Foo\n"
5798 "@property(weak) id delegate;\n"
5799 "- (NSUInteger)numberOfThings;\n"
5800 "@end");
5801
Nico Weber5f500df2013-01-10 20:12:55 +00005802 verifyFormat("@protocol MyProtocol <NSObject>\n"
Nico Weber1abe6ea2013-01-09 21:15:03 +00005803 "- (NSUInteger)numberOfThings;\n"
5804 "@end");
5805
Nico Weber5f500df2013-01-10 20:12:55 +00005806 verifyGoogleFormat("@protocol MyProtocol<NSObject>\n"
Nico Weberaab60052013-01-17 06:14:50 +00005807 "- (NSUInteger)numberOfThings;\n"
Nico Weber5f500df2013-01-10 20:12:55 +00005808 "@end");
5809
Nico Weber1abe6ea2013-01-09 21:15:03 +00005810 verifyFormat("@protocol Foo;\n"
5811 "@protocol Bar;\n");
Nico Weber049c4472013-01-09 21:42:32 +00005812
5813 verifyFormat("@protocol Foo\n"
5814 "@end\n"
5815 "@protocol Bar\n"
5816 "@end");
Nico Weberb530fa32013-01-10 00:25:19 +00005817
5818 verifyFormat("@protocol myProtocol\n"
5819 "- (void)mandatoryWithInt:(int)i;\n"
5820 "@optional\n"
5821 "- (void)optional;\n"
5822 "@required\n"
5823 "- (void)required;\n"
Nico Weber880e5382013-01-10 00:42:07 +00005824 "@optional\n"
5825 "@property(assign) int madProp;\n"
Nico Weberb530fa32013-01-10 00:25:19 +00005826 "@end\n");
Daniel Jasperaa9e7b12013-08-01 13:46:58 +00005827
5828 verifyFormat("@property(nonatomic, assign, readonly)\n"
5829 " int *looooooooooooooooooooooooooooongNumber;\n"
5830 "@property(nonatomic, assign, readonly)\n"
5831 " NSString *looooooooooooooooooooooooooooongName;");
Stephen Hines651f13c2014-04-23 16:59:28 -07005832
5833 verifyFormat("@implementation PR18406\n"
5834 "}\n"
5835 "@end");
Nico Weber1abe6ea2013-01-09 21:15:03 +00005836}
5837
Daniel Jasper63d7ced2013-02-05 10:07:47 +00005838TEST_F(FormatTest, FormatObjCMethodDeclarations) {
5839 verifyFormat("- (void)doSomethingWith:(GTMFoo *)theFoo\n"
5840 " rect:(NSRect)theRect\n"
5841 " interval:(float)theInterval {\n"
5842 "}");
5843 verifyFormat("- (void)shortf:(GTMFoo *)theFoo\n"
5844 " longKeyword:(NSRect)theRect\n"
5845 " evenLongerKeyword:(float)theInterval\n"
5846 " error:(NSError **)theError {\n"
5847 "}");
5848}
5849
Nico Weberbcfdd262013-01-12 06:18:40 +00005850TEST_F(FormatTest, FormatObjCMethodExpr) {
5851 verifyFormat("[foo bar:baz];");
5852 verifyFormat("return [foo bar:baz];");
5853 verifyFormat("f([foo bar:baz]);");
5854 verifyFormat("f(2, [foo bar:baz]);");
5855 verifyFormat("f(2, a ? b : c);");
5856 verifyFormat("[[self initWithInt:4] bar:[baz quux:arrrr]];");
5857
Nico Weberee0feec2013-02-05 16:21:00 +00005858 // Unary operators.
5859 verifyFormat("int a = +[foo bar:baz];");
5860 verifyFormat("int a = -[foo bar:baz];");
5861 verifyFormat("int a = ![foo bar:baz];");
5862 verifyFormat("int a = ~[foo bar:baz];");
5863 verifyFormat("int a = ++[foo bar:baz];");
5864 verifyFormat("int a = --[foo bar:baz];");
5865 verifyFormat("int a = sizeof [foo bar:baz];");
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00005866 verifyFormat("int a = alignof [foo bar:baz];", getGoogleStyle());
Nico Webere8a97982013-02-06 06:20:11 +00005867 verifyFormat("int a = &[foo bar:baz];");
5868 verifyFormat("int a = *[foo bar:baz];");
Nico Weberee0feec2013-02-05 16:21:00 +00005869 // FIXME: Make casts work, without breaking f()[4].
Nico Weber4c2cc602013-02-13 03:48:27 +00005870 //verifyFormat("int a = (int)[foo bar:baz];");
Nico Webere0dc7c72013-02-13 04:40:03 +00005871 //verifyFormat("return (int)[foo bar:baz];");
5872 //verifyFormat("(void)[foo bar:baz];");
Nico Weber4c2cc602013-02-13 03:48:27 +00005873 verifyFormat("return (MyType *)[self.tableView cellForRowAtIndexPath:cell];");
Nico Weberee0feec2013-02-05 16:21:00 +00005874
5875 // Binary operators.
Nico Weberbcfdd262013-01-12 06:18:40 +00005876 verifyFormat("[foo bar:baz], [foo bar:baz];");
5877 verifyFormat("[foo bar:baz] = [foo bar:baz];");
5878 verifyFormat("[foo bar:baz] *= [foo bar:baz];");
5879 verifyFormat("[foo bar:baz] /= [foo bar:baz];");
5880 verifyFormat("[foo bar:baz] %= [foo bar:baz];");
5881 verifyFormat("[foo bar:baz] += [foo bar:baz];");
5882 verifyFormat("[foo bar:baz] -= [foo bar:baz];");
5883 verifyFormat("[foo bar:baz] <<= [foo bar:baz];");
5884 verifyFormat("[foo bar:baz] >>= [foo bar:baz];");
5885 verifyFormat("[foo bar:baz] &= [foo bar:baz];");
5886 verifyFormat("[foo bar:baz] ^= [foo bar:baz];");
5887 verifyFormat("[foo bar:baz] |= [foo bar:baz];");
5888 verifyFormat("[foo bar:baz] ? [foo bar:baz] : [foo bar:baz];");
5889 verifyFormat("[foo bar:baz] || [foo bar:baz];");
5890 verifyFormat("[foo bar:baz] && [foo bar:baz];");
5891 verifyFormat("[foo bar:baz] | [foo bar:baz];");
5892 verifyFormat("[foo bar:baz] ^ [foo bar:baz];");
5893 verifyFormat("[foo bar:baz] & [foo bar:baz];");
5894 verifyFormat("[foo bar:baz] == [foo bar:baz];");
5895 verifyFormat("[foo bar:baz] != [foo bar:baz];");
5896 verifyFormat("[foo bar:baz] >= [foo bar:baz];");
5897 verifyFormat("[foo bar:baz] <= [foo bar:baz];");
5898 verifyFormat("[foo bar:baz] > [foo bar:baz];");
5899 verifyFormat("[foo bar:baz] < [foo bar:baz];");
5900 verifyFormat("[foo bar:baz] >> [foo bar:baz];");
5901 verifyFormat("[foo bar:baz] << [foo bar:baz];");
5902 verifyFormat("[foo bar:baz] - [foo bar:baz];");
5903 verifyFormat("[foo bar:baz] + [foo bar:baz];");
5904 verifyFormat("[foo bar:baz] * [foo bar:baz];");
5905 verifyFormat("[foo bar:baz] / [foo bar:baz];");
5906 verifyFormat("[foo bar:baz] % [foo bar:baz];");
5907 // Whew!
5908
Nico Weberc2e6d2a2013-02-11 15:32:15 +00005909 verifyFormat("return in[42];");
5910 verifyFormat("for (id foo in [self getStuffFor:bla]) {\n"
5911 "}");
5912
Nico Weberbcfdd262013-01-12 06:18:40 +00005913 verifyFormat("[self stuffWithInt:(4 + 2) float:4.5];");
5914 verifyFormat("[self stuffWithInt:a ? b : c float:4.5];");
5915 verifyFormat("[self stuffWithInt:a ? [self foo:bar] : c];");
5916 verifyFormat("[self stuffWithInt:a ? (e ? f : g) : c];");
5917 verifyFormat("[cond ? obj1 : obj2 methodWithParam:param]");
Nico Weber6292dd42013-01-12 23:41:33 +00005918 verifyFormat("[button setAction:@selector(zoomOut:)];");
Nico Webercd458332013-01-12 23:48:49 +00005919 verifyFormat("[color getRed:&r green:&g blue:&b alpha:&a];");
Daniel Jasper63d7ced2013-02-05 10:07:47 +00005920
Nico Weberbcfdd262013-01-12 06:18:40 +00005921 verifyFormat("arr[[self indexForFoo:a]];");
5922 verifyFormat("throw [self errorFor:a];");
5923 verifyFormat("@throw [self errorFor:a];");
5924
Nico Weber465e8612013-06-25 00:55:57 +00005925 verifyFormat("[(id)foo bar:(id)baz quux:(id)snorf];");
5926 verifyFormat("[(id)foo bar:(id) ? baz : quux];");
5927 verifyFormat("4 > 4 ? (id)a : (id)baz;");
5928
Nico Webere8ccc812013-01-12 22:48:47 +00005929 // This tests that the formatter doesn't break after "backing" but before ":",
5930 // which would be at 80 columns.
Nico Weberbcfdd262013-01-12 06:18:40 +00005931 verifyFormat(
5932 "void f() {\n"
Daniel Jasper63d7ced2013-02-05 10:07:47 +00005933 " if ((self = [super initWithContentRect:contentRect\n"
Daniel Jasper1eaa9972013-08-01 23:13:03 +00005934 " styleMask:styleMask ?: otherMask\n"
Daniel Jasper63d7ced2013-02-05 10:07:47 +00005935 " backing:NSBackingStoreBuffered\n"
5936 " defer:YES]))");
5937
Daniel Jasper4e778092013-02-06 10:05:46 +00005938 verifyFormat(
5939 "[foo checkThatBreakingAfterColonWorksOk:\n"
Daniel Jasper1eaa9972013-08-01 23:13:03 +00005940 " [bar ifItDoes:reduceOverallLineLengthLikeInThisCase]];");
Daniel Jasper63d7ced2013-02-05 10:07:47 +00005941
5942 verifyFormat("[myObj short:arg1 // Force line break\n"
Daniel Jasper1eaa9972013-08-01 23:13:03 +00005943 " longKeyword:arg2 != nil ? arg2 : @\"longKeyword\"\n"
5944 " evenLongerKeyword:arg3 ?: @\"evenLongerKeyword\"\n"
Daniel Jasper63d7ced2013-02-05 10:07:47 +00005945 " error:arg4];");
5946 verifyFormat(
5947 "void f() {\n"
5948 " popup_window_.reset([[RenderWidgetPopupWindow alloc]\n"
5949 " initWithContentRect:NSMakeRect(origin_global.x, origin_global.y,\n"
5950 " pos.width(), pos.height())\n"
5951 " styleMask:NSBorderlessWindowMask\n"
5952 " backing:NSBackingStoreBuffered\n"
5953 " defer:NO]);\n"
5954 "}");
Daniel Jasperdeb61c52013-11-08 17:33:24 +00005955 verifyFormat(
5956 "void f() {\n"
5957 " popup_wdow_.reset([[RenderWidgetPopupWindow alloc]\n"
5958 " iniithContentRect:NSMakRet(origin_global.x, origin_global.y,\n"
5959 " pos.width(), pos.height())\n"
5960 " syeMask:NSBorderlessWindowMask\n"
5961 " bking:NSBackingStoreBuffered\n"
5962 " der:NO]);\n"
5963 "}",
5964 getLLVMStyleWithColumns(70));
Stephen Hines651f13c2014-04-23 16:59:28 -07005965 verifyFormat("{\n"
5966 " popup_window_.reset([[RenderWidgetPopupWindow alloc]\n"
5967 " initWithContentRect:NSMakeRect(origin_global.x,\n"
5968 " origin_global.y,\n"
5969 " pos.width(),\n"
5970 " pos.height())\n"
5971 " styleMask:NSBorderlessWindowMask\n"
5972 " backing:NSBackingStoreBuffered\n"
5973 " defer:NO]);\n"
5974 "}",
5975 getChromiumStyle(FormatStyle::LK_Cpp));
Daniel Jasper4e778092013-02-06 10:05:46 +00005976 verifyFormat("[contentsContainer replaceSubview:[subviews objectAtIndex:0]\n"
5977 " with:contentsNativeView];");
5978
5979 verifyFormat(
5980 "[pboard addTypes:[NSArray arrayWithObject:kBookmarkButtonDragType]\n"
5981 " owner:nillllll];");
5982
Daniel Jasper4e778092013-02-06 10:05:46 +00005983 verifyFormat(
Daniel Jasperce3d1a62013-02-08 08:22:00 +00005984 "[pboard setData:[NSData dataWithBytes:&button length:sizeof(button)]\n"
Daniel Jasper4e778092013-02-06 10:05:46 +00005985 " forType:kBookmarkButtonDragType];");
5986
5987 verifyFormat("[defaultCenter addObserver:self\n"
5988 " selector:@selector(willEnterFullscreen)\n"
5989 " name:kWillEnterFullscreenNotification\n"
5990 " object:nil];");
Daniel Jasper9e9e6e02013-02-06 16:00:26 +00005991 verifyFormat("[image_rep drawInRect:drawRect\n"
5992 " fromRect:NSZeroRect\n"
5993 " operation:NSCompositeCopy\n"
5994 " fraction:1.0\n"
5995 " respectFlipped:NO\n"
5996 " hints:nil];");
Nico Weber4ed7f3e2013-02-06 16:54:35 +00005997
5998 verifyFormat(
5999 "scoped_nsobject<NSTextField> message(\n"
6000 " // The frame will be fixed up when |-setMessageText:| is called.\n"
6001 " [[NSTextField alloc] initWithFrame:NSMakeRect(0, 0, 0, 0)]);");
Daniel Jasper1eaa9972013-08-01 23:13:03 +00006002 verifyFormat("[self aaaaaa:bbbbbbbbbbbbb\n"
6003 " aaaaaaaaaa:bbbbbbbbbbbbbbbbb\n"
6004 " aaaaa:bbbbbbbbbbb + bbbbbbbbbbbb\n"
6005 " aaaa:bbb];");
Daniel Jasperdeb61c52013-11-08 17:33:24 +00006006 verifyFormat("[self param:function( //\n"
6007 " parameter)]");
Daniel Jasper966e6d32013-11-07 19:23:49 +00006008 verifyFormat(
6009 "[self aaaaaaaaaa:aaaaaaaaaaaaaaa | aaaaaaaaaaaaaaa | aaaaaaaaaaaaaaa |\n"
6010 " aaaaaaaaaaaaaaa | aaaaaaaaaaaaaaa | aaaaaaaaaaaaaaa |\n"
6011 " aaaaaaaaaaaaaaa | aaaaaaaaaaaaaaa];");
Daniel Jasper8f54d882013-10-26 17:00:22 +00006012
6013 // Variadic parameters.
6014 verifyFormat(
6015 "NSArray *myStrings = [NSArray stringarray:@\"a\", @\"b\", nil];");
Daniel Jasper966e6d32013-11-07 19:23:49 +00006016 verifyFormat(
6017 "[self aaaaaaaaaaaaa:aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaa,\n"
6018 " aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaa,\n"
6019 " aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaa];");
Daniel Jasper072ac6c2013-11-08 02:08:01 +00006020 verifyFormat("[self // break\n"
6021 " a:a\n"
6022 " aaa:aaa];");
Stephen Hines651f13c2014-04-23 16:59:28 -07006023 verifyFormat("bool a = ([aaaaaaaa aaaaa] == aaaaaaaaaaaaaaaaa ||\n"
6024 " [aaaaaaaa aaaaa] == aaaaaaaaaaaaaaaaaaaa);");
Nico Weberbcfdd262013-01-12 06:18:40 +00006025}
6026
Nico Weber581f5572013-01-07 15:56:25 +00006027TEST_F(FormatTest, ObjCAt) {
Nico Weber4a293a22013-01-07 16:07:07 +00006028 verifyFormat("@autoreleasepool");
Nico Weberd0af4b42013-01-07 16:14:28 +00006029 verifyFormat("@catch");
6030 verifyFormat("@class");
Nico Weber4a293a22013-01-07 16:07:07 +00006031 verifyFormat("@compatibility_alias");
6032 verifyFormat("@defs");
Nico Weberefcfe732013-01-07 15:17:23 +00006033 verifyFormat("@dynamic");
Nico Weber4a293a22013-01-07 16:07:07 +00006034 verifyFormat("@encode");
6035 verifyFormat("@end");
6036 verifyFormat("@finally");
6037 verifyFormat("@implementation");
6038 verifyFormat("@import");
6039 verifyFormat("@interface");
6040 verifyFormat("@optional");
6041 verifyFormat("@package");
Nico Weberd0af4b42013-01-07 16:14:28 +00006042 verifyFormat("@private");
Nico Weber4a293a22013-01-07 16:07:07 +00006043 verifyFormat("@property");
Nico Weberd0af4b42013-01-07 16:14:28 +00006044 verifyFormat("@protected");
Nico Weber4a293a22013-01-07 16:07:07 +00006045 verifyFormat("@protocol");
Nico Weberd0af4b42013-01-07 16:14:28 +00006046 verifyFormat("@public");
Nico Weber4a293a22013-01-07 16:07:07 +00006047 verifyFormat("@required");
6048 verifyFormat("@selector");
6049 verifyFormat("@synchronized");
6050 verifyFormat("@synthesize");
Nico Weberd0af4b42013-01-07 16:14:28 +00006051 verifyFormat("@throw");
6052 verifyFormat("@try");
Nico Weber4a293a22013-01-07 16:07:07 +00006053
Nico Weber581f5572013-01-07 15:56:25 +00006054 EXPECT_EQ("@interface", format("@ interface"));
6055
6056 // The precise formatting of this doesn't matter, nobody writes code like
6057 // this.
6058 verifyFormat("@ /*foo*/ interface");
Nico Weberefcfe732013-01-07 15:17:23 +00006059}
6060
Nico Weberc31689a2013-01-08 19:15:23 +00006061TEST_F(FormatTest, ObjCSnippets) {
Manuel Klimekd5688cf2013-01-11 19:17:44 +00006062 verifyFormat("@autoreleasepool {\n"
6063 " foo();\n"
6064 "}");
Nico Webercf4a79c2013-01-08 17:56:31 +00006065 verifyFormat("@class Foo, Bar;");
Nico Weberc31689a2013-01-08 19:15:23 +00006066 verifyFormat("@compatibility_alias AliasName ExistingClass;");
Nico Webercf4a79c2013-01-08 17:56:31 +00006067 verifyFormat("@dynamic textColor;");
Nico Weber5dfe9b42013-01-18 05:11:47 +00006068 verifyFormat("char *buf1 = @encode(int *);");
6069 verifyFormat("char *buf1 = @encode(typeof(4 * 5));");
Nico Weber95e8e462013-02-12 16:17:07 +00006070 verifyFormat("char *buf1 = @encode(int **);");
Nico Weber3a2673e2013-01-08 20:16:23 +00006071 verifyFormat("Protocol *proto = @protocol(p1);");
Nico Weber6a21a552013-01-18 02:43:57 +00006072 verifyFormat("SEL s = @selector(foo:);");
Manuel Klimekd5688cf2013-01-11 19:17:44 +00006073 verifyFormat("@synchronized(self) {\n"
6074 " f();\n"
6075 "}");
Nico Webercf4a79c2013-01-08 17:56:31 +00006076
Nico Weber70848232013-01-10 21:30:42 +00006077 verifyFormat("@synthesize dropArrowPosition = dropArrowPosition_;");
6078 verifyGoogleFormat("@synthesize dropArrowPosition = dropArrowPosition_;");
6079
Nico Webercf4a79c2013-01-08 17:56:31 +00006080 verifyFormat("@property(assign, nonatomic) CGFloat hoverAlpha;");
Nico Weber70848232013-01-10 21:30:42 +00006081 verifyFormat("@property(assign, getter=isEditable) BOOL editable;");
6082 verifyGoogleFormat("@property(assign, getter=isEditable) BOOL editable;");
Stephen Hines651f13c2014-04-23 16:59:28 -07006083 verifyFormat("@property (assign, getter=isEditable) BOOL editable;",
6084 getMozillaStyle());
6085 verifyFormat("@property BOOL editable;", getMozillaStyle());
6086 verifyFormat("@property (assign, getter=isEditable) BOOL editable;",
6087 getWebKitStyle());
6088 verifyFormat("@property BOOL editable;", getWebKitStyle());
Nico Weber10fc2c62013-06-25 00:25:40 +00006089
6090 verifyFormat("@import foo.bar;\n"
6091 "@import baz;");
Nico Webercf4a79c2013-01-08 17:56:31 +00006092}
6093
Nico Weber712f5b32013-02-07 00:19:29 +00006094TEST_F(FormatTest, ObjCLiterals) {
6095 verifyFormat("@\"String\"");
6096 verifyFormat("@1");
6097 verifyFormat("@+4.8");
6098 verifyFormat("@-4");
6099 verifyFormat("@1LL");
6100 verifyFormat("@.5");
6101 verifyFormat("@'c'");
6102 verifyFormat("@true");
6103
6104 verifyFormat("NSNumber *smallestInt = @(-INT_MAX - 1);");
6105 verifyFormat("NSNumber *piOverTwo = @(M_PI / 2);");
6106 verifyFormat("NSNumber *favoriteColor = @(Green);");
6107 verifyFormat("NSString *path = @(getenv(\"PATH\"));");
Stephen Hines651f13c2014-04-23 16:59:28 -07006108
6109 verifyFormat("[dictionary setObject:@(1) forKey:@\"number\"];");
Daniel Jasper3c6aea72013-10-24 10:31:50 +00006110}
Nico Weber712f5b32013-02-07 00:19:29 +00006111
Daniel Jasper3c6aea72013-10-24 10:31:50 +00006112TEST_F(FormatTest, ObjCDictLiterals) {
Nico Weber712f5b32013-02-07 00:19:29 +00006113 verifyFormat("@{");
Nico Weberd74fcdb2013-02-10 20:35:35 +00006114 verifyFormat("@{}");
Stephen Hines651f13c2014-04-23 16:59:28 -07006115 verifyFormat("@{@\"one\" : @1}");
6116 verifyFormat("return @{@\"one\" : @1;");
6117 verifyFormat("@{@\"one\" : @1}");
Manuel Klimek67d080d2013-04-12 14:13:36 +00006118
Stephen Hines651f13c2014-04-23 16:59:28 -07006119 verifyFormat("@{@\"one\" : @{@2 : @1}}");
6120 verifyFormat("@{\n"
6121 " @\"one\" : @{@2 : @1},\n"
6122 "}");
Manuel Klimek67d080d2013-04-12 14:13:36 +00006123
Stephen Hines651f13c2014-04-23 16:59:28 -07006124 verifyFormat("@{1 > 2 ? @\"one\" : @\"two\" : 1 > 2 ? @1 : @2}");
Nico Weberd74fcdb2013-02-10 20:35:35 +00006125 verifyFormat("[self setDict:@{}");
Stephen Hines651f13c2014-04-23 16:59:28 -07006126 verifyFormat("[self setDict:@{@1 : @2}");
6127 verifyFormat("NSLog(@\"%@\", @{@1 : @2, @2 : @3}[@1]);");
Nico Weberd74fcdb2013-02-10 20:35:35 +00006128 verifyFormat(
Stephen Hines651f13c2014-04-23 16:59:28 -07006129 "NSDictionary *masses = @{@\"H\" : @1.0078, @\"He\" : @4.0026};");
Nico Webere6262002013-02-10 20:39:05 +00006130 verifyFormat(
Stephen Hines651f13c2014-04-23 16:59:28 -07006131 "NSDictionary *settings = @{AVEncoderKey : @(AVAudioQualityMax)};");
Daniel Jasper66d19bd2013-02-18 11:59:17 +00006132
Nico Weber0ac717b2013-02-10 20:48:24 +00006133 verifyFormat(
Daniel Jaspera53bbae2013-10-20 16:45:46 +00006134 "NSDictionary *d = @{\n"
6135 " @\"nam\" : NSUserNam(),\n"
6136 " @\"dte\" : [NSDate date],\n"
6137 " @\"processInfo\" : [NSProcessInfo processInfo]\n"
6138 "};");
Nico Weberf2ff8122013-05-26 05:39:26 +00006139 verifyFormat(
Daniel Jaspera53bbae2013-10-20 16:45:46 +00006140 "@{\n"
6141 " NSFontAttributeNameeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee : "
6142 "regularFont,\n"
6143 "};");
Daniel Jasperc9689432013-10-22 15:45:58 +00006144 verifyGoogleFormat(
6145 "@{\n"
6146 " NSFontAttributeNameeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee : "
6147 "regularFont,\n"
6148 "};");
Stephen Hines651f13c2014-04-23 16:59:28 -07006149 verifyFormat(
6150 "@{\n"
6151 " NSFontAttributeNameeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee :\n"
6152 " reeeeeeeeeeeeeeeeeeeeeeeegularFont,\n"
6153 "};");
Daniel Jasper3c6aea72013-10-24 10:31:50 +00006154
6155 // We should try to be robust in case someone forgets the "@".
6156 verifyFormat(
6157 "NSDictionary *d = {\n"
6158 " @\"nam\" : NSUserNam(),\n"
6159 " @\"dte\" : [NSDate date],\n"
6160 " @\"processInfo\" : [NSProcessInfo processInfo]\n"
6161 "};");
6162}
6163
6164TEST_F(FormatTest, ObjCArrayLiterals) {
6165 verifyFormat("@[");
6166 verifyFormat("@[]");
6167 verifyFormat(
6168 "NSArray *array = @[ @\" Hey \", NSApp, [NSNumber numberWithInt:42] ];");
6169 verifyFormat("return @[ @3, @[], @[ @4, @5 ] ];");
6170 verifyFormat("NSArray *array = @[ [foo description] ];");
6171
6172 verifyFormat(
6173 "NSArray *some_variable = @[\n"
6174 " aaaa == bbbbbbbbbbb ? @\"aaaaaaaaaaaa\" : @\"aaaaaaaaaaaaaa\",\n"
6175 " @\"aaaaaaaaaaaaaaaaa\",\n"
6176 " @\"aaaaaaaaaaaaaaaaa\",\n"
6177 " @\"aaaaaaaaaaaaaaaaa\"\n"
Daniel Jasperc9689432013-10-22 15:45:58 +00006178 "];");
Daniel Jasper3c6aea72013-10-24 10:31:50 +00006179 verifyFormat("NSArray *some_variable = @[\n"
6180 " @\"aaaaaaaaaaaaaaaaa\",\n"
6181 " @\"aaaaaaaaaaaaaaaaa\",\n"
6182 " @\"aaaaaaaaaaaaaaaaa\",\n"
6183 " @\"aaaaaaaaaaaaaaaaa\",\n"
6184 "];");
6185 verifyGoogleFormat("NSArray *some_variable = @[\n"
6186 " @\"aaaaaaaaaaaaaaaaa\",\n"
6187 " @\"aaaaaaaaaaaaaaaaa\",\n"
6188 " @\"aaaaaaaaaaaaaaaaa\",\n"
6189 " @\"aaaaaaaaaaaaaaaaa\"\n"
6190 "];");
6191
6192 // We should try to be robust in case someone forgets the "@".
6193 verifyFormat("NSArray *some_variable = [\n"
6194 " @\"aaaaaaaaaaaaaaaaa\",\n"
6195 " @\"aaaaaaaaaaaaaaaaa\",\n"
6196 " @\"aaaaaaaaaaaaaaaaa\",\n"
6197 " @\"aaaaaaaaaaaaaaaaa\",\n"
6198 "];");
Stephen Hines651f13c2014-04-23 16:59:28 -07006199 verifyFormat(
6200 "- (NSAttributedString *)attributedStringForSegment:(NSUInteger)segment\n"
6201 " index:(NSUInteger)index\n"
6202 " nonDigitAttributes:\n"
6203 " (NSDictionary *)noDigitAttributes;");
6204 verifyFormat(
6205 "[someFunction someLooooooooooooongParameter:\n"
6206 " @[ NSBundle.mainBundle.infoDictionary[@\"a\"] ]];");
Nico Weber712f5b32013-02-07 00:19:29 +00006207}
6208
Manuel Klimek547d5db2013-02-08 17:38:27 +00006209TEST_F(FormatTest, ReformatRegionAdjustsIndent) {
6210 EXPECT_EQ("{\n"
6211 "{\n"
6212 "a;\n"
6213 "b;\n"
6214 "}\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00006215 "}",
6216 format("{\n"
6217 "{\n"
6218 "a;\n"
6219 " b;\n"
6220 "}\n"
6221 "}",
6222 13, 2, getLLVMStyle()));
Manuel Klimek547d5db2013-02-08 17:38:27 +00006223 EXPECT_EQ("{\n"
6224 "{\n"
6225 " a;\n"
6226 "b;\n"
6227 "}\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00006228 "}",
6229 format("{\n"
6230 "{\n"
6231 " a;\n"
6232 "b;\n"
6233 "}\n"
6234 "}",
6235 9, 2, getLLVMStyle()));
Manuel Klimek547d5db2013-02-08 17:38:27 +00006236 EXPECT_EQ("{\n"
6237 "{\n"
6238 "public:\n"
6239 " b;\n"
6240 "}\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00006241 "}",
6242 format("{\n"
6243 "{\n"
6244 "public:\n"
6245 " b;\n"
6246 "}\n"
6247 "}",
6248 17, 2, getLLVMStyle()));
Manuel Klimek547d5db2013-02-08 17:38:27 +00006249 EXPECT_EQ("{\n"
6250 "{\n"
6251 "a;\n"
6252 "}\n"
6253 "{\n"
Daniel Jasper1fb8d882013-05-14 09:30:02 +00006254 " b; //\n"
Manuel Klimek547d5db2013-02-08 17:38:27 +00006255 "}\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00006256 "}",
6257 format("{\n"
6258 "{\n"
6259 "a;\n"
6260 "}\n"
6261 "{\n"
Daniel Jasper1fb8d882013-05-14 09:30:02 +00006262 " b; //\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00006263 "}\n"
6264 "}",
6265 22, 2, getLLVMStyle()));
Manuel Klimek52635ff2013-02-08 19:53:32 +00006266 EXPECT_EQ(" {\n"
Daniel Jasper1fb8d882013-05-14 09:30:02 +00006267 " a; //\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00006268 " }",
6269 format(" {\n"
Daniel Jasper1fb8d882013-05-14 09:30:02 +00006270 "a; //\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00006271 " }",
6272 4, 2, getLLVMStyle()));
Daniel Jasper9ece2bb2013-02-12 16:51:23 +00006273 EXPECT_EQ("void f() {}\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00006274 "void g() {}",
6275 format("void f() {}\n"
6276 "void g() {}",
6277 13, 0, getLLVMStyle()));
Daniel Jasper83a90e52013-03-20 14:31:47 +00006278 EXPECT_EQ("int a; // comment\n"
6279 " // line 2\n"
6280 "int b;",
6281 format("int a; // comment\n"
6282 " // line 2\n"
6283 " int b;",
6284 35, 0, getLLVMStyle()));
Daniel Jasper15ec3a82013-07-11 21:27:40 +00006285 EXPECT_EQ(" int a;\n"
6286 " void\n"
6287 " ffffff() {\n"
6288 " }",
6289 format(" int a;\n"
6290 "void ffffff() {}",
6291 11, 0, getLLVMStyleWithColumns(11)));
Stephen Hines651f13c2014-04-23 16:59:28 -07006292
6293 EXPECT_EQ(" void f() {\n"
6294 "#define A 1\n"
6295 " }",
6296 format(" void f() {\n"
6297 " #define A 1\n" // Format this line.
6298 " }",
6299 20, 0, getLLVMStyle()));
6300 EXPECT_EQ(" void f() {\n"
6301 " int i;\n"
6302 "#define A \\\n"
6303 " int i; \\\n"
6304 " int j;\n"
6305 " int k;\n"
6306 " }",
6307 format(" void f() {\n"
6308 " int i;\n"
6309 "#define A \\\n"
6310 " int i; \\\n"
6311 " int j;\n"
6312 " int k;\n" // Format this line.
6313 " }",
6314 67, 0, getLLVMStyle()));
Manuel Klimek52635ff2013-02-08 19:53:32 +00006315}
Manuel Klimek547d5db2013-02-08 17:38:27 +00006316
Manuel Klimek8092a942013-02-20 10:15:13 +00006317TEST_F(FormatTest, BreakStringLiterals) {
6318 EXPECT_EQ("\"some text \"\n"
6319 "\"other\";",
6320 format("\"some text other\";", getLLVMStyleWithColumns(12)));
Alexander Kornienko919398b2013-04-17 17:34:05 +00006321 EXPECT_EQ("\"some text \"\n"
6322 "\"other\";",
6323 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
Manuel Klimek8092a942013-02-20 10:15:13 +00006324 EXPECT_EQ(
6325 "#define A \\\n"
6326 " \"some \" \\\n"
6327 " \"text \" \\\n"
6328 " \"other\";",
6329 format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
6330 EXPECT_EQ(
6331 "#define A \\\n"
6332 " \"so \" \\\n"
6333 " \"text \" \\\n"
6334 " \"other\";",
6335 format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
6336
6337 EXPECT_EQ("\"some text\"",
6338 format("\"some text\"", getLLVMStyleWithColumns(1)));
6339 EXPECT_EQ("\"some text\"",
6340 format("\"some text\"", getLLVMStyleWithColumns(11)));
6341 EXPECT_EQ("\"some \"\n"
6342 "\"text\"",
6343 format("\"some text\"", getLLVMStyleWithColumns(10)));
6344 EXPECT_EQ("\"some \"\n"
6345 "\"text\"",
6346 format("\"some text\"", getLLVMStyleWithColumns(7)));
Manuel Klimekaf31fd72013-03-01 13:14:08 +00006347 EXPECT_EQ("\"some\"\n"
Alexander Kornienko70ce7882013-04-15 14:28:00 +00006348 "\" tex\"\n"
6349 "\"t\"",
Manuel Klimek8092a942013-02-20 10:15:13 +00006350 format("\"some text\"", getLLVMStyleWithColumns(6)));
Manuel Klimek00905912013-03-04 20:03:38 +00006351 EXPECT_EQ("\"some\"\n"
6352 "\" tex\"\n"
6353 "\" and\"",
6354 format("\"some tex and\"", getLLVMStyleWithColumns(6)));
6355 EXPECT_EQ("\"some\"\n"
6356 "\"/tex\"\n"
6357 "\"/and\"",
6358 format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
Manuel Klimek8092a942013-02-20 10:15:13 +00006359
6360 EXPECT_EQ("variable =\n"
6361 " \"long string \"\n"
6362 " \"literal\";",
6363 format("variable = \"long string literal\";",
6364 getLLVMStyleWithColumns(20)));
6365
6366 EXPECT_EQ("variable = f(\n"
6367 " \"long string \"\n"
Daniel Jasperfaab0d32013-02-27 09:47:53 +00006368 " \"literal\",\n"
6369 " short,\n"
Manuel Klimek8092a942013-02-20 10:15:13 +00006370 " loooooooooooooooooooong);",
6371 format("variable = f(\"long string literal\", short, "
6372 "loooooooooooooooooooong);",
6373 getLLVMStyleWithColumns(20)));
Alexander Kornienko22d0e292013-06-17 12:59:44 +00006374
6375 EXPECT_EQ("f(g(\"long string \"\n"
6376 " \"literal\"),\n"
6377 " b);",
6378 format("f(g(\"long string literal\"), b);",
6379 getLLVMStyleWithColumns(20)));
6380 EXPECT_EQ("f(g(\"long string \"\n"
6381 " \"literal\",\n"
6382 " a),\n"
6383 " b);",
6384 format("f(g(\"long string literal\", a), b);",
6385 getLLVMStyleWithColumns(20)));
Manuel Klimek8092a942013-02-20 10:15:13 +00006386 EXPECT_EQ(
6387 "f(\"one two\".split(\n"
Daniel Jasper13d2aa52013-08-30 08:29:25 +00006388 " variable));",
Manuel Klimek8092a942013-02-20 10:15:13 +00006389 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
6390 EXPECT_EQ("f(\"one two three four five six \"\n"
6391 " \"seven\".split(\n"
6392 " really_looooong_variable));",
6393 format("f(\"one two three four five six seven\"."
6394 "split(really_looooong_variable));",
6395 getLLVMStyleWithColumns(33)));
6396
6397 EXPECT_EQ("f(\"some \"\n"
6398 " \"text\",\n"
6399 " other);",
6400 format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
Daniel Jasper0fb382b2013-02-26 12:52:34 +00006401
6402 // Only break as a last resort.
6403 verifyFormat(
6404 "aaaaaaaaaaaaaaaaaaaa(\n"
6405 " aaaaaaaaaaaaaaaaaaaa,\n"
6406 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
Manuel Klimekaf31fd72013-03-01 13:14:08 +00006407
6408 EXPECT_EQ(
6409 "\"splitmea\"\n"
Manuel Klimekbc30c712013-03-01 13:29:19 +00006410 "\"trandomp\"\n"
6411 "\"oint\"",
Manuel Klimekaf31fd72013-03-01 13:14:08 +00006412 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
Manuel Klimekbc30c712013-03-01 13:29:19 +00006413
6414 EXPECT_EQ(
6415 "\"split/\"\n"
6416 "\"pathat/\"\n"
6417 "\"slashes\"",
6418 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
Daniel Jasper2972d042013-04-25 08:56:26 +00006419
Alexander Kornienkof2b2c7d2013-06-19 14:22:47 +00006420 EXPECT_EQ(
6421 "\"split/\"\n"
6422 "\"pathat/\"\n"
6423 "\"slashes\"",
6424 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
6425 EXPECT_EQ("\"split at \"\n"
6426 "\"spaces/at/\"\n"
6427 "\"slashes.at.any$\"\n"
6428 "\"non-alphanumeric%\"\n"
6429 "\"1111111111characte\"\n"
6430 "\"rs\"",
6431 format("\"split at "
6432 "spaces/at/"
6433 "slashes.at."
6434 "any$non-"
6435 "alphanumeric%"
6436 "1111111111characte"
6437 "rs\"",
6438 getLLVMStyleWithColumns(20)));
6439
Daniel Jasper0fde9502013-07-12 11:37:05 +00006440 // Verify that splitting the strings understands
6441 // Style::AlwaysBreakBeforeMultilineStrings.
6442 EXPECT_EQ("aaaaaaaaaaaa(aaaaaaaaaaaaa,\n"
6443 " \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
6444 " \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
6445 format("aaaaaaaaaaaa(aaaaaaaaaaaaa, \"aaaaaaaaaaaaaaaaaaaaaa "
6446 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa "
6447 "aaaaaaaaaaaaaaaaaaaaaa\");",
6448 getGoogleStyle()));
Daniel Jasper49c77b22013-10-18 16:47:55 +00006449 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
6450 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",
6451 format("return \"aaaaaaaaaaaaaaaaaaaaaa "
6452 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
6453 "aaaaaaaaaaaaaaaaaaaaaa\";",
6454 getGoogleStyle()));
Daniel Jasper75e58bb2013-08-02 11:01:15 +00006455 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
6456 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
6457 format("llvm::outs() << "
6458 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
6459 "aaaaaaaaaaaaaaaaaaa\";"));
Daniel Jasper4df1ff92013-08-23 11:57:34 +00006460 EXPECT_EQ("ffff(\n"
6461 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
6462 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
6463 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
6464 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
6465 getGoogleStyle()));
Daniel Jasper0fde9502013-07-12 11:37:05 +00006466
Daniel Jasper2972d042013-04-25 08:56:26 +00006467 FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
6468 AlignLeft.AlignEscapedNewlinesLeft = true;
6469 EXPECT_EQ(
6470 "#define A \\\n"
6471 " \"some \" \\\n"
6472 " \"text \" \\\n"
6473 " \"other\";",
6474 format("#define A \"some text other\";", AlignLeft));
Manuel Klimek8092a942013-02-20 10:15:13 +00006475}
6476
Stephen Hines651f13c2014-04-23 16:59:28 -07006477TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {
Alexander Kornienko2c2f7292013-09-16 20:20:49 +00006478 EXPECT_EQ(
6479 "u8\"utf8 string \"\n"
6480 "u8\"literal\";",
6481 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
6482 EXPECT_EQ(
6483 "u\"utf16 string \"\n"
6484 "u\"literal\";",
6485 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
6486 EXPECT_EQ(
6487 "U\"utf32 string \"\n"
6488 "U\"literal\";",
6489 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
6490 EXPECT_EQ("L\"wide string \"\n"
6491 "L\"literal\";",
6492 format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
Stephen Hines651f13c2014-04-23 16:59:28 -07006493 EXPECT_EQ("@\"NSString \"\n"
6494 "@\"literal\";",
6495 format("@\"NSString literal\";", getGoogleStyleWithColumns(19)));
Alexander Kornienko2c2f7292013-09-16 20:20:49 +00006496}
6497
6498TEST_F(FormatTest, BreaksRawStringLiterals) {
6499 EXPECT_EQ("R\"x(raw )x\"\n"
6500 "R\"x(literal)x\";",
6501 format("R\"x(raw literal)x\";", getGoogleStyleWithColumns(15)));
6502 EXPECT_EQ("uR\"x(raw )x\"\n"
6503 "uR\"x(literal)x\";",
6504 format("uR\"x(raw literal)x\";", getGoogleStyleWithColumns(16)));
6505 EXPECT_EQ("u8R\"x(raw )x\"\n"
6506 "u8R\"x(literal)x\";",
6507 format("u8R\"x(raw literal)x\";", getGoogleStyleWithColumns(17)));
6508 EXPECT_EQ("LR\"x(raw )x\"\n"
6509 "LR\"x(literal)x\";",
6510 format("LR\"x(raw literal)x\";", getGoogleStyleWithColumns(16)));
6511 EXPECT_EQ("UR\"x(raw )x\"\n"
6512 "UR\"x(literal)x\";",
6513 format("UR\"x(raw literal)x\";", getGoogleStyleWithColumns(16)));
6514}
6515
6516TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
6517 FormatStyle Style = getLLVMStyleWithColumns(20);
6518 EXPECT_EQ(
6519 "_T(\"aaaaaaaaaaaaaa\")\n"
6520 "_T(\"aaaaaaaaaaaaaa\")\n"
6521 "_T(\"aaaaaaaaaaaa\")",
6522 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
6523 EXPECT_EQ("f(x, _T(\"aaaaaaaaa\")\n"
6524 " _T(\"aaaaaa\"),\n"
6525 " z);",
6526 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
6527
6528 // FIXME: Handle embedded spaces in one iteration.
6529 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
6530 // "_T(\"aaaaaaaaaaaaa\")\n"
6531 // "_T(\"aaaaaaaaaaaaa\")\n"
6532 // "_T(\"a\")",
6533 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
6534 // getLLVMStyleWithColumns(20)));
6535 EXPECT_EQ(
6536 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
6537 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
6538}
6539
Alexander Kornienko10c26b22013-07-16 21:06:13 +00006540TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
Alexander Kornienkodcc0c5b2013-08-29 17:32:57 +00006541 EXPECT_EQ(
6542 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
6543 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
6544 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
6545 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
6546 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
6547 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
6548}
6549
6550TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
6551 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
Stephen Hines651f13c2014-04-23 16:59:28 -07006552 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle()));
Alexander Kornienkodcc0c5b2013-08-29 17:32:57 +00006553 EXPECT_EQ("fffffffffff(g(R\"x(\n"
6554 "multiline raw string literal xxxxxxxxxxxxxx\n"
6555 ")x\",\n"
6556 " a),\n"
6557 " b);",
6558 format("fffffffffff(g(R\"x(\n"
6559 "multiline raw string literal xxxxxxxxxxxxxx\n"
6560 ")x\", a), b);",
6561 getGoogleStyleWithColumns(20)));
6562 EXPECT_EQ("fffffffffff(\n"
6563 " g(R\"x(qqq\n"
6564 "multiline raw string literal xxxxxxxxxxxxxx\n"
6565 ")x\",\n"
6566 " a),\n"
6567 " b);",
6568 format("fffffffffff(g(R\"x(qqq\n"
6569 "multiline raw string literal xxxxxxxxxxxxxx\n"
6570 ")x\", a), b);",
6571 getGoogleStyleWithColumns(20)));
6572
6573 EXPECT_EQ("fffffffffff(R\"x(\n"
6574 "multiline raw string literal xxxxxxxxxxxxxx\n"
6575 ")x\");",
6576 format("fffffffffff(R\"x(\n"
6577 "multiline raw string literal xxxxxxxxxxxxxx\n"
6578 ")x\");",
6579 getGoogleStyleWithColumns(20)));
6580 EXPECT_EQ("fffffffffff(R\"x(\n"
6581 "multiline raw string literal xxxxxxxxxxxxxx\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07006582 ")x\" + bbbbbb);",
Alexander Kornienkodcc0c5b2013-08-29 17:32:57 +00006583 format("fffffffffff(R\"x(\n"
6584 "multiline raw string literal xxxxxxxxxxxxxx\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07006585 ")x\" + bbbbbb);",
6586 getGoogleStyleWithColumns(20)));
6587 EXPECT_EQ("fffffffffff(\n"
6588 " R\"x(\n"
6589 "multiline raw string literal xxxxxxxxxxxxxx\n"
6590 ")x\" +\n"
6591 " bbbbbb);",
6592 format("fffffffffff(\n"
6593 " R\"x(\n"
6594 "multiline raw string literal xxxxxxxxxxxxxx\n"
Alexander Kornienkodcc0c5b2013-08-29 17:32:57 +00006595 ")x\" + bbbbbb);",
6596 getGoogleStyleWithColumns(20)));
Alexander Kornienko10c26b22013-07-16 21:06:13 +00006597}
6598
Alexander Kornienko16a0ec62013-06-14 11:46:10 +00006599TEST_F(FormatTest, SkipsUnknownStringLiterals) {
Daniel Jasper561211d2013-07-16 20:28:33 +00006600 verifyFormat("string a = \"unterminated;");
6601 EXPECT_EQ("function(\"unterminated,\n"
6602 " OtherParameter);",
6603 format("function( \"unterminated,\n"
6604 " OtherParameter);"));
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00006605}
6606
6607TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
Stephen Hines651f13c2014-04-23 16:59:28 -07006608 FormatStyle Style = getLLVMStyle();
6609 Style.Standard = FormatStyle::LS_Cpp03;
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00006610 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
Stephen Hines651f13c2014-04-23 16:59:28 -07006611 format("#define x(_a) printf(\"foo\"_a);", Style));
Alexander Kornienko16a0ec62013-06-14 11:46:10 +00006612}
6613
Manuel Klimek2a9805d2013-05-14 09:04:24 +00006614TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
6615 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
6616 " \"ddeeefff\");",
6617 format("someFunction(\"aaabbbcccdddeeefff\");",
6618 getLLVMStyleWithColumns(25)));
6619 EXPECT_EQ("someFunction1234567890(\n"
6620 " \"aaabbbcccdddeeefff\");",
6621 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
6622 getLLVMStyleWithColumns(26)));
6623 EXPECT_EQ("someFunction1234567890(\n"
6624 " \"aaabbbcccdddeeeff\"\n"
6625 " \"f\");",
6626 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
6627 getLLVMStyleWithColumns(25)));
6628 EXPECT_EQ("someFunction1234567890(\n"
6629 " \"aaabbbcccdddeeeff\"\n"
6630 " \"f\");",
6631 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
6632 getLLVMStyleWithColumns(24)));
Daniel Jasperf5461782013-08-28 10:03:58 +00006633 EXPECT_EQ("someFunction(\"aaabbbcc \"\n"
6634 " \"ddde \"\n"
6635 " \"efff\");",
6636 format("someFunction(\"aaabbbcc ddde efff\");",
Manuel Klimek2a9805d2013-05-14 09:04:24 +00006637 getLLVMStyleWithColumns(25)));
6638 EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
6639 " \"ddeeefff\");",
6640 format("someFunction(\"aaabbbccc ddeeefff\");",
6641 getLLVMStyleWithColumns(25)));
6642 EXPECT_EQ("someFunction1234567890(\n"
6643 " \"aaabb \"\n"
6644 " \"cccdddeeefff\");",
6645 format("someFunction1234567890(\"aaabb cccdddeeefff\");",
6646 getLLVMStyleWithColumns(25)));
6647 EXPECT_EQ("#define A \\\n"
6648 " string s = \\\n"
6649 " \"123456789\" \\\n"
6650 " \"0\"; \\\n"
6651 " int i;",
6652 format("#define A string s = \"1234567890\"; int i;",
6653 getLLVMStyleWithColumns(20)));
Daniel Jasperf5461782013-08-28 10:03:58 +00006654 // FIXME: Put additional penalties on breaking at non-whitespace locations.
6655 EXPECT_EQ("someFunction(\"aaabbbcc \"\n"
6656 " \"dddeeeff\"\n"
6657 " \"f\");",
6658 format("someFunction(\"aaabbbcc dddeeefff\");",
6659 getLLVMStyleWithColumns(25)));
Manuel Klimek2a9805d2013-05-14 09:04:24 +00006660}
6661
Manuel Klimekaa62d0c2013-03-08 18:59:48 +00006662TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
6663 EXPECT_EQ("\"\\a\"",
6664 format("\"\\a\"", getLLVMStyleWithColumns(3)));
6665 EXPECT_EQ("\"\\\"",
6666 format("\"\\\"", getLLVMStyleWithColumns(2)));
6667 EXPECT_EQ("\"test\"\n"
6668 "\"\\n\"",
6669 format("\"test\\n\"", getLLVMStyleWithColumns(7)));
6670 EXPECT_EQ("\"tes\\\\\"\n"
6671 "\"n\"",
6672 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
6673 EXPECT_EQ("\"\\\\\\\\\"\n"
6674 "\"\\n\"",
6675 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
6676 EXPECT_EQ("\"\\uff01\"",
6677 format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
6678 EXPECT_EQ("\"\\uff01\"\n"
6679 "\"test\"",
6680 format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
6681 EXPECT_EQ("\"\\Uff01ff02\"",
6682 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
6683 EXPECT_EQ("\"\\x000000000001\"\n"
6684 "\"next\"",
6685 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
6686 EXPECT_EQ("\"\\x000000000001next\"",
6687 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
6688 EXPECT_EQ("\"\\x000000000001\"",
6689 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
6690 EXPECT_EQ("\"test\"\n"
6691 "\"\\000000\"\n"
6692 "\"000001\"",
6693 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
6694 EXPECT_EQ("\"test\\000\"\n"
Alexander Kornienko70ce7882013-04-15 14:28:00 +00006695 "\"00000000\"\n"
6696 "\"1\"",
Manuel Klimekaa62d0c2013-03-08 18:59:48 +00006697 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
Alexander Kornienko2c2f7292013-09-16 20:20:49 +00006698 // FIXME: We probably don't need to care about escape sequences in raw
6699 // literals.
6700 EXPECT_EQ("R\"(\\x)\"\n"
6701 "R\"(\\x00)\"\n",
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00006702 format("R\"(\\x\\x00)\"\n", getGoogleStyleWithColumns(7)));
Manuel Klimekaa62d0c2013-03-08 18:59:48 +00006703}
6704
Manuel Klimek423dd932013-04-10 09:52:05 +00006705TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
6706 verifyFormat("void f() {\n"
6707 " return g() {}\n"
6708 " void h() {}");
Stephen Hines651f13c2014-04-23 16:59:28 -07006709 verifyFormat("int a[] = {void forgot_closing_brace() {f();\n"
Daniel Jasper88959b72013-05-28 18:50:02 +00006710 "g();\n"
Manuel Klimek423dd932013-04-10 09:52:05 +00006711 "}");
6712}
6713
Stephen Hines651f13c2014-04-23 16:59:28 -07006714TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) {
6715 verifyFormat(
6716 "void f() {\n"
6717 " return C{param1, param2}.SomeCall(param1, param2);\n"
6718 "}\n");
6719}
6720
Manuel Klimek07a64ec2013-05-13 08:42:42 +00006721TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
6722 verifyFormat("class X {\n"
6723 " void f() {\n"
6724 " }\n"
6725 "};",
6726 getLLVMStyleWithColumns(12));
6727}
6728
6729TEST_F(FormatTest, ConfigurableIndentWidth) {
6730 FormatStyle EightIndent = getLLVMStyleWithColumns(18);
6731 EightIndent.IndentWidth = 8;
Stephen Hines651f13c2014-04-23 16:59:28 -07006732 EightIndent.ContinuationIndentWidth = 8;
Manuel Klimek07a64ec2013-05-13 08:42:42 +00006733 verifyFormat("void f() {\n"
6734 " someFunction();\n"
6735 " if (true) {\n"
6736 " f();\n"
6737 " }\n"
6738 "}",
6739 EightIndent);
6740 verifyFormat("class X {\n"
6741 " void f() {\n"
6742 " }\n"
6743 "};",
6744 EightIndent);
6745 verifyFormat("int x[] = {\n"
6746 " call(),\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07006747 " call()};",
Manuel Klimek07a64ec2013-05-13 08:42:42 +00006748 EightIndent);
6749}
6750
Alexander Kornienkoc1c76252013-06-22 01:35:36 +00006751TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
Manuel Klimeka9a7f102013-06-21 17:25:42 +00006752 verifyFormat("void\n"
6753 "f();",
6754 getLLVMStyleWithColumns(8));
6755}
6756
Manuel Klimek7c9a93e2013-05-13 09:22:11 +00006757TEST_F(FormatTest, ConfigurableUseOfTab) {
6758 FormatStyle Tab = getLLVMStyleWithColumns(42);
6759 Tab.IndentWidth = 8;
Alexander Kornienko3d9ffcf2013-09-27 16:14:22 +00006760 Tab.UseTab = FormatStyle::UT_Always;
Manuel Klimek7c9a93e2013-05-13 09:22:11 +00006761 Tab.AlignEscapedNewlinesLeft = true;
Alexander Kornienkoacf8e902013-09-27 09:45:40 +00006762
6763 EXPECT_EQ("if (aaaaaaaa && // q\n"
6764 " bb)\t\t// w\n"
6765 "\t;",
6766 format("if (aaaaaaaa &&// q\n"
6767 "bb)// w\n"
6768 ";",
6769 Tab));
6770 EXPECT_EQ("if (aaa && bbb) // w\n"
6771 "\t;",
6772 format("if(aaa&&bbb)// w\n"
6773 ";",
6774 Tab));
6775
Manuel Klimek7c9a93e2013-05-13 09:22:11 +00006776 verifyFormat("class X {\n"
6777 "\tvoid f() {\n"
6778 "\t\tsomeFunction(parameter1,\n"
6779 "\t\t\t parameter2);\n"
6780 "\t}\n"
6781 "};",
6782 Tab);
6783 verifyFormat("#define A \\\n"
6784 "\tvoid f() { \\\n"
6785 "\t\tsomeFunction( \\\n"
6786 "\t\t parameter1, \\\n"
6787 "\t\t parameter2); \\\n"
6788 "\t}",
6789 Tab);
Manuel Klimekc41e8192013-08-29 15:21:40 +00006790 EXPECT_EQ("void f() {\n"
6791 "\tf();\n"
6792 "\tg();\n"
6793 "}",
6794 format("void f() {\n"
6795 "\tf();\n"
6796 "\tg();\n"
6797 "}",
6798 0, 0, Tab));
6799 EXPECT_EQ("void f() {\n"
6800 "\tf();\n"
6801 "\tg();\n"
6802 "}",
6803 format("void f() {\n"
6804 "\tf();\n"
6805 "\tg();\n"
6806 "}",
6807 16, 0, Tab));
6808 EXPECT_EQ("void f() {\n"
6809 " \tf();\n"
6810 "\tg();\n"
6811 "}",
6812 format("void f() {\n"
6813 " \tf();\n"
6814 " \tg();\n"
6815 "}",
6816 21, 0, Tab));
Manuel Klimekd63312b2013-05-28 10:01:59 +00006817
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00006818 Tab.TabWidth = 4;
6819 Tab.IndentWidth = 8;
6820 verifyFormat("class TabWidth4Indent8 {\n"
6821 "\t\tvoid f() {\n"
6822 "\t\t\t\tsomeFunction(parameter1,\n"
6823 "\t\t\t\t\t\t\t parameter2);\n"
6824 "\t\t}\n"
6825 "};",
6826 Tab);
6827
6828 Tab.TabWidth = 4;
6829 Tab.IndentWidth = 4;
6830 verifyFormat("class TabWidth4Indent4 {\n"
6831 "\tvoid f() {\n"
6832 "\t\tsomeFunction(parameter1,\n"
6833 "\t\t\t\t\t parameter2);\n"
6834 "\t}\n"
6835 "};",
6836 Tab);
6837
6838 Tab.TabWidth = 8;
6839 Tab.IndentWidth = 4;
6840 verifyFormat("class TabWidth8Indent4 {\n"
6841 " void f() {\n"
6842 "\tsomeFunction(parameter1,\n"
6843 "\t\t parameter2);\n"
6844 " }\n"
6845 "};",
6846 Tab);
6847
Alexander Kornienko83a7dcd2013-09-10 09:38:25 +00006848 Tab.TabWidth = 8;
6849 Tab.IndentWidth = 8;
6850 EXPECT_EQ("/*\n"
6851 "\t a\t\tcomment\n"
6852 "\t in multiple lines\n"
6853 " */",
6854 format(" /*\t \t \n"
6855 " \t \t a\t\tcomment\t \t\n"
6856 " \t \t in multiple lines\t\n"
6857 " \t */",
6858 Tab));
Alexander Kornienkoacf8e902013-09-27 09:45:40 +00006859
Alexander Kornienko3d9ffcf2013-09-27 16:14:22 +00006860 Tab.UseTab = FormatStyle::UT_ForIndentation;
Stephen Hines651f13c2014-04-23 16:59:28 -07006861 verifyFormat("{\n"
6862 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
6863 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
6864 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
6865 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
6866 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
6867 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
Alexander Kornienkof0fc89c2013-10-14 00:46:35 +00006868 "};",
6869 Tab);
6870 verifyFormat("enum A {\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07006871 "\ta1, // Force multiple lines\n"
Alexander Kornienkof0fc89c2013-10-14 00:46:35 +00006872 "\ta2,\n"
6873 "\ta3\n"
6874 "};",
6875 Tab);
Alexander Kornienko3d9ffcf2013-09-27 16:14:22 +00006876 EXPECT_EQ("if (aaaaaaaa && // q\n"
6877 " bb) // w\n"
6878 "\t;",
6879 format("if (aaaaaaaa &&// q\n"
6880 "bb)// w\n"
6881 ";",
6882 Tab));
6883 verifyFormat("class X {\n"
6884 "\tvoid f() {\n"
6885 "\t\tsomeFunction(parameter1,\n"
6886 "\t\t parameter2);\n"
6887 "\t}\n"
6888 "};",
6889 Tab);
6890 verifyFormat("{\n"
6891 "\tQ({\n"
6892 "\t\t int a;\n"
6893 "\t\t someFunction(aaaaaaaaaa,\n"
6894 "\t\t bbbbbbbbb);\n"
6895 "\t },\n"
6896 "\t p);\n"
6897 "}",
6898 Tab);
6899 EXPECT_EQ("{\n"
6900 "\t/* aaaa\n"
6901 "\t bbbb */\n"
6902 "}",
6903 format("{\n"
6904 "/* aaaa\n"
6905 " bbbb */\n"
6906 "}",
6907 Tab));
6908 EXPECT_EQ("{\n"
6909 "\t/*\n"
6910 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6911 "\t bbbbbbbbbbbbb\n"
6912 "\t*/\n"
6913 "}",
6914 format("{\n"
6915 "/*\n"
6916 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
6917 "*/\n"
6918 "}",
6919 Tab));
6920 EXPECT_EQ("{\n"
6921 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6922 "\t// bbbbbbbbbbbbb\n"
6923 "}",
6924 format("{\n"
6925 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
6926 "}",
6927 Tab));
6928 EXPECT_EQ("{\n"
6929 "\t/*\n"
6930 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6931 "\t bbbbbbbbbbbbb\n"
6932 "\t*/\n"
6933 "}",
6934 format("{\n"
6935 "\t/*\n"
6936 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
6937 "\t*/\n"
6938 "}",
6939 Tab));
6940 EXPECT_EQ("{\n"
6941 "\t/*\n"
6942 "\n"
6943 "\t*/\n"
6944 "}",
6945 format("{\n"
6946 "\t/*\n"
6947 "\n"
6948 "\t*/\n"
Alexander Kornienko6967e782013-09-27 16:40:11 +00006949 "}",
6950 Tab));
6951 EXPECT_EQ("{\n"
6952 "\t/*\n"
6953 " asdf\n"
6954 "\t*/\n"
6955 "}",
6956 format("{\n"
6957 "\t/*\n"
6958 " asdf\n"
6959 "\t*/\n"
6960 "}",
6961 Tab));
Alexander Kornienko3d9ffcf2013-09-27 16:14:22 +00006962
6963 Tab.UseTab = FormatStyle::UT_Never;
Alexander Kornienko83a7dcd2013-09-10 09:38:25 +00006964 EXPECT_EQ("/*\n"
6965 " a\t\tcomment\n"
6966 " in multiple lines\n"
6967 " */",
6968 format(" /*\t \t \n"
6969 " \t \t a\t\tcomment\t \t\n"
6970 " \t \t in multiple lines\t\n"
6971 " \t */",
6972 Tab));
6973 EXPECT_EQ("/* some\n"
6974 " comment */",
6975 format(" \t \t /* some\n"
6976 " \t \t comment */",
6977 Tab));
6978 EXPECT_EQ("int a; /* some\n"
6979 " comment */",
6980 format(" \t \t int a; /* some\n"
6981 " \t \t comment */",
6982 Tab));
Manuel Klimekd63312b2013-05-28 10:01:59 +00006983
Alexander Kornienko83a7dcd2013-09-10 09:38:25 +00006984 EXPECT_EQ("int a; /* some\n"
6985 "comment */",
6986 format(" \t \t int\ta; /* some\n"
6987 " \t \t comment */",
6988 Tab));
6989 EXPECT_EQ("f(\"\t\t\"); /* some\n"
6990 " comment */",
6991 format(" \t \t f(\"\t\t\"); /* some\n"
6992 " \t \t comment */",
6993 Tab));
Manuel Klimekd63312b2013-05-28 10:01:59 +00006994 EXPECT_EQ("{\n"
6995 " /*\n"
6996 " * Comment\n"
6997 " */\n"
6998 " int i;\n"
6999 "}",
7000 format("{\n"
7001 "\t/*\n"
7002 "\t * Comment\n"
7003 "\t */\n"
7004 "\t int i;\n"
7005 "}"));
Manuel Klimek7c9a93e2013-05-13 09:22:11 +00007006}
7007
Alexander Kornienko6f6154c2013-09-10 12:29:48 +00007008TEST_F(FormatTest, CalculatesOriginalColumn) {
7009 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
7010 "q\"; /* some\n"
7011 " comment */",
7012 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
7013 "q\"; /* some\n"
7014 " comment */",
7015 getLLVMStyle()));
7016 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
7017 "/* some\n"
7018 " comment */",
7019 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
7020 " /* some\n"
7021 " comment */",
7022 getLLVMStyle()));
7023 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
7024 "qqq\n"
7025 "/* some\n"
7026 " comment */",
7027 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
7028 "qqq\n"
7029 " /* some\n"
7030 " comment */",
7031 getLLVMStyle()));
7032 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
7033 "wwww; /* some\n"
7034 " comment */",
7035 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
7036 "wwww; /* some\n"
7037 " comment */",
7038 getLLVMStyle()));
7039}
7040
Stephen Hines651f13c2014-04-23 16:59:28 -07007041TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
Daniel Jasper7df56bf2013-08-20 12:36:34 +00007042 FormatStyle NoSpace = getLLVMStyle();
Stephen Hines651f13c2014-04-23 16:59:28 -07007043 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never;
Daniel Jasper7df56bf2013-08-20 12:36:34 +00007044
7045 verifyFormat("while(true)\n"
7046 " continue;", NoSpace);
7047 verifyFormat("for(;;)\n"
7048 " continue;", NoSpace);
7049 verifyFormat("if(true)\n"
7050 " f();\n"
7051 "else if(true)\n"
7052 " f();", NoSpace);
7053 verifyFormat("do {\n"
7054 " do_something();\n"
7055 "} while(something());", NoSpace);
7056 verifyFormat("switch(x) {\n"
7057 "default:\n"
7058 " break;\n"
7059 "}", NoSpace);
Stephen Hines651f13c2014-04-23 16:59:28 -07007060
7061 FormatStyle Space = getLLVMStyle();
7062 Space.SpaceBeforeParens = FormatStyle::SBPO_Always;
7063
7064 verifyFormat("int f ();", Space);
7065 verifyFormat("void f (int a, T b) {\n"
7066 " while (true)\n"
7067 " continue;\n"
7068 "}",
7069 Space);
7070 verifyFormat("if (true)\n"
7071 " f ();\n"
7072 "else if (true)\n"
7073 " f ();",
7074 Space);
7075 verifyFormat("do {\n"
7076 " do_something ();\n"
7077 "} while (something ());",
7078 Space);
7079 verifyFormat("switch (x) {\n"
7080 "default:\n"
7081 " break;\n"
7082 "}",
7083 Space);
7084 verifyFormat("A::A () : a (1) {}", Space);
7085 verifyFormat("void f () __attribute__ ((asdf));", Space);
7086 verifyFormat("*(&a + 1);\n"
7087 "&((&a)[1]);\n"
7088 "a[(b + c) * d];\n"
7089 "(((a + 1) * 2) + 3) * 4;",
7090 Space);
7091 verifyFormat("#define A(x) x", Space);
7092 verifyFormat("#define A (x) x", Space);
7093 verifyFormat("#if defined(x)\n"
7094 "#endif",
7095 Space);
Daniel Jasper7df56bf2013-08-20 12:36:34 +00007096}
7097
7098TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
7099 FormatStyle Spaces = getLLVMStyle();
7100
7101 Spaces.SpacesInParentheses = true;
7102 verifyFormat("call( x, y, z );", Spaces);
7103 verifyFormat("while ( (bool)1 )\n"
7104 " continue;", Spaces);
7105 verifyFormat("for ( ;; )\n"
7106 " continue;", Spaces);
7107 verifyFormat("if ( true )\n"
7108 " f();\n"
7109 "else if ( true )\n"
7110 " f();", Spaces);
7111 verifyFormat("do {\n"
7112 " do_something( (int)i );\n"
7113 "} while ( something() );", Spaces);
7114 verifyFormat("switch ( x ) {\n"
7115 "default:\n"
7116 " break;\n"
7117 "}", Spaces);
7118
7119 Spaces.SpacesInParentheses = false;
7120 Spaces.SpacesInCStyleCastParentheses = true;
7121 verifyFormat("Type *A = ( Type * )P;", Spaces);
7122 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
7123 verifyFormat("x = ( int32 )y;", Spaces);
7124 verifyFormat("int a = ( int )(2.0f);", Spaces);
7125 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
7126 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
7127 verifyFormat("#define x (( int )-1)", Spaces);
7128
7129 Spaces.SpacesInParentheses = false;
7130 Spaces.SpaceInEmptyParentheses = true;
7131 verifyFormat("call(x, y, z);", Spaces);
7132 verifyFormat("call( )", Spaces);
7133
7134 // Run the first set of tests again with
7135 // Spaces.SpacesInParentheses = false,
7136 // Spaces.SpaceInEmptyParentheses = true and
7137 // Spaces.SpacesInCStyleCastParentheses = true
7138 Spaces.SpacesInParentheses = false,
7139 Spaces.SpaceInEmptyParentheses = true;
7140 Spaces.SpacesInCStyleCastParentheses = true;
7141 verifyFormat("call(x, y, z);", Spaces);
7142 verifyFormat("while (( bool )1)\n"
7143 " continue;", Spaces);
7144 verifyFormat("for (;;)\n"
7145 " continue;", Spaces);
7146 verifyFormat("if (true)\n"
7147 " f( );\n"
7148 "else if (true)\n"
7149 " f( );", Spaces);
7150 verifyFormat("do {\n"
7151 " do_something(( int )i);\n"
7152 "} while (something( ));", Spaces);
7153 verifyFormat("switch (x) {\n"
7154 "default:\n"
7155 " break;\n"
7156 "}", Spaces);
7157}
7158
Daniel Jasper9b4de852013-09-25 15:15:02 +00007159TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
7160 verifyFormat("int a = 5;");
7161 verifyFormat("a += 42;");
7162 verifyFormat("a or_eq 8;");
7163
7164 FormatStyle Spaces = getLLVMStyle();
7165 Spaces.SpaceBeforeAssignmentOperators = false;
7166 verifyFormat("int a= 5;", Spaces);
7167 verifyFormat("a+= 42;", Spaces);
7168 verifyFormat("a or_eq 8;", Spaces);
7169}
7170
Manuel Klimek44135b82013-05-13 12:51:40 +00007171TEST_F(FormatTest, LinuxBraceBreaking) {
7172 FormatStyle BreakBeforeBrace = getLLVMStyle();
7173 BreakBeforeBrace.BreakBeforeBraces = FormatStyle::BS_Linux;
7174 verifyFormat("namespace a\n"
7175 "{\n"
7176 "class A\n"
7177 "{\n"
7178 " void f()\n"
7179 " {\n"
7180 " if (true) {\n"
7181 " a();\n"
7182 " b();\n"
7183 " }\n"
7184 " }\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07007185 " void g() { return; }\n"
Manuel Klimek44135b82013-05-13 12:51:40 +00007186 "}\n"
7187 "}",
7188 BreakBeforeBrace);
7189}
7190
7191TEST_F(FormatTest, StroustrupBraceBreaking) {
7192 FormatStyle BreakBeforeBrace = getLLVMStyle();
7193 BreakBeforeBrace.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
7194 verifyFormat("namespace a {\n"
7195 "class A {\n"
7196 " void f()\n"
7197 " {\n"
7198 " if (true) {\n"
7199 " a();\n"
7200 " b();\n"
7201 " }\n"
7202 " }\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07007203 " void g() { return; }\n"
Manuel Klimek44135b82013-05-13 12:51:40 +00007204 "}\n"
7205 "}",
7206 BreakBeforeBrace);
7207}
7208
Manuel Klimeke4907052013-08-02 21:31:59 +00007209TEST_F(FormatTest, AllmanBraceBreaking) {
7210 FormatStyle BreakBeforeBrace = getLLVMStyle();
7211 BreakBeforeBrace.BreakBeforeBraces = FormatStyle::BS_Allman;
7212 verifyFormat("namespace a\n"
7213 "{\n"
7214 "class A\n"
7215 "{\n"
7216 " void f()\n"
7217 " {\n"
7218 " if (true)\n"
7219 " {\n"
7220 " a();\n"
7221 " b();\n"
7222 " }\n"
7223 " }\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07007224 " void g() { return; }\n"
Manuel Klimeke4907052013-08-02 21:31:59 +00007225 "}\n"
7226 "}",
7227 BreakBeforeBrace);
7228
7229 verifyFormat("void f()\n"
7230 "{\n"
7231 " if (true)\n"
7232 " {\n"
7233 " a();\n"
7234 " }\n"
7235 " else if (false)\n"
7236 " {\n"
7237 " b();\n"
7238 " }\n"
7239 " else\n"
7240 " {\n"
7241 " c();\n"
7242 " }\n"
7243 "}\n",
7244 BreakBeforeBrace);
7245
7246 verifyFormat("void f()\n"
7247 "{\n"
7248 " for (int i = 0; i < 10; ++i)\n"
7249 " {\n"
7250 " a();\n"
7251 " }\n"
7252 " while (false)\n"
7253 " {\n"
7254 " b();\n"
7255 " }\n"
7256 " do\n"
7257 " {\n"
7258 " c();\n"
7259 " } while (false)\n"
7260 "}\n",
7261 BreakBeforeBrace);
7262
7263 verifyFormat("void f(int a)\n"
7264 "{\n"
7265 " switch (a)\n"
7266 " {\n"
7267 " case 0:\n"
7268 " break;\n"
7269 " case 1:\n"
7270 " {\n"
7271 " break;\n"
7272 " }\n"
7273 " case 2:\n"
7274 " {\n"
7275 " }\n"
7276 " break;\n"
7277 " default:\n"
7278 " break;\n"
7279 " }\n"
7280 "}\n",
7281 BreakBeforeBrace);
Manuel Klimekd3a247c2013-08-07 19:20:45 +00007282
7283 verifyFormat("enum X\n"
7284 "{\n"
7285 " Y = 0,\n"
7286 "}\n",
7287 BreakBeforeBrace);
7288
Stephen Hines651f13c2014-04-23 16:59:28 -07007289 BreakBeforeBrace.ColumnLimit = 19;
7290 verifyFormat("void f() { int i; }", BreakBeforeBrace);
7291 BreakBeforeBrace.ColumnLimit = 18;
7292 verifyFormat("void f()\n"
7293 "{\n"
7294 " int i;\n"
7295 "}",
7296 BreakBeforeBrace);
7297 BreakBeforeBrace.ColumnLimit = 80;
7298
Manuel Klimekd3a247c2013-08-07 19:20:45 +00007299 FormatStyle BreakBeforeBraceShortIfs = BreakBeforeBrace;
7300 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = true;
7301 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
7302 verifyFormat("void f(bool b)\n"
7303 "{\n"
7304 " if (b)\n"
7305 " {\n"
7306 " return;\n"
7307 " }\n"
7308 "}\n",
7309 BreakBeforeBraceShortIfs);
7310 verifyFormat("void f(bool b)\n"
7311 "{\n"
7312 " if (b) return;\n"
7313 "}\n",
7314 BreakBeforeBraceShortIfs);
7315 verifyFormat("void f(bool b)\n"
7316 "{\n"
7317 " while (b)\n"
7318 " {\n"
7319 " return;\n"
7320 " }\n"
7321 "}\n",
7322 BreakBeforeBraceShortIfs);
Manuel Klimeke4907052013-08-02 21:31:59 +00007323}
7324
Stephen Hines651f13c2014-04-23 16:59:28 -07007325TEST_F(FormatTest, GNUBraceBreaking) {
7326 FormatStyle GNUBraceStyle = getLLVMStyle();
7327 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU;
7328 verifyFormat("namespace a\n"
7329 "{\n"
7330 "class A\n"
7331 "{\n"
7332 " void f()\n"
7333 " {\n"
7334 " int a;\n"
7335 " {\n"
7336 " int b;\n"
7337 " }\n"
7338 " if (true)\n"
7339 " {\n"
7340 " a();\n"
7341 " b();\n"
7342 " }\n"
7343 " }\n"
7344 " void g() { return; }\n"
7345 "}\n"
7346 "}",
7347 GNUBraceStyle);
7348
7349 verifyFormat("void f()\n"
7350 "{\n"
7351 " if (true)\n"
7352 " {\n"
7353 " a();\n"
7354 " }\n"
7355 " else if (false)\n"
7356 " {\n"
7357 " b();\n"
7358 " }\n"
7359 " else\n"
7360 " {\n"
7361 " c();\n"
7362 " }\n"
7363 "}\n",
7364 GNUBraceStyle);
7365
7366 verifyFormat("void f()\n"
7367 "{\n"
7368 " for (int i = 0; i < 10; ++i)\n"
7369 " {\n"
7370 " a();\n"
7371 " }\n"
7372 " while (false)\n"
7373 " {\n"
7374 " b();\n"
7375 " }\n"
7376 " do\n"
7377 " {\n"
7378 " c();\n"
7379 " }\n"
7380 " while (false);\n"
7381 "}\n",
7382 GNUBraceStyle);
7383
7384 verifyFormat("void f(int a)\n"
7385 "{\n"
7386 " switch (a)\n"
7387 " {\n"
7388 " case 0:\n"
7389 " break;\n"
7390 " case 1:\n"
7391 " {\n"
7392 " break;\n"
7393 " }\n"
7394 " case 2:\n"
7395 " {\n"
7396 " }\n"
7397 " break;\n"
7398 " default:\n"
7399 " break;\n"
7400 " }\n"
7401 "}\n",
7402 GNUBraceStyle);
7403
7404 verifyFormat("enum X\n"
7405 "{\n"
7406 " Y = 0,\n"
7407 "}\n",
7408 GNUBraceStyle);
7409}
Manuel Klimek2530fd52013-08-12 03:51:17 +00007410TEST_F(FormatTest, CatchExceptionReferenceBinding) {
7411 verifyFormat("void f() {\n"
7412 " try {\n"
7413 " }\n"
7414 " catch (const Exception &e) {\n"
7415 " }\n"
7416 "}\n",
7417 getLLVMStyle());
7418}
7419
Daniel Jasper1dc6f742013-08-07 16:29:23 +00007420TEST_F(FormatTest, UnderstandsPragmas) {
7421 verifyFormat("#pragma omp reduction(| : var)");
7422 verifyFormat("#pragma omp reduction(+ : var)");
Stephen Hines651f13c2014-04-23 16:59:28 -07007423
7424 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
7425 "(including parentheses).",
7426 format("#pragma mark Any non-hyphenated or hyphenated string "
7427 "(including parentheses)."));
Daniel Jasper1dc6f742013-08-07 16:29:23 +00007428}
7429
Stephen Hines651f13c2014-04-23 16:59:28 -07007430#define EXPECT_ALL_STYLES_EQUAL(Styles) \
7431 for (size_t i = 1; i < Styles.size(); ++i) \
7432 EXPECT_EQ(Styles[0], Styles[i]) << "Style #" << i << " of " \
7433 << Styles.size() \
7434 << " differs from Style #0"
Alexander Kornienkod71ec162013-05-07 15:32:14 +00007435
7436TEST_F(FormatTest, GetsPredefinedStyleByName) {
Stephen Hines651f13c2014-04-23 16:59:28 -07007437 SmallVector<FormatStyle, 3> Styles;
7438 Styles.resize(3);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00007439
Alexander Kornienko885f87b2013-05-19 00:53:30 +00007440 Styles[0] = getLLVMStyle();
Stephen Hines651f13c2014-04-23 16:59:28 -07007441 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
7442 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
7443 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00007444
Alexander Kornienko885f87b2013-05-19 00:53:30 +00007445 Styles[0] = getGoogleStyle();
Stephen Hines651f13c2014-04-23 16:59:28 -07007446 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
7447 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
7448 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00007449
Stephen Hines651f13c2014-04-23 16:59:28 -07007450 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
7451 EXPECT_TRUE(
7452 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
7453 EXPECT_TRUE(
7454 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
7455 EXPECT_ALL_STYLES_EQUAL(Styles);
7456
7457 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
7458 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
7459 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
7460 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienko885f87b2013-05-19 00:53:30 +00007461
7462 Styles[0] = getMozillaStyle();
Stephen Hines651f13c2014-04-23 16:59:28 -07007463 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
7464 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
7465 EXPECT_ALL_STYLES_EQUAL(Styles);
Alexander Kornienko885f87b2013-05-19 00:53:30 +00007466
Daniel Jaspere05dc6d2013-07-24 13:10:59 +00007467 Styles[0] = getWebKitStyle();
Stephen Hines651f13c2014-04-23 16:59:28 -07007468 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
7469 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
7470 EXPECT_ALL_STYLES_EQUAL(Styles);
Daniel Jaspere05dc6d2013-07-24 13:10:59 +00007471
Stephen Hines651f13c2014-04-23 16:59:28 -07007472 Styles[0] = getGNUStyle();
7473 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
7474 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
7475 EXPECT_ALL_STYLES_EQUAL(Styles);
7476
7477 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
Alexander Kornienkod71ec162013-05-07 15:32:14 +00007478}
7479
Stephen Hines651f13c2014-04-23 16:59:28 -07007480TEST_F(FormatTest, GetsCorrectBasedOnStyle) {
7481 SmallVector<FormatStyle, 8> Styles;
7482 Styles.resize(2);
7483
7484 Styles[0] = getGoogleStyle();
7485 Styles[1] = getLLVMStyle();
7486 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
7487 EXPECT_ALL_STYLES_EQUAL(Styles);
7488
7489 Styles.resize(5);
7490 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
7491 Styles[1] = getLLVMStyle();
7492 Styles[1].Language = FormatStyle::LK_JavaScript;
7493 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
7494
7495 Styles[2] = getLLVMStyle();
7496 Styles[2].Language = FormatStyle::LK_JavaScript;
7497 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
7498 "BasedOnStyle: Google",
7499 &Styles[2]).value());
7500
7501 Styles[3] = getLLVMStyle();
7502 Styles[3].Language = FormatStyle::LK_JavaScript;
7503 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
7504 "Language: JavaScript",
7505 &Styles[3]).value());
7506
7507 Styles[4] = getLLVMStyle();
7508 Styles[4].Language = FormatStyle::LK_JavaScript;
7509 EXPECT_EQ(0, parseConfiguration("---\n"
7510 "BasedOnStyle: LLVM\n"
7511 "IndentWidth: 123\n"
7512 "---\n"
7513 "BasedOnStyle: Google\n"
7514 "Language: JavaScript",
7515 &Styles[4]).value());
7516 EXPECT_ALL_STYLES_EQUAL(Styles);
7517}
7518
Alexander Kornienkod71ec162013-05-07 15:32:14 +00007519#define CHECK_PARSE(TEXT, FIELD, VALUE) \
7520 EXPECT_NE(VALUE, Style.FIELD); \
7521 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \
7522 EXPECT_EQ(VALUE, Style.FIELD)
7523
7524#define CHECK_PARSE_BOOL(FIELD) \
7525 Style.FIELD = false; \
7526 EXPECT_EQ(0, parseConfiguration(#FIELD ": true", &Style).value()); \
Alexander Kornienko885f87b2013-05-19 00:53:30 +00007527 EXPECT_TRUE(Style.FIELD); \
Alexander Kornienkod71ec162013-05-07 15:32:14 +00007528 EXPECT_EQ(0, parseConfiguration(#FIELD ": false", &Style).value()); \
Patrik Hagglund33717112013-05-14 07:53:53 +00007529 EXPECT_FALSE(Style.FIELD);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00007530
Stephen Hines651f13c2014-04-23 16:59:28 -07007531TEST_F(FormatTest, ParsesConfiguration) {
7532 FormatStyle Style = {};
7533 Style.Language = FormatStyle::LK_Cpp;
Alexander Kornienkod71ec162013-05-07 15:32:14 +00007534 CHECK_PARSE_BOOL(AlignEscapedNewlinesLeft);
Daniel Jasper893ea8d2013-07-31 23:55:15 +00007535 CHECK_PARSE_BOOL(AlignTrailingComments);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00007536 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
Stephen Hines651f13c2014-04-23 16:59:28 -07007537 CHECK_PARSE_BOOL(AllowShortFunctionsOnASingleLine);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00007538 CHECK_PARSE_BOOL(AllowShortIfStatementsOnASingleLine);
Daniel Jasper2a2579a2013-05-16 12:16:23 +00007539 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
Daniel Jasperbbc87762013-05-29 12:07:31 +00007540 CHECK_PARSE_BOOL(AlwaysBreakTemplateDeclarations);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00007541 CHECK_PARSE_BOOL(BinPackParameters);
Daniel Jaspere8b10d32013-07-26 16:56:36 +00007542 CHECK_PARSE_BOOL(BreakBeforeBinaryOperators);
Daniel Jasper1a896a52013-11-08 00:57:11 +00007543 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
Daniel Jaspere8b10d32013-07-26 16:56:36 +00007544 CHECK_PARSE_BOOL(BreakConstructorInitializersBeforeComma);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00007545 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
7546 CHECK_PARSE_BOOL(DerivePointerBinding);
7547 CHECK_PARSE_BOOL(IndentCaseLabels);
Stephen Hines651f13c2014-04-23 16:59:28 -07007548 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
7549 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00007550 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
7551 CHECK_PARSE_BOOL(PointerBindsToType);
Daniel Jasperb5dc3f42013-07-16 18:22:10 +00007552 CHECK_PARSE_BOOL(Cpp11BracedListStyle);
Manuel Klimeka9a7f102013-06-21 17:25:42 +00007553 CHECK_PARSE_BOOL(IndentFunctionDeclarationAfterType);
Daniel Jasper7df56bf2013-08-20 12:36:34 +00007554 CHECK_PARSE_BOOL(SpacesInParentheses);
Daniel Jasperd8ee5c12013-10-29 14:52:02 +00007555 CHECK_PARSE_BOOL(SpacesInAngles);
Daniel Jasper7df56bf2013-08-20 12:36:34 +00007556 CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
Stephen Hines651f13c2014-04-23 16:59:28 -07007557 CHECK_PARSE_BOOL(SpacesInContainerLiterals);
Daniel Jasper7df56bf2013-08-20 12:36:34 +00007558 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
Daniel Jasper9b4de852013-09-25 15:15:02 +00007559 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00007560
7561 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
Daniel Jasper6315fec2013-08-13 10:58:30 +00007562 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
7563 ConstructorInitializerIndentWidth, 1234u);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00007564 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
7565 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
Daniel Jasper47066e42013-10-25 14:29:37 +00007566 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
7567 PenaltyBreakBeforeFirstCallParameter, 1234u);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00007568 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
7569 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
7570 PenaltyReturnTypeOnItsOwnLine, 1234u);
7571 CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
7572 SpacesBeforeTrailingComments, 1234u);
Manuel Klimek07a64ec2013-05-13 08:42:42 +00007573 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
Daniel Jasperc2827ec2013-10-18 10:38:14 +00007574 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00007575
7576 Style.Standard = FormatStyle::LS_Auto;
Alexander Kornienko9321e872013-09-04 14:09:13 +00007577 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
7578 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Cpp11);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00007579 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
7580 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
7581 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
7582
Alexander Kornienko3d9ffcf2013-09-27 16:14:22 +00007583 Style.UseTab = FormatStyle::UT_ForIndentation;
7584 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
7585 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
7586 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
7587 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
7588 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
7589
Stephen Hines651f13c2014-04-23 16:59:28 -07007590 Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
7591 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
7592 FormatStyle::SBPO_Never);
7593 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
7594 FormatStyle::SBPO_Always);
7595 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
7596 FormatStyle::SBPO_ControlStatements);
7597 // For backward compatibility:
7598 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
7599 FormatStyle::SBPO_Never);
7600 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
7601 FormatStyle::SBPO_ControlStatements);
7602
Alexander Kornienkod71ec162013-05-07 15:32:14 +00007603 Style.ColumnLimit = 123;
7604 FormatStyle BaseStyle = getLLVMStyle();
7605 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
7606 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
7607
Manuel Klimek44135b82013-05-13 12:51:40 +00007608 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
7609 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
7610 FormatStyle::BS_Attach);
7611 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
7612 FormatStyle::BS_Linux);
7613 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
7614 FormatStyle::BS_Stroustrup);
Stephen Hines651f13c2014-04-23 16:59:28 -07007615 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
7616 FormatStyle::BS_Allman);
7617 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
Manuel Klimek44135b82013-05-13 12:51:40 +00007618
Daniel Jaspereff18b92013-07-31 23:16:02 +00007619 Style.NamespaceIndentation = FormatStyle::NI_All;
7620 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
7621 FormatStyle::NI_None);
7622 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
7623 FormatStyle::NI_Inner);
7624 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
7625 FormatStyle::NI_All);
7626
Stephen Hines651f13c2014-04-23 16:59:28 -07007627 Style.ForEachMacros.clear();
7628 std::vector<std::string> BoostForeach;
7629 BoostForeach.push_back("BOOST_FOREACH");
7630 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
7631 std::vector<std::string> BoostAndQForeach;
7632 BoostAndQForeach.push_back("BOOST_FOREACH");
7633 BoostAndQForeach.push_back("Q_FOREACH");
7634 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
7635 BoostAndQForeach);
7636}
7637
7638TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
7639 FormatStyle Style = {};
7640 Style.Language = FormatStyle::LK_Cpp;
7641 CHECK_PARSE("Language: Cpp\n"
7642 "IndentWidth: 12",
7643 IndentWidth, 12u);
7644 EXPECT_EQ(llvm::errc::not_supported,
7645 parseConfiguration("Language: JavaScript\n"
7646 "IndentWidth: 34",
7647 &Style));
7648 EXPECT_EQ(12u, Style.IndentWidth);
7649 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
7650 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
7651
7652 Style.Language = FormatStyle::LK_JavaScript;
7653 CHECK_PARSE("Language: JavaScript\n"
7654 "IndentWidth: 12",
7655 IndentWidth, 12u);
7656 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
7657 EXPECT_EQ(llvm::errc::not_supported, parseConfiguration("Language: Cpp\n"
7658 "IndentWidth: 34",
7659 &Style));
7660 EXPECT_EQ(23u, Style.IndentWidth);
7661 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
7662 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
7663
7664 CHECK_PARSE("BasedOnStyle: LLVM\n"
7665 "IndentWidth: 67",
7666 IndentWidth, 67u);
7667
7668 CHECK_PARSE("---\n"
7669 "Language: JavaScript\n"
7670 "IndentWidth: 12\n"
7671 "---\n"
7672 "Language: Cpp\n"
7673 "IndentWidth: 34\n"
7674 "...\n",
7675 IndentWidth, 12u);
7676
7677 Style.Language = FormatStyle::LK_Cpp;
7678 CHECK_PARSE("---\n"
7679 "Language: JavaScript\n"
7680 "IndentWidth: 12\n"
7681 "---\n"
7682 "Language: Cpp\n"
7683 "IndentWidth: 34\n"
7684 "...\n",
7685 IndentWidth, 34u);
7686 CHECK_PARSE("---\n"
7687 "IndentWidth: 78\n"
7688 "---\n"
7689 "Language: JavaScript\n"
7690 "IndentWidth: 56\n"
7691 "...\n",
7692 IndentWidth, 78u);
7693
7694 Style.ColumnLimit = 123;
7695 Style.IndentWidth = 234;
7696 Style.BreakBeforeBraces = FormatStyle::BS_Linux;
7697 Style.TabWidth = 345;
7698 EXPECT_EQ(llvm::errc::success,
7699 parseConfiguration("---\n"
7700 "IndentWidth: 456\n"
7701 "BreakBeforeBraces: Allman\n"
7702 "---\n"
7703 "Language: JavaScript\n"
7704 "IndentWidth: 111\n"
7705 "TabWidth: 111\n"
7706 "---\n"
7707 "Language: Cpp\n"
7708 "BreakBeforeBraces: Stroustrup\n"
7709 "TabWidth: 789\n"
7710 "...\n",
7711 &Style));
7712 EXPECT_EQ(123u, Style.ColumnLimit);
7713 EXPECT_EQ(456u, Style.IndentWidth);
7714 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
7715 EXPECT_EQ(789u, Style.TabWidth);
7716
7717
7718 EXPECT_EQ(llvm::errc::invalid_argument,
7719 parseConfiguration("---\n"
7720 "Language: JavaScript\n"
7721 "IndentWidth: 56\n"
7722 "---\n"
7723 "IndentWidth: 78\n"
7724 "...\n",
7725 &Style));
7726 EXPECT_EQ(llvm::errc::invalid_argument,
7727 parseConfiguration("---\n"
7728 "Language: JavaScript\n"
7729 "IndentWidth: 56\n"
7730 "---\n"
7731 "Language: JavaScript\n"
7732 "IndentWidth: 78\n"
7733 "...\n",
7734 &Style));
7735
7736 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
7737}
7738
Alexander Kornienkod71ec162013-05-07 15:32:14 +00007739#undef CHECK_PARSE
7740#undef CHECK_PARSE_BOOL
Stephen Hines651f13c2014-04-23 16:59:28 -07007741
7742TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
7743 FormatStyle Style = {};
7744 Style.Language = FormatStyle::LK_JavaScript;
7745 Style.BreakBeforeTernaryOperators = true;
7746 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
7747 EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
7748
7749 Style.BreakBeforeTernaryOperators = true;
7750 EXPECT_EQ(0, parseConfiguration("---\n"
7751 "BasedOnStyle: Google\n"
7752 "---\n"
7753 "Language: JavaScript\n"
7754 "IndentWidth: 76\n"
7755 "...\n", &Style).value());
7756 EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
7757 EXPECT_EQ(76u, Style.IndentWidth);
7758 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00007759}
7760
7761TEST_F(FormatTest, ConfigurationRoundTripTest) {
7762 FormatStyle Style = getLLVMStyle();
7763 std::string YAML = configurationAsText(Style);
7764 FormatStyle ParsedStyle = {};
Stephen Hines651f13c2014-04-23 16:59:28 -07007765 ParsedStyle.Language = FormatStyle::LK_Cpp;
Alexander Kornienkod71ec162013-05-07 15:32:14 +00007766 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
7767 EXPECT_EQ(Style, ParsedStyle);
7768}
7769
Alexander Kornienko00895102013-06-05 14:09:10 +00007770TEST_F(FormatTest, WorksFor8bitEncodings) {
7771 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
7772 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
7773 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
7774 "\"\xef\xee\xf0\xf3...\"",
7775 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
7776 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
7777 "\xef\xee\xf0\xf3...\"",
7778 getLLVMStyleWithColumns(12)));
7779}
7780
Alexander Kornienkoa9f28092013-11-13 14:04:17 +00007781TEST_F(FormatTest, HandlesUTF8BOM) {
7782 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
7783 EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
7784 format("\xef\xbb\xbf#include <iostream>"));
7785 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
7786 format("\xef\xbb\xbf\n#include <iostream>"));
7787}
7788
NAKAMURA Takumi07eda942013-06-06 01:14:58 +00007789// FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
7790#if !defined(_MSC_VER)
7791
Alexander Kornienko00895102013-06-05 14:09:10 +00007792TEST_F(FormatTest, CountsUTF8CharactersProperly) {
7793 verifyFormat("\"Однажды в студёную зимнюю пору...\"",
7794 getLLVMStyleWithColumns(35));
7795 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00007796 getLLVMStyleWithColumns(31));
Alexander Kornienko00895102013-06-05 14:09:10 +00007797 verifyFormat("// Однажды в студёную зимнюю пору...",
7798 getLLVMStyleWithColumns(36));
7799 verifyFormat("// 一 二 三 四 五 六 七 八 九 十",
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00007800 getLLVMStyleWithColumns(32));
Alexander Kornienko00895102013-06-05 14:09:10 +00007801 verifyFormat("/* Однажды в студёную зимнюю пору... */",
7802 getLLVMStyleWithColumns(39));
7803 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00007804 getLLVMStyleWithColumns(35));
Alexander Kornienko00895102013-06-05 14:09:10 +00007805}
7806
7807TEST_F(FormatTest, SplitsUTF8Strings) {
Stephen Hines651f13c2014-04-23 16:59:28 -07007808 // Non-printable characters' width is currently considered to be the length in
7809 // bytes in UTF8. The characters can be displayed in very different manner
7810 // (zero-width, single width with a substitution glyph, expanded to their code
7811 // (e.g. "<8d>"), so there's no single correct way to handle them.
7812 EXPECT_EQ("\"aaaaÄ\"\n"
7813 "\"\xc2\x8d\";",
7814 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
7815 EXPECT_EQ("\"aaaaaaaÄ\"\n"
7816 "\"\xc2\x8d\";",
7817 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
Alexander Kornienko00895102013-06-05 14:09:10 +00007818 EXPECT_EQ(
7819 "\"Однажды, в \"\n"
7820 "\"студёную \"\n"
7821 "\"зимнюю \"\n"
7822 "\"пору,\"",
7823 format("\"Однажды, в студёную зимнюю пору,\"",
7824 getLLVMStyleWithColumns(13)));
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00007825 EXPECT_EQ("\"一 二 三 \"\n"
7826 "\"四 五六 \"\n"
7827 "\"七 八 九 \"\n"
7828 "\"十\"",
7829 format("\"一 二 三 四 五六 七 八 九 十\"",
7830 getLLVMStyleWithColumns(11)));
7831 EXPECT_EQ("\"一\t二 \"\n"
7832 "\"\t三 \"\n"
7833 "\"四 五\t六 \"\n"
7834 "\"\t七 \"\n"
7835 "\"八九十\tqq\"",
7836 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
7837 getLLVMStyleWithColumns(11)));
7838}
7839
7840
7841TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
7842 EXPECT_EQ("const char *sssss =\n"
7843 " \"一二三四五六七八\\\n"
7844 " 九 十\";",
7845 format("const char *sssss = \"一二三四五六七八\\\n"
7846 " 九 十\";",
7847 getLLVMStyleWithColumns(30)));
Alexander Kornienko00895102013-06-05 14:09:10 +00007848}
7849
7850TEST_F(FormatTest, SplitsUTF8LineComments) {
Stephen Hines651f13c2014-04-23 16:59:28 -07007851 EXPECT_EQ("// aaaaÄ\xc2\x8d",
7852 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
Alexander Kornienko00895102013-06-05 14:09:10 +00007853 EXPECT_EQ("// Я из лесу\n"
7854 "// вышел; был\n"
7855 "// сильный\n"
7856 "// мороз.",
7857 format("// Я из лесу вышел; был сильный мороз.",
7858 getLLVMStyleWithColumns(13)));
7859 EXPECT_EQ("// 一二三\n"
7860 "// 四五六七\n"
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00007861 "// 八 九\n"
7862 "// 十",
7863 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9)));
Alexander Kornienko00895102013-06-05 14:09:10 +00007864}
7865
7866TEST_F(FormatTest, SplitsUTF8BlockComments) {
7867 EXPECT_EQ("/* Гляжу,\n"
7868 " * поднимается\n"
7869 " * медленно в\n"
7870 " * гору\n"
7871 " * Лошадка,\n"
7872 " * везущая\n"
7873 " * хворосту\n"
7874 " * воз. */",
7875 format("/* Гляжу, поднимается медленно в гору\n"
7876 " * Лошадка, везущая хворосту воз. */",
7877 getLLVMStyleWithColumns(13)));
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00007878 EXPECT_EQ(
7879 "/* 一二三\n"
7880 " * 四五六七\n"
7881 " * 八 九\n"
7882 " * 十 */",
7883 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9)));
Alexander Kornienkodda770b2013-06-05 15:08:20 +00007884 EXPECT_EQ("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯\n"
7885 " * 𝕓𝕪𝕥𝕖\n"
7886 " * 𝖀𝕿𝕱-𝟠 */",
7887 format("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯 𝕓𝕪𝕥𝕖 𝖀𝕿𝕱-𝟠 */", getLLVMStyleWithColumns(12)));
Alexander Kornienko00895102013-06-05 14:09:10 +00007888}
7889
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00007890#endif // _MSC_VER
7891
Daniel Jasper6315fec2013-08-13 10:58:30 +00007892TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
7893 FormatStyle Style = getLLVMStyle();
7894
7895 Style.ConstructorInitializerIndentWidth = 4;
7896 verifyFormat(
7897 "SomeClass::Constructor()\n"
7898 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
7899 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
7900 Style);
7901
7902 Style.ConstructorInitializerIndentWidth = 2;
7903 verifyFormat(
7904 "SomeClass::Constructor()\n"
7905 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
7906 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
7907 Style);
7908
7909 Style.ConstructorInitializerIndentWidth = 0;
7910 verifyFormat(
7911 "SomeClass::Constructor()\n"
7912 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
7913 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
7914 Style);
7915
7916 Style.BreakConstructorInitializersBeforeComma = true;
7917 Style.ConstructorInitializerIndentWidth = 4;
7918 verifyFormat("SomeClass::Constructor()\n"
7919 " : a(a)\n"
7920 " , b(b)\n"
7921 " , c(c) {}",
7922 Style);
Stephen Hines651f13c2014-04-23 16:59:28 -07007923 verifyFormat("SomeClass::Constructor()\n"
7924 " : a(a) {}",
7925 Style);
Daniel Jasper6315fec2013-08-13 10:58:30 +00007926
Stephen Hines651f13c2014-04-23 16:59:28 -07007927 Style.ColumnLimit = 0;
7928 verifyFormat("SomeClass::Constructor()\n"
7929 " : a(a) {}",
7930 Style);
7931 verifyFormat("SomeClass::Constructor()\n"
7932 " : a(a)\n"
7933 " , b(b)\n"
7934 " , c(c) {}",
7935 Style);
7936 verifyFormat("SomeClass::Constructor()\n"
7937 " : a(a) {\n"
7938 " foo();\n"
7939 " bar();\n"
7940 "}",
7941 Style);
7942
7943 Style.AllowShortFunctionsOnASingleLine = false;
7944 verifyFormat("SomeClass::Constructor()\n"
7945 " : a(a)\n"
7946 " , b(b)\n"
7947 " , c(c) {\n}",
7948 Style);
7949 verifyFormat("SomeClass::Constructor()\n"
7950 " : a(a) {\n}",
7951 Style);
7952
7953 Style.ColumnLimit = 80;
7954 Style.AllowShortFunctionsOnASingleLine = true;
Daniel Jasper6315fec2013-08-13 10:58:30 +00007955 Style.ConstructorInitializerIndentWidth = 2;
7956 verifyFormat("SomeClass::Constructor()\n"
7957 " : a(a)\n"
7958 " , b(b)\n"
7959 " , c(c) {}",
7960 Style);
7961
7962 Style.ConstructorInitializerIndentWidth = 0;
7963 verifyFormat("SomeClass::Constructor()\n"
7964 ": a(a)\n"
7965 ", b(b)\n"
7966 ", c(c) {}",
7967 Style);
Daniel Jasper19ccb122013-10-08 05:11:18 +00007968
7969 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
7970 Style.ConstructorInitializerIndentWidth = 4;
Stephen Hines651f13c2014-04-23 16:59:28 -07007971 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
7972 verifyFormat(
7973 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
7974 Style);
Daniel Jasper19ccb122013-10-08 05:11:18 +00007975 verifyFormat(
7976 "SomeClass::Constructor()\n"
7977 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
7978 Style);
7979 Style.ConstructorInitializerIndentWidth = 4;
7980 Style.ColumnLimit = 60;
7981 verifyFormat("SomeClass::Constructor()\n"
7982 " : aaaaaaaa(aaaaaaaa)\n"
7983 " , aaaaaaaa(aaaaaaaa)\n"
7984 " , aaaaaaaa(aaaaaaaa) {}",
7985 Style);
Daniel Jasper6315fec2013-08-13 10:58:30 +00007986}
7987
Daniel Jaspere05dc6d2013-07-24 13:10:59 +00007988TEST_F(FormatTest, FormatsWithWebKitStyle) {
7989 FormatStyle Style = getWebKitStyle();
7990
7991 // Don't indent in outer namespaces.
7992 verifyFormat("namespace outer {\n"
7993 "int i;\n"
7994 "namespace inner {\n"
Daniel Jaspereff18b92013-07-31 23:16:02 +00007995 " int i;\n"
Daniel Jaspere05dc6d2013-07-24 13:10:59 +00007996 "} // namespace inner\n"
7997 "} // namespace outer\n"
7998 "namespace other_outer {\n"
7999 "int i;\n"
8000 "}",
8001 Style);
8002
8003 // Don't indent case labels.
8004 verifyFormat("switch (variable) {\n"
8005 "case 1:\n"
8006 "case 2:\n"
8007 " doSomething();\n"
8008 " break;\n"
8009 "default:\n"
8010 " ++variable;\n"
8011 "}",
8012 Style);
8013
8014 // Wrap before binary operators.
8015 EXPECT_EQ(
8016 "void f()\n"
8017 "{\n"
8018 " if (aaaaaaaaaaaaaaaa\n"
8019 " && bbbbbbbbbbbbbbbbbbbbbbbb\n"
8020 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
8021 " return;\n"
8022 "}",
8023 format(
8024 "void f() {\n"
8025 "if (aaaaaaaaaaaaaaaa\n"
8026 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
8027 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
8028 "return;\n"
8029 "}",
8030 Style));
8031
8032 // Constructor initializers are formatted one per line with the "," on the
8033 // new line.
Daniel Jaspere8b10d32013-07-26 16:56:36 +00008034 verifyFormat("Constructor()\n"
8035 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
8036 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
8037 " aaaaaaaaaaaaaa)\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07008038 " , aaaaaaaaaaaaaaaaaaaaaaa()\n"
8039 "{\n"
8040 "}",
8041 Style);
8042 verifyFormat("SomeClass::Constructor()\n"
8043 " : a(a)\n"
8044 "{\n"
8045 "}",
8046 Style);
8047 EXPECT_EQ("SomeClass::Constructor()\n"
8048 " : a(a)\n"
8049 "{\n"
8050 "}",
8051 format("SomeClass::Constructor():a(a){}", Style));
8052 verifyFormat("SomeClass::Constructor()\n"
8053 " : a(a)\n"
8054 " , b(b)\n"
8055 " , c(c)\n"
8056 "{\n"
8057 "}", Style);
8058 verifyFormat("SomeClass::Constructor()\n"
8059 " : a(a)\n"
8060 "{\n"
8061 " foo();\n"
8062 " bar();\n"
8063 "}",
Daniel Jaspere8b10d32013-07-26 16:56:36 +00008064 Style);
Daniel Jaspere05dc6d2013-07-24 13:10:59 +00008065
Daniel Jaspereff18b92013-07-31 23:16:02 +00008066 // Access specifiers should be aligned left.
8067 verifyFormat("class C {\n"
8068 "public:\n"
8069 " int i;\n"
8070 "};",
8071 Style);
8072
Daniel Jaspere05dc6d2013-07-24 13:10:59 +00008073 // Do not align comments.
Daniel Jasper893ea8d2013-07-31 23:55:15 +00008074 verifyFormat("int a; // Do not\n"
8075 "double b; // align comments.",
8076 Style);
Daniel Jaspere05dc6d2013-07-24 13:10:59 +00008077
8078 // Accept input's line breaks.
8079 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
8080 " || bbbbbbbbbbbbbbb) {\n"
8081 " i++;\n"
8082 "}",
8083 format("if (aaaaaaaaaaaaaaa\n"
8084 "|| bbbbbbbbbbbbbbb) { i++; }",
8085 Style));
8086 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
8087 " i++;\n"
8088 "}",
8089 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
Daniel Jasperc2e03292013-11-08 17:33:27 +00008090
8091 // Don't automatically break all macro definitions (llvm.org/PR17842).
8092 verifyFormat("#define aNumber 10", Style);
8093 // However, generally keep the line breaks that the user authored.
8094 EXPECT_EQ("#define aNumber \\\n"
8095 " 10",
8096 format("#define aNumber \\\n"
8097 " 10",
8098 Style));
Daniel Jaspere05dc6d2013-07-24 13:10:59 +00008099}
8100
Manuel Klimekb61a8af2013-09-03 15:10:01 +00008101TEST_F(FormatTest, FormatsLambdas) {
Daniel Jasper567dcf92013-09-05 09:29:45 +00008102 verifyFormat("int c = [b]() mutable {\n"
8103 " return [&b] { return b++; }();\n"
8104 "}();\n");
8105 verifyFormat("int c = [&] {\n"
8106 " [=] { return b++; }();\n"
8107 "}();\n");
8108 verifyFormat("int c = [&, &a, a] {\n"
8109 " [=, c, &d] { return b++; }();\n"
8110 "}();\n");
8111 verifyFormat("int c = [&a, &a, a] {\n"
8112 " [=, a, b, &c] { return b++; }();\n"
8113 "}();\n");
Stephen Hines651f13c2014-04-23 16:59:28 -07008114 verifyFormat("auto c = {[&a, &a, a] {\n"
Daniel Jasper567dcf92013-09-05 09:29:45 +00008115 " [=, a, b, &c] { return b++; }();\n"
Stephen Hines651f13c2014-04-23 16:59:28 -07008116 "}}\n");
8117 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
Daniel Jasper567dcf92013-09-05 09:29:45 +00008118 verifyFormat("void f() {\n"
8119 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
8120 "}\n");
Daniel Jasper567dcf92013-09-05 09:29:45 +00008121 verifyFormat("void f() {\n"
8122 " other(x.begin(), //\n"
8123 " x.end(), //\n"
Daniel Jasperac2c9742013-09-05 10:04:31 +00008124 " [&](int, int) { return 1; });\n"
Daniel Jasper567dcf92013-09-05 09:29:45 +00008125 "}\n");
Daniel Jasper2d657052013-09-05 11:49:39 +00008126
Stephen Hines651f13c2014-04-23 16:59:28 -07008127 // Lambdas with return types.
8128 verifyFormat("int c = []() -> int { return 2; }();\n");
8129 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
8130 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
8131 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
8132 " int j) -> int {\n"
8133 " return fffffffffffffffffffffffffffffffffffffff(i * j);\n"
8134 "};");
8135
Daniel Jasper2d657052013-09-05 11:49:39 +00008136 // Not lambdas.
Stephen Hines651f13c2014-04-23 16:59:28 -07008137 verifyFormat("constexpr char hello[]{\"hello\"};");
Daniel Jasper520cca82013-09-06 21:25:51 +00008138 verifyFormat("double &operator[](int i) { return 0; }\n"
8139 "int i;");
Stephen Hines651f13c2014-04-23 16:59:28 -07008140 verifyFormat("std::unique_ptr<int[]> foo() {}");
8141 verifyFormat("int i = a[a][a]->f();");
8142 verifyFormat("int i = (*b)[a]->f();");
8143
8144 // Other corner cases.
8145 verifyFormat("void f() {\n"
8146 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n"
8147 " );\n"
8148 "}");
8149
8150 // Lambdas created through weird macros.
8151 verifyFormat("void f() {\n"
8152 " MACRO((const AA &a) { return 1; });\n"
8153 "}");
Manuel Klimekb61a8af2013-09-03 15:10:01 +00008154}
8155
Manuel Klimek753a5112013-09-04 13:25:30 +00008156TEST_F(FormatTest, FormatsBlocks) {
Stephen Hines651f13c2014-04-23 16:59:28 -07008157 verifyFormat("int (^Block)(int, int);");
8158 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)");
8159 verifyFormat("void (^block)(int) = ^(id test) { int i; };");
8160 verifyFormat("void (^block)(int) = ^(int test) { int i; };");
8161 verifyFormat("void (^block)(int) = ^id(int test) { int i; };");
8162 verifyFormat("void (^block)(int) = ^int(int test) { int i; };");
8163
8164 verifyFormat("foo(^{ bar(); });");
8165 verifyFormat("foo(a, ^{ bar(); });");
8166
Manuel Klimek753a5112013-09-04 13:25:30 +00008167 // FIXME: Make whitespace formatting consistent. Ask a ObjC dev how
8168 // it would ideally look.
Daniel Jasper567dcf92013-09-05 09:29:45 +00008169 verifyFormat("[operation setCompletionBlock:^{ [self onOperationDone]; }];");
8170 verifyFormat("int i = {[operation setCompletionBlock : ^{ [self "
Stephen Hines651f13c2014-04-23 16:59:28 -07008171 "onOperationDone]; }]};");
8172 verifyFormat("[operation setCompletionBlock:^(int *i) { f(); }];");
8173 verifyFormat("int a = [operation block:^int(int *i) { return 1; }];");
8174 verifyFormat("[myObject doSomethingWith:arg1\n"
8175 " aaa:^int(int *a) { return 1; }\n"
8176 " bbb:f(a * b)];");
8177
8178 verifyFormat("[operation setCompletionBlock:^{\n"
8179 " [self.delegate newDataAvailable];\n"
8180 "}];",
8181 getLLVMStyleWithColumns(60));
8182 verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
8183 " NSString *path = [self sessionFilePath];\n"
8184 " if (path) {\n"
8185 " // ...\n"
8186 " }\n"
8187 "});");
8188 verifyFormat("[[SessionService sharedService]\n"
8189 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
8190 " if (window) {\n"
8191 " [self windowDidLoad:window];\n"
8192 " } else {\n"
8193 " [self errorLoadingWindow];\n"
8194 " }\n"
8195 " }];");
8196 verifyFormat("void (^largeBlock)(void) = ^{\n"
8197 " // ...\n"
8198 "};\n",
8199 getLLVMStyleWithColumns(40));
8200 verifyFormat("[[SessionService sharedService]\n"
8201 " loadWindowWithCompletionBlock: //\n"
8202 " ^(SessionWindow *window) {\n"
8203 " if (window) {\n"
8204 " [self windowDidLoad:window];\n"
8205 " } else {\n"
8206 " [self errorLoadingWindow];\n"
8207 " }\n"
8208 " }];",
8209 getLLVMStyleWithColumns(60));
8210 verifyFormat("[myObject doSomethingWith:arg1\n"
8211 " firstBlock:^(Foo *a) {\n"
8212 " // ...\n"
8213 " int i;\n"
8214 " }\n"
8215 " secondBlock:^(Bar *b) {\n"
8216 " // ...\n"
8217 " int i;\n"
8218 " }\n"
8219 " thirdBlock:^Foo(Bar *b) {\n"
8220 " // ...\n"
8221 " int i;\n"
8222 " }];");
8223
8224 verifyFormat("f(^{\n"
8225 " @autoreleasepool {\n"
8226 " if (a) {\n"
8227 " g();\n"
8228 " }\n"
8229 " }\n"
8230 "});");
Manuel Klimek753a5112013-09-04 13:25:30 +00008231}
8232
Alexander Kornienko73d845c2013-09-11 12:25:57 +00008233TEST_F(FormatTest, SupportsCRLF) {
8234 EXPECT_EQ("int a;\r\n"
8235 "int b;\r\n"
8236 "int c;\r\n",
8237 format("int a;\r\n"
8238 " int b;\r\n"
8239 " int c;\r\n",
8240 getLLVMStyle()));
8241 EXPECT_EQ("int a;\r\n"
8242 "int b;\r\n"
8243 "int c;\r\n",
8244 format("int a;\r\n"
8245 " int b;\n"
8246 " int c;\r\n",
8247 getLLVMStyle()));
8248 EXPECT_EQ("int a;\n"
8249 "int b;\n"
8250 "int c;\n",
8251 format("int a;\r\n"
8252 " int b;\n"
8253 " int c;\n",
8254 getLLVMStyle()));
8255 EXPECT_EQ("\"aaaaaaa \"\r\n"
8256 "\"bbbbbbb\";\r\n",
8257 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
8258 EXPECT_EQ("#define A \\\r\n"
8259 " b; \\\r\n"
8260 " c; \\\r\n"
8261 " d;\r\n",
8262 format("#define A \\\r\n"
8263 " b; \\\r\n"
8264 " c; d; \r\n",
8265 getGoogleStyle()));
Daniel Jasper74b73632013-10-30 07:36:40 +00008266
8267 EXPECT_EQ("/*\r\n"
8268 "multi line block comments\r\n"
8269 "should not introduce\r\n"
8270 "an extra carriage return\r\n"
8271 "*/\r\n",
8272 format("/*\r\n"
8273 "multi line block comments\r\n"
8274 "should not introduce\r\n"
8275 "an extra carriage return\r\n"
8276 "*/\r\n"));
Alexander Kornienko73d845c2013-09-11 12:25:57 +00008277}
8278
Manuel Klimekaabfb272013-10-12 22:46:56 +00008279TEST_F(FormatTest, MunchSemicolonAfterBlocks) {
8280 verifyFormat("MY_CLASS(C) {\n"
8281 " int i;\n"
8282 " int j;\n"
8283 "};");
8284}
8285
Daniel Jasperc2827ec2013-10-18 10:38:14 +00008286TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {
8287 FormatStyle TwoIndent = getLLVMStyleWithColumns(15);
8288 TwoIndent.ContinuationIndentWidth = 2;
8289
8290 EXPECT_EQ("int i =\n"
8291 " longFunction(\n"
8292 " arg);",
8293 format("int i = longFunction(arg);", TwoIndent));
8294
8295 FormatStyle SixIndent = getLLVMStyleWithColumns(20);
8296 SixIndent.ContinuationIndentWidth = 6;
8297
8298 EXPECT_EQ("int i =\n"
8299 " longFunction(\n"
8300 " arg);",
8301 format("int i = longFunction(arg);", SixIndent));
8302}
8303
Daniel Jasperd8ee5c12013-10-29 14:52:02 +00008304TEST_F(FormatTest, SpacesInAngles) {
8305 FormatStyle Spaces = getLLVMStyle();
8306 Spaces.SpacesInAngles = true;
8307
8308 verifyFormat("static_cast< int >(arg);", Spaces);
8309 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
8310 verifyFormat("f< int, float >();", Spaces);
8311 verifyFormat("template <> g() {}", Spaces);
8312 verifyFormat("template < std::vector< int > > f() {}", Spaces);
8313
8314 Spaces.Standard = FormatStyle::LS_Cpp03;
8315 Spaces.SpacesInAngles = true;
8316 verifyFormat("A< A< int > >();", Spaces);
8317
8318 Spaces.SpacesInAngles = false;
8319 verifyFormat("A<A<int> >();", Spaces);
8320
8321 Spaces.Standard = FormatStyle::LS_Cpp11;
8322 Spaces.SpacesInAngles = true;
8323 verifyFormat("A< A< int > >();", Spaces);
Stephen Hines651f13c2014-04-23 16:59:28 -07008324
Daniel Jasperd8ee5c12013-10-29 14:52:02 +00008325 Spaces.SpacesInAngles = false;
8326 verifyFormat("A<A<int>>();", Spaces);
8327}
8328
Stephen Hines651f13c2014-04-23 16:59:28 -07008329TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {
8330 std::string code = "#if A\n"
8331 "#if B\n"
8332 "a.\n"
8333 "#endif\n"
8334 " a = 1;\n"
8335 "#else\n"
8336 "#endif\n"
8337 "#if C\n"
8338 "#else\n"
8339 "#endif\n";
8340 EXPECT_EQ(code, format(code));
8341}
8342
Daniel Jaspercd162382013-01-07 13:26:07 +00008343} // end namespace tooling
8344} // end namespace clang