blob: 59596bc54399649fbf1c61f36b976cf46bdc2354 [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
Chandler Carruth1050e8b2012-12-04 09:45:34 +000012#include "clang/Format/Format.h"
Chandler Carruthb1ba0ef2013-01-19 08:09:44 +000013#include "clang/Lex/Lexer.h"
14#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
20class FormatTest : public ::testing::Test {
21protected:
22 std::string format(llvm::StringRef Code, unsigned Offset, unsigned Length,
23 const FormatStyle &Style) {
Manuel Klimekca547db2013-01-16 14:55:28 +000024 DEBUG(llvm::errs() << "---\n");
Daniel Jasper8a999452013-05-16 10:40:07 +000025 std::vector<tooling::Range> Ranges(1, tooling::Range(Offset, Length));
26 tooling::Replacements Replaces = reformat(Style, Code, Ranges);
27 ReplacementCount = Replaces.size();
28 std::string Result = applyAllReplacements(Code, Replaces);
29 EXPECT_NE("", Result);
30 DEBUG(llvm::errs() << "\n" << Result << "\n\n");
31 return Result;
Daniel Jasperbac016b2012-12-03 18:12:45 +000032 }
33
Daniel Jasper66d19bd2013-02-18 11:59:17 +000034 std::string
35 format(llvm::StringRef Code, const FormatStyle &Style = getLLVMStyle()) {
Daniel Jasperbac016b2012-12-03 18:12:45 +000036 return format(Code, 0, Code.size(), Style);
37 }
38
Daniel Jaspere35ec2b2012-12-18 19:56:56 +000039 std::string messUp(llvm::StringRef Code) {
40 std::string MessedUp(Code.str());
41 bool InComment = false;
Manuel Klimek526ed112013-01-09 15:25:02 +000042 bool InPreprocessorDirective = false;
Daniel Jaspere35ec2b2012-12-18 19:56:56 +000043 bool JustReplacedNewline = false;
44 for (unsigned i = 0, e = MessedUp.size() - 1; i != e; ++i) {
45 if (MessedUp[i] == '/' && MessedUp[i + 1] == '/') {
46 if (JustReplacedNewline)
47 MessedUp[i - 1] = '\n';
48 InComment = true;
Daniel Jaspere0b15ea2013-01-14 15:40:57 +000049 } else if (MessedUp[i] == '#' && (JustReplacedNewline || i == 0)) {
Daniel Jasper66d19bd2013-02-18 11:59:17 +000050 if (i != 0)
51 MessedUp[i - 1] = '\n';
Manuel Klimek526ed112013-01-09 15:25:02 +000052 InPreprocessorDirective = true;
Manuel Klimekd4397b92013-01-04 23:34:14 +000053 } else if (MessedUp[i] == '\\' && MessedUp[i + 1] == '\n') {
54 MessedUp[i] = ' ';
Manuel Klimek526ed112013-01-09 15:25:02 +000055 MessedUp[i + 1] = ' ';
Daniel Jaspere35ec2b2012-12-18 19:56:56 +000056 } else if (MessedUp[i] == '\n') {
57 if (InComment) {
58 InComment = false;
Manuel Klimek526ed112013-01-09 15:25:02 +000059 } else if (InPreprocessorDirective) {
60 InPreprocessorDirective = false;
Daniel Jaspere35ec2b2012-12-18 19:56:56 +000061 } else {
62 JustReplacedNewline = true;
63 MessedUp[i] = ' ';
64 }
Manuel Klimekd4397b92013-01-04 23:34:14 +000065 } else if (MessedUp[i] != ' ') {
66 JustReplacedNewline = false;
Daniel Jaspere35ec2b2012-12-18 19:56:56 +000067 }
Daniel Jasperbac016b2012-12-03 18:12:45 +000068 }
Daniel Jaspere35ec2b2012-12-18 19:56:56 +000069 return MessedUp;
70 }
71
Manuel Klimek060143e2013-01-02 18:33:23 +000072 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) {
73 FormatStyle Style = getLLVMStyle();
74 Style.ColumnLimit = ColumnLimit;
75 return Style;
76 }
77
Daniel Jasper6f5bb2c2013-01-14 16:24:39 +000078 FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) {
79 FormatStyle Style = getGoogleStyle();
80 Style.ColumnLimit = ColumnLimit;
81 return Style;
82 }
83
Manuel Klimek060143e2013-01-02 18:33:23 +000084 void verifyFormat(llvm::StringRef Code,
85 const FormatStyle &Style = getLLVMStyle()) {
86 EXPECT_EQ(Code.str(), format(messUp(Code), Style));
Daniel Jasperbac016b2012-12-03 18:12:45 +000087 }
88
89 void verifyGoogleFormat(llvm::StringRef Code) {
Manuel Klimek060143e2013-01-02 18:33:23 +000090 verifyFormat(Code, getGoogleStyle());
Daniel Jasperbac016b2012-12-03 18:12:45 +000091 }
Daniel Jasper4bfc65a2013-01-23 12:10:53 +000092
93 void verifyIndependentOfContext(llvm::StringRef text) {
94 verifyFormat(text);
95 verifyFormat(llvm::Twine("void f() { " + text + " }").str());
96 }
Daniel Jasperafcbd852013-01-30 09:46:12 +000097
98 int ReplacementCount;
Daniel Jasperbac016b2012-12-03 18:12:45 +000099};
100
Manuel Klimek526ed112013-01-09 15:25:02 +0000101TEST_F(FormatTest, MessUp) {
102 EXPECT_EQ("1 2 3", messUp("1 2 3"));
103 EXPECT_EQ("1 2 3\n", messUp("1\n2\n3\n"));
104 EXPECT_EQ("a\n//b\nc", messUp("a\n//b\nc"));
105 EXPECT_EQ("a\n#b\nc", messUp("a\n#b\nc"));
106 EXPECT_EQ("a\n#b c d\ne", messUp("a\n#b\\\nc\\\nd\ne"));
107}
108
Alexander Kornienko15757312012-12-06 18:03:27 +0000109//===----------------------------------------------------------------------===//
110// Basic function tests.
111//===----------------------------------------------------------------------===//
112
Daniel Jasper567dcf92013-09-05 09:29:45 +0000113TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) {
Daniel Jasperbac016b2012-12-03 18:12:45 +0000114 EXPECT_EQ(";", format(";"));
115}
116
117TEST_F(FormatTest, FormatsGlobalStatementsAt0) {
118 EXPECT_EQ("int i;", format(" int i;"));
Alexander Kornienko73d845c2013-09-11 12:25:57 +0000119 EXPECT_EQ("\nint i;", format(" \n\t \v \f int i;"));
Daniel Jasperbac016b2012-12-03 18:12:45 +0000120 EXPECT_EQ("int i;\nint j;", format(" int i; int j;"));
121 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;"));
122}
123
124TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) {
125 EXPECT_EQ("int i;", format("int\ni;"));
126}
127
128TEST_F(FormatTest, FormatsNestedBlockStatements) {
Manuel Klimek36fab8d2013-01-10 13:24:24 +0000129 EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}"));
Daniel Jasperbac016b2012-12-03 18:12:45 +0000130}
131
Alexander Kornienko15757312012-12-06 18:03:27 +0000132TEST_F(FormatTest, FormatsNestedCall) {
133 verifyFormat("Method(f1, f2(f3));");
134 verifyFormat("Method(f1(f2, f3()));");
Daniel Jasper4e9008a2013-01-13 08:19:51 +0000135 verifyFormat("Method(f1(f2, (f3())));");
Alexander Kornienko15757312012-12-06 18:03:27 +0000136}
137
Daniel Jasperdaf1a152013-02-07 21:08:36 +0000138TEST_F(FormatTest, NestedNameSpecifiers) {
Daniel Jasper6b825c22013-01-16 07:19:28 +0000139 verifyFormat("vector< ::Type> v;");
Daniel Jasperdaf1a152013-02-07 21:08:36 +0000140 verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())");
Daniel Jasper081fc172013-08-28 07:07:07 +0000141 verifyFormat("static constexpr bool Bar = decltype(bar())::value;");
Daniel Jasper6b825c22013-01-16 07:19:28 +0000142}
143
Daniel Jasperafcbd852013-01-30 09:46:12 +0000144TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) {
145 EXPECT_EQ("if (a) {\n"
146 " f();\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000147 "}",
148 format("if(a){f();}"));
Daniel Jasperafcbd852013-01-30 09:46:12 +0000149 EXPECT_EQ(4, ReplacementCount);
150 EXPECT_EQ("if (a) {\n"
151 " f();\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000152 "}",
153 format("if (a) {\n"
154 " f();\n"
155 "}"));
Daniel Jasperafcbd852013-01-30 09:46:12 +0000156 EXPECT_EQ(0, ReplacementCount);
157}
158
Daniel Jasperc78c6b32013-02-14 09:58:41 +0000159TEST_F(FormatTest, RemovesTrailingWhitespaceOfFormattedLine) {
160 EXPECT_EQ("int a;\nint b;", format("int a; \nint b;", 0, 0, getLLVMStyle()));
Daniel Jasper516fb312013-03-01 18:11:39 +0000161 EXPECT_EQ("int a;", format("int a; "));
162 EXPECT_EQ("int a;\n", format("int a; \n \n \n "));
163 EXPECT_EQ("int a;\nint b; ",
164 format("int a; \nint b; ", 0, 0, getLLVMStyle()));
Daniel Jasperc78c6b32013-02-14 09:58:41 +0000165}
166
Daniel Jasper1eee6c42013-03-04 13:43:19 +0000167TEST_F(FormatTest, FormatsCorrectRegionForLeadingWhitespace) {
168 EXPECT_EQ("int b;\nint a;",
169 format("int b;\n int a;", 7, 0, getLLVMStyle()));
170 EXPECT_EQ("int b;\n int a;",
171 format("int b;\n int a;", 6, 0, getLLVMStyle()));
172
173 EXPECT_EQ("#define A \\\n"
174 " int a; \\\n"
175 " int b;",
176 format("#define A \\\n"
177 " int a; \\\n"
178 " int b;",
179 26, 0, getLLVMStyleWithColumns(12)));
180 EXPECT_EQ("#define A \\\n"
181 " int a; \\\n"
182 " int b;",
183 format("#define A \\\n"
184 " int a; \\\n"
185 " int b;",
186 25, 0, getLLVMStyleWithColumns(12)));
187}
188
Daniel Jasperf3023542013-03-07 20:50:00 +0000189TEST_F(FormatTest, RemovesWhitespaceWhenTriggeredOnEmptyLine) {
190 EXPECT_EQ("int a;\n\n int b;",
191 format("int a;\n \n\n int b;", 7, 0, getLLVMStyle()));
192 EXPECT_EQ("int a;\n\n int b;",
193 format("int a;\n \n\n int b;", 9, 0, getLLVMStyle()));
194}
195
Daniel Jasper15f33f02013-06-03 16:16:41 +0000196TEST_F(FormatTest, RemovesEmptyLines) {
197 EXPECT_EQ("class C {\n"
198 " int i;\n"
199 "};",
200 format("class C {\n"
201 " int i;\n"
202 "\n"
203 "};"));
204
205 // Don't remove empty lines in more complex control statements.
206 EXPECT_EQ("void f() {\n"
207 " if (a) {\n"
208 " f();\n"
209 "\n"
210 " } else if (b) {\n"
211 " f();\n"
212 " }\n"
213 "}",
214 format("void f() {\n"
215 " if (a) {\n"
216 " f();\n"
217 "\n"
218 " } else if (b) {\n"
219 " f();\n"
220 "\n"
221 " }\n"
222 "\n"
223 "}"));
224
225 // FIXME: This is slightly inconsistent.
226 EXPECT_EQ("namespace {\n"
227 "int i;\n"
228 "}",
229 format("namespace {\n"
230 "int i;\n"
231 "\n"
232 "}"));
233 EXPECT_EQ("namespace {\n"
234 "int i;\n"
235 "\n"
236 "} // namespace",
237 format("namespace {\n"
238 "int i;\n"
239 "\n"
240 "} // namespace"));
241}
242
Daniel Jasper29333162013-02-18 13:08:03 +0000243TEST_F(FormatTest, ReformatsMovedLines) {
244 EXPECT_EQ(
245 "template <typename T> T *getFETokenInfo() const {\n"
246 " return static_cast<T *>(FETokenInfo);\n"
247 "}\n"
248 " int a; // <- Should not be formatted",
249 format(
250 "template<typename T>\n"
251 "T *getFETokenInfo() const { return static_cast<T*>(FETokenInfo); }\n"
252 " int a; // <- Should not be formatted",
253 9, 5, getLLVMStyle()));
254}
255
Alexander Kornienko15757312012-12-06 18:03:27 +0000256//===----------------------------------------------------------------------===//
257// Tests for control statements.
258//===----------------------------------------------------------------------===//
259
Daniel Jasper84f5ddf2013-05-14 10:31:09 +0000260TEST_F(FormatTest, FormatIfWithoutCompoundStatement) {
Daniel Jasper6f5bb2c2013-01-14 16:24:39 +0000261 verifyFormat("if (true)\n f();\ng();");
262 verifyFormat("if (a)\n if (b)\n if (c)\n g();\nh();");
Alexander Kornienko15757312012-12-06 18:03:27 +0000263 verifyFormat("if (a)\n if (b) {\n f();\n }\ng();");
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000264
Daniel Jasperf11bbb92013-05-16 12:12:21 +0000265 FormatStyle AllowsMergedIf = getLLVMStyle();
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000266 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true;
267 verifyFormat("if (a)\n"
268 " // comment\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000269 " f();",
270 AllowsMergedIf);
Daniel Jasperf11bbb92013-05-16 12:12:21 +0000271 verifyFormat("if (a)\n"
272 " ;",
273 AllowsMergedIf);
274 verifyFormat("if (a)\n"
275 " if (b) return;",
276 AllowsMergedIf);
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000277
Daniel Jasperf11bbb92013-05-16 12:12:21 +0000278 verifyFormat("if (a) // Can't merge this\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000279 " f();\n",
280 AllowsMergedIf);
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000281 verifyFormat("if (a) /* still don't merge */\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000282 " f();",
283 AllowsMergedIf);
Daniel Jasperf11bbb92013-05-16 12:12:21 +0000284 verifyFormat("if (a) { // Never merge this\n"
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000285 " f();\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000286 "}",
287 AllowsMergedIf);
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000288 verifyFormat("if (a) { /* Never merge this */\n"
289 " f();\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000290 "}",
291 AllowsMergedIf);
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000292
Daniel Jasper1fb8d882013-05-14 09:30:02 +0000293 EXPECT_EQ("if (a) return;", format("if(a)\nreturn;", 7, 1, AllowsMergedIf));
Daniel Jasperf11bbb92013-05-16 12:12:21 +0000294 EXPECT_EQ("if (a) return; // comment",
Daniel Jasper84f5ddf2013-05-14 10:31:09 +0000295 format("if(a)\nreturn; // comment", 20, 1, AllowsMergedIf));
Daniel Jasper1fb8d882013-05-14 09:30:02 +0000296
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000297 AllowsMergedIf.ColumnLimit = 14;
298 verifyFormat("if (a) return;", AllowsMergedIf);
Daniel Jasperfd0ca972013-01-14 16:02:06 +0000299 verifyFormat("if (aaaaaaaaa)\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000300 " return;",
301 AllowsMergedIf);
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000302
303 AllowsMergedIf.ColumnLimit = 13;
304 verifyFormat("if (a)\n return;", AllowsMergedIf);
Alexander Kornienko15757312012-12-06 18:03:27 +0000305}
306
Daniel Jasperf11bbb92013-05-16 12:12:21 +0000307TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) {
308 FormatStyle AllowsMergedLoops = getLLVMStyle();
309 AllowsMergedLoops.AllowShortLoopsOnASingleLine = true;
310 verifyFormat("while (true) continue;", AllowsMergedLoops);
311 verifyFormat("for (;;) continue;", AllowsMergedLoops);
312 verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops);
313 verifyFormat("while (true)\n"
314 " ;",
315 AllowsMergedLoops);
316 verifyFormat("for (;;)\n"
317 " ;",
318 AllowsMergedLoops);
319 verifyFormat("for (;;)\n"
320 " for (;;) continue;",
321 AllowsMergedLoops);
322 verifyFormat("for (;;) // Can't merge this\n"
323 " continue;",
324 AllowsMergedLoops);
325 verifyFormat("for (;;) /* still don't merge */\n"
326 " continue;",
327 AllowsMergedLoops);
328}
329
Alexander Kornienko15757312012-12-06 18:03:27 +0000330TEST_F(FormatTest, ParseIfElse) {
331 verifyFormat("if (true)\n"
332 " if (true)\n"
333 " if (true)\n"
334 " f();\n"
335 " else\n"
336 " g();\n"
337 " else\n"
338 " h();\n"
339 "else\n"
340 " i();");
341 verifyFormat("if (true)\n"
342 " if (true)\n"
343 " if (true) {\n"
Daniel Jasper6f5bb2c2013-01-14 16:24:39 +0000344 " if (true)\n"
345 " f();\n"
Alexander Kornienko15757312012-12-06 18:03:27 +0000346 " } else {\n"
347 " g();\n"
348 " }\n"
349 " else\n"
350 " h();\n"
351 "else {\n"
352 " i();\n"
353 "}");
Daniel Jaspere63a48a2013-09-17 08:28:05 +0000354 verifyFormat("void f() {\n"
355 " if (a) {\n"
356 " } else {\n"
357 " }\n"
358 "}");
Alexander Kornienko15757312012-12-06 18:03:27 +0000359}
360
361TEST_F(FormatTest, ElseIf) {
Manuel Klimek2f1ac412013-01-21 16:42:44 +0000362 verifyFormat("if (a) {\n} else if (b) {\n}");
Alexander Kornienko15757312012-12-06 18:03:27 +0000363 verifyFormat("if (a)\n"
364 " f();\n"
365 "else if (b)\n"
366 " g();\n"
367 "else\n"
368 " h();");
369}
370
Daniel Jasperbac016b2012-12-03 18:12:45 +0000371TEST_F(FormatTest, FormatsForLoop) {
372 verifyFormat(
373 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n"
Alexander Kornienko2e97cfc2012-12-05 15:06:06 +0000374 " ++VeryVeryLongLoopVariable)\n"
375 " ;");
376 verifyFormat("for (;;)\n"
377 " f();");
Manuel Klimek2f1ac412013-01-21 16:42:44 +0000378 verifyFormat("for (;;) {\n}");
Alexander Kornienko2e97cfc2012-12-05 15:06:06 +0000379 verifyFormat("for (;;) {\n"
380 " f();\n"
381 "}");
Daniel Jasper454cb702013-05-03 14:50:50 +0000382 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}");
Daniel Jaspera324a0e2012-12-21 14:37:20 +0000383
384 verifyFormat(
385 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
386 " E = UnwrappedLines.end();\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +0000387 " I != E; ++I) {\n}");
Daniel Jaspera324a0e2012-12-21 14:37:20 +0000388
389 verifyFormat(
390 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +0000391 " ++IIIII) {\n}");
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +0000392 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n"
393 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000394 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}");
Daniel Jasper7d812812013-02-21 15:00:29 +0000395 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n"
396 " I = FD->getDeclsInPrototypeScope().begin(),\n"
397 " E = FD->getDeclsInPrototypeScope().end();\n"
398 " I != E; ++I) {\n}");
Daniel Jasper75223182013-01-28 17:30:17 +0000399
400 // FIXME: Not sure whether we want extra identation in line 3 here:
401 verifyFormat(
402 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
403 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n"
Daniel Jasperf9955d32013-03-20 12:37:50 +0000404 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
405 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
Daniel Jasper75223182013-01-28 17:30:17 +0000406 " ++aaaaaaaaaaa) {\n}");
Daniel Jasperfaab0d32013-02-27 09:47:53 +0000407 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n"
408 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
409 "}");
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +0000410 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n"
411 " aaaaaaaaaa);\n"
412 " iter; ++iter) {\n"
413 "}");
Daniel Jasper8159d2f2013-02-04 07:30:30 +0000414
Daniel Jasperfaab0d32013-02-27 09:47:53 +0000415 FormatStyle NoBinPacking = getLLVMStyle();
416 NoBinPacking.BinPackParameters = false;
417 verifyFormat("for (int aaaaaaaaaaa = 1;\n"
418 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n"
419 " aaaaaaaaaaaaaaaa,\n"
420 " aaaaaaaaaaaaaaaa,\n"
421 " aaaaaaaaaaaaaaaa);\n"
422 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
423 "}",
424 NoBinPacking);
425 verifyFormat(
Daniel Jasper237d4c12013-02-23 21:01:55 +0000426 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
427 " E = UnwrappedLines.end();\n"
428 " I != E;\n"
Daniel Jasperfaab0d32013-02-27 09:47:53 +0000429 " ++I) {\n}",
430 NoBinPacking);
Daniel Jasperbac016b2012-12-03 18:12:45 +0000431}
432
Daniel Jasper3b9a8fc2013-01-28 13:21:16 +0000433TEST_F(FormatTest, RangeBasedForLoops) {
434 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
435 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
436 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n"
437 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}");
Daniel Jasper84a1a632013-02-26 13:18:08 +0000438 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n"
439 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasper3b9a8fc2013-01-28 13:21:16 +0000440}
441
Daniel Jasperbac016b2012-12-03 18:12:45 +0000442TEST_F(FormatTest, FormatsWhileLoop) {
Manuel Klimek2f1ac412013-01-21 16:42:44 +0000443 verifyFormat("while (true) {\n}");
Alexander Kornienko2e97cfc2012-12-05 15:06:06 +0000444 verifyFormat("while (true)\n"
445 " f();");
Manuel Klimek2f1ac412013-01-21 16:42:44 +0000446 verifyFormat("while () {\n}");
Alexander Kornienko2e97cfc2012-12-05 15:06:06 +0000447 verifyFormat("while () {\n"
448 " f();\n"
449 "}");
Daniel Jasperbac016b2012-12-03 18:12:45 +0000450}
451
Alexander Kornienko15757312012-12-06 18:03:27 +0000452TEST_F(FormatTest, FormatsDoWhile) {
453 verifyFormat("do {\n"
454 " do_something();\n"
455 "} while (something());");
456 verifyFormat("do\n"
457 " do_something();\n"
458 "while (something());");
Daniel Jasperbac016b2012-12-03 18:12:45 +0000459}
460
Alexander Kornienko15757312012-12-06 18:03:27 +0000461TEST_F(FormatTest, FormatsSwitchStatement) {
Daniel Jasperbac016b2012-12-03 18:12:45 +0000462 verifyFormat("switch (x) {\n"
463 "case 1:\n"
464 " f();\n"
465 " break;\n"
466 "case kFoo:\n"
467 "case ns::kBar:\n"
468 "case kBaz:\n"
469 " break;\n"
470 "default:\n"
471 " g();\n"
472 " break;\n"
473 "}");
474 verifyFormat("switch (x) {\n"
475 "case 1: {\n"
476 " f();\n"
477 " break;\n"
478 "}\n"
479 "}");
Nico Weber94fb7292013-01-18 05:50:57 +0000480 verifyFormat("switch (x) {\n"
481 "case 1: {\n"
482 " f();\n"
483 " {\n"
484 " g();\n"
485 " h();\n"
486 " }\n"
487 " break;\n"
488 "}\n"
489 "}");
490 verifyFormat("switch (x) {\n"
491 "case 1: {\n"
492 " f();\n"
493 " if (foo) {\n"
494 " g();\n"
495 " h();\n"
496 " }\n"
497 " break;\n"
498 "}\n"
499 "}");
500 verifyFormat("switch (x) {\n"
501 "case 1: {\n"
502 " f();\n"
503 " g();\n"
504 "} break;\n"
505 "}");
Daniel Jasperbac016b2012-12-03 18:12:45 +0000506 verifyFormat("switch (test)\n"
507 " ;");
Daniel Jasper4ba9bfd2013-03-12 12:26:55 +0000508 verifyFormat("switch (x) {\n"
509 "default: {\n"
510 " // Do nothing.\n"
Manuel Klimek67d080d2013-04-12 14:13:36 +0000511 "}\n"
Daniel Jasper4ba9bfd2013-03-12 12:26:55 +0000512 "}");
Daniel Jasper6050a1e2013-03-13 15:53:12 +0000513 verifyFormat("switch (x) {\n"
Daniel Jasper5999f762013-04-09 17:46:55 +0000514 "// comment\n"
Daniel Jasper6050a1e2013-03-13 15:53:12 +0000515 "// if 1, do f()\n"
516 "case 1:\n"
517 " f();\n"
518 "}");
Daniel Jasperc30eb512013-03-19 18:33:58 +0000519 verifyFormat("switch (x) {\n"
520 "case 1:\n"
521 " // Do amazing stuff\n"
522 " {\n"
523 " f();\n"
524 " g();\n"
525 " }\n"
526 " break;\n"
527 "}");
Daniel Jasperbcca7e42013-03-20 10:23:53 +0000528 verifyFormat("#define A \\\n"
529 " switch (x) { \\\n"
530 " case a: \\\n"
531 " foo = b; \\\n"
532 " }", getLLVMStyleWithColumns(20));
Daniel Jasper67cf1db2013-09-02 08:26:29 +0000533 verifyFormat("#define OPERATION_CASE(name) \\\n"
534 " case OP_name: \\\n"
535 " return operations::Operation##name\n",
536 getLLVMStyleWithColumns(40));
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000537
Alexander Kornienko15757312012-12-06 18:03:27 +0000538 verifyGoogleFormat("switch (x) {\n"
539 " case 1:\n"
540 " f();\n"
541 " break;\n"
542 " case kFoo:\n"
543 " case ns::kBar:\n"
544 " case kBaz:\n"
545 " break;\n"
546 " default:\n"
547 " g();\n"
548 " break;\n"
549 "}");
550 verifyGoogleFormat("switch (x) {\n"
551 " case 1: {\n"
552 " f();\n"
553 " break;\n"
554 " }\n"
555 "}");
556 verifyGoogleFormat("switch (test)\n"
Daniel Jaspere865cc52013-07-25 11:31:57 +0000557 " ;");
558
559 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n"
560 " case OP_name: \\\n"
561 " return operations::Operation##name\n");
562 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n"
563 " // Get the correction operation class.\n"
564 " switch (OpCode) {\n"
565 " CASE(Add);\n"
566 " CASE(Subtract);\n"
567 " default:\n"
568 " return operations::Unknown;\n"
569 " }\n"
570 "#undef OPERATION_CASE\n"
571 "}");
Daniel Jasperb77d7412013-09-06 07:54:20 +0000572 verifyFormat("DEBUG({\n"
573 " switch (x) {\n"
574 " case A:\n"
575 " f();\n"
576 " break;\n"
577 " // On B:\n"
578 " case B:\n"
579 " g();\n"
580 " break;\n"
581 " }\n"
582 "});");
Daniel Jasperbac016b2012-12-03 18:12:45 +0000583}
584
Alexander Kornienko15757312012-12-06 18:03:27 +0000585TEST_F(FormatTest, FormatsLabels) {
Daniel Jasperbac016b2012-12-03 18:12:45 +0000586 verifyFormat("void f() {\n"
587 " some_code();\n"
588 "test_label:\n"
589 " some_other_code();\n"
590 " {\n"
591 " some_more_code();\n"
592 " another_label:\n"
593 " some_more_code();\n"
594 " }\n"
595 "}");
596 verifyFormat("some_code();\n"
597 "test_label:\n"
598 "some_other_code();");
599}
600
Alexander Kornienko15757312012-12-06 18:03:27 +0000601//===----------------------------------------------------------------------===//
602// Tests for comments.
603//===----------------------------------------------------------------------===//
604
605TEST_F(FormatTest, UnderstandsSingleLineComments) {
Daniel Jasperb64eca02013-03-22 10:01:29 +0000606 verifyFormat("//* */");
Daniel Jaspere35ec2b2012-12-18 19:56:56 +0000607 verifyFormat("// line 1\n"
608 "// line 2\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +0000609 "void f() {}\n");
Alexander Kornienko15757312012-12-06 18:03:27 +0000610
Daniel Jaspere35ec2b2012-12-18 19:56:56 +0000611 verifyFormat("void f() {\n"
612 " // Doesn't do anything\n"
613 "}");
Daniel Jaspere1f9a8e2013-07-11 13:48:16 +0000614 verifyFormat("SomeObject\n"
615 " // Calling someFunction on SomeObject\n"
616 " .someFunction();");
Daniel Jasperdcc2a622013-01-18 08:44:07 +0000617 verifyFormat("void f(int i, // some comment (probably for i)\n"
618 " int j, // some comment (probably for j)\n"
Daniel Jasper487f64b2013-01-13 16:10:20 +0000619 " int k); // some comment (probably for k)");
620 verifyFormat("void f(int i,\n"
621 " // some comment (probably for j)\n"
622 " int j,\n"
623 " // some comment (probably for k)\n"
624 " int k);");
Alexander Kornienko15757312012-12-06 18:03:27 +0000625
Daniel Jasperdcc2a622013-01-18 08:44:07 +0000626 verifyFormat("int i // This is a fancy variable\n"
627 " = 5; // with nicely aligned comment.");
628
629 verifyFormat("// Leading comment.\n"
630 "int a; // Trailing comment.");
631 verifyFormat("int a; // Trailing comment\n"
632 " // on 2\n"
633 " // or 3 lines.\n"
634 "int b;");
635 verifyFormat("int a; // Trailing comment\n"
636 "\n"
637 "// Leading comment.\n"
638 "int b;");
639 verifyFormat("int a; // Comment.\n"
640 " // More details.\n"
641 "int bbbb; // Another comment.");
642 verifyFormat(
643 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; // comment\n"
644 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; // comment\n"
645 "int cccccccccccccccccccccccccccccc; // comment\n"
646 "int ddd; // looooooooooooooooooooooooong comment\n"
647 "int aaaaaaaaaaaaaaaaaaaaaaa; // comment\n"
648 "int bbbbbbbbbbbbbbbbbbbbb; // comment\n"
649 "int ccccccccccccccccccc; // comment");
650
Daniel Jasper7d1185d2013-01-18 09:19:33 +0000651 verifyFormat("#include \"a\" // comment\n"
652 "#include \"a/b/c\" // comment");
653 verifyFormat("#include <a> // comment\n"
654 "#include <a/b/c> // comment");
Manuel Klimekad3094b2013-05-23 10:56:37 +0000655 EXPECT_EQ("#include \\\n"
656 " \"a\" // comment\n"
657 "#include \"a/b/c\" // comment",
658 format("#include \\\n"
659 " \"a\" // comment\n"
660 "#include \"a/b/c\" // comment"));
Alexander Kornienko15757312012-12-06 18:03:27 +0000661
Daniel Jaspere35ec2b2012-12-18 19:56:56 +0000662 verifyFormat("enum E {\n"
663 " // comment\n"
Daniel Jasper7ad4eff2013-01-07 11:09:06 +0000664 " VAL_A, // comment\n"
Daniel Jaspere35ec2b2012-12-18 19:56:56 +0000665 " VAL_B\n"
666 "};");
Daniel Jasper05b1ac82012-12-17 11:29:41 +0000667
668 verifyFormat(
669 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Daniel Jasper7ad4eff2013-01-07 11:09:06 +0000670 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; // Trailing comment");
Daniel Jasper043835a2013-01-09 09:33:39 +0000671 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
672 " // Comment inside a statement.\n"
673 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
Daniel Jasper36ba0ff2013-02-06 15:23:09 +0000674 verifyFormat(
675 "bool aaaaaaaaaaaaa = // comment\n"
676 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
677 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Manuel Klimek6cf58142013-01-07 08:54:53 +0000678
Daniel Jasper42f458d2013-02-13 19:25:54 +0000679 verifyFormat("int aaaa; // aaaaa\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000680 "int aa; // aaaaaaa",
681 getLLVMStyleWithColumns(20));
Daniel Jasper42f458d2013-02-13 19:25:54 +0000682
Daniel Jasper821627e2013-01-21 22:49:20 +0000683 EXPECT_EQ("void f() { // This does something ..\n"
684 "}\n"
685 "int a; // This is unrelated",
686 format("void f() { // This does something ..\n"
687 " }\n"
688 "int a; // This is unrelated"));
Daniel Jaspercbe86cc2013-07-01 11:22:57 +0000689 EXPECT_EQ("class C {\n"
690 " void f() { // This does something ..\n"
691 " } // awesome..\n"
Daniel Jasper821627e2013-01-21 22:49:20 +0000692 "\n"
Daniel Jaspercbe86cc2013-07-01 11:22:57 +0000693 " int a; // This is unrelated\n"
694 "};",
695 format("class C{void f() { // This does something ..\n"
Daniel Jasper821627e2013-01-21 22:49:20 +0000696 " } // awesome..\n"
697 " \n"
Daniel Jaspercbe86cc2013-07-01 11:22:57 +0000698 "int a; // This is unrelated\n"
699 "};"));
Daniel Jasper821627e2013-01-21 22:49:20 +0000700
Daniel Jasper7ad4eff2013-01-07 11:09:06 +0000701 EXPECT_EQ("int i; // single line trailing comment",
Manuel Klimek6cf58142013-01-07 08:54:53 +0000702 format("int i;\\\n// single line trailing comment"));
Daniel Jasper7ad4eff2013-01-07 11:09:06 +0000703
704 verifyGoogleFormat("int a; // Trailing comment.");
Daniel Jasperd4f2c2e2013-01-29 19:41:55 +0000705
706 verifyFormat("someFunction(anotherFunction( // Force break.\n"
707 " parameter));");
Daniel Jasper5b7e7b02013-02-05 09:34:14 +0000708
709 verifyGoogleFormat("#endif // HEADER_GUARD");
Daniel Jasper474e4622013-02-06 22:04:05 +0000710
711 verifyFormat("const char *test[] = {\n"
712 " // A\n"
713 " \"aaaa\",\n"
714 " // B\n"
715 " \"aaaaa\",\n"
716 "};");
Daniel Jasper729a7432013-02-11 12:36:37 +0000717 verifyGoogleFormat(
718 "aaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Alexander Kornienko2785b9a2013-06-07 16:02:52 +0000719 " aaaaaaaaaaaaaaaaaaaaaa); // 81_cols_with_this_comment");
Alexander Kornienko4128e192013-04-03 12:38:53 +0000720 EXPECT_EQ("D(a, {\n"
721 " // test\n"
722 " int a;\n"
723 "});",
724 format("D(a, {\n"
725 "// test\n"
726 "int a;\n"
727 "});"));
Manuel Klimekebfb88c2013-05-23 11:42:52 +0000728
729 EXPECT_EQ("lineWith(); // comment\n"
730 "// at start\n"
731 "otherLine();",
732 format("lineWith(); // comment\n"
733 "// at start\n"
734 "otherLine();"));
735 EXPECT_EQ("lineWith(); // comment\n"
736 " // at start\n"
737 "otherLine();",
738 format("lineWith(); // comment\n"
739 " // at start\n"
740 "otherLine();"));
Manuel Klimek23ad3392013-05-23 19:54:43 +0000741
742 EXPECT_EQ("lineWith(); // comment\n"
743 "// at start\n"
744 "otherLine(); // comment",
745 format("lineWith(); // comment\n"
746 "// at start\n"
747 "otherLine(); // comment"));
Manuel Klimek854ca792013-05-23 20:46:07 +0000748 EXPECT_EQ("lineWith();\n"
749 "// at start\n"
750 "otherLine(); // comment",
751 format("lineWith();\n"
752 " // at start\n"
753 "otherLine(); // comment"));
754 EXPECT_EQ("// first\n"
755 "// at start\n"
756 "otherLine(); // comment",
757 format("// first\n"
758 " // at start\n"
759 "otherLine(); // comment"));
760 EXPECT_EQ("f();\n"
761 "// first\n"
762 "// at start\n"
763 "otherLine(); // comment",
764 format("f();\n"
765 "// first\n"
766 " // at start\n"
767 "otherLine(); // comment"));
Daniel Jasper05b1ac82012-12-17 11:29:41 +0000768}
769
Daniel Jasperc363dbb2013-03-22 16:25:51 +0000770TEST_F(FormatTest, CanFormatCommentsLocally) {
771 EXPECT_EQ("int a; // comment\n"
772 "int b; // comment",
773 format("int a; // comment\n"
774 "int b; // comment",
775 0, 0, getLLVMStyle()));
776 EXPECT_EQ("int a; // comment\n"
777 " // line 2\n"
778 "int b;",
779 format("int a; // comment\n"
780 " // line 2\n"
781 "int b;",
782 28, 0, getLLVMStyle()));
Daniel Jasperaf849762013-04-24 06:33:59 +0000783 EXPECT_EQ("int aaaaaa; // comment\n"
784 "int b;\n"
785 "int c; // unrelated comment",
786 format("int aaaaaa; // comment\n"
787 "int b;\n"
788 "int c; // unrelated comment",
789 31, 0, getLLVMStyle()));
Daniel Jasperc363dbb2013-03-22 16:25:51 +0000790}
791
Daniel Jasper812c0452013-03-01 16:45:59 +0000792TEST_F(FormatTest, RemovesTrailingWhitespaceOfComments) {
793 EXPECT_EQ("// comment", format("// comment "));
794 EXPECT_EQ("int aaaaaaa, bbbbbbb; // comment",
795 format("int aaaaaaa, bbbbbbb; // comment ",
796 getLLVMStyleWithColumns(33)));
Alexander Kornienko51bb5d92013-09-06 17:24:54 +0000797 EXPECT_EQ("// comment\\\n", format("// comment\\\n \t \v \f "));
798 EXPECT_EQ("// comment \\\n", format("// comment \\\n \t \v \f "));
Daniel Jasper812c0452013-03-01 16:45:59 +0000799}
800
Alexander Kornienkoc36c5c22013-06-19 19:50:11 +0000801TEST_F(FormatTest, UnderstandsBlockComments) {
Nico Weber861576b2013-06-26 00:15:19 +0000802 verifyFormat("f(/*noSpaceAfterParameterNamingComment=*/true);");
Daniel Jasper2c6cc482013-01-17 12:53:34 +0000803 EXPECT_EQ(
804 "f(aaaaaaaaaaaaaaaaaaaaaaaaa, /* Trailing comment for aa... */\n"
805 " bbbbbbbbbbbbbbbbbbbbbbbbb);",
Alexander Kornienko919398b2013-04-17 17:34:05 +0000806 format("f(aaaaaaaaaaaaaaaaaaaaaaaaa , \\\n/* Trailing comment for aa... */\n"
Daniel Jasper2c6cc482013-01-17 12:53:34 +0000807 " bbbbbbbbbbbbbbbbbbbbbbbbb);"));
808 EXPECT_EQ(
809 "f(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
810 " /* Leading comment for bb... */ bbbbbbbbbbbbbbbbbbbbbbbbb);",
811 format("f(aaaaaaaaaaaaaaaaaaaaaaaaa , \n"
812 "/* Leading comment for bb... */ bbbbbbbbbbbbbbbbbbbbbbbbb);"));
Daniel Jasper65d2c382013-06-06 16:08:57 +0000813 EXPECT_EQ(
814 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
815 " aaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper88cc5622013-07-08 14:25:23 +0000816 " aaaaaaaaaaaaaaaaaa) { /*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*/\n"
Daniel Jasper65d2c382013-06-06 16:08:57 +0000817 "}",
818 format("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
819 " aaaaaaaaaaaaaaaaaa ,\n"
Daniel Jasper88cc5622013-07-08 14:25:23 +0000820 " aaaaaaaaaaaaaaaaaa) { /*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*/\n"
Daniel Jasper65d2c382013-06-06 16:08:57 +0000821 "}"));
Daniel Jasperd4f2c2e2013-01-29 19:41:55 +0000822
Daniel Jasperfaab0d32013-02-27 09:47:53 +0000823 FormatStyle NoBinPacking = getLLVMStyle();
824 NoBinPacking.BinPackParameters = false;
825 verifyFormat("aaaaaaaa(/* parameter 1 */ aaaaaa,\n"
826 " /* parameter 2 */ aaaaaa,\n"
827 " /* parameter 3 */ aaaaaa,\n"
828 " /* parameter 4 */ aaaaaa);",
829 NoBinPacking);
Daniel Jasper2c6cc482013-01-17 12:53:34 +0000830}
831
Alexander Kornienkoc36c5c22013-06-19 19:50:11 +0000832TEST_F(FormatTest, AlignsBlockComments) {
Alexander Kornienkof7536152013-03-14 16:10:54 +0000833 EXPECT_EQ("/*\n"
834 " * Really multi-line\n"
835 " * comment.\n"
836 " */\n"
837 "void f() {}",
838 format(" /*\n"
839 " * Really multi-line\n"
840 " * comment.\n"
841 " */\n"
842 " void f() {}"));
Alexander Kornienkof7536152013-03-14 16:10:54 +0000843 EXPECT_EQ("class C {\n"
844 " /*\n"
845 " * Another multi-line\n"
846 " * comment.\n"
847 " */\n"
848 " void f() {}\n"
849 "};",
850 format("class C {\n"
851 "/*\n"
852 " * Another multi-line\n"
853 " * comment.\n"
854 " */\n"
855 "void f() {}\n"
856 "};"));
Alexander Kornienko1fdd8b32013-03-15 13:42:02 +0000857 EXPECT_EQ("/*\n"
858 " 1. This is a comment with non-trivial formatting.\n"
859 " 1.1. We have to indent/outdent all lines equally\n"
860 " 1.1.1. to keep the formatting.\n"
861 " */",
862 format(" /*\n"
863 " 1. This is a comment with non-trivial formatting.\n"
864 " 1.1. We have to indent/outdent all lines equally\n"
865 " 1.1.1. to keep the formatting.\n"
866 " */"));
867 EXPECT_EQ("/*\n"
Daniel Jaspereff18b92013-07-31 23:16:02 +0000868 "Don't try to outdent if there's not enough indentation.\n"
Manuel Klimekde008c02013-05-27 15:23:34 +0000869 "*/",
Alexander Kornienko1fdd8b32013-03-15 13:42:02 +0000870 format(" /*\n"
Daniel Jaspereff18b92013-07-31 23:16:02 +0000871 " Don't try to outdent if there's not enough indentation.\n"
Alexander Kornienko1fdd8b32013-03-15 13:42:02 +0000872 " */"));
Manuel Klimekc5cc4bf2013-05-28 08:55:01 +0000873
874 EXPECT_EQ("int i; /* Comment with empty...\n"
875 " *\n"
876 " * line. */",
877 format("int i; /* Comment with empty...\n"
878 " *\n"
879 " * line. */"));
Alexander Kornienkof7536152013-03-14 16:10:54 +0000880}
881
Alexander Kornienkoc36c5c22013-06-19 19:50:11 +0000882TEST_F(FormatTest, CorrectlyHandlesLengthOfBlockComments) {
883 EXPECT_EQ("double *x; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
884 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */",
885 format("double *x; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
886 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */"));
Alexander Kornienkod446f732013-07-01 13:42:42 +0000887 EXPECT_EQ(
888 "void ffffffffffff(\n"
889 " int aaaaaaaa, int bbbbbbbb,\n"
890 " int cccccccccccc) { /*\n"
891 " aaaaaaaaaa\n"
892 " aaaaaaaaaaaaa\n"
893 " bbbbbbbbbbbbbb\n"
894 " bbbbbbbbbb\n"
895 " */\n"
896 "}",
897 format("void ffffffffffff(int aaaaaaaa, int bbbbbbbb, int cccccccccccc)\n"
898 "{ /*\n"
899 " aaaaaaaaaa aaaaaaaaaaaaa\n"
900 " bbbbbbbbbbbbbb bbbbbbbbbb\n"
901 " */\n"
902 "}",
903 getLLVMStyleWithColumns(40)));
Alexander Kornienkoc36c5c22013-06-19 19:50:11 +0000904}
905
Alexander Kornienkob4b4a522013-07-16 23:47:22 +0000906TEST_F(FormatTest, DontBreakNonTrailingBlockComments) {
907 EXPECT_EQ("void\n"
908 "ffffffffff(int aaaaa /* test */);",
909 format("void ffffffffff(int aaaaa /* test */);",
910 getLLVMStyleWithColumns(35)));
911}
912
Alexander Kornienko5262dd92013-03-27 11:52:18 +0000913TEST_F(FormatTest, SplitsLongCxxComments) {
914 EXPECT_EQ("// A comment that\n"
915 "// doesn't fit on\n"
916 "// one line",
917 format("// A comment that doesn't fit on one line",
918 getLLVMStyleWithColumns(20)));
Alexander Kornienko919398b2013-04-17 17:34:05 +0000919 EXPECT_EQ("// a b c d\n"
920 "// e f g\n"
921 "// h i j k",
922 format("// a b c d e f g h i j k",
923 getLLVMStyleWithColumns(10)));
924 EXPECT_EQ("// a b c d\n"
925 "// e f g\n"
926 "// h i j k",
927 format("\\\n// a b c d e f g h i j k",
928 getLLVMStyleWithColumns(10)));
Alexander Kornienko5262dd92013-03-27 11:52:18 +0000929 EXPECT_EQ("if (true) // A comment that\n"
930 " // doesn't fit on\n"
931 " // one line",
932 format("if (true) // A comment that doesn't fit on one line ",
933 getLLVMStyleWithColumns(30)));
934 EXPECT_EQ("// Don't_touch_leading_whitespace",
935 format("// Don't_touch_leading_whitespace",
936 getLLVMStyleWithColumns(20)));
Alexander Kornienko2b2faa52013-06-11 16:01:49 +0000937 EXPECT_EQ("// Add leading\n"
938 "// whitespace",
939 format("//Add leading whitespace", getLLVMStyleWithColumns(20)));
940 EXPECT_EQ("// whitespace", format("//whitespace", getLLVMStyle()));
941 EXPECT_EQ("// Even if it makes the line exceed the column\n"
942 "// limit",
943 format("//Even if it makes the line exceed the column limit",
944 getLLVMStyleWithColumns(51)));
945 EXPECT_EQ("//--But not here", format("//--But not here", getLLVMStyle()));
Alexander Kornienko9fdc00a2013-03-28 18:40:55 +0000946 EXPECT_EQ("// A comment before\n"
947 "// a macro\n"
948 "// definition\n"
949 "#define a b",
950 format("// A comment before a macro definition\n"
951 "#define a b",
952 getLLVMStyleWithColumns(20)));
Alexander Kornienko22d0e292013-06-17 12:59:44 +0000953 EXPECT_EQ("void ffffff(int aaaaaaaaa, // wwww\n"
954 " int a, int bbb, // xxxxxxx\n"
955 " // yyyyyyyyy\n"
956 " int c, int d, int e) {}",
957 format("void ffffff(\n"
958 " int aaaaaaaaa, // wwww\n"
959 " int a,\n"
960 " int bbb, // xxxxxxx yyyyyyyyy\n"
961 " int c, int d, int e) {}",
962 getLLVMStyleWithColumns(40)));
Alexander Kornienko8afa39b2013-06-20 13:58:37 +0000963 EXPECT_EQ("//\t aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
964 format("//\t aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
965 getLLVMStyleWithColumns(20)));
Alexander Kornienko2785b9a2013-06-07 16:02:52 +0000966}
Manuel Klimekde008c02013-05-27 15:23:34 +0000967
Alexander Kornienko10c26b22013-07-16 21:06:13 +0000968TEST_F(FormatTest, DontSplitLineCommentsWithEscapedNewlines) {
969 EXPECT_EQ("// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
970 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
971 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
972 format("// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
973 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
974 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
975 EXPECT_EQ("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
976 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
977 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
978 format("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
979 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
980 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
981 getLLVMStyleWithColumns(50)));
982 // FIXME: One day we might want to implement adjustment of leading whitespace
983 // of the consecutive lines in this kind of comment:
984 EXPECT_EQ("int\n"
985 "a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
986 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
987 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
988 format("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
989 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
990 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
991 getLLVMStyleWithColumns(49)));
992}
993
Alexander Kornienko2785b9a2013-06-07 16:02:52 +0000994TEST_F(FormatTest, PriorityOfCommentBreaking) {
Daniel Jasperf5461782013-08-28 10:03:58 +0000995 EXPECT_EQ("if (xxx ==\n"
996 " yyy && // aaaaaaaaaaaa bbbbbbbbb\n"
Alexander Kornienko2785b9a2013-06-07 16:02:52 +0000997 " zzz)\n"
998 " q();",
999 format("if (xxx == yyy && // aaaaaaaaaaaa bbbbbbbbb\n"
1000 " zzz) q();",
1001 getLLVMStyleWithColumns(40)));
1002 EXPECT_EQ("if (xxxxxxxxxx ==\n"
1003 " yyy && // aaaaaa bbbbbbbb cccc\n"
1004 " zzz)\n"
1005 " q();",
1006 format("if (xxxxxxxxxx == yyy && // aaaaaa bbbbbbbb cccc\n"
1007 " zzz) q();",
1008 getLLVMStyleWithColumns(40)));
1009 EXPECT_EQ("if (xxxxxxxxxx &&\n"
1010 " yyy || // aaaaaa bbbbbbbb cccc\n"
1011 " zzz)\n"
1012 " q();",
1013 format("if (xxxxxxxxxx && yyy || // aaaaaa bbbbbbbb cccc\n"
1014 " zzz) q();",
1015 getLLVMStyleWithColumns(40)));
1016 EXPECT_EQ("fffffffff(&xxx, // aaaaaaaaaaaa\n"
1017 " // bbbbbbbbbbb\n"
1018 " zzz);",
1019 format("fffffffff(&xxx, // aaaaaaaaaaaa bbbbbbbbbbb\n"
1020 " zzz);",
1021 getLLVMStyleWithColumns(40)));
Manuel Klimekde008c02013-05-27 15:23:34 +00001022}
1023
1024TEST_F(FormatTest, MultiLineCommentsInDefines) {
Alexander Kornienkoc36c5c22013-06-19 19:50:11 +00001025 EXPECT_EQ("#define A(x) /* \\\n"
1026 " a comment \\\n"
1027 " inside */ \\\n"
Manuel Klimekde008c02013-05-27 15:23:34 +00001028 " f();",
1029 format("#define A(x) /* \\\n"
1030 " a comment \\\n"
1031 " inside */ \\\n"
1032 " f();",
1033 getLLVMStyleWithColumns(17)));
Alexander Kornienkoc36c5c22013-06-19 19:50:11 +00001034 EXPECT_EQ("#define A( \\\n"
1035 " x) /* \\\n"
1036 " a comment \\\n"
1037 " inside */ \\\n"
Manuel Klimekde008c02013-05-27 15:23:34 +00001038 " f();",
1039 format("#define A( \\\n"
1040 " x) /* \\\n"
1041 " a comment \\\n"
1042 " inside */ \\\n"
1043 " f();",
1044 getLLVMStyleWithColumns(17)));
Alexander Kornienko5262dd92013-03-27 11:52:18 +00001045}
1046
Alexander Kornienkof52d5272013-04-02 13:04:06 +00001047TEST_F(FormatTest, ParsesCommentsAdjacentToPPDirectives) {
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001048 EXPECT_EQ("namespace {}\n// Test\n#define A",
Alexander Kornienkof52d5272013-04-02 13:04:06 +00001049 format("namespace {}\n // Test\n#define A"));
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001050 EXPECT_EQ("namespace {}\n/* Test */\n#define A",
Alexander Kornienkof52d5272013-04-02 13:04:06 +00001051 format("namespace {}\n /* Test */\n#define A"));
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001052 EXPECT_EQ("namespace {}\n/* Test */ #define A",
Alexander Kornienkof52d5272013-04-02 13:04:06 +00001053 format("namespace {}\n /* Test */ #define A"));
1054}
1055
Alexander Kornienko052685c2013-03-19 17:41:36 +00001056TEST_F(FormatTest, SplitsLongLinesInComments) {
1057 EXPECT_EQ("/* This is a long\n"
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001058 " * comment that\n"
1059 " * doesn't\n"
1060 " * fit on one line.\n"
1061 " */",
Alexander Kornienko052685c2013-03-19 17:41:36 +00001062 format("/* "
1063 "This is a long "
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001064 "comment that "
1065 "doesn't "
Alexander Kornienko052685c2013-03-19 17:41:36 +00001066 "fit on one line. */",
1067 getLLVMStyleWithColumns(20)));
Alexander Kornienko919398b2013-04-17 17:34:05 +00001068 EXPECT_EQ("/* a b c d\n"
1069 " * e f g\n"
1070 " * h i j k\n"
1071 " */",
1072 format("/* a b c d e f g h i j k */",
1073 getLLVMStyleWithColumns(10)));
1074 EXPECT_EQ("/* a b c d\n"
1075 " * e f g\n"
1076 " * h i j k\n"
1077 " */",
1078 format("\\\n/* a b c d e f g h i j k */",
1079 getLLVMStyleWithColumns(10)));
Alexander Kornienko052685c2013-03-19 17:41:36 +00001080 EXPECT_EQ("/*\n"
1081 "This is a long\n"
1082 "comment that doesn't\n"
1083 "fit on one line.\n"
1084 "*/",
1085 format("/*\n"
1086 "This is a long "
1087 "comment that doesn't "
1088 "fit on one line. \n"
1089 "*/", getLLVMStyleWithColumns(20)));
1090 EXPECT_EQ("/*\n"
1091 " * This is a long\n"
1092 " * comment that\n"
1093 " * doesn't fit on\n"
1094 " * one line.\n"
1095 " */",
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001096 format("/* \n"
Alexander Kornienko052685c2013-03-19 17:41:36 +00001097 " * This is a long "
1098 " comment that "
1099 " doesn't fit on "
1100 " one line. \n"
1101 " */", getLLVMStyleWithColumns(20)));
1102 EXPECT_EQ("/*\n"
1103 " * This_is_a_comment_with_words_that_dont_fit_on_one_line\n"
1104 " * so_it_should_be_broken\n"
1105 " * wherever_a_space_occurs\n"
1106 " */",
1107 format("/*\n"
1108 " * This_is_a_comment_with_words_that_dont_fit_on_one_line "
1109 " so_it_should_be_broken "
1110 " wherever_a_space_occurs \n"
1111 " */",
1112 getLLVMStyleWithColumns(20)));
1113 EXPECT_EQ("/*\n"
Alexander Kornienko5262dd92013-03-27 11:52:18 +00001114 " * This_comment_can_not_be_broken_into_lines\n"
Alexander Kornienko052685c2013-03-19 17:41:36 +00001115 " */",
1116 format("/*\n"
Alexander Kornienko5262dd92013-03-27 11:52:18 +00001117 " * This_comment_can_not_be_broken_into_lines\n"
Alexander Kornienko052685c2013-03-19 17:41:36 +00001118 " */",
1119 getLLVMStyleWithColumns(20)));
1120 EXPECT_EQ("{\n"
1121 " /*\n"
1122 " This is another\n"
1123 " long comment that\n"
1124 " doesn't fit on one\n"
1125 " line 1234567890\n"
1126 " */\n"
1127 "}",
1128 format("{\n"
1129 "/*\n"
1130 "This is another "
1131 " long comment that "
1132 " doesn't fit on one"
1133 " line 1234567890\n"
1134 "*/\n"
1135 "}", getLLVMStyleWithColumns(20)));
1136 EXPECT_EQ("{\n"
1137 " /*\n"
1138 " * This i s\n"
1139 " * another comment\n"
1140 " * t hat doesn' t\n"
1141 " * fit on one l i\n"
1142 " * n e\n"
1143 " */\n"
1144 "}",
1145 format("{\n"
1146 "/*\n"
1147 " * This i s"
1148 " another comment"
1149 " t hat doesn' t"
1150 " fit on one l i"
1151 " n e\n"
1152 " */\n"
1153 "}", getLLVMStyleWithColumns(20)));
1154 EXPECT_EQ("/*\n"
1155 " * This is a long\n"
1156 " * comment that\n"
1157 " * doesn't fit on\n"
1158 " * one line\n"
1159 " */",
1160 format(" /*\n"
1161 " * This is a long comment that doesn't fit on one line\n"
1162 " */", getLLVMStyleWithColumns(20)));
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001163 EXPECT_EQ("{\n"
1164 " if (something) /* This is a\n"
Manuel Klimekde008c02013-05-27 15:23:34 +00001165 " long\n"
1166 " comment */\n"
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001167 " ;\n"
1168 "}",
1169 format("{\n"
1170 " if (something) /* This is a long comment */\n"
1171 " ;\n"
1172 "}",
1173 getLLVMStyleWithColumns(30)));
Alexander Kornienko2785b9a2013-06-07 16:02:52 +00001174
1175 EXPECT_EQ("/* A comment before\n"
1176 " * a macro\n"
1177 " * definition */\n"
1178 "#define a b",
1179 format("/* A comment before a macro definition */\n"
1180 "#define a b",
1181 getLLVMStyleWithColumns(20)));
1182
1183 EXPECT_EQ("/* some comment\n"
1184 " * a comment\n"
1185 "* that we break\n"
1186 " * another comment\n"
1187 "* we have to break\n"
1188 "* a left comment\n"
1189 " */",
1190 format(" /* some comment\n"
1191 " * a comment that we break\n"
1192 " * another comment we have to break\n"
1193 "* a left comment\n"
1194 " */",
1195 getLLVMStyleWithColumns(20)));
1196
1197 EXPECT_EQ("/*\n"
1198 "\n"
1199 "\n"
1200 " */\n",
1201 format(" /* \n"
1202 " \n"
1203 " \n"
1204 " */\n"));
Alexander Kornienko052685c2013-03-19 17:41:36 +00001205}
1206
1207TEST_F(FormatTest, SplitsLongLinesInCommentsInPreprocessor) {
1208 EXPECT_EQ("#define X \\\n"
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001209 " /* \\\n"
1210 " Test \\\n"
Alexander Kornienko052685c2013-03-19 17:41:36 +00001211 " Macro comment \\\n"
1212 " with a long \\\n"
1213 " line \\\n"
Alexander Kornienko70ce7882013-04-15 14:28:00 +00001214 " */ \\\n"
Alexander Kornienko052685c2013-03-19 17:41:36 +00001215 " A + B",
1216 format("#define X \\\n"
1217 " /*\n"
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001218 " Test\n"
Alexander Kornienko052685c2013-03-19 17:41:36 +00001219 " Macro comment with a long line\n"
1220 " */ \\\n"
1221 " A + B",
1222 getLLVMStyleWithColumns(20)));
1223 EXPECT_EQ("#define X \\\n"
1224 " /* Macro comment \\\n"
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001225 " with a long \\\n"
Alexander Kornienko70ce7882013-04-15 14:28:00 +00001226 " line */ \\\n"
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001227 " A + B",
1228 format("#define X \\\n"
1229 " /* Macro comment with a long\n"
1230 " line */ \\\n"
1231 " A + B",
1232 getLLVMStyleWithColumns(20)));
1233 EXPECT_EQ("#define X \\\n"
1234 " /* Macro comment \\\n"
1235 " * with a long \\\n"
Alexander Kornienko70ce7882013-04-15 14:28:00 +00001236 " * line */ \\\n"
Alexander Kornienko052685c2013-03-19 17:41:36 +00001237 " A + B",
1238 format("#define X \\\n"
1239 " /* Macro comment with a long line */ \\\n"
1240 " A + B",
1241 getLLVMStyleWithColumns(20)));
1242}
1243
Daniel Jasper2c6cc482013-01-17 12:53:34 +00001244TEST_F(FormatTest, CommentsInStaticInitializers) {
1245 EXPECT_EQ(
1246 "static SomeType type = { aaaaaaaaaaaaaaaaaaaa, /* comment */\n"
1247 " aaaaaaaaaaaaaaaaaaaa /* comment */,\n"
1248 " /* comment */ aaaaaaaaaaaaaaaaaaaa,\n"
1249 " aaaaaaaaaaaaaaaaaaaa, // comment\n"
1250 " aaaaaaaaaaaaaaaaaaaa };",
1251 format("static SomeType type = { aaaaaaaaaaaaaaaaaaaa , /* comment */\n"
1252 " aaaaaaaaaaaaaaaaaaaa /* comment */ ,\n"
1253 " /* comment */ aaaaaaaaaaaaaaaaaaaa ,\n"
1254 " aaaaaaaaaaaaaaaaaaaa , // comment\n"
1255 " aaaaaaaaaaaaaaaaaaaa };"));
1256 verifyFormat("static SomeType type = { aaaaaaaaaaa, // comment for aa...\n"
1257 " bbbbbbbbbbb, ccccccccccc };");
1258 verifyFormat("static SomeType type = { aaaaaaaaaaa,\n"
1259 " // comment for bb....\n"
1260 " bbbbbbbbbbb, ccccccccccc };");
1261 verifyGoogleFormat(
Daniel Jasper2424eef2013-05-23 10:15:45 +00001262 "static SomeType type = {aaaaaaaaaaa, // comment for aa...\n"
1263 " bbbbbbbbbbb, ccccccccccc};");
1264 verifyGoogleFormat("static SomeType type = {aaaaaaaaaaa,\n"
1265 " // comment for bb....\n"
1266 " bbbbbbbbbbb, ccccccccccc};");
Daniel Jasper2c6cc482013-01-17 12:53:34 +00001267
Daniel Jasperf343cab2013-01-31 14:59:26 +00001268 verifyFormat("S s = { { a, b, c }, // Group #1\n"
1269 " { d, e, f }, // Group #2\n"
1270 " { g, h, i } }; // Group #3");
1271 verifyFormat("S s = { { // Group #1\n"
1272 " a, b, c },\n"
1273 " { // Group #2\n"
1274 " d, e, f },\n"
1275 " { // Group #3\n"
1276 " g, h, i } };");
Daniel Jasperc4615b72013-02-20 12:56:39 +00001277
1278 EXPECT_EQ("S s = {\n"
1279 " // Some comment\n"
Daniel Jasper1ef81d52013-02-26 13:10:34 +00001280 " a,\n"
Daniel Jasperc4615b72013-02-20 12:56:39 +00001281 "\n"
1282 " // Comment after empty line\n"
1283 " b\n"
Daniel Jasper1ef81d52013-02-26 13:10:34 +00001284 "}",
1285 format("S s = {\n"
1286 " // Some comment\n"
1287 " a,\n"
1288 " \n"
1289 " // Comment after empty line\n"
1290 " b\n"
1291 "}"));
Alexander Kornienkoe3f11972013-06-12 19:04:12 +00001292 EXPECT_EQ("S s = {\n"
1293 " /* Some comment */\n"
1294 " a,\n"
1295 "\n"
1296 " /* Comment after empty line */\n"
1297 " b\n"
1298 "}",
1299 format("S s = {\n"
1300 " /* Some comment */\n"
1301 " a,\n"
1302 " \n"
1303 " /* Comment after empty line */\n"
1304 " b\n"
1305 "}"));
Daniel Jasper25e81b22013-02-28 15:04:12 +00001306 verifyFormat("const uint8_t aaaaaaaaaaaaaaaaaaaaaa[0] = {\n"
1307 " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n"
1308 " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n"
1309 " 0x00, 0x00, 0x00, 0x00 // comment\n"
1310 "};");
Alexander Kornienko15757312012-12-06 18:03:27 +00001311}
1312
Alexander Kornienko6fb46b02013-05-24 18:24:24 +00001313TEST_F(FormatTest, IgnoresIf0Contents) {
1314 EXPECT_EQ("#if 0\n"
1315 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n"
1316 "#endif\n"
1317 "void f() {}",
1318 format("#if 0\n"
1319 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n"
1320 "#endif\n"
1321 "void f( ) { }"));
1322 EXPECT_EQ("#if false\n"
1323 "void f( ) { }\n"
1324 "#endif\n"
1325 "void g() {}\n",
1326 format("#if false\n"
1327 "void f( ) { }\n"
1328 "#endif\n"
1329 "void g( ) { }\n"));
1330 EXPECT_EQ("enum E {\n"
1331 " One,\n"
1332 " Two,\n"
1333 "#if 0\n"
1334 "Three,\n"
1335 " Four,\n"
1336 "#endif\n"
1337 " Five\n"
1338 "};",
1339 format("enum E {\n"
1340 " One,Two,\n"
1341 "#if 0\n"
1342 "Three,\n"
1343 " Four,\n"
1344 "#endif\n"
1345 " Five};"));
1346 EXPECT_EQ("enum F {\n"
1347 " One,\n"
1348 "#if 1\n"
1349 " Two,\n"
1350 "#if 0\n"
1351 "Three,\n"
1352 " Four,\n"
1353 "#endif\n"
1354 " Five\n"
1355 "#endif\n"
1356 "};",
1357 format("enum F {\n"
1358 "One,\n"
1359 "#if 1\n"
1360 "Two,\n"
1361 "#if 0\n"
1362 "Three,\n"
1363 " Four,\n"
1364 "#endif\n"
1365 "Five\n"
1366 "#endif\n"
1367 "};"));
1368 EXPECT_EQ("enum G {\n"
1369 " One,\n"
1370 "#if 0\n"
1371 "Two,\n"
1372 "#else\n"
1373 " Three,\n"
1374 "#endif\n"
1375 " Four\n"
1376 "};",
1377 format("enum G {\n"
1378 "One,\n"
1379 "#if 0\n"
1380 "Two,\n"
1381 "#else\n"
1382 "Three,\n"
1383 "#endif\n"
1384 "Four\n"
1385 "};"));
1386 EXPECT_EQ("enum H {\n"
1387 " One,\n"
1388 "#if 0\n"
1389 "#ifdef Q\n"
1390 "Two,\n"
1391 "#else\n"
1392 "Three,\n"
1393 "#endif\n"
1394 "#endif\n"
1395 " Four\n"
1396 "};",
1397 format("enum H {\n"
1398 "One,\n"
1399 "#if 0\n"
1400 "#ifdef Q\n"
1401 "Two,\n"
1402 "#else\n"
1403 "Three,\n"
1404 "#endif\n"
1405 "#endif\n"
1406 "Four\n"
1407 "};"));
1408 EXPECT_EQ("enum I {\n"
1409 " One,\n"
1410 "#if /* test */ 0 || 1\n"
1411 "Two,\n"
1412 "Three,\n"
1413 "#endif\n"
1414 " Four\n"
1415 "};",
1416 format("enum I {\n"
1417 "One,\n"
1418 "#if /* test */ 0 || 1\n"
1419 "Two,\n"
1420 "Three,\n"
1421 "#endif\n"
1422 "Four\n"
1423 "};"));
1424 EXPECT_EQ("enum J {\n"
1425 " One,\n"
1426 "#if 0\n"
1427 "#if 0\n"
1428 "Two,\n"
1429 "#else\n"
1430 "Three,\n"
1431 "#endif\n"
1432 "Four,\n"
1433 "#endif\n"
1434 " Five\n"
1435 "};",
1436 format("enum J {\n"
1437 "One,\n"
1438 "#if 0\n"
1439 "#if 0\n"
1440 "Two,\n"
1441 "#else\n"
1442 "Three,\n"
1443 "#endif\n"
1444 "Four,\n"
1445 "#endif\n"
1446 "Five\n"
1447 "};"));
1448
1449}
1450
Alexander Kornienko15757312012-12-06 18:03:27 +00001451//===----------------------------------------------------------------------===//
1452// Tests for classes, namespaces, etc.
1453//===----------------------------------------------------------------------===//
1454
1455TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) {
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001456 verifyFormat("class A {};");
Alexander Kornienko15757312012-12-06 18:03:27 +00001457}
1458
1459TEST_F(FormatTest, UnderstandsAccessSpecifiers) {
1460 verifyFormat("class A {\n"
1461 "public:\n"
Daniel Jasperac3223e2013-04-10 09:49:49 +00001462 "public: // comment\n"
Alexander Kornienko15757312012-12-06 18:03:27 +00001463 "protected:\n"
1464 "private:\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +00001465 " void f() {}\n"
Alexander Kornienko15757312012-12-06 18:03:27 +00001466 "};");
1467 verifyGoogleFormat("class A {\n"
1468 " public:\n"
1469 " protected:\n"
1470 " private:\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +00001471 " void f() {}\n"
Alexander Kornienko15757312012-12-06 18:03:27 +00001472 "};");
1473}
1474
Alexander Kornienko94b748f2013-03-27 17:08:02 +00001475TEST_F(FormatTest, SeparatesLogicalBlocks) {
1476 EXPECT_EQ("class A {\n"
1477 "public:\n"
1478 " void f();\n"
1479 "\n"
1480 "private:\n"
1481 " void g() {}\n"
1482 " // test\n"
1483 "protected:\n"
1484 " int h;\n"
1485 "};",
1486 format("class A {\n"
1487 "public:\n"
1488 "void f();\n"
1489 "private:\n"
1490 "void g() {}\n"
1491 "// test\n"
1492 "protected:\n"
1493 "int h;\n"
1494 "};"));
Daniel Jasper63cfb892013-10-06 11:40:08 +00001495 EXPECT_EQ("class A {\n"
1496 "protected:\n"
1497 "public:\n"
1498 " void f();\n"
1499 "};",
1500 format("class A {\n"
1501 "protected:\n"
1502 "\n"
1503 "public:\n"
1504 "\n"
1505 " void f();\n"
1506 "};"));
Alexander Kornienko94b748f2013-03-27 17:08:02 +00001507}
1508
Daniel Jasper6b119d62013-04-05 17:22:09 +00001509TEST_F(FormatTest, FormatsClasses) {
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001510 verifyFormat("class A : public B {};");
1511 verifyFormat("class A : public ::B {};");
Daniel Jasper6cabab42013-02-14 08:42:54 +00001512
1513 verifyFormat(
1514 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001515 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
Daniel Jasperc194c952013-05-06 06:45:09 +00001516 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
1517 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001518 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
Daniel Jasper6cabab42013-02-14 08:42:54 +00001519 verifyFormat(
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001520 "class A : public B, public C, public D, public E, public F {};");
Daniel Jasper6cabab42013-02-14 08:42:54 +00001521 verifyFormat("class AAAAAAAAAAAA : public B,\n"
1522 " public C,\n"
1523 " public D,\n"
1524 " public E,\n"
1525 " public F,\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001526 " public G {};");
Daniel Jasper6b119d62013-04-05 17:22:09 +00001527
1528 verifyFormat("class\n"
Daniel Jasper567dcf92013-09-05 09:29:45 +00001529 " ReallyReallyLongClassName {\n"
1530 " int i;\n"
1531 "};",
Daniel Jasper6b119d62013-04-05 17:22:09 +00001532 getLLVMStyleWithColumns(32));
Daniel Jaspercea014b2013-10-08 16:24:07 +00001533 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n"
1534 " aaaaaaaaaaaaaaaa> {};");
1535 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n"
1536 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n"
1537 " aaaaaaaaaaaaaaaaaaaaaa> {};");
Daniel Jasperbac016b2012-12-03 18:12:45 +00001538}
1539
Manuel Klimekde768542013-01-07 18:10:23 +00001540TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) {
Manuel Klimek2f1ac412013-01-21 16:42:44 +00001541 verifyFormat("class A {\n} a, b;");
1542 verifyFormat("struct A {\n} a, b;");
1543 verifyFormat("union A {\n} a;");
Manuel Klimekde768542013-01-07 18:10:23 +00001544}
1545
Alexander Kornienko15757312012-12-06 18:03:27 +00001546TEST_F(FormatTest, FormatsEnum) {
Alexander Kornienkoa166e732012-12-04 14:46:19 +00001547 verifyFormat("enum {\n"
1548 " Zero,\n"
1549 " One = 1,\n"
1550 " Two = One + 1,\n"
1551 " Three = (One + Two),\n"
1552 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1553 " Five = (One, Two, Three, Four, 5)\n"
1554 "};");
Daniel Jasper57981202013-09-13 09:20:45 +00001555 verifyGoogleFormat("enum {\n"
1556 " Zero,\n"
1557 " One = 1,\n"
1558 " Two = One + 1,\n"
1559 " Three = (One + Two),\n"
1560 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1561 " Five = (One, Two, Three, Four, 5)\n"
1562 "};");
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001563 verifyFormat("enum Enum {};");
1564 verifyFormat("enum {};");
Daniel Jasper57981202013-09-13 09:20:45 +00001565 verifyFormat("enum X E {} d;");
1566 verifyFormat("enum __attribute__((...)) E {} d;");
1567 verifyFormat("enum __declspec__((...)) E {} d;");
Manuel Klimek308232c2013-01-21 19:17:52 +00001568 verifyFormat("enum X f() {\n a();\n return 42;\n}");
Daniel Jasper57981202013-09-13 09:20:45 +00001569 verifyFormat("enum {\n"
1570 " Bar = Foo<int, int>::value\n"
1571 "};");
Alexander Kornienkoa166e732012-12-04 14:46:19 +00001572}
1573
Daniel Jasper4b434cf2013-08-30 10:10:19 +00001574TEST_F(FormatTest, FormatsEnumsWithErrors) {
1575 verifyFormat("enum Type {\n"
1576 " One = 0;\n" // These semicolons should be commas.
1577 " Two = 1;\n"
1578 "};");
1579 verifyFormat("namespace n {\n"
1580 "enum Type {\n"
1581 " One,\n"
1582 " Two,\n" // missing };
1583 " int i;\n"
1584 "}\n"
1585 "void g() {}");
1586}
1587
Daniel Jaspercbeb1c62013-08-20 12:42:50 +00001588TEST_F(FormatTest, FormatsEnumStruct) {
1589 verifyFormat("enum struct {\n"
1590 " Zero,\n"
1591 " One = 1,\n"
1592 " Two = One + 1,\n"
1593 " Three = (One + Two),\n"
1594 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1595 " Five = (One, Two, Three, Four, 5)\n"
1596 "};");
1597 verifyFormat("enum struct Enum {};");
1598 verifyFormat("enum struct {};");
Daniel Jasper57981202013-09-13 09:20:45 +00001599 verifyFormat("enum struct X E {} d;");
1600 verifyFormat("enum struct __attribute__((...)) E {} d;");
1601 verifyFormat("enum struct __declspec__((...)) E {} d;");
Daniel Jaspercbeb1c62013-08-20 12:42:50 +00001602 verifyFormat("enum struct X f() {\n a();\n return 42;\n}");
1603}
1604
1605TEST_F(FormatTest, FormatsEnumClass) {
1606 verifyFormat("enum class {\n"
1607 " Zero,\n"
1608 " One = 1,\n"
1609 " Two = One + 1,\n"
1610 " Three = (One + Two),\n"
1611 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1612 " Five = (One, Two, Three, Four, 5)\n"
1613 "};");
1614 verifyFormat("enum class Enum {};");
1615 verifyFormat("enum class {};");
Daniel Jasper57981202013-09-13 09:20:45 +00001616 verifyFormat("enum class X E {} d;");
1617 verifyFormat("enum class __attribute__((...)) E {} d;");
1618 verifyFormat("enum class __declspec__((...)) E {} d;");
Daniel Jaspercbeb1c62013-08-20 12:42:50 +00001619 verifyFormat("enum class X f() {\n a();\n return 42;\n}");
1620}
1621
Manuel Klimeke11e45f2013-09-05 15:34:55 +00001622TEST_F(FormatTest, FormatsEnumTypes) {
1623 verifyFormat("enum X : int {\n"
1624 " A,\n"
1625 " B\n"
1626 "};");
Daniel Jaspere27dc5d2013-09-06 21:32:35 +00001627 verifyFormat("enum X : std::uint32_t {\n"
1628 " A,\n"
1629 " B\n"
1630 "};");
Manuel Klimeke11e45f2013-09-05 15:34:55 +00001631}
1632
Nico Weberefaddc02013-01-14 05:49:49 +00001633TEST_F(FormatTest, FormatsBitfields) {
1634 verifyFormat("struct Bitfields {\n"
1635 " unsigned sClass : 8;\n"
1636 " unsigned ValueKind : 2;\n"
1637 "};");
Alexander Kornienko01fe9f92013-10-10 13:36:20 +00001638 verifyFormat("struct A {\n"
1639 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n"
1640 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n"
1641 "};");
Nico Weberefaddc02013-01-14 05:49:49 +00001642}
1643
Alexander Kornienko15757312012-12-06 18:03:27 +00001644TEST_F(FormatTest, FormatsNamespaces) {
1645 verifyFormat("namespace some_namespace {\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001646 "class A {};\n"
Manuel Klimek517e8942013-01-11 17:54:10 +00001647 "void f() { f(); }\n"
Alexander Kornienko15757312012-12-06 18:03:27 +00001648 "}");
1649 verifyFormat("namespace {\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001650 "class A {};\n"
Manuel Klimek517e8942013-01-11 17:54:10 +00001651 "void f() { f(); }\n"
Alexander Kornienko15757312012-12-06 18:03:27 +00001652 "}");
Dmitri Gribenko1f94f2b2012-12-30 21:27:25 +00001653 verifyFormat("inline namespace X {\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001654 "class A {};\n"
Manuel Klimek517e8942013-01-11 17:54:10 +00001655 "void f() { f(); }\n"
Dmitri Gribenko1f94f2b2012-12-30 21:27:25 +00001656 "}");
Alexander Kornienko15757312012-12-06 18:03:27 +00001657 verifyFormat("using namespace some_namespace;\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001658 "class A {};\n"
Manuel Klimek517e8942013-01-11 17:54:10 +00001659 "void f() { f(); }");
Manuel Klimek7fc2db02013-02-06 16:08:09 +00001660
1661 // This code is more common than we thought; if we
1662 // layout this correctly the semicolon will go into
1663 // its own line, which is undesireable.
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001664 verifyFormat("namespace {};");
Manuel Klimek7fc2db02013-02-06 16:08:09 +00001665 verifyFormat("namespace {\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001666 "class A {};\n"
Manuel Klimek7fc2db02013-02-06 16:08:09 +00001667 "};");
Daniel Jaspercbe86cc2013-07-01 11:22:57 +00001668
1669 verifyFormat("namespace {\n"
1670 "int SomeVariable = 0; // comment\n"
1671 "} // namespace");
1672 EXPECT_EQ("#ifndef HEADER_GUARD\n"
1673 "#define HEADER_GUARD\n"
1674 "namespace my_namespace {\n"
1675 "int i;\n"
1676 "} // my_namespace\n"
1677 "#endif // HEADER_GUARD",
1678 format("#ifndef HEADER_GUARD\n"
1679 " #define HEADER_GUARD\n"
1680 " namespace my_namespace {\n"
1681 "int i;\n"
1682 "} // my_namespace\n"
1683 "#endif // HEADER_GUARD"));
Daniel Jaspereff18b92013-07-31 23:16:02 +00001684
1685 FormatStyle Style = getLLVMStyle();
1686 Style.NamespaceIndentation = FormatStyle::NI_All;
1687 EXPECT_EQ("namespace out {\n"
1688 " int i;\n"
1689 " namespace in {\n"
1690 " int i;\n"
1691 " } // namespace\n"
1692 "} // namespace",
1693 format("namespace out {\n"
1694 "int i;\n"
1695 "namespace in {\n"
1696 "int i;\n"
1697 "} // namespace\n"
1698 "} // namespace",
1699 Style));
1700
1701 Style.NamespaceIndentation = FormatStyle::NI_Inner;
1702 EXPECT_EQ("namespace out {\n"
1703 "int i;\n"
1704 "namespace in {\n"
1705 " int i;\n"
1706 "} // namespace\n"
1707 "} // namespace",
1708 format("namespace out {\n"
1709 "int i;\n"
1710 "namespace in {\n"
1711 "int i;\n"
1712 "} // namespace\n"
1713 "} // namespace",
1714 Style));
Alexander Kornienko15757312012-12-06 18:03:27 +00001715}
1716
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001717TEST_F(FormatTest, FormatsExternC) { verifyFormat("extern \"C\" {\nint a;"); }
Manuel Klimekd19dc2d2013-01-21 14:32:05 +00001718
Daniel Jasper923ebef2013-03-14 13:45:21 +00001719TEST_F(FormatTest, FormatsInlineASM) {
1720 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));");
1721 verifyFormat(
1722 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
1723 " \"cpuid\\n\\t\"\n"
1724 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
Daniel Jaspera8fda852013-05-15 07:51:51 +00001725 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n"
Daniel Jasper923ebef2013-03-14 13:45:21 +00001726 " : \"a\"(value));");
1727}
1728
Nico Webera9ccdd12013-01-07 16:36:17 +00001729TEST_F(FormatTest, FormatTryCatch) {
Manuel Klimek517e8942013-01-11 17:54:10 +00001730 // FIXME: Handle try-catch explicitly in the UnwrappedLineParser, then we'll
1731 // also not create single-line-blocks.
Nico Webera9ccdd12013-01-07 16:36:17 +00001732 verifyFormat("try {\n"
1733 " throw a * b;\n"
1734 "}\n"
1735 "catch (int a) {\n"
1736 " // Do nothing.\n"
1737 "}\n"
1738 "catch (...) {\n"
1739 " exit(42);\n"
1740 "}");
1741
1742 // Function-level try statements.
Manuel Klimek517e8942013-01-11 17:54:10 +00001743 verifyFormat("int f() try { return 4; }\n"
Nico Webera9ccdd12013-01-07 16:36:17 +00001744 "catch (...) {\n"
1745 " return 5;\n"
1746 "}");
1747 verifyFormat("class A {\n"
1748 " int a;\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +00001749 " A() try : a(0) {}\n"
Nico Webera9ccdd12013-01-07 16:36:17 +00001750 " catch (...) {\n"
1751 " throw;\n"
1752 " }\n"
1753 "};\n");
1754}
1755
1756TEST_F(FormatTest, FormatObjCTryCatch) {
Manuel Klimekd5688cf2013-01-11 19:17:44 +00001757 verifyFormat("@try {\n"
1758 " f();\n"
1759 "}\n"
1760 "@catch (NSException e) {\n"
1761 " @throw;\n"
1762 "}\n"
1763 "@finally {\n"
1764 " exit(42);\n"
1765 "}");
Nico Webera9ccdd12013-01-07 16:36:17 +00001766}
1767
Daniel Jasper05b1ac82012-12-17 11:29:41 +00001768TEST_F(FormatTest, StaticInitializers) {
1769 verifyFormat("static SomeClass SC = { 1, 'a' };");
1770
Daniel Jasper05b1ac82012-12-17 11:29:41 +00001771 verifyFormat(
Daniel Jasper9cda8002013-01-07 13:08:40 +00001772 "static SomeClass WithALoooooooooooooooooooongName = {\n"
Manuel Klimekc8c8a472013-01-10 15:58:26 +00001773 " 100000000, \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
1774 "};");
1775
Daniel Jasper399914b2013-05-17 09:35:01 +00001776 // Here, everything other than the "}" would fit on a line.
1777 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
1778 " 100000000000000000000000\n"
1779 "};");
Alexander Kornienkoe3f11972013-06-12 19:04:12 +00001780 EXPECT_EQ("S s = { a, b };", format("S s = {\n"
1781 " a,\n"
1782 "\n"
1783 " b\n"
1784 "};"));
Daniel Jasper399914b2013-05-17 09:35:01 +00001785
1786 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first
1787 // line. However, the formatting looks a bit off and this probably doesn't
1788 // happen often in practice.
1789 verifyFormat("static int Variable[1] = {\n"
1790 " { 1000000000000000000000000000000000000 }\n"
1791 "};",
1792 getLLVMStyleWithColumns(40));
Daniel Jasper05b1ac82012-12-17 11:29:41 +00001793}
1794
Daniel Jasper5ad390d2013-05-28 11:30:49 +00001795TEST_F(FormatTest, DesignatedInitializers) {
1796 verifyFormat("const struct A a = { .a = 1, .b = 2 };");
1797 verifyFormat("const struct A a = { .aaaaaaaaaa = 1,\n"
1798 " .bbbbbbbbbb = 2,\n"
1799 " .cccccccccc = 3,\n"
1800 " .dddddddddd = 4,\n"
1801 " .eeeeeeeeee = 5 };");
1802 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
1803 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n"
1804 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n"
1805 " .ccccccccccccccccccccccccccc = 3,\n"
1806 " .ddddddddddddddddddddddddddd = 4,\n"
1807 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5\n"
1808 "};");
1809
1810 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};");
1811}
1812
Manuel Klimek2c7739e2013-01-14 16:41:43 +00001813TEST_F(FormatTest, NestedStaticInitializers) {
1814 verifyFormat("static A x = { { {} } };\n");
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001815 verifyFormat("static A x = { { { init1, init2, init3, init4 },\n"
1816 " { init1, init2, init3, init4 } } };");
Daniel Jasper0df6acd2013-01-16 14:59:02 +00001817
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001818 verifyFormat("somes Status::global_reps[3] = {\n"
1819 " { kGlobalRef, OK_CODE, NULL, NULL, NULL },\n"
1820 " { kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL },\n"
1821 " { kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL }\n"
1822 "};");
Daniel Jasper2424eef2013-05-23 10:15:45 +00001823 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n"
Daniel Jasperb5dc3f42013-07-16 18:22:10 +00001824 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
1825 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
1826 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};");
Manuel Klimek2c7739e2013-01-14 16:41:43 +00001827 verifyFormat(
1828 "CGRect cg_rect = { { rect.fLeft, rect.fTop },\n"
1829 " { rect.fRight - rect.fLeft, rect.fBottom - rect.fTop"
1830 " } };");
1831
Daniel Jasperf343cab2013-01-31 14:59:26 +00001832 verifyFormat(
1833 "SomeArrayOfSomeType a = { { { 1, 2, 3 }, { 1, 2, 3 },\n"
1834 " { 111111111111111111111111111111,\n"
1835 " 222222222222222222222222222222,\n"
1836 " 333333333333333333333333333333 },\n"
1837 " { 1, 2, 3 }, { 1, 2, 3 } } };");
Daniel Jasper6bd02322013-02-03 18:07:15 +00001838 verifyFormat(
1839 "SomeArrayOfSomeType a = { { { 1, 2, 3 } }, { { 1, 2, 3 } },\n"
1840 " { { 111111111111111111111111111111,\n"
1841 " 222222222222222222222222222222,\n"
1842 " 333333333333333333333333333333 } },\n"
1843 " { { 1, 2, 3 } }, { { 1, 2, 3 } } };");
Daniel Jasper2424eef2013-05-23 10:15:45 +00001844 verifyGoogleFormat(
Daniel Jasperb5dc3f42013-07-16 18:22:10 +00001845 "SomeArrayOfSomeType a = {\n"
1846 " {{1, 2, 3}}, {{1, 2, 3}},\n"
1847 " {{111111111111111111111111111111, 222222222222222222222222222222,\n"
1848 " 333333333333333333333333333333}},\n"
1849 " {{1, 2, 3}}, {{1, 2, 3}}};");
Daniel Jasperf343cab2013-01-31 14:59:26 +00001850
Nico Weber6a21a552013-01-18 02:43:57 +00001851 // FIXME: We might at some point want to handle this similar to parameter
Manuel Klimek2c7739e2013-01-14 16:41:43 +00001852 // lists, where we have an option to put each on a single line.
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001853 verifyFormat(
1854 "struct {\n"
1855 " unsigned bit;\n"
1856 " const char *const name;\n"
Daniel Jasperd4a03db2013-08-22 15:00:41 +00001857 "} kBitsToOs[] = { { kOsMac, \"Mac\" }, { kOsWin, \"Windows\" },\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001858 " { kOsLinux, \"Linux\" }, { kOsCrOS, \"Chrome OS\" } };");
Manuel Klimek2c7739e2013-01-14 16:41:43 +00001859}
1860
Manuel Klimeka080a182013-01-02 16:30:12 +00001861TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) {
1862 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("
1863 " \\\n"
1864 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)");
1865}
1866
Daniel Jasper71607512013-01-07 10:48:50 +00001867TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) {
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +00001868 verifyFormat(
Daniel Jasper1407bee2013-04-11 14:29:13 +00001869 "virtual void write(ELFWriter *writerrr,\n"
1870 " OwningPtr<FileOutputBuffer> &buffer) = 0;");
Daniel Jasper71607512013-01-07 10:48:50 +00001871}
1872
Manuel Klimekbd04f2a2013-01-31 15:58:48 +00001873TEST_F(FormatTest, LayoutUnknownPPDirective) {
1874 EXPECT_EQ("#123 \"A string literal\"",
1875 format(" # 123 \"A string literal\""));
1876 EXPECT_EQ("#;", format("#;"));
Manuel Klimekdd5b1012013-01-07 10:03:37 +00001877 verifyFormat("#\n;\n;\n;");
Manuel Klimeka080a182013-01-02 16:30:12 +00001878}
1879
1880TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) {
1881 EXPECT_EQ("#line 42 \"test\"\n",
1882 format("# \\\n line \\\n 42 \\\n \"test\"\n"));
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001883 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n",
1884 getLLVMStyleWithColumns(12)));
Manuel Klimeka080a182013-01-02 16:30:12 +00001885}
1886
1887TEST_F(FormatTest, EndOfFileEndsPPDirective) {
1888 EXPECT_EQ("#line 42 \"test\"",
1889 format("# \\\n line \\\n 42 \\\n \"test\""));
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001890 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B"));
Manuel Klimeka080a182013-01-02 16:30:12 +00001891}
1892
Daniel Jasper1d82b1a2013-10-11 19:45:02 +00001893TEST_F(FormatTest, DoesntRemoveUnknownTokens) {
1894 verifyFormat("#define A \\x20");
1895 verifyFormat("#define A \\ x20");
1896 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20"));
1897 verifyFormat("#define A ''");
1898 verifyFormat("#define A ''qqq");
1899 verifyFormat("#define A `qqq");
1900 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");
1901}
1902
Manuel Klimek060143e2013-01-02 18:33:23 +00001903TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {
Daniel Jaspera4d46212013-02-28 11:05:57 +00001904 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
1905 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12));
Manuel Klimek060143e2013-01-02 18:33:23 +00001906 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12));
Daniel Jaspera4d46212013-02-28 11:05:57 +00001907 // FIXME: We never break before the macro name.
Daniel Jasperc9346c92013-08-28 09:07:32 +00001908 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12));
Daniel Jaspere0b15ea2013-01-14 15:40:57 +00001909
1910 verifyFormat("#define A A\n#define A A");
1911 verifyFormat("#define A(X) A\n#define A A");
1912
Daniel Jaspera4d46212013-02-28 11:05:57 +00001913 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
1914 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22));
Manuel Klimek060143e2013-01-02 18:33:23 +00001915}
1916
1917TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {
Alexander Kornienko9fdc00a2013-03-28 18:40:55 +00001918 EXPECT_EQ("// somecomment\n"
Manuel Klimekd4397b92013-01-04 23:34:14 +00001919 "#include \"a.h\"\n"
Daniel Jaspera4d46212013-02-28 11:05:57 +00001920 "#define A( \\\n"
1921 " A, B)\n"
Manuel Klimekd4397b92013-01-04 23:34:14 +00001922 "#include \"b.h\"\n"
Alexander Kornienko5262dd92013-03-27 11:52:18 +00001923 "// somecomment\n",
Alexander Kornienko9fdc00a2013-03-28 18:40:55 +00001924 format(" // somecomment\n"
Manuel Klimekd4397b92013-01-04 23:34:14 +00001925 " #include \"a.h\"\n"
1926 "#define A(A,\\\n"
1927 " B)\n"
1928 " #include \"b.h\"\n"
Alexander Kornienko5262dd92013-03-27 11:52:18 +00001929 " // somecomment\n",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001930 getLLVMStyleWithColumns(13)));
Manuel Klimek060143e2013-01-02 18:33:23 +00001931}
1932
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001933TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
Manuel Klimekd4397b92013-01-04 23:34:14 +00001934
1935TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
1936 EXPECT_EQ("#define A \\\n"
1937 " c; \\\n"
1938 " e;\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001939 "f;",
1940 format("#define A c; e;\n"
1941 "f;",
1942 getLLVMStyleWithColumns(14)));
Manuel Klimekd4397b92013-01-04 23:34:14 +00001943}
1944
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001945TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
Manuel Klimekd4397b92013-01-04 23:34:14 +00001946
Daniel Jasper89b3a7f2013-05-10 13:00:49 +00001947TEST_F(FormatTest, AlwaysFormatsEntireMacroDefinitions) {
1948 EXPECT_EQ("int i;\n"
1949 "#define A \\\n"
1950 " int i; \\\n"
1951 " int j\n"
1952 "int k;",
1953 format("int i;\n"
1954 "#define A \\\n"
1955 " int i ; \\\n"
1956 " int j\n"
1957 "int k;",
1958 8, 0, getGoogleStyle())); // 8: position of "#define".
1959 EXPECT_EQ("int i;\n"
1960 "#define A \\\n"
1961 " int i; \\\n"
1962 " int j\n"
1963 "int k;",
1964 format("int i;\n"
1965 "#define A \\\n"
1966 " int i ; \\\n"
1967 " int j\n"
1968 "int k;",
1969 45, 0, getGoogleStyle())); // 45: position of "j".
Manuel Klimekd4397b92013-01-04 23:34:14 +00001970}
1971
1972TEST_F(FormatTest, MacroDefinitionInsideStatement) {
Manuel Klimek526ed112013-01-09 15:25:02 +00001973 EXPECT_EQ("int x,\n"
1974 "#define A\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001975 " y;",
1976 format("int x,\n#define A\ny;"));
Manuel Klimekd4397b92013-01-04 23:34:14 +00001977}
1978
Manuel Klimek6f8424b2013-01-05 21:34:55 +00001979TEST_F(FormatTest, HashInMacroDefinition) {
Alexander Kornienkodaa07e92013-09-10 13:41:43 +00001980 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle()));
Manuel Klimek6f8424b2013-01-05 21:34:55 +00001981 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11));
Daniel Jasperc9346c92013-08-28 09:07:32 +00001982 verifyFormat("#define A \\\n"
1983 " { \\\n"
1984 " f(#c); \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001985 " }",
1986 getLLVMStyleWithColumns(11));
Daniel Jasper765561f2013-01-08 16:17:54 +00001987
1988 verifyFormat("#define A(X) \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001989 " void function##X()",
1990 getLLVMStyleWithColumns(22));
Daniel Jasper765561f2013-01-08 16:17:54 +00001991
1992 verifyFormat("#define A(a, b, c) \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001993 " void a##b##c()",
1994 getLLVMStyleWithColumns(22));
Daniel Jasper765561f2013-01-08 16:17:54 +00001995
Daniel Jaspere0b15ea2013-01-14 15:40:57 +00001996 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
Manuel Klimek6f8424b2013-01-05 21:34:55 +00001997}
1998
Manuel Klimek7ccbc212013-01-23 14:37:36 +00001999TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) {
2000 verifyFormat("#define A (1)");
2001}
2002
Manuel Klimeka28fc062013-02-11 12:33:24 +00002003TEST_F(FormatTest, EmptyLinesInMacroDefinitions) {
2004 EXPECT_EQ("#define A b;", format("#define A \\\n"
2005 " \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002006 " b;",
2007 getLLVMStyleWithColumns(25)));
Manuel Klimeka28fc062013-02-11 12:33:24 +00002008 EXPECT_EQ("#define A \\\n"
2009 " \\\n"
2010 " a; \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002011 " b;",
2012 format("#define A \\\n"
2013 " \\\n"
2014 " a; \\\n"
2015 " b;",
2016 getLLVMStyleWithColumns(11)));
Manuel Klimeka28fc062013-02-11 12:33:24 +00002017 EXPECT_EQ("#define A \\\n"
2018 " a; \\\n"
2019 " \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002020 " b;",
2021 format("#define A \\\n"
2022 " a; \\\n"
2023 " \\\n"
2024 " b;",
2025 getLLVMStyleWithColumns(11)));
Manuel Klimeka28fc062013-02-11 12:33:24 +00002026}
2027
Daniel Jasper34511fb2013-02-19 17:14:38 +00002028TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
Daniel Jaspercf6d76a2013-03-18 12:50:26 +00002029 verifyFormat("#define A :");
Daniel Jasper34511fb2013-02-19 17:14:38 +00002030 verifyFormat("#define SOMECASES \\\n"
Daniel Jasperbcca7e42013-03-20 10:23:53 +00002031 " case 1: \\\n"
Daniel Jasper34511fb2013-02-19 17:14:38 +00002032 " case 2\n",
2033 getLLVMStyleWithColumns(20));
Daniel Jasper34511fb2013-02-19 17:14:38 +00002034 verifyFormat("#define A template <typename T>");
Daniel Jasper03628b82013-02-19 20:05:41 +00002035 verifyFormat("#define STR(x) #x\n"
2036 "f(STR(this_is_a_string_literal{));");
Daniel Jasper7143a212013-08-28 09:17:37 +00002037 verifyFormat("#pragma omp threadprivate( \\\n"
2038 " y)), // expected-warning",
2039 getLLVMStyleWithColumns(28));
Daniel Jasper34511fb2013-02-19 17:14:38 +00002040}
2041
Daniel Jasper7e70f4c2013-05-29 13:16:10 +00002042TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) {
2043 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
2044 EXPECT_EQ("class A : public QObject {\n"
2045 " Q_OBJECT\n"
2046 "\n"
2047 " A() {}\n"
2048 "};",
2049 format("class A : public QObject {\n"
2050 " Q_OBJECT\n"
2051 "\n"
2052 " A() {\n}\n"
2053 "} ;"));
Daniel Jasperc76d59d2013-05-29 14:09:17 +00002054 EXPECT_EQ("SOME_MACRO\n"
2055 "namespace {\n"
2056 "void f();\n"
2057 "}",
2058 format("SOME_MACRO\n"
2059 " namespace {\n"
2060 "void f( );\n"
2061 "}"));
Daniel Jasper7e70f4c2013-05-29 13:16:10 +00002062 // Only if the identifier contains at least 5 characters.
2063 EXPECT_EQ("HTTP f();",
2064 format("HTTP\nf();"));
2065 EXPECT_EQ("MACRO\nf();",
2066 format("MACRO\nf();"));
2067 // Only if everything is upper case.
2068 EXPECT_EQ("class A : public QObject {\n"
2069 " Q_Object A() {}\n"
2070 "};",
2071 format("class A : public QObject {\n"
2072 " Q_Object\n"
2073 "\n"
2074 " A() {\n}\n"
2075 "} ;"));
2076}
2077
Alexander Kornienko3d713a72013-04-08 22:16:06 +00002078TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) {
2079 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
2080 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
2081 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00002082 "class X {};\n"
Alexander Kornienko3d713a72013-04-08 22:16:06 +00002083 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
2084 "int *createScopDetectionPass() { return 0; }",
2085 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
2086 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
2087 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
2088 " class X {};\n"
2089 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
2090 " int *createScopDetectionPass() { return 0; }"));
Alexander Kornienko99b0e142013-04-09 16:15:19 +00002091 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as
2092 // braces, so that inner block is indented one level more.
2093 EXPECT_EQ("int q() {\n"
2094 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
2095 " IPC_MESSAGE_HANDLER(xxx, qqq)\n"
2096 " IPC_END_MESSAGE_MAP()\n"
2097 "}",
2098 format("int q() {\n"
2099 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
2100 " IPC_MESSAGE_HANDLER(xxx, qqq)\n"
2101 " IPC_END_MESSAGE_MAP()\n"
2102 "}"));
Daniel Jasper42ff2632013-09-17 09:26:07 +00002103
2104 // These must not be recognized as macros.
Alexander Kornienko99b0e142013-04-09 16:15:19 +00002105 EXPECT_EQ("int q() {\n"
2106 " f(x);\n"
2107 " f(x) {}\n"
2108 " f(x)->g();\n"
2109 " f(x)->*g();\n"
2110 " f(x).g();\n"
2111 " f(x) = x;\n"
2112 " f(x) += x;\n"
2113 " f(x) -= x;\n"
2114 " f(x) *= x;\n"
2115 " f(x) /= x;\n"
2116 " f(x) %= x;\n"
2117 " f(x) &= x;\n"
2118 " f(x) |= x;\n"
2119 " f(x) ^= x;\n"
2120 " f(x) >>= x;\n"
2121 " f(x) <<= x;\n"
2122 " f(x)[y].z();\n"
2123 " LOG(INFO) << x;\n"
2124 " ifstream(x) >> x;\n"
2125 "}\n",
2126 format("int q() {\n"
2127 " f(x)\n;\n"
2128 " f(x)\n {}\n"
2129 " f(x)\n->g();\n"
2130 " f(x)\n->*g();\n"
2131 " f(x)\n.g();\n"
2132 " f(x)\n = x;\n"
2133 " f(x)\n += x;\n"
2134 " f(x)\n -= x;\n"
2135 " f(x)\n *= x;\n"
2136 " f(x)\n /= x;\n"
2137 " f(x)\n %= x;\n"
2138 " f(x)\n &= x;\n"
2139 " f(x)\n |= x;\n"
2140 " f(x)\n ^= x;\n"
2141 " f(x)\n >>= x;\n"
2142 " f(x)\n <<= x;\n"
2143 " f(x)\n[y].z();\n"
2144 " LOG(INFO)\n << x;\n"
2145 " ifstream(x)\n >> x;\n"
2146 "}\n"));
2147 EXPECT_EQ("int q() {\n"
2148 " f(x)\n"
2149 " if (1) {\n"
2150 " }\n"
2151 " f(x)\n"
2152 " while (1) {\n"
2153 " }\n"
2154 " f(x)\n"
2155 " g(x);\n"
2156 " f(x)\n"
2157 " try {\n"
2158 " q();\n"
2159 " }\n"
2160 " catch (...) {\n"
2161 " }\n"
2162 "}\n",
2163 format("int q() {\n"
2164 "f(x)\n"
2165 "if (1) {}\n"
2166 "f(x)\n"
2167 "while (1) {}\n"
2168 "f(x)\n"
2169 "g(x);\n"
2170 "f(x)\n"
2171 "try { q(); } catch (...) {}\n"
2172 "}\n"));
2173 EXPECT_EQ("class A {\n"
2174 " A() : t(0) {}\n"
2175 " A(X x)\n" // FIXME: function-level try blocks are broken.
2176 " try : t(0) {\n"
2177 " }\n"
2178 " catch (...) {\n"
2179 " }\n"
2180 "};",
2181 format("class A {\n"
2182 " A()\n : t(0) {}\n"
2183 " A(X x)\n"
2184 " try : t(0) {} catch (...) {}\n"
2185 "};"));
Alexander Kornienko3d713a72013-04-08 22:16:06 +00002186}
2187
Manuel Klimeke573c3f2013-05-22 12:51:29 +00002188TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) {
2189 verifyFormat("#define A \\\n"
2190 " f({ \\\n"
2191 " g(); \\\n"
2192 " });", getLLVMStyleWithColumns(11));
2193}
2194
Manuel Klimekc37b4d62013-01-05 22:14:16 +00002195TEST_F(FormatTest, IndentPreprocessorDirectivesAtZero) {
2196 EXPECT_EQ("{\n {\n#define A\n }\n}", format("{{\n#define A\n}}"));
2197}
2198
Manuel Klimekf6fd00b2013-01-05 22:56:06 +00002199TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) {
Manuel Klimek517e8942013-01-11 17:54:10 +00002200 verifyFormat("{\n { a #c; }\n}");
Manuel Klimekf6fd00b2013-01-05 22:56:06 +00002201}
2202
Manuel Klimeka5342db2013-01-06 20:07:31 +00002203TEST_F(FormatTest, FormatUnbalancedStructuralElements) {
2204 EXPECT_EQ("#define A \\\n { \\\n {\nint i;",
2205 format("#define A { {\nint i;", getLLVMStyleWithColumns(11)));
2206 EXPECT_EQ("#define A \\\n } \\\n }\nint i;",
2207 format("#define A } }\nint i;", getLLVMStyleWithColumns(11)));
2208}
Manuel Klimekd4397b92013-01-04 23:34:14 +00002209
Alexander Kornienko54e6c9d2013-06-07 17:45:07 +00002210TEST_F(FormatTest, EscapedNewlineAtStartOfToken) {
Daniel Jaspercd162382013-01-07 13:26:07 +00002211 EXPECT_EQ(
2212 "#define A \\\n int i; \\\n int j;",
2213 format("#define A \\\nint i;\\\n int j;", getLLVMStyleWithColumns(11)));
Alexander Kornienko54e6c9d2013-06-07 17:45:07 +00002214 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
Manuel Klimek95419382013-01-07 07:56:50 +00002215}
2216
Alexander Kornienko16a0ec62013-06-14 11:46:10 +00002217TEST_F(FormatTest, NoEscapedNewlineHandlingInBlockComments) {
2218 EXPECT_EQ("/* \\ \\ \\\n*/", format("\\\n/* \\ \\ \\\n*/"));
2219}
2220
Manuel Klimekd544c572013-01-07 09:24:17 +00002221TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) {
2222 verifyFormat("#define A \\\n"
2223 " int v( \\\n"
2224 " a); \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002225 " int i;",
2226 getLLVMStyleWithColumns(11));
Manuel Klimekd544c572013-01-07 09:24:17 +00002227}
2228
Manuel Klimeka080a182013-01-02 16:30:12 +00002229TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) {
Manuel Klimekd4397b92013-01-04 23:34:14 +00002230 EXPECT_EQ(
2231 "#define ALooooooooooooooooooooooooooooooooooooooongMacro("
2232 " \\\n"
2233 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
2234 "\n"
2235 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
2236 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n",
2237 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro("
2238 "\\\n"
2239 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
2240 " \n"
2241 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
2242 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n"));
Manuel Klimeka080a182013-01-02 16:30:12 +00002243}
2244
Manuel Klimek526ed112013-01-09 15:25:02 +00002245TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {
2246 EXPECT_EQ("int\n"
2247 "#define A\n"
Daniel Jasper53e72cd2013-05-06 08:27:33 +00002248 " a;",
Manuel Klimeka9a7f102013-06-21 17:25:42 +00002249 format("int\n#define A\na;", getGoogleStyle()));
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002250 verifyFormat("functionCallTo(\n"
2251 " someOtherFunction(\n"
2252 " withSomeParameters, whichInSequence,\n"
2253 " areLongerThanALine(andAnotherCall,\n"
2254 "#define A B\n"
2255 " withMoreParamters,\n"
2256 " whichStronglyInfluenceTheLayout),\n"
Daniel Jasper7d812812013-02-21 15:00:29 +00002257 " andMoreParameters),\n"
2258 " trailing);",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002259 getLLVMStyleWithColumns(69));
Daniel Jasperebaa1712013-09-17 09:52:48 +00002260 verifyFormat("Foo::Foo()\n"
2261 "#ifdef BAR\n"
2262 " : baz(0)\n"
2263 "#endif\n"
2264 "{\n"
2265 "}");
Manuel Klimek526ed112013-01-09 15:25:02 +00002266}
2267
Manuel Klimekbb42bf12013-01-10 11:52:21 +00002268TEST_F(FormatTest, LayoutBlockInsideParens) {
Daniel Jasper567dcf92013-09-05 09:29:45 +00002269 EXPECT_EQ("functionCall({ int i; });", format(" functionCall ( {int i;} );"));
Manuel Klimekbb42bf12013-01-10 11:52:21 +00002270 EXPECT_EQ("functionCall({\n"
2271 " int i;\n"
Daniel Jasper567dcf92013-09-05 09:29:45 +00002272 " int j;\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002273 "});",
Daniel Jasper567dcf92013-09-05 09:29:45 +00002274 format(" functionCall ( {int i;int j;} );"));
Daniel Jasperf7ec1cc2013-05-31 14:56:29 +00002275 EXPECT_EQ("functionCall({\n"
Daniel Jasper567dcf92013-09-05 09:29:45 +00002276 " int i;\n"
2277 " int j;\n"
2278 " },\n"
Daniel Jasperf7ec1cc2013-05-31 14:56:29 +00002279 " aaaa, bbbb, cccc);",
Daniel Jasper567dcf92013-09-05 09:29:45 +00002280 format(" functionCall ( {int i;int j;}, aaaa, bbbb, cccc);"));
2281 EXPECT_EQ("functionCall(aaaa, bbbb, { int i; });",
2282 format(" functionCall (aaaa, bbbb, {int i;});"));
2283 EXPECT_EQ("functionCall(aaaa, bbbb, {\n"
2284 " int i;\n"
2285 " int j;\n"
2286 "});",
2287 format(" functionCall (aaaa, bbbb, {int i;int j;});"));
2288 EXPECT_EQ("functionCall(aaaa, bbbb, { int i; });",
2289 format(" functionCall (aaaa, bbbb, {int i;});"));
Daniel Jasperf7ec1cc2013-05-31 14:56:29 +00002290 verifyFormat(
2291 "Aaa({\n"
Daniel Jasper567dcf92013-09-05 09:29:45 +00002292 " int i; // break\n"
2293 " },\n"
Daniel Jasperf7ec1cc2013-05-31 14:56:29 +00002294 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
2295 " ccccccccccccccccc));");
Daniel Jasper567dcf92013-09-05 09:29:45 +00002296 verifyFormat("DEBUG({\n"
2297 " if (a)\n"
2298 " f();\n"
2299 "});");
Manuel Klimekbb42bf12013-01-10 11:52:21 +00002300}
2301
2302TEST_F(FormatTest, LayoutBlockInsideStatement) {
Manuel Klimek517e8942013-01-11 17:54:10 +00002303 EXPECT_EQ("SOME_MACRO { int i; }\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002304 "int i;",
2305 format(" SOME_MACRO {int i;} int i;"));
Manuel Klimekbb42bf12013-01-10 11:52:21 +00002306}
2307
2308TEST_F(FormatTest, LayoutNestedBlocks) {
2309 verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
2310 " struct s {\n"
2311 " int i;\n"
2312 " };\n"
2313 " s kBitsToOs[] = { { 10 } };\n"
2314 " for (int i = 0; i < 10; ++i)\n"
2315 " return;\n"
2316 "}");
Daniel Jasperb77d7412013-09-06 07:54:20 +00002317 verifyFormat("call(parameter, {\n"
2318 " something();\n"
2319 " // Comment using all columns.\n"
2320 " somethingelse();\n"
2321 "});",
2322 getLLVMStyleWithColumns(40));
2323 EXPECT_EQ("call(parameter, {\n"
2324 " something();\n"
2325 " // Comment too\n"
2326 " // looooooooooong.\n"
2327 " somethingElse();\n"
2328 "});",
2329 format("call(parameter, {\n"
2330 " something();\n"
2331 " // Comment too looooooooooong.\n"
2332 " somethingElse();\n"
2333 "});",
2334 getLLVMStyleWithColumns(29)));
Daniel Jasper14e25c02013-09-08 14:07:57 +00002335 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });"));
2336 EXPECT_EQ("DEBUG({\n"
2337 " int i;\n"
2338 "\n"
2339 " // comment\n"
2340 " int j;\n"
2341 "});",
2342 format("DEBUG({\n"
2343 " int i;\n"
2344 "\n"
2345 " // comment\n"
2346 " int j;\n"
2347 "});"));
Manuel Klimekbb42bf12013-01-10 11:52:21 +00002348}
2349
Manuel Klimek36fab8d2013-01-10 13:24:24 +00002350TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) {
2351 EXPECT_EQ("{}", format("{}"));
Daniel Jasper8893b8a2013-05-31 14:56:20 +00002352 verifyFormat("enum E {};");
Manuel Klimek2f1ac412013-01-21 16:42:44 +00002353 verifyFormat("enum E {}");
Manuel Klimek36fab8d2013-01-10 13:24:24 +00002354}
2355
Alexander Kornienko15757312012-12-06 18:03:27 +00002356//===----------------------------------------------------------------------===//
2357// Line break tests.
2358//===----------------------------------------------------------------------===//
2359
Daniel Jasper13d2aa52013-08-30 08:29:25 +00002360TEST_F(FormatTest, PreventConfusingIndents) {
Alexander Kornienko15757312012-12-06 18:03:27 +00002361 verifyFormat(
Daniel Jasper986e17f2013-01-28 07:35:34 +00002362 "SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n"
2363 " parameter, parameter, parameter)),\n"
Daniel Jaspera4974cf2012-12-24 16:43:00 +00002364 " SecondLongCall(parameter));");
Daniel Jasper986e17f2013-01-28 07:35:34 +00002365 verifyFormat(
2366 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2367 " aaaaaaaaaaaaaaaaaaaaaaaa(\n"
2368 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
2369 " aaaaaaaaaaaaaaaaaaaaaaaa);");
2370 verifyFormat(
Daniel Jasper011c35d2013-07-12 11:19:37 +00002371 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2372 " [aaaaaaaaaaaaaaaaaaaaaaaa\n"
2373 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
2374 " [aaaaaaaaaaaaaaaaaaaaaaaa]];");
Daniel Jasper986e17f2013-01-28 07:35:34 +00002375 verifyFormat(
2376 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
2377 " aaaaaaaaaaaaaaaaaaaaaaaa<\n"
2378 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n"
2379 " aaaaaaaaaaaaaaaaaaaaaaaa>;");
Daniel Jasperae8699b2013-01-28 09:35:24 +00002380 verifyFormat("int a = bbbb && ccc && fffff(\n"
2381 "#define A Just forcing a new line\n"
2382 " ddd);");
Daniel Jasper986e17f2013-01-28 07:35:34 +00002383}
2384
Daniel Jasper11e13802013-05-08 14:12:04 +00002385TEST_F(FormatTest, LineBreakingInBinaryExpressions) {
2386 verifyFormat(
2387 "bool aaaaaaa =\n"
2388 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n"
2389 " bbbbbbbb();");
2390 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
2391 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n"
2392 " ccccccccc == ddddddddddd;");
2393
2394 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
2395 " aaaaaa) &&\n"
2396 " bbbbbb && cccccc;");
Daniel Jasper69c43712013-05-28 07:42:44 +00002397 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
2398 " aaaaaa) >>\n"
2399 " bbbbbb;");
Daniel Jasper11e13802013-05-08 14:12:04 +00002400 verifyFormat("Whitespaces.addUntouchableComment(\n"
2401 " SourceMgr.getSpellingColumnNumber(\n"
2402 " TheLine.Last->FormatTok.Tok.getLocation()) -\n"
2403 " 1);");
Daniel Jasperd741f022013-05-14 20:39:56 +00002404
Daniel Jasper5ef8aac2013-06-03 08:42:05 +00002405 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
2406 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n"
2407 " cccccc) {\n}");
2408
Daniel Jasper6df7a2d2013-07-03 10:34:47 +00002409 // If the LHS of a comparison is not a binary expression itself, the
2410 // additional linebreak confuses many people.
2411 verifyFormat(
2412 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2413 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n"
2414 "}");
2415 verifyFormat(
2416 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2417 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
2418 "}");
Daniel Jasperdb4813a2013-09-06 08:08:14 +00002419 verifyFormat(
2420 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n"
2421 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
2422 "}");
Daniel Jasper6df7a2d2013-07-03 10:34:47 +00002423 // Even explicit parentheses stress the precedence enough to make the
2424 // additional break unnecessary.
2425 verifyFormat(
2426 "if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2427 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
2428 "}");
2429 // This cases is borderline, but with the indentation it is still readable.
2430 verifyFormat(
2431 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2432 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2433 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
2434 "}",
2435 getLLVMStyleWithColumns(75));
2436
2437 // If the LHS is a binary expression, we should still use the additional break
2438 // as otherwise the formatting hides the operator precedence.
2439 verifyFormat(
2440 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2441 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2442 " 5) {\n"
2443 "}");
2444
Daniel Jasperd741f022013-05-14 20:39:56 +00002445 FormatStyle OnePerLine = getLLVMStyle();
2446 OnePerLine.BinPackParameters = false;
2447 verifyFormat(
2448 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
2449 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
2450 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}",
2451 OnePerLine);
Daniel Jasper11e13802013-05-08 14:12:04 +00002452}
2453
Daniel Jasperbf71ba22013-04-08 20:33:42 +00002454TEST_F(FormatTest, ExpressionIndentation) {
2455 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2456 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2457 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2458 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2459 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
2460 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n"
2461 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2462 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n"
2463 " ccccccccccccccccccccccccccccccccccccccccc;");
2464 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2465 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2466 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2467 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
2468 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2469 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2470 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2471 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
2472 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2473 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2474 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2475 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
Daniel Jasper9acb8b42013-06-06 09:11:58 +00002476 verifyFormat("if () {\n"
2477 "} else if (aaaaa && bbbbb > // break\n"
2478 " ccccc) {\n"
2479 "}");
Alexander Kornienkod71b15b2013-06-17 13:19:53 +00002480
2481 // Presence of a trailing comment used to change indentation of b.
2482 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
2483 " b;\n"
2484 "return aaaaaaaaaaaaaaaaaaa +\n"
2485 " b; //",
2486 getLLVMStyleWithColumns(30));
Daniel Jasperbf71ba22013-04-08 20:33:42 +00002487}
2488
Daniel Jaspere8b10d32013-07-26 16:56:36 +00002489TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) {
2490 // Not sure what the best system is here. Like this, the LHS can be found
2491 // immediately above an operator (everything with the same or a higher
2492 // indent). The RHS is aligned right of the operator and so compasses
2493 // everything until something with the same indent as the operator is found.
2494 // FIXME: Is this a good system?
2495 FormatStyle Style = getLLVMStyle();
2496 Style.BreakBeforeBinaryOperators = true;
2497 verifyFormat(
2498 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2499 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2500 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2501 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2502 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
2503 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
2504 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2505 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2506 " > ccccccccccccccccccccccccccccccccccccccccc;",
2507 Style);
2508 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2509 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2510 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2511 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
2512 Style);
2513 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2514 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2515 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2516 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
2517 Style);
2518 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2519 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2520 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2521 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
2522 Style);
2523 verifyFormat("if () {\n"
2524 "} else if (aaaaa && bbbbb // break\n"
2525 " > ccccc) {\n"
2526 "}",
2527 Style);
2528}
2529
Daniel Jasper1321eb52012-12-18 21:05:13 +00002530TEST_F(FormatTest, ConstructorInitializers) {
Manuel Klimek36fab8d2013-01-10 13:24:24 +00002531 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
Daniel Jasper7e9bf8c2013-01-11 11:37:55 +00002532 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
2533 getLLVMStyleWithColumns(45));
Daniel Jasperf11a7052013-02-21 21:33:55 +00002534 verifyFormat("Constructor()\n"
2535 " : Inttializer(FitsOnTheLine) {}",
Daniel Jasper7e9bf8c2013-01-11 11:37:55 +00002536 getLLVMStyleWithColumns(44));
Manuel Klimek2f1ac412013-01-21 16:42:44 +00002537 verifyFormat("Constructor()\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002538 " : Inttializer(FitsOnTheLine) {}",
Manuel Klimek2f1ac412013-01-21 16:42:44 +00002539 getLLVMStyleWithColumns(43));
Daniel Jasper1321eb52012-12-18 21:05:13 +00002540
2541 verifyFormat(
2542 "SomeClass::Constructor()\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002543 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
Daniel Jasper1321eb52012-12-18 21:05:13 +00002544
2545 verifyFormat(
2546 "SomeClass::Constructor()\n"
Daniel Jasper7e9bf8c2013-01-11 11:37:55 +00002547 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002548 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}");
Daniel Jasper7e9bf8c2013-01-11 11:37:55 +00002549 verifyFormat(
2550 "SomeClass::Constructor()\n"
Daniel Jasper1321eb52012-12-18 21:05:13 +00002551 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002552 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
Daniel Jasper1321eb52012-12-18 21:05:13 +00002553
2554 verifyFormat("Constructor()\n"
2555 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
2556 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2557 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002558 " aaaaaaaaaaaaaaaaaaaaaaa() {}");
Daniel Jasper1321eb52012-12-18 21:05:13 +00002559
Daniel Jasper02b771e2013-01-28 13:31:35 +00002560 verifyFormat("Constructor()\n"
2561 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002562 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasper02b771e2013-01-28 13:31:35 +00002563
Daniel Jasper9c3e71a2013-02-25 15:59:54 +00002564 verifyFormat("Constructor(int Parameter = 0)\n"
2565 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
2566 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}");
Daniel Jasper00e0f432013-09-06 21:46:41 +00002567 verifyFormat("Constructor()\n"
2568 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
2569 "}",
2570 getLLVMStyleWithColumns(60));
Daniel Jasper9c3e71a2013-02-25 15:59:54 +00002571
Daniel Jasper1321eb52012-12-18 21:05:13 +00002572 // Here a line could be saved by splitting the second initializer onto two
2573 // lines, but that is not desireable.
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002574 verifyFormat("Constructor()\n"
2575 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
2576 " aaaaaaaaaaa(aaaaaaaaaaa),\n"
2577 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasper1321eb52012-12-18 21:05:13 +00002578
Daniel Jasperb130a542013-02-15 16:49:44 +00002579 FormatStyle OnePerLine = getLLVMStyle();
2580 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
2581 verifyFormat("SomeClass::Constructor()\n"
2582 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
2583 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002584 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002585 OnePerLine);
Daniel Jasperb130a542013-02-15 16:49:44 +00002586 verifyFormat("SomeClass::Constructor()\n"
2587 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
2588 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002589 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002590 OnePerLine);
Daniel Jasperb130a542013-02-15 16:49:44 +00002591 verifyFormat("MyClass::MyClass(int var)\n"
2592 " : some_var_(var), // 4 space indent\n"
2593 " some_other_var_(var + 1) { // lined up\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002594 "}",
2595 OnePerLine);
Daniel Jasper3a39ac72013-02-28 09:39:12 +00002596 verifyFormat("Constructor()\n"
2597 " : aaaaa(aaaaaa),\n"
2598 " aaaaa(aaaaaa),\n"
2599 " aaaaa(aaaaaa),\n"
2600 " aaaaa(aaaaaa),\n"
2601 " aaaaa(aaaaaa) {}",
2602 OnePerLine);
Daniel Jasper001bf4e2013-04-22 07:59:53 +00002603 verifyFormat("Constructor()\n"
2604 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
2605 " aaaaaaaaaaaaaaaaaaaaaa) {}",
2606 OnePerLine);
Daniel Jasperfca24bc2013-04-25 13:31:51 +00002607}
2608
2609TEST_F(FormatTest, MemoizationTests) {
2610 // This breaks if the memoization lookup does not take \c Indent and
2611 // \c LastSpace into account.
2612 verifyFormat(
2613 "extern CFRunLoopTimerRef\n"
2614 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
2615 " CFTimeInterval interval, CFOptionFlags flags,\n"
2616 " CFIndex order, CFRunLoopTimerCallBack callout,\n"
Daniel Jasper53e72cd2013-05-06 08:27:33 +00002617 " CFRunLoopTimerContext *context) {}");
Daniel Jasperfca24bc2013-04-25 13:31:51 +00002618
2619 // Deep nesting somewhat works around our memoization.
2620 verifyFormat(
2621 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
2622 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
2623 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
2624 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
2625 " aaaaa())))))))))))))))))))))))))))))))))))))));",
2626 getLLVMStyleWithColumns(65));
Daniel Jasperc3df5ff2013-05-13 09:19:24 +00002627 verifyFormat(
2628 "aaaaa(\n"
2629 " aaaaa,\n"
2630 " aaaaa(\n"
2631 " aaaaa,\n"
2632 " aaaaa(\n"
2633 " aaaaa,\n"
2634 " aaaaa(\n"
2635 " aaaaa,\n"
2636 " aaaaa(\n"
2637 " aaaaa,\n"
2638 " aaaaa(\n"
2639 " aaaaa,\n"
2640 " aaaaa(\n"
2641 " aaaaa,\n"
2642 " aaaaa(\n"
2643 " aaaaa,\n"
2644 " aaaaa(\n"
2645 " aaaaa,\n"
2646 " aaaaa(\n"
2647 " aaaaa,\n"
2648 " aaaaa(\n"
2649 " aaaaa,\n"
2650 " aaaaa(\n"
2651 " aaaaa,\n"
2652 " aaaaa))))))))))));",
2653 getLLVMStyleWithColumns(65));
Daniel Jasper54b4e442013-05-22 05:27:42 +00002654 verifyFormat(
2655 "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"
2656 " a),\n"
2657 " a),\n"
2658 " a),\n"
2659 " a),\n"
2660 " a),\n"
2661 " a),\n"
2662 " a),\n"
2663 " a),\n"
2664 " a),\n"
2665 " a),\n"
2666 " a),\n"
2667 " a),\n"
2668 " a),\n"
2669 " a),\n"
2670 " a),\n"
2671 " a),\n"
2672 " a)",
2673 getLLVMStyleWithColumns(65));
Daniel Jasperb3123142013-01-12 07:36:22 +00002674
2675 // This test takes VERY long when memoization is broken.
Daniel Jasperfca24bc2013-04-25 13:31:51 +00002676 FormatStyle OnePerLine = getLLVMStyle();
2677 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002678 OnePerLine.BinPackParameters = false;
Daniel Jasper0df6acd2013-01-16 14:59:02 +00002679 std::string input = "Constructor()\n"
Daniel Jasper3499dda2013-01-25 15:43:32 +00002680 " : aaaa(a,\n";
Daniel Jasper0df6acd2013-01-16 14:59:02 +00002681 for (unsigned i = 0, e = 80; i != e; ++i) {
2682 input += " a,\n";
2683 }
Daniel Jasperf11a7052013-02-21 21:33:55 +00002684 input += " a) {}";
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002685 verifyFormat(input, OnePerLine);
Daniel Jasper1321eb52012-12-18 21:05:13 +00002686}
2687
Alexander Kornienko15757312012-12-06 18:03:27 +00002688TEST_F(FormatTest, BreaksAsHighAsPossible) {
2689 verifyFormat(
Alexander Kornienko3fd9ccd2013-03-12 16:28:18 +00002690 "void f() {\n"
2691 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
2692 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
2693 " f();\n"
2694 "}");
Daniel Jasper518ee342013-02-26 13:59:14 +00002695 verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
Daniel Jasperbf71ba22013-04-08 20:33:42 +00002696 " Intervals[i - 1].getRange().getLast()) {\n}");
Alexander Kornienko15757312012-12-06 18:03:27 +00002697}
2698
Daniel Jasper1407bee2013-04-11 14:29:13 +00002699TEST_F(FormatTest, BreaksFunctionDeclarations) {
2700 // Principially, we break function declarations in a certain order:
2701 // 1) break amongst arguments.
2702 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
2703 " Cccccccccccccc cccccccccccccc);");
Daniel Jasper92495a82013-08-19 10:16:18 +00002704 verifyFormat(
2705 "template <class TemplateIt>\n"
2706 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n"
2707 " TemplateIt *stop) {}");
Daniel Jasper1407bee2013-04-11 14:29:13 +00002708
2709 // 2) break after return type.
Daniel Jasper53e72cd2013-05-06 08:27:33 +00002710 verifyFormat(
Manuel Klimeka9a7f102013-06-21 17:25:42 +00002711 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2712 " bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);",
2713 getGoogleStyle());
Daniel Jasper1407bee2013-04-11 14:29:13 +00002714
2715 // 3) break after (.
2716 verifyFormat(
2717 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00002718 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);",
2719 getGoogleStyle());
Daniel Jasper1407bee2013-04-11 14:29:13 +00002720
2721 // 4) break before after nested name specifiers.
2722 verifyFormat(
2723 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper53e72cd2013-05-06 08:27:33 +00002724 " SomeClasssssssssssssssssssssssssssssssssssssss::\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00002725 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);",
2726 getGoogleStyle());
Daniel Jasper1407bee2013-04-11 14:29:13 +00002727
2728 // However, there are exceptions, if a sufficient amount of lines can be
2729 // saved.
2730 // FIXME: The precise cut-offs wrt. the number of saved lines might need some
2731 // more adjusting.
2732 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
2733 " Cccccccccccccc cccccccccc,\n"
2734 " Cccccccccccccc cccccccccc,\n"
2735 " Cccccccccccccc cccccccccc,\n"
2736 " Cccccccccccccc cccccccccc);");
2737 verifyFormat(
Manuel Klimeka9a7f102013-06-21 17:25:42 +00002738 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper53e72cd2013-05-06 08:27:33 +00002739 " bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
2740 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00002741 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);",
2742 getGoogleStyle());
Daniel Jasper1407bee2013-04-11 14:29:13 +00002743 verifyFormat(
2744 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
2745 " Cccccccccccccc cccccccccc,\n"
2746 " Cccccccccccccc cccccccccc,\n"
2747 " Cccccccccccccc cccccccccc,\n"
2748 " Cccccccccccccc cccccccccc,\n"
2749 " Cccccccccccccc cccccccccc,\n"
2750 " Cccccccccccccc cccccccccc);");
2751 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
2752 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
2753 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
2754 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
2755 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
Daniel Jasper01218ff2013-04-15 22:36:37 +00002756
2757 // Break after multi-line parameters.
2758 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2759 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2760 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2761 " bbbb bbbb);");
Daniel Jasper6561f6a2013-07-09 07:43:55 +00002762
2763 // Treat overloaded operators like other functions.
2764 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
2765 "operator>(const SomeLoooooooooooooooooooooooooogType &other);");
Daniel Jasperc476ea92013-08-28 07:27:35 +00002766 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
2767 "operator>>(const SomeLooooooooooooooooooooooooogType &other);");
Daniel Jasper6561f6a2013-07-09 07:43:55 +00002768 verifyGoogleFormat(
2769 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n"
2770 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
Daniel Jasper1407bee2013-04-11 14:29:13 +00002771}
2772
Daniel Jasper2ca37412013-07-09 14:36:48 +00002773TEST_F(FormatTest, TrailingReturnType) {
2774 verifyFormat("auto foo() -> int;\n");
2775 verifyFormat("struct S {\n"
2776 " auto bar() const -> int;\n"
2777 "};");
2778 verifyFormat("template <size_t Order, typename T>\n"
2779 "auto load_img(const std::string &filename)\n"
2780 " -> alias::tensor<Order, T, mem::tag::cpu> {}");
Daniel Jasper3262f4c2013-07-11 14:33:06 +00002781
2782 // Not trailing return types.
2783 verifyFormat("void f() { auto a = b->c(); }");
Daniel Jasper2ca37412013-07-09 14:36:48 +00002784}
2785
Daniel Jaspere033e872013-05-21 09:16:31 +00002786TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) {
Daniel Jasper20a0f8c2013-07-11 21:02:56 +00002787 // Avoid breaking before trailing 'const'.
Daniel Jasper5ad72bb2013-05-22 08:28:26 +00002788 verifyFormat("void someLongFunction(\n"
2789 " int someLongParameter) const {}",
2790 getLLVMStyleWithColumns(46));
2791 FormatStyle Style = getGoogleStyle();
2792 Style.ColumnLimit = 47;
2793 verifyFormat("void\n"
2794 "someLongFunction(int someLongParameter) const {\n}",
2795 getLLVMStyleWithColumns(47));
2796 verifyFormat("void someLongFunction(\n"
2797 " int someLongParameter) const {}",
2798 Style);
2799 verifyFormat("LoooooongReturnType\n"
2800 "someLoooooooongFunction() const {}",
2801 getLLVMStyleWithColumns(47));
2802 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
2803 " const {}",
2804 Style);
Daniel Jaspere033e872013-05-21 09:16:31 +00002805
Daniel Jasper20a0f8c2013-07-11 21:02:56 +00002806 // Avoid breaking before other trailing annotations, if they are not
2807 // function-like.
2808 verifyFormat("void SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2809 " aaaaaaaaaaaaaaaaaaaaaaaaaa) OVERRIDE;");
Daniel Jasper6b3ff8c2013-09-27 08:29:16 +00002810 verifyFormat("void SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2811 " aaaaaaaaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;");
2812 verifyFormat("void SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2813 " aaaaaaaaaaaaaaaaaaaaaaaaaa) override final;");
Daniel Jasper20a0f8c2013-07-11 21:02:56 +00002814
2815 // Breaking before function-like trailing annotations is fine to keep them
2816 // close to their arguments.
Daniel Jaspere033e872013-05-21 09:16:31 +00002817 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
2818 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
2819 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
2820 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
2821 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
2822 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}");
2823
2824 verifyFormat(
2825 "void aaaaaaaaaaaaaaaaaa()\n"
2826 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
2827 " aaaaaaaaaaaaaaaaaaaaaaaaa));");
2828 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2829 " __attribute__((unused));");
2830 verifyFormat(
Manuel Klimeka9a7f102013-06-21 17:25:42 +00002831 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2832 " GUARDED_BY(aaaaaaaaaaaa);",
2833 getGoogleStyle());
Daniel Jasperc18cff32013-07-11 12:34:23 +00002834 verifyFormat(
2835 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2836 " GUARDED_BY(aaaaaaaaaaaa);",
2837 getGoogleStyle());
Daniel Jaspere033e872013-05-21 09:16:31 +00002838}
2839
Daniel Jasperbac016b2012-12-03 18:12:45 +00002840TEST_F(FormatTest, BreaksDesireably) {
2841 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
2842 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00002843 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
Daniel Jaspere438bac2013-01-23 20:41:06 +00002844 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2845 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
2846 "}");
Daniel Jasperbac016b2012-12-03 18:12:45 +00002847
2848 verifyFormat(
2849 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002850 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasperbac016b2012-12-03 18:12:45 +00002851
2852 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2853 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2854 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jaspera88bb452012-12-04 10:50:12 +00002855
2856 verifyFormat(
2857 "aaaaaaaa(aaaaaaaaaaaaa, aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2858 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
2859 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2860 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));");
Daniel Jasper33182dd2012-12-05 14:57:28 +00002861
2862 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
2863 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
2864
Daniel Jasper723f0302013-01-02 14:40:02 +00002865 verifyFormat(
Alexander Kornienko3fd9ccd2013-03-12 16:28:18 +00002866 "void f() {\n"
2867 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
2868 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
2869 "}");
Daniel Jasper3499dda2013-01-25 15:43:32 +00002870 verifyFormat(
2871 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2872 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
2873 verifyFormat(
2874 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2875 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jasper64f09282013-03-20 13:53:11 +00002876 verifyFormat(
2877 "aaaaaaaaaaaaaaaaa(\n"
2878 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2879 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper723f0302013-01-02 14:40:02 +00002880
Daniel Jasper13d2aa52013-08-30 08:29:25 +00002881 // Indent consistently indenpendent of call expression.
2882 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
2883 " dddddddddddddddddddddddddddddd));\n"
2884 "aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
2885 " dddddddddddddddddddddddddddddd));");
2886
Daniel Jasper33182dd2012-12-05 14:57:28 +00002887 // This test case breaks on an incorrect memoization, i.e. an optimization not
2888 // taking into account the StopAt value.
2889 verifyFormat(
2890 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
Daniel Jaspercf225b62012-12-24 13:43:52 +00002891 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
2892 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
2893 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jaspera4974cf2012-12-24 16:43:00 +00002894
Daniel Jaspercd162382013-01-07 13:26:07 +00002895 verifyFormat("{\n {\n {\n"
2896 " Annotation.SpaceRequiredBefore =\n"
2897 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
2898 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
2899 " }\n }\n}");
Alexander Kornienko22d0e292013-06-17 12:59:44 +00002900
2901 // Break on an outer level if there was a break on an inner level.
2902 EXPECT_EQ("f(g(h(a, // comment\n"
2903 " b, c),\n"
2904 " d, e),\n"
2905 " x, y);",
2906 format("f(g(h(a, // comment\n"
2907 " b, c), d, e), x, y);"));
Daniel Jasper88cc5622013-07-08 14:25:23 +00002908
2909 // Prefer breaking similar line breaks.
2910 verifyFormat(
2911 "const int kTrackingOptions = NSTrackingMouseMoved |\n"
2912 " NSTrackingMouseEnteredAndExited |\n"
2913 " NSTrackingActiveAlways;");
Daniel Jasperbac016b2012-12-03 18:12:45 +00002914}
2915
Daniel Jasper0df6acd2013-01-16 14:59:02 +00002916TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +00002917 FormatStyle NoBinPacking = getGoogleStyle();
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002918 NoBinPacking.BinPackParameters = false;
2919 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
2920 " aaaaaaaaaaaaaaaaaaaa,\n"
2921 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);",
2922 NoBinPacking);
2923 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
2924 " aaaaaaaaaaaaa,\n"
2925 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));",
2926 NoBinPacking);
2927 verifyFormat(
Daniel Jasper0df6acd2013-01-16 14:59:02 +00002928 "aaaaaaaa(aaaaaaaaaaaaa,\n"
2929 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2930 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
2931 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002932 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));",
2933 NoBinPacking);
2934 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
2935 " .aaaaaaaaaaaaaaaaaa();",
2936 NoBinPacking);
2937 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2938 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);",
2939 NoBinPacking);
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002940
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002941 verifyFormat(
Daniel Jasper8f4bd7a2013-01-23 10:08:28 +00002942 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2943 " aaaaaaaaaaaa,\n"
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002944 " aaaaaaaaaaaa);",
2945 NoBinPacking);
2946 verifyFormat(
Daniel Jasper0df6acd2013-01-16 14:59:02 +00002947 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
2948 " ddddddddddddddddddddddddddddd),\n"
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002949 " test);",
2950 NoBinPacking);
Daniel Jasper0df6acd2013-01-16 14:59:02 +00002951
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002952 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
2953 " aaaaaaaaaaaaaaaaaaaaaaa,\n"
2954 " aaaaaaaaaaaaaaaaaaaaaaa> aaaaaaaaaaaaaaaaaa;",
2955 NoBinPacking);
2956 verifyFormat("a(\"a\"\n"
2957 " \"a\",\n"
2958 " a);");
Daniel Jasper8f4bd7a2013-01-23 10:08:28 +00002959
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002960 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
Daniel Jasperf1579602013-01-29 16:03:49 +00002961 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
Daniel Jasper8f4bd7a2013-01-23 10:08:28 +00002962 " aaaaaaaaa,\n"
Daniel Jasperf1579602013-01-29 16:03:49 +00002963 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002964 NoBinPacking);
Daniel Jasperfc759082013-02-14 14:26:07 +00002965 verifyFormat(
2966 "void f() {\n"
2967 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
2968 " .aaaaaaa();\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002969 "}",
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002970 NoBinPacking);
Daniel Jasper24e19e42013-05-22 08:55:55 +00002971 verifyFormat(
2972 "template <class SomeType, class SomeOtherType>\n"
2973 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
2974 NoBinPacking);
Daniel Jasper0df6acd2013-01-16 14:59:02 +00002975}
2976
Daniel Jasperc7bd68f2013-07-10 14:02:49 +00002977TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
2978 FormatStyle Style = getLLVMStyleWithColumns(15);
2979 Style.ExperimentalAutoDetectBinPacking = true;
2980 EXPECT_EQ("aaa(aaaa,\n"
2981 " aaaa,\n"
2982 " aaaa);\n"
2983 "aaa(aaaa,\n"
2984 " aaaa,\n"
2985 " aaaa);",
2986 format("aaa(aaaa,\n" // one-per-line
2987 " aaaa,\n"
2988 " aaaa );\n"
2989 "aaa(aaaa, aaaa, aaaa);", // inconclusive
2990 Style));
2991 EXPECT_EQ("aaa(aaaa, aaaa,\n"
2992 " aaaa);\n"
2993 "aaa(aaaa, aaaa,\n"
2994 " aaaa);",
2995 format("aaa(aaaa, aaaa,\n" // bin-packed
2996 " aaaa );\n"
2997 "aaa(aaaa, aaaa, aaaa);", // inconclusive
2998 Style));
2999}
3000
Daniel Jasperc79afda2013-01-18 10:56:38 +00003001TEST_F(FormatTest, FormatsBuilderPattern) {
3002 verifyFormat(
3003 "return llvm::StringSwitch<Reference::Kind>(name)\n"
Daniel Jasper29082452013-08-30 07:27:13 +00003004 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
3005 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
3006 " .StartsWith(\".init\", ORDER_INIT)\n"
3007 " .StartsWith(\".fini\", ORDER_FINI)\n"
3008 " .StartsWith(\".hash\", ORDER_HASH)\n"
3009 " .Default(ORDER_TEXT);\n");
Daniel Jasper33f4b902013-05-15 09:35:08 +00003010
Daniel Jasper4a544e52013-02-15 20:33:06 +00003011 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
Daniel Jasperbf71ba22013-04-08 20:33:42 +00003012 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
Daniel Jasper515f65d2013-02-18 13:24:21 +00003013 verifyFormat(
Daniel Jasperefed6872013-08-07 05:34:02 +00003014 "aaaaaaa->aaaaaaa->aaaaaaaaaaaaaaaa(\n"
3015 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
Daniel Jasper515f65d2013-02-18 13:24:21 +00003016 " ->aaaaaaaa(aaaaaaaaaaaaaaa);");
Daniel Jasper82282dc2013-02-18 13:52:06 +00003017 verifyFormat(
3018 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
Daniel Jasper24849712013-03-01 16:48:32 +00003019 " aaaaaaaaaaaaaa);");
Daniel Jasper82282dc2013-02-18 13:52:06 +00003020 verifyFormat(
Daniel Jasperd489f8c2013-08-27 11:09:05 +00003021 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n"
3022 " aaaaaa->aaaaaaaaaaaa()\n"
3023 " ->aaaaaaaaaaaaaaaa(\n"
3024 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3025 " ->aaaaaaaaaaaaaaaaa();");
3026 verifyFormat(
3027 "someobj->Add((new util::filetools::Handler(dir))\n"
3028 " ->OnEvent1(NewPermanentCallback(\n"
3029 " this, &HandlerHolderClass::EventHandlerCBA))\n"
3030 " ->OnEvent2(NewPermanentCallback(\n"
3031 " this, &HandlerHolderClass::EventHandlerCBB))\n"
3032 " ->OnEvent3(NewPermanentCallback(\n"
3033 " this, &HandlerHolderClass::EventHandlerCBC))\n"
3034 " ->OnEvent5(NewPermanentCallback(\n"
3035 " this, &HandlerHolderClass::EventHandlerCBD))\n"
3036 " ->OnEvent6(NewPermanentCallback(\n"
3037 " this, &HandlerHolderClass::EventHandlerCBE)));");
Daniel Jasperd3fef0f2013-08-27 14:24:43 +00003038
3039 verifyFormat(
3040 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();");
3041 verifyFormat("aaaaaaaaaaaaaaa()\n"
3042 " .aaaaaaaaaaaaaaa()\n"
3043 " .aaaaaaaaaaaaaaa()\n"
3044 " .aaaaaaaaaaaaaaa()\n"
3045 " .aaaaaaaaaaaaaaa();");
3046 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
3047 " .aaaaaaaaaaaaaaa()\n"
3048 " .aaaaaaaaaaaaaaa()\n"
3049 " .aaaaaaaaaaaaaaa();");
3050 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
3051 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
3052 " .aaaaaaaaaaaaaaa();");
Daniel Jaspereb331832013-08-30 07:12:40 +00003053 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
3054 " ->aaaaaaaaaaaaaae(0)\n"
3055 " ->aaaaaaaaaaaaaaa();");
Daniel Jasper2f0a0202013-09-06 08:54:24 +00003056
3057 // Prefer not to break after empty parentheses.
3058 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
3059 " First->LastNewlineOffset);");
Daniel Jasperc79afda2013-01-18 10:56:38 +00003060}
3061
Daniel Jaspere2c7acf2012-12-24 00:13:23 +00003062TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) {
3063 verifyFormat(
3064 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003065 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
Daniel Jaspercd162382013-01-07 13:26:07 +00003066 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003067 " ccccccccccccccccccccccccc) {\n}");
Daniel Jaspercd162382013-01-07 13:26:07 +00003068 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003069 " ccccccccccccccccccccccccc) {\n}");
Daniel Jaspere2c7acf2012-12-24 00:13:23 +00003070 verifyFormat(
3071 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003072 " ccccccccccccccccccccccccc) {\n}");
Daniel Jasper29f123b2013-02-08 15:28:42 +00003073 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
3074 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
3075 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
3076 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
3077 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
3078 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
3079 " aaaaaaaaaaaaaaa != aa) {\n}");
Daniel Jaspere2c7acf2012-12-24 00:13:23 +00003080}
3081
Daniel Jasper7006e7e2013-01-23 12:27:43 +00003082TEST_F(FormatTest, BreaksAfterAssignments) {
Daniel Jasper9cda8002013-01-07 13:08:40 +00003083 verifyFormat(
Daniel Jasper7006e7e2013-01-23 12:27:43 +00003084 "unsigned Cost =\n"
3085 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
3086 " SI->getPointerAddressSpaceee());\n");
Daniel Jasper9cda8002013-01-07 13:08:40 +00003087 verifyFormat(
Daniel Jasper13cb7c22013-01-23 15:55:19 +00003088 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
3089 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
Daniel Jasperf39c8852013-01-23 16:58:21 +00003090
3091 verifyFormat(
Daniel Jasperd489f8c2013-08-27 11:09:05 +00003092 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
3093 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper512843a2013-05-27 12:45:09 +00003094 verifyFormat("unsigned OriginalStartColumn =\n"
3095 " SourceMgr.getSpellingColumnNumber(\n"
3096 " Current.FormatTok.getStartOfNonWhitespace()) -\n"
3097 " 1;");
Daniel Jasper9cda8002013-01-07 13:08:40 +00003098}
3099
Daniel Jaspercf225b62012-12-24 13:43:52 +00003100TEST_F(FormatTest, AlignsAfterAssignments) {
3101 verifyFormat(
3102 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper9cda8002013-01-07 13:08:40 +00003103 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jaspercf225b62012-12-24 13:43:52 +00003104 verifyFormat(
3105 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper9cda8002013-01-07 13:08:40 +00003106 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jaspercf225b62012-12-24 13:43:52 +00003107 verifyFormat(
3108 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper9cda8002013-01-07 13:08:40 +00003109 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jaspercf225b62012-12-24 13:43:52 +00003110 verifyFormat(
3111 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper9cda8002013-01-07 13:08:40 +00003112 " aaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper88cc5622013-07-08 14:25:23 +00003113 verifyFormat(
3114 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n"
3115 " aaaaaaaaaaaaaaaaaaaaaaaa +\n"
3116 " aaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jaspercf225b62012-12-24 13:43:52 +00003117}
3118
3119TEST_F(FormatTest, AlignsAfterReturn) {
3120 verifyFormat(
3121 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3122 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
3123 verifyFormat(
3124 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3125 " aaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper37911302013-04-02 14:33:13 +00003126 verifyFormat(
3127 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
Daniel Jasperbf71ba22013-04-08 20:33:42 +00003128 " aaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper37911302013-04-02 14:33:13 +00003129 verifyFormat(
3130 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
Daniel Jasperbf71ba22013-04-08 20:33:42 +00003131 " aaaaaaaaaaaaaaaaaaaaaa());");
3132 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3133 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
3134 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3135 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
3136 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasperf78bf4a2013-09-30 08:29:03 +00003137 verifyFormat("return\n"
3138 " // true if code is one of a or b.\n"
3139 " code == a || code == b;");
Daniel Jaspercf225b62012-12-24 13:43:52 +00003140}
3141
Daniel Jasper9c837d02013-01-09 07:06:56 +00003142TEST_F(FormatTest, BreaksConditionalExpressions) {
3143 verifyFormat(
Daniel Jasper88cc5622013-07-08 14:25:23 +00003144 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3145 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3146 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper1f2b0782013-01-16 16:23:19 +00003147 verifyFormat(
Daniel Jasperbfe6fd42013-01-28 12:45:14 +00003148 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3149 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
3150 verifyFormat(
3151 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
3152 " : aaaaaaaaaaaaa);");
3153 verifyFormat(
3154 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper64f09282013-03-20 13:53:11 +00003155 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasperbfe6fd42013-01-28 12:45:14 +00003156 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3157 " aaaaaaaaaaaaa);");
Daniel Jasperab3ce592013-08-01 22:05:00 +00003158 verifyFormat(
3159 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3160 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3161 " aaaaaaaaaaaaa);");
Daniel Jasperbfe6fd42013-01-28 12:45:14 +00003162 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3163 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3164 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3165 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3166 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
3167 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3168 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3169 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3170 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3171 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3172 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3173 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperab3ce592013-08-01 22:05:00 +00003174 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3175 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3176 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3177 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3178 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper7878a7b2013-02-15 11:07:25 +00003179 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3180 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3181 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper37911302013-04-02 14:33:13 +00003182 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
3183 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3184 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3185 " : aaaaaaaaaaaaaaaa;");
Daniel Jasper237d4c12013-02-23 21:01:55 +00003186 verifyFormat(
3187 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3188 " ? aaaaaaaaaaaaaaa\n"
3189 " : aaaaaaaaaaaaaaa;");
3190 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
Daniel Jasperbf71ba22013-04-08 20:33:42 +00003191 " aaaaaaaaa\n"
Daniel Jasper65622aa2013-04-08 10:45:44 +00003192 " ? b\n"
3193 " : c);");
Daniel Jasper087387a2013-02-08 16:49:27 +00003194 verifyFormat(
Daniel Jasper7878a7b2013-02-15 11:07:25 +00003195 "unsigned Indent =\n"
3196 " format(TheLine.First, IndentForLevel[TheLine.Level] >= 0\n"
3197 " ? IndentForLevel[TheLine.Level]\n"
Daniel Jasper7d812812013-02-21 15:00:29 +00003198 " : TheLine * 2,\n"
3199 " TheLine.InPPDirective, PreviousEndOfLineColumn);",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003200 getLLVMStyleWithColumns(70));
Daniel Jasperc01897c2013-05-31 14:56:12 +00003201 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
3202 " ? aaaaaaaaaaaaaaa\n"
3203 " : bbbbbbbbbbbbbbb //\n"
3204 " ? ccccccccccccccc\n"
3205 " : ddddddddddddddd;");
3206 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
3207 " ? aaaaaaaaaaaaaaa\n"
3208 " : (bbbbbbbbbbbbbbb //\n"
3209 " ? ccccccccccccccc\n"
3210 " : ddddddddddddddd);");
Daniel Jasper7878a7b2013-02-15 11:07:25 +00003211
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003212 FormatStyle NoBinPacking = getLLVMStyle();
3213 NoBinPacking.BinPackParameters = false;
3214 verifyFormat(
Daniel Jasper237d4c12013-02-23 21:01:55 +00003215 "void f() {\n"
3216 " g(aaa,\n"
3217 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
3218 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3219 " ? aaaaaaaaaaaaaaa\n"
3220 " : aaaaaaaaaaaaaaa);\n"
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003221 "}",
3222 NoBinPacking);
Daniel Jasperab3ce592013-08-01 22:05:00 +00003223 verifyFormat(
3224 "void f() {\n"
3225 " g(aaa,\n"
3226 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
3227 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3228 " ?: aaaaaaaaaaaaaaa);\n"
3229 "}",
3230 NoBinPacking);
Daniel Jasper9c837d02013-01-09 07:06:56 +00003231}
3232
Daniel Jasper2e603772013-01-29 11:21:01 +00003233TEST_F(FormatTest, DeclarationsOfMultipleVariables) {
3234 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
3235 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();");
3236 verifyFormat("bool a = true, b = false;");
3237
Daniel Jasper2e603772013-01-29 11:21:01 +00003238 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +00003239 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
Daniel Jasper2e603772013-01-29 11:21:01 +00003240 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
Daniel Jasper37911302013-04-02 14:33:13 +00003241 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);");
Daniel Jasper2e603772013-01-29 11:21:01 +00003242 verifyFormat(
Daniel Jasper7d812812013-02-21 15:00:29 +00003243 "bool aaaaaaaaaaaaaaaaaaaaa =\n"
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +00003244 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
Daniel Jasper7d812812013-02-21 15:00:29 +00003245 " d = e && f;");
Daniel Jasperadc0f092013-04-05 09:38:50 +00003246 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
3247 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;");
3248 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
3249 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;");
3250 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
3251 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;");
3252 // FIXME: If multiple variables are defined, the "*" needs to move to the new
3253 // line. Also fix indent for breaking after the type, this looks bad.
Manuel Klimeka9a7f102013-06-21 17:25:42 +00003254 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
Daniel Jasper53e72cd2013-05-06 08:27:33 +00003255 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00003256 " *b = bbbbbbbbbbbbbbbbbbb;",
3257 getGoogleStyle());
Daniel Jasper2e603772013-01-29 11:21:01 +00003258
Daniel Jasperadc0f092013-04-05 09:38:50 +00003259 // Not ideal, but pointer-with-type does not allow much here.
3260 verifyGoogleFormat(
3261 "aaaaaaaaa* a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
3262 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;");
Daniel Jasper2e603772013-01-29 11:21:01 +00003263}
3264
Nico Weber7d37b8b2013-01-12 01:28:06 +00003265TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
3266 verifyFormat("arr[foo ? bar : baz];");
3267 verifyFormat("f()[foo ? bar : baz];");
3268 verifyFormat("(a + b)[foo ? bar : baz];");
3269 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
3270}
3271
Daniel Jasperbac016b2012-12-03 18:12:45 +00003272TEST_F(FormatTest, AlignsStringLiterals) {
3273 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
3274 " \"short literal\");");
3275 verifyFormat(
3276 "looooooooooooooooooooooooongFunction(\n"
3277 " \"short literal\"\n"
3278 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003279 verifyFormat("someFunction(\"Always break between multi-line\"\n"
3280 " \" string literals\",\n"
3281 " and, other, parameters);");
Manuel Klimekb56b6d12013-02-20 15:25:48 +00003282 EXPECT_EQ("fun + \"1243\" /* comment */\n"
3283 " \"5678\";",
3284 format("fun + \"1243\" /* comment */\n"
3285 " \"5678\";",
3286 getLLVMStyleWithColumns(28)));
3287 EXPECT_EQ(
3288 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
3289 " \"aaaaaaaaaaaaaaaaaaaaa\"\n"
3290 " \"aaaaaaaaaaaaaaaa\";",
3291 format("aaaaaa ="
3292 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
3293 "aaaaaaaaaaaaaaaaaaaaa\" "
3294 "\"aaaaaaaaaaaaaaaa\";"));
Manuel Klimeke9a62262013-02-20 15:32:58 +00003295 verifyFormat("a = a + \"a\"\n"
3296 " \"a\"\n"
3297 " \"a\";");
Daniel Jasper9a2f8d02013-05-16 04:26:02 +00003298 verifyFormat("f(\"a\", \"b\"\n"
3299 " \"c\");");
Daniel Jasper3a204412013-02-23 07:46:38 +00003300
3301 verifyFormat(
3302 "#define LL_FORMAT \"ll\"\n"
3303 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
3304 " \"d, ddddddddd: %\" LL_FORMAT \"d\");");
Daniel Jasper27c7f542013-05-13 20:50:15 +00003305
3306 verifyFormat("#define A(X) \\\n"
3307 " \"aaaaa\" #X \"bbbbbb\" \\\n"
3308 " \"ccccc\"",
3309 getLLVMStyleWithColumns(23));
3310 verifyFormat("#define A \"def\"\n"
3311 "f(\"abc\" A \"ghi\"\n"
3312 " \"jkl\");");
Daniel Jasperbac016b2012-12-03 18:12:45 +00003313}
3314
Alexander Kornienko56312022013-07-04 12:02:44 +00003315TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) {
3316 FormatStyle NoBreak = getLLVMStyle();
3317 NoBreak.AlwaysBreakBeforeMultilineStrings = false;
3318 FormatStyle Break = getLLVMStyle();
3319 Break.AlwaysBreakBeforeMultilineStrings = true;
Daniel Jasper215c57f2013-07-17 15:38:19 +00003320 verifyFormat("aaaa = \"bbbb\"\n"
3321 " \"cccc\";",
3322 NoBreak);
3323 verifyFormat("aaaa =\n"
3324 " \"bbbb\"\n"
3325 " \"cccc\";",
3326 Break);
3327 verifyFormat("aaaa(\"bbbb\"\n"
3328 " \"cccc\");",
3329 NoBreak);
3330 verifyFormat("aaaa(\n"
3331 " \"bbbb\"\n"
3332 " \"cccc\");",
3333 Break);
3334 verifyFormat("aaaa(qqq, \"bbbb\"\n"
3335 " \"cccc\");",
3336 NoBreak);
3337 verifyFormat("aaaa(qqq,\n"
3338 " \"bbbb\"\n"
3339 " \"cccc\");",
3340 Break);
3341
3342 // Don't break if there is no column gain.
3343 verifyFormat("f(\"aaaa\"\n"
3344 " \"bbbb\");",
3345 Break);
3346
3347 // Treat literals with escaped newlines like multi-line string literals.
Alexander Kornienko10c26b22013-07-16 21:06:13 +00003348 EXPECT_EQ("x = \"a\\\n"
3349 "b\\\n"
3350 "c\";",
3351 format("x = \"a\\\n"
3352 "b\\\n"
3353 "c\";",
3354 NoBreak));
3355 EXPECT_EQ("x =\n"
3356 " \"a\\\n"
3357 "b\\\n"
3358 "c\";",
3359 format("x = \"a\\\n"
3360 "b\\\n"
3361 "c\";",
3362 Break));
Alexander Kornienko56312022013-07-04 12:02:44 +00003363}
3364
Alexander Kornienko15757312012-12-06 18:03:27 +00003365TEST_F(FormatTest, AlignsPipes) {
3366 verifyFormat(
3367 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3368 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3369 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
3370 verifyFormat(
3371 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
3372 " << aaaaaaaaaaaaaaaaaaaa;");
3373 verifyFormat(
3374 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3375 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
3376 verifyFormat(
3377 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
3378 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
3379 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";");
3380 verifyFormat(
3381 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3382 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3383 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasperfa543ac2013-02-04 07:34:48 +00003384
3385 verifyFormat("return out << \"somepacket = {\\n\"\n"
3386 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
3387 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
3388 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
3389 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
3390 " << \"}\";");
Daniel Jasper4e8a7b42013-02-06 21:04:05 +00003391
Daniel Jasper3e12e872013-07-15 14:12:30 +00003392 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
3393 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
3394 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;");
Daniel Jasper4e8a7b42013-02-06 21:04:05 +00003395 verifyFormat(
3396 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
3397 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
3398 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
3399 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
3400 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;");
Daniel Jasperbfa1edd2013-03-14 14:00:17 +00003401 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
3402 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
Daniel Jasper9637dda2013-07-15 14:33:14 +00003403 verifyFormat(
3404 "void f() {\n"
3405 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n"
3406 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
3407 "}");
Daniel Jasper37911302013-04-02 14:33:13 +00003408
Daniel Jasperfaec47b2013-07-11 20:41:21 +00003409 // Breaking before the first "<<" is generally not desirable.
3410 verifyFormat(
3411 "llvm::errs()\n"
3412 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3413 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3414 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3415 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
3416 getLLVMStyleWithColumns(70));
3417 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
3418 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3419 " << \"aaaaaaaaaaaaaaaaaaa: \"\n"
3420 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3421 " << \"aaaaaaaaaaaaaaaaaaa: \"\n"
3422 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
3423 getLLVMStyleWithColumns(70));
3424
Daniel Jasperb349a782013-08-12 12:58:05 +00003425 // But sometimes, breaking before the first "<<" is desirable.
Daniel Jaspera0740f52013-07-12 15:14:05 +00003426 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
3427 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3428 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasperb349a782013-08-12 12:58:05 +00003429 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
3430 " << BEF << IsTemplate << Description << E->getType();");
Daniel Jaspera0740f52013-07-12 15:14:05 +00003431
Daniel Jasper37911302013-04-02 14:33:13 +00003432 verifyFormat(
3433 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3434 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper20376982013-09-29 12:02:57 +00003435
3436 // Incomplete string literal.
3437 EXPECT_EQ("llvm::errs() << \"\n"
3438 " << a;",
3439 format("llvm::errs() << \"\n<<a;"));
Alexander Kornienko15757312012-12-06 18:03:27 +00003440}
3441
Daniel Jasperbac016b2012-12-03 18:12:45 +00003442TEST_F(FormatTest, UnderstandsEquals) {
3443 verifyFormat(
3444 "aaaaaaaaaaaaaaaaa =\n"
3445 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
3446 verifyFormat(
3447 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003448 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasperbac016b2012-12-03 18:12:45 +00003449 verifyFormat(
3450 "if (a) {\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +00003451 " f();\n"
Daniel Jasperbac016b2012-12-03 18:12:45 +00003452 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003453 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
3454 "}");
Daniel Jasperbac016b2012-12-03 18:12:45 +00003455
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003456 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
3457 " 100000000 + 10000000) {\n}");
Daniel Jasperbac016b2012-12-03 18:12:45 +00003458}
3459
Daniel Jasper9a0b4942012-12-17 14:34:14 +00003460TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
Daniel Jasper1321eb52012-12-18 21:05:13 +00003461 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
3462 " .looooooooooooooooooooooooooooooooooooooongFunction();");
Daniel Jasper9a0b4942012-12-17 14:34:14 +00003463
Daniel Jasper1321eb52012-12-18 21:05:13 +00003464 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
3465 " ->looooooooooooooooooooooooooooooooooooooongFunction();");
Daniel Jasper9a0b4942012-12-17 14:34:14 +00003466
3467 verifyFormat(
3468 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
3469 " Parameter2);");
3470
3471 verifyFormat(
3472 "ShortObject->shortFunction(\n"
3473 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
3474 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);");
3475
3476 verifyFormat("loooooooooooooongFunction(\n"
3477 " LoooooooooooooongObject->looooooooooooooooongFunction());");
3478
3479 verifyFormat(
3480 "function(LoooooooooooooooooooooooooooooooooooongObject\n"
3481 " ->loooooooooooooooooooooooooooooooooooooooongFunction());");
3482
Daniel Jasperfc759082013-02-14 14:26:07 +00003483 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
3484 " .WillRepeatedly(Return(SomeValue));");
3485 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)]\n"
3486 " .insert(ccccccccccccccccccccccc);");
Daniel Jasper259a0382013-05-27 11:50:16 +00003487 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3488 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa).aaaaa(aaaaa),\n"
3489 " aaaaaaaaaaaaaaaaaaaaa);");
Daniel Jaspere60084d2013-08-13 06:50:04 +00003490 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3491 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());");
Daniel Jasper3af59ce2013-03-15 14:57:30 +00003492 verifyFormat(
3493 "aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3494 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
Daniel Jasper88cc5622013-07-08 14:25:23 +00003495 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3496 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3497 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jasper37911302013-04-02 14:33:13 +00003498 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3499 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3500 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3501 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
3502 "}");
Daniel Jasperfc759082013-02-14 14:26:07 +00003503
Daniel Jasper46a46a22013-01-07 07:13:20 +00003504 // Here, it is not necessary to wrap at "." or "->".
Daniel Jasper1321eb52012-12-18 21:05:13 +00003505 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003506 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasper46a46a22013-01-07 07:13:20 +00003507 verifyFormat(
3508 "aaaaaaaaaaa->aaaaaaaaa(\n"
3509 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3510 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
Daniel Jasper9fc56f22013-02-14 15:01:34 +00003511
3512 verifyFormat(
3513 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3514 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
Daniel Jasper8d0d19a2013-03-13 15:37:48 +00003515 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
3516 " aaaaaaaaa()->aaaaaa()->aaaaa());");
3517 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
3518 " aaaaaaaaa()->aaaaaa()->aaaaa());");
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003519
Daniel Jasper3af59ce2013-03-15 14:57:30 +00003520 // FIXME: Should we break before .a()?
3521 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3522 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa).a();");
3523
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003524 FormatStyle NoBinPacking = getLLVMStyle();
3525 NoBinPacking.BinPackParameters = false;
3526 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
3527 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
3528 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
3529 " aaaaaaaaaaaaaaaaaaa,\n"
3530 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
3531 NoBinPacking);
Daniel Jasperb1491792013-07-09 11:57:27 +00003532
3533 // If there is a subsequent call, change to hanging indentation.
3534 verifyFormat(
3535 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3536 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n"
3537 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
3538 verifyFormat(
3539 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3540 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));");
Daniel Jasper9a0b4942012-12-17 14:34:14 +00003541}
3542
Daniel Jasper9a64fb52013-01-02 15:08:56 +00003543TEST_F(FormatTest, WrapsTemplateDeclarations) {
3544 verifyFormat("template <typename T>\n"
3545 "virtual void loooooooooooongFunction(int Param1, int Param2);");
Daniel Jasper48c099f2013-09-27 07:49:08 +00003546 verifyFormat("template <typename T>\n"
3547 "// T should be one of {A, B}.\n"
3548 "virtual void loooooooooooongFunction(int Param1, int Param2);");
Daniel Jasper9a64fb52013-01-02 15:08:56 +00003549 verifyFormat(
Daniel Jasperc79afda2013-01-18 10:56:38 +00003550 "template <typename T>\n"
Daniel Jasper29f123b2013-02-08 15:28:42 +00003551 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;");
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003552 verifyFormat("template <typename T>\n"
3553 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
3554 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);");
Daniel Jasper9a64fb52013-01-02 15:08:56 +00003555 verifyFormat(
3556 "template <typename T>\n"
3557 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
3558 " int Paaaaaaaaaaaaaaaaaaaaram2);");
Daniel Jasper5eda31e2013-01-02 18:30:06 +00003559 verifyFormat(
3560 "template <typename T>\n"
3561 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
3562 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
3563 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperd64f7382013-01-09 09:50:48 +00003564 verifyFormat("template <typename T>\n"
3565 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +00003566 " int aaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper3fc0bb72013-01-09 10:40:23 +00003567 verifyFormat(
3568 "template <typename T1, typename T2 = char, typename T3 = char,\n"
3569 " typename T4 = char>\n"
3570 "void f();");
Daniel Jasper3499dda2013-01-25 15:43:32 +00003571 verifyFormat(
3572 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
3573 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper01786732013-02-04 07:21:18 +00003574
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003575 verifyFormat("a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
3576 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));");
Daniel Jasperbbc87762013-05-29 12:07:31 +00003577
Daniel Jasper8893b8a2013-05-31 14:56:20 +00003578 verifyFormat("template <typename T> class C {};");
Daniel Jasperbbc87762013-05-29 12:07:31 +00003579 verifyFormat("template <typename T> void f();");
3580 verifyFormat("template <typename T> void f() {}");
Daniel Jasper07ca5472013-07-05 09:14:35 +00003581 verifyFormat(
3582 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
3583 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3584 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
3585 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
3586 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3587 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
3588 " bbbbbbbbbbbbbbbbbbbbbbbb);",
3589 getLLVMStyleWithColumns(72));
Daniel Jasperd3d9e0f2013-09-14 08:13:22 +00003590
3591 FormatStyle AlwaysBreak = getLLVMStyle();
3592 AlwaysBreak.AlwaysBreakTemplateDeclarations = true;
3593 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
3594 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
3595 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
3596 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3597 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
3598 " ccccccccccccccccccccccccccccccccccccccccccccccc);");
3599 verifyFormat("template <template <typename> class Fooooooo,\n"
3600 " template <typename> class Baaaaaaar>\n"
3601 "struct C {};",
3602 AlwaysBreak);
Daniel Jasper6e7f1932013-10-09 15:06:17 +00003603 verifyFormat("template <typename T> // T can be A, B or C.\n"
3604 "struct C {};",
3605 AlwaysBreak);
Daniel Jasper9a64fb52013-01-02 15:08:56 +00003606}
3607
Daniel Jasper63f00362013-01-25 10:57:27 +00003608TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
3609 verifyFormat(
3610 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
3611 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
3612 verifyFormat(
3613 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
3614 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3615 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
3616
Daniel Jasperb2f063a2013-05-08 10:00:18 +00003617 // FIXME: Should we have the extra indent after the second break?
Daniel Jasper63f00362013-01-25 10:57:27 +00003618 verifyFormat(
3619 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
3620 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
Daniel Jasperb2f063a2013-05-08 10:00:18 +00003621 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper63f00362013-01-25 10:57:27 +00003622
Daniel Jasper63f00362013-01-25 10:57:27 +00003623 verifyFormat(
3624 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
Daniel Jasper5f2173e2013-01-28 07:43:15 +00003625 " cccccccccccccccccccccccccccccccccccccccccccccc());");
Daniel Jasper63f00362013-01-25 10:57:27 +00003626
3627 // Breaking at nested name specifiers is generally not desirable.
3628 verifyFormat(
3629 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3630 " aaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperbfe6fd42013-01-28 12:45:14 +00003631
3632 verifyFormat(
3633 "aaaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
3634 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3635 " aaaaaaaaaaaaaaaaaaaaa);",
3636 getLLVMStyleWithColumns(74));
Daniel Jasper37911302013-04-02 14:33:13 +00003637
3638 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
3639 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3640 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper63f00362013-01-25 10:57:27 +00003641}
3642
Daniel Jasperbac016b2012-12-03 18:12:45 +00003643TEST_F(FormatTest, UnderstandsTemplateParameters) {
3644 verifyFormat("A<int> a;");
3645 verifyFormat("A<A<A<int> > > a;");
3646 verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
3647 verifyFormat("bool x = a < 1 || 2 > a;");
3648 verifyFormat("bool x = 5 < f<int>();");
3649 verifyFormat("bool x = f<int>() > 5;");
3650 verifyFormat("bool x = 5 < a<int>::x;");
3651 verifyFormat("bool x = a < 4 ? a > 2 : false;");
3652 verifyFormat("bool x = f() ? a < 2 : a > 2;");
3653
3654 verifyGoogleFormat("A<A<int>> a;");
3655 verifyGoogleFormat("A<A<A<int>>> a;");
3656 verifyGoogleFormat("A<A<A<A<int>>>> a;");
Daniel Jasper8ff690a2013-02-06 14:22:40 +00003657 verifyGoogleFormat("A<A<int> > a;");
3658 verifyGoogleFormat("A<A<A<int> > > a;");
3659 verifyGoogleFormat("A<A<A<A<int> > > > a;");
3660 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
3661 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
Daniel Jasperbac016b2012-12-03 18:12:45 +00003662
3663 verifyFormat("test >> a >> b;");
3664 verifyFormat("test << a >> b;");
3665
3666 verifyFormat("f<int>();");
Manuel Klimek36fab8d2013-01-10 13:24:24 +00003667 verifyFormat("template <typename T> void f() {}");
Daniel Jasper0348be02013-06-01 18:56:00 +00003668
3669 // Not template parameters.
3670 verifyFormat("return a < b && c > d;");
3671 verifyFormat("void f() {\n"
3672 " while (a < b && c > d) {\n"
3673 " }\n"
3674 "}");
Daniel Jasper0236dd02013-07-30 22:37:19 +00003675 verifyFormat("template <typename... Types>\n"
3676 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}");
Daniel Jasper26356cc2013-09-17 08:15:46 +00003677
3678 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3679 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);",
3680 getLLVMStyleWithColumns(60));
Daniel Jasperbac016b2012-12-03 18:12:45 +00003681}
3682
Daniel Jasper807809c2013-02-28 09:21:10 +00003683TEST_F(FormatTest, UnderstandsBinaryOperators) {
3684 verifyFormat("COMPARE(a, ==, b);");
Alexander Kornienko54a38bd2013-03-20 16:41:56 +00003685}
3686
3687TEST_F(FormatTest, UnderstandsPointersToMembers) {
3688 verifyFormat("int A::*x;");
Daniel Jasper395228f2013-05-08 14:58:20 +00003689 verifyFormat("int (S::*func)(void *);");
Daniel Jasper431f5912013-05-28 08:33:00 +00003690 verifyFormat("void f() { int (S::*func)(void *); }");
Daniel Jasper4b7b1042013-05-08 15:06:58 +00003691 verifyFormat("typedef bool *(Class::*Member)() const;");
Daniel Jasper395228f2013-05-08 14:58:20 +00003692 verifyFormat("void f() {\n"
3693 " (a->*f)();\n"
3694 " a->*x;\n"
3695 " (a.*f)();\n"
3696 " ((*a).*f)();\n"
3697 " a.*x;\n"
3698 "}");
Daniel Jasper5e2169f2013-07-18 14:46:07 +00003699 verifyFormat("void f() {\n"
3700 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
3701 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n"
3702 "}");
Daniel Jasper4b7b1042013-05-08 15:06:58 +00003703 FormatStyle Style = getLLVMStyle();
3704 Style.PointerBindsToType = true;
3705 verifyFormat("typedef bool* (Class::*Member)() const;", Style);
Daniel Jasper807809c2013-02-28 09:21:10 +00003706}
3707
Daniel Jasper98e6b4a2012-12-21 09:41:31 +00003708TEST_F(FormatTest, UnderstandsUnaryOperators) {
Daniel Jasperbac016b2012-12-03 18:12:45 +00003709 verifyFormat("int a = -2;");
Daniel Jasper8822d3a2012-12-04 13:02:32 +00003710 verifyFormat("f(-1, -2, -3);");
3711 verifyFormat("a[-1] = 5;");
3712 verifyFormat("int a = 5 + -2;");
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003713 verifyFormat("if (i == -1) {\n}");
3714 verifyFormat("if (i != -1) {\n}");
3715 verifyFormat("if (i > -1) {\n}");
3716 verifyFormat("if (i < -1) {\n}");
Daniel Jasperd56a7372012-12-06 13:16:39 +00003717 verifyFormat("++(a->f());");
3718 verifyFormat("--(a->f());");
Daniel Jasper4abbb532013-01-14 12:18:19 +00003719 verifyFormat("(a->f())++;");
3720 verifyFormat("a[42]++;");
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003721 verifyFormat("if (!(a->f())) {\n}");
Daniel Jasper98e6b4a2012-12-21 09:41:31 +00003722
3723 verifyFormat("a-- > b;");
3724 verifyFormat("b ? -a : c;");
3725 verifyFormat("n * sizeof char16;");
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00003726 verifyFormat("n * alignof char16;", getGoogleStyle());
Daniel Jasper98e6b4a2012-12-21 09:41:31 +00003727 verifyFormat("sizeof(char);");
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00003728 verifyFormat("alignof(char);", getGoogleStyle());
Daniel Jasper1f0754b2013-01-02 15:26:16 +00003729
3730 verifyFormat("return -1;");
3731 verifyFormat("switch (a) {\n"
3732 "case -1:\n"
3733 " break;\n"
3734 "}");
Daniel Jasperb5985422013-03-22 10:44:43 +00003735 verifyFormat("#define X -1");
3736 verifyFormat("#define X -kConstant");
Nico Webercc191d12013-01-12 05:41:23 +00003737
3738 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = { -5, +3 };");
3739 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = { +5, -3 };");
Daniel Jasperb369c2c2013-01-15 14:27:39 +00003740
3741 verifyFormat("int a = /* confusing comment */ -1;");
3742 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case.
3743 verifyFormat("int a = i /* confusing comment */++;");
Daniel Jasperbac016b2012-12-03 18:12:45 +00003744}
3745
Daniel Jasper34f3d052013-08-21 08:39:01 +00003746TEST_F(FormatTest, IndentsRelativeToUnaryOperators) {
3747 verifyFormat("if (!aaaaaaaaaa( // break\n"
3748 " aaaaa)) {\n"
3749 "}");
3750 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
3751 " aaaaa));");
Daniel Jasper3618e6f2013-08-23 15:14:03 +00003752
3753 // Only indent relative to unary operators if the expression is nested.
3754 verifyFormat("*aaa = aaaaaaa( // break\n"
3755 " bbbbbb);");
Daniel Jasper34f3d052013-08-21 08:39:01 +00003756}
3757
Daniel Jasper332c6772013-08-26 08:10:17 +00003758TEST_F(FormatTest, UnderstandsOverloadedOperators) {
Daniel Jasperf6aef6a2012-12-24 10:56:04 +00003759 verifyFormat("bool operator<();");
3760 verifyFormat("bool operator>();");
3761 verifyFormat("bool operator=();");
3762 verifyFormat("bool operator==();");
3763 verifyFormat("bool operator!=();");
3764 verifyFormat("int operator+();");
3765 verifyFormat("int operator++();");
3766 verifyFormat("bool operator();");
3767 verifyFormat("bool operator()();");
3768 verifyFormat("bool operator[]();");
3769 verifyFormat("operator bool();");
Daniel Jasper2b4c9242013-02-11 08:01:18 +00003770 verifyFormat("operator int();");
3771 verifyFormat("operator void *();");
Daniel Jasperf6aef6a2012-12-24 10:56:04 +00003772 verifyFormat("operator SomeType<int>();");
Daniel Jasper2b4c9242013-02-11 08:01:18 +00003773 verifyFormat("operator SomeType<int, int>();");
3774 verifyFormat("operator SomeType<SomeType<int> >();");
Daniel Jasperf6aef6a2012-12-24 10:56:04 +00003775 verifyFormat("void *operator new(std::size_t size);");
3776 verifyFormat("void *operator new[](std::size_t size);");
3777 verifyFormat("void operator delete(void *ptr);");
3778 verifyFormat("void operator delete[](void *ptr);");
Daniel Jasper6ea933c2013-05-10 07:59:58 +00003779 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
3780 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);");
Daniel Jasper2b4c9242013-02-11 08:01:18 +00003781
Daniel Jasperdc2efa12013-02-15 19:24:08 +00003782 verifyFormat(
3783 "ostream &operator<<(ostream &OutputStream,\n"
3784 " SomeReallyLongType WithSomeReallyLongValue);");
Daniel Jasper27b91cc2013-04-05 17:21:59 +00003785 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
3786 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
3787 " return left.group < right.group;\n"
3788 "}");
Daniel Jasper2eb23b72013-04-11 08:48:20 +00003789 verifyFormat("SomeType &operator=(const SomeType &S);");
Daniel Jasperdc2efa12013-02-15 19:24:08 +00003790
Daniel Jasper2b4c9242013-02-11 08:01:18 +00003791 verifyGoogleFormat("operator void*();");
3792 verifyGoogleFormat("operator SomeType<SomeType<int>>();");
Daniel Jasper174f60f2013-09-02 09:20:39 +00003793
3794 verifyFormat("using A::operator+;");
Daniel Jasperbac016b2012-12-03 18:12:45 +00003795}
3796
Daniel Jasper088dab52013-01-11 16:09:04 +00003797TEST_F(FormatTest, UnderstandsNewAndDelete) {
Daniel Jasper37eff832013-02-23 08:07:18 +00003798 verifyFormat("void f() {\n"
3799 " A *a = new A;\n"
3800 " A *a = new (placement) A;\n"
3801 " delete a;\n"
3802 " delete (A *)a;\n"
3803 "}");
Daniel Jasper088dab52013-01-11 16:09:04 +00003804}
3805
Daniel Jasper5d334402013-01-02 08:57:10 +00003806TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
Manuel Klimek36fab8d2013-01-10 13:24:24 +00003807 verifyFormat("int *f(int *a) {}");
Manuel Klimek36fab8d2013-01-10 13:24:24 +00003808 verifyFormat("int main(int argc, char **argv) {}");
Daniel Jasperd0f349b2013-02-18 12:44:35 +00003809 verifyFormat("Test::Test(int b) : a(b * b) {}");
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003810 verifyIndependentOfContext("f(a, *a);");
Daniel Jasper8a5d7cd2013-03-01 17:13:29 +00003811 verifyFormat("void g() { f(*a); }");
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003812 verifyIndependentOfContext("int a = b * 10;");
3813 verifyIndependentOfContext("int a = 10 * b;");
3814 verifyIndependentOfContext("int a = b * c;");
3815 verifyIndependentOfContext("int a += b * c;");
3816 verifyIndependentOfContext("int a -= b * c;");
3817 verifyIndependentOfContext("int a *= b * c;");
3818 verifyIndependentOfContext("int a /= b * c;");
3819 verifyIndependentOfContext("int a = *b;");
3820 verifyIndependentOfContext("int a = *b * c;");
3821 verifyIndependentOfContext("int a = b * *c;");
3822 verifyIndependentOfContext("return 10 * b;");
3823 verifyIndependentOfContext("return *b * *c;");
3824 verifyIndependentOfContext("return a & ~b;");
3825 verifyIndependentOfContext("f(b ? *c : *d);");
3826 verifyIndependentOfContext("int a = b ? *c : *d;");
3827 verifyIndependentOfContext("*b = a;");
3828 verifyIndependentOfContext("a * ~b;");
3829 verifyIndependentOfContext("a * !b;");
3830 verifyIndependentOfContext("a * +b;");
3831 verifyIndependentOfContext("a * -b;");
3832 verifyIndependentOfContext("a * ++b;");
3833 verifyIndependentOfContext("a * --b;");
3834 verifyIndependentOfContext("a[4] * b;");
Daniel Jasper9c65b062013-02-27 11:43:50 +00003835 verifyIndependentOfContext("a[a * a] = 1;");
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003836 verifyIndependentOfContext("f() * b;");
3837 verifyIndependentOfContext("a * [self dostuff];");
Daniel Jasper81d2d382013-04-01 17:13:26 +00003838 verifyIndependentOfContext("int x = a * (a + b);");
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003839 verifyIndependentOfContext("(a *)(a + b);");
3840 verifyIndependentOfContext("int *pa = (int *)&a;");
Nico Weber95e8e462013-02-12 16:17:07 +00003841 verifyIndependentOfContext("return sizeof(int **);");
3842 verifyIndependentOfContext("return sizeof(int ******);");
3843 verifyIndependentOfContext("return (int **&)a;");
Daniel Jasper3ff4a2f2013-05-28 15:27:10 +00003844 verifyIndependentOfContext("f((*PointerToArray)[10]);");
Daniel Jasper8a5d7cd2013-03-01 17:13:29 +00003845 verifyFormat("void f(Type (*parameter)[10]) {}");
Nico Weber95e8e462013-02-12 16:17:07 +00003846 verifyGoogleFormat("return sizeof(int**);");
3847 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);");
3848 verifyGoogleFormat("Type** A = static_cast<Type**>(P);");
Daniel Jasper567dcf92013-09-05 09:29:45 +00003849 verifyFormat("auto a = [](int **&, int ***) {};");
Daniel Jasperdb8afe42013-09-10 10:26:38 +00003850 verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
Daniel Jasperc74e2792012-12-07 09:52:15 +00003851
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003852 verifyIndependentOfContext("InvalidRegions[*R] = 0;");
Daniel Jasper9bb0d282013-01-04 20:46:38 +00003853
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003854 verifyIndependentOfContext("A<int *> a;");
3855 verifyIndependentOfContext("A<int **> a;");
3856 verifyIndependentOfContext("A<int *, int *> a;");
Daniel Jasper4e778092013-02-06 10:05:46 +00003857 verifyIndependentOfContext(
3858 "const char *const p = reinterpret_cast<const char *const>(q);");
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003859 verifyIndependentOfContext("A<int **, int **> a;");
Daniel Jasper6b5ba8b2013-02-06 10:57:42 +00003860 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);");
Daniel Jasperd3cf17b2013-03-14 10:50:25 +00003861 verifyFormat("for (char **a = b; *a; ++a) {\n}");
Daniel Jasper16a69ef2013-05-03 14:41:24 +00003862 verifyFormat("for (; a && b;) {\n}");
Daniel Jasper8b39c662012-12-10 18:59:13 +00003863
Daniel Jasper2db356d2013-01-08 20:03:18 +00003864 verifyFormat(
3865 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3866 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
3867
Manuel Klimek36fab8d2013-01-10 13:24:24 +00003868 verifyGoogleFormat("int main(int argc, char** argv) {}");
Daniel Jasper8b39c662012-12-10 18:59:13 +00003869 verifyGoogleFormat("A<int*> a;");
3870 verifyGoogleFormat("A<int**> a;");
3871 verifyGoogleFormat("A<int*, int*> a;");
3872 verifyGoogleFormat("A<int**, int**> a;");
Daniel Jasper5d334402013-01-02 08:57:10 +00003873 verifyGoogleFormat("f(b ? *c : *d);");
3874 verifyGoogleFormat("int a = b ? *c : *d;");
Daniel Jasper48bd7b72013-01-16 16:04:06 +00003875 verifyGoogleFormat("Type* t = **x;");
3876 verifyGoogleFormat("Type* t = *++*x;");
3877 verifyGoogleFormat("*++*x;");
3878 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);");
3879 verifyGoogleFormat("Type* t = x++ * y;");
Daniel Jasper4e778092013-02-06 10:05:46 +00003880 verifyGoogleFormat(
3881 "const char* const p = reinterpret_cast<const char* const>(q);");
Manuel Klimek1b6f4bd2013-01-14 10:58:01 +00003882
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003883 verifyIndependentOfContext("a = *(x + y);");
3884 verifyIndependentOfContext("a = &(x + y);");
3885 verifyIndependentOfContext("*(x + y).call();");
3886 verifyIndependentOfContext("&(x + y)->call();");
Daniel Jasper8a5d7cd2013-03-01 17:13:29 +00003887 verifyFormat("void f() { &(*I).first; }");
Daniel Jasperb369c2c2013-01-15 14:27:39 +00003888
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003889 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
Daniel Jasperb369c2c2013-01-15 14:27:39 +00003890 verifyFormat(
3891 "int *MyValues = {\n"
3892 " *A, // Operator detection might be confused by the '{'\n"
3893 " *BB // Operator detection might be confused by previous comment\n"
3894 "};");
Nico Weber5096a442013-01-17 17:17:19 +00003895
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003896 verifyIndependentOfContext("if (int *a = &b)");
3897 verifyIndependentOfContext("if (int &a = *b)");
3898 verifyIndependentOfContext("if (a & b[i])");
3899 verifyIndependentOfContext("if (a::b::c::d & b[i])");
3900 verifyIndependentOfContext("if (*b[i])");
3901 verifyIndependentOfContext("if (int *a = (&b))");
3902 verifyIndependentOfContext("while (int *a = &b)");
Daniel Jasper65da8e92013-09-21 17:31:51 +00003903 verifyIndependentOfContext("size = sizeof *a;");
Daniel Jasper20d35832013-01-23 12:58:14 +00003904 verifyFormat("void f() {\n"
3905 " for (const int &v : Values) {\n"
3906 " }\n"
3907 "}");
Daniel Jasperd0f349b2013-02-18 12:44:35 +00003908 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
3909 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
Daniel Jasper7e274002013-09-11 20:37:10 +00003910 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}");
Daniel Jasperffee1712013-01-22 11:46:26 +00003911
Daniel Jasper378d93d2013-05-13 07:14:40 +00003912 verifyFormat("#define MACRO \\\n"
3913 " int *i = a * b; \\\n"
3914 " void f(a *b);",
3915 getLLVMStyleWithColumns(19));
3916
Daniel Jasper6f21a982013-03-13 07:49:51 +00003917 verifyIndependentOfContext("A = new SomeType *[Length];");
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003918 verifyIndependentOfContext("A = new SomeType *[Length]();");
Daniel Jasperd6104f62013-07-05 13:30:40 +00003919 verifyIndependentOfContext("T **t = new T *;");
3920 verifyIndependentOfContext("T **t = new T *();");
Daniel Jasperffee1712013-01-22 11:46:26 +00003921 verifyGoogleFormat("A = new SomeType* [Length]();");
Daniel Jasper6f21a982013-03-13 07:49:51 +00003922 verifyGoogleFormat("A = new SomeType* [Length];");
Daniel Jasperd6104f62013-07-05 13:30:40 +00003923 verifyGoogleFormat("T** t = new T*;");
3924 verifyGoogleFormat("T** t = new T*();");
Daniel Jasper378d93d2013-05-13 07:14:40 +00003925
Daniel Jasperdbef71e2013-05-07 14:17:18 +00003926 FormatStyle PointerLeft = getLLVMStyle();
3927 PointerLeft.PointerBindsToType = true;
3928 verifyFormat("delete *x;", PointerLeft);
Daniel Jasper8a5d7cd2013-03-01 17:13:29 +00003929}
Daniel Jasper8ff690a2013-02-06 14:22:40 +00003930
Daniel Jaspere0fa4c52013-07-17 20:25:02 +00003931TEST_F(FormatTest, UnderstandsAttributes) {
3932 verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
3933}
3934
Daniel Jasperf0220182013-05-06 06:35:44 +00003935TEST_F(FormatTest, UnderstandsEllipsis) {
3936 verifyFormat("int printf(const char *fmt, ...);");
3937 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
Daniel Jasperc47d7f12013-07-01 09:47:25 +00003938 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}");
3939
3940 FormatStyle PointersLeft = getLLVMStyle();
3941 PointersLeft.PointerBindsToType = true;
3942 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft);
Daniel Jasperf0220182013-05-06 06:35:44 +00003943}
3944
Daniel Jasper8a5d7cd2013-03-01 17:13:29 +00003945TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
Daniel Jasper8ff690a2013-02-06 14:22:40 +00003946 EXPECT_EQ("int *a;\n"
3947 "int *a;\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003948 "int *a;",
3949 format("int *a;\n"
3950 "int* a;\n"
3951 "int *a;",
3952 getGoogleStyle()));
Daniel Jasper8ff690a2013-02-06 14:22:40 +00003953 EXPECT_EQ("int* a;\n"
3954 "int* a;\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003955 "int* a;",
3956 format("int* a;\n"
3957 "int* a;\n"
3958 "int *a;",
3959 getGoogleStyle()));
Daniel Jasper8ff690a2013-02-06 14:22:40 +00003960 EXPECT_EQ("int *a;\n"
3961 "int *a;\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003962 "int *a;",
3963 format("int *a;\n"
3964 "int * a;\n"
3965 "int * a;",
3966 getGoogleStyle()));
Daniel Jasperbac016b2012-12-03 18:12:45 +00003967}
3968
Alexander Kornienko3fd9ccd2013-03-12 16:28:18 +00003969TEST_F(FormatTest, UnderstandsRvalueReferences) {
3970 verifyFormat("int f(int &&a) {}");
3971 verifyFormat("int f(int a, char &&b) {}");
3972 verifyFormat("void f() { int &&a = b; }");
3973 verifyGoogleFormat("int f(int a, char&& b) {}");
3974 verifyGoogleFormat("void f() { int&& a = b; }");
3975
Daniel Jasper131884a2013-05-27 16:36:33 +00003976 verifyIndependentOfContext("A<int &&> a;");
3977 verifyIndependentOfContext("A<int &&, int &&> a;");
3978 verifyGoogleFormat("A<int&&> a;");
3979 verifyGoogleFormat("A<int&&, int&&> a;");
Daniel Jasperb7000ca2013-08-01 17:58:23 +00003980
3981 // Not rvalue references:
3982 verifyFormat("template <bool B, bool C> class A {\n"
3983 " static_assert(B && C, \"Something is wrong\");\n"
3984 "};");
Daniel Jasperb644dd62013-08-13 09:09:09 +00003985 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))");
3986 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))");
Alexander Kornienko3fd9ccd2013-03-12 16:28:18 +00003987}
3988
Manuel Klimeka32a7fd2013-01-23 14:08:21 +00003989TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
3990 verifyFormat("void f() {\n"
3991 " x[aaaaaaaaa -\n"
Daniel Jasperbf71ba22013-04-08 20:33:42 +00003992 " b] = 23;\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003993 "}",
3994 getLLVMStyleWithColumns(15));
Manuel Klimeka32a7fd2013-01-23 14:08:21 +00003995}
3996
Daniel Jasper4981bd02013-01-13 08:01:36 +00003997TEST_F(FormatTest, FormatsCasts) {
3998 verifyFormat("Type *A = static_cast<Type *>(P);");
3999 verifyFormat("Type *A = (Type *)P;");
4000 verifyFormat("Type *A = (vector<Type *, int *>)P;");
4001 verifyFormat("int a = (int)(2.0f);");
Daniel Jasperb8b42952013-05-31 16:14:28 +00004002 verifyFormat("int a = (int)2.0f;");
4003 verifyFormat("x[(int32)y];");
4004 verifyFormat("x = (int32)y;");
4005 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
4006 verifyFormat("int a = (int)*b;");
4007 verifyFormat("int a = (int)2.0f;");
4008 verifyFormat("int a = (int)~0;");
4009 verifyFormat("int a = (int)++a;");
4010 verifyFormat("int a = (int)sizeof(int);");
4011 verifyFormat("int a = (int)+2;");
4012 verifyFormat("my_int a = (my_int)2.0f;");
4013 verifyFormat("my_int a = (my_int)sizeof(int);");
Daniel Jasperff1a2e52013-06-06 08:20:20 +00004014 verifyFormat("return (my_int)aaa;");
Daniel Jasper0c368782013-07-15 15:04:42 +00004015 verifyFormat("#define x ((int)-1)");
4016 verifyFormat("#define p(q) ((int *)&q)");
Daniel Jasper4981bd02013-01-13 08:01:36 +00004017
Daniel Jasperb8b42952013-05-31 16:14:28 +00004018 // FIXME: Without type knowledge, this can still fall apart miserably.
4019 verifyFormat("void f() { my_int a = (my_int) * b; }");
Alexander Kornienko2785b9a2013-06-07 16:02:52 +00004020 verifyFormat("void f() { return P ? (my_int) * P : (my_int)0; }");
Daniel Jasperb8b42952013-05-31 16:14:28 +00004021 verifyFormat("my_int a = (my_int) ~0;");
4022 verifyFormat("my_int a = (my_int)++ a;");
4023 verifyFormat("my_int a = (my_int) + 2;");
Daniel Jasper4981bd02013-01-13 08:01:36 +00004024
Daniel Jasper5e2169f2013-07-18 14:46:07 +00004025 // Don't break after a cast's
4026 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
4027 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
4028 " bbbbbbbbbbbbbbbbbbbbbb);");
4029
Daniel Jasper4981bd02013-01-13 08:01:36 +00004030 // These are not casts.
4031 verifyFormat("void f(int *) {}");
Nico Weber6fa7e742013-02-13 04:32:57 +00004032 verifyFormat("f(foo)->b;");
4033 verifyFormat("f(foo).b;");
4034 verifyFormat("f(foo)(b);");
4035 verifyFormat("f(foo)[b];");
Daniel Jasper567dcf92013-09-05 09:29:45 +00004036 verifyFormat("[](foo) { return 4; }(bar);");
Nico Weber6fa7e742013-02-13 04:32:57 +00004037 verifyFormat("(*funptr)(foo)[4];");
4038 verifyFormat("funptrs[4](foo)[4];");
Daniel Jasper4981bd02013-01-13 08:01:36 +00004039 verifyFormat("void f(int *);");
4040 verifyFormat("void f(int *) = 0;");
4041 verifyFormat("void f(SmallVector<int>) {}");
4042 verifyFormat("void f(SmallVector<int>);");
4043 verifyFormat("void f(SmallVector<int>) = 0;");
Nico Weber77280572013-02-09 18:02:07 +00004044 verifyFormat("void f(int i = (kValue) * kMask) {}");
4045 verifyFormat("void f(int i = (kA * kB) & kMask) {}");
Nico Weber6fa7e742013-02-13 04:32:57 +00004046 verifyFormat("int a = sizeof(int) * b;");
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00004047 verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
Daniel Jasperff1a2e52013-06-06 08:20:20 +00004048 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
4049 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
Daniel Jasper526df0f2013-07-08 14:58:01 +00004050 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
Daniel Jasperfaab0d32013-02-27 09:47:53 +00004051
Daniel Jasper37eff832013-02-23 08:07:18 +00004052 // These are not casts, but at some point were confused with casts.
4053 verifyFormat("virtual void foo(int *) override;");
4054 verifyFormat("virtual void foo(char &) const;");
4055 verifyFormat("virtual void foo(int *a, char *) const;");
Daniel Jasper6a365aa2013-03-13 17:13:53 +00004056 verifyFormat("int a = sizeof(int *) + b;");
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00004057 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
Daniel Jasper198c8bf2013-07-05 07:58:34 +00004058
4059 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
4060 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
Daniel Jasper011c35d2013-07-12 11:19:37 +00004061 // FIXME: The indentation here is not ideal.
Daniel Jasper07ca5472013-07-05 09:14:35 +00004062 verifyFormat(
Daniel Jasper011c35d2013-07-12 11:19:37 +00004063 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4064 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
4065 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];");
Daniel Jasper4981bd02013-01-13 08:01:36 +00004066}
4067
Daniel Jasper46ef8522013-01-10 13:08:12 +00004068TEST_F(FormatTest, FormatsFunctionTypes) {
Daniel Jasper46ef8522013-01-10 13:08:12 +00004069 verifyFormat("A<bool()> a;");
4070 verifyFormat("A<SomeType()> a;");
Daniel Jasper431f5912013-05-28 08:33:00 +00004071 verifyFormat("A<void (*)(int, std::string)> a;");
Daniel Jasper9322aae2013-03-20 09:53:18 +00004072 verifyFormat("A<void *(int)>;");
Daniel Jasper81d2d382013-04-01 17:13:26 +00004073 verifyFormat("void *(*a)(int *, SomeType *);");
Daniel Jasper8a5d7cd2013-03-01 17:13:29 +00004074 verifyFormat("int (*func)(void *);");
Daniel Jasper431f5912013-05-28 08:33:00 +00004075 verifyFormat("void f() { int (*func)(void *); }");
Daniel Jasper53352602013-08-12 12:16:34 +00004076 verifyFormat("template <class CallbackClass>\n"
4077 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);");
Daniel Jasper9322aae2013-03-20 09:53:18 +00004078
Daniel Jasper81d2d382013-04-01 17:13:26 +00004079 verifyGoogleFormat("A<void*(int*, SomeType*)>;");
4080 verifyGoogleFormat("void* (*a)(int);");
Daniel Jasper53352602013-08-12 12:16:34 +00004081 verifyGoogleFormat(
4082 "template <class CallbackClass>\n"
4083 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);");
Daniel Jasper7424d792013-05-14 08:34:47 +00004084
Daniel Jaspera8fda852013-05-15 07:51:51 +00004085 // Other constructs can look somewhat like function types:
Daniel Jasper7424d792013-05-14 08:34:47 +00004086 verifyFormat("A<sizeof(*x)> a;");
Daniel Jaspera8fda852013-05-15 07:51:51 +00004087 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
Daniel Jaspere7d3bff2013-07-16 11:37:21 +00004088 verifyFormat("some_var = function(*some_pointer_var)[0];");
4089 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
Daniel Jasper46ef8522013-01-10 13:08:12 +00004090}
4091
Daniel Jasper3c08a812013-02-24 18:54:32 +00004092TEST_F(FormatTest, BreaksLongDeclarations) {
Daniel Jasper53e72cd2013-05-06 08:27:33 +00004093 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00004094 " AnotherNameForTheLongType;",
4095 getGoogleStyle());
Daniel Jasper53e72cd2013-05-06 08:27:33 +00004096 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00004097 " LoooooooooooooooooooooooooooooooooooooooongVariable;",
4098 getGoogleStyle());
Daniel Jasper6ac431c2013-07-02 09:47:29 +00004099 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
4100 " LoooooooooooooooooooooooooooooooooooooooongVariable;",
4101 getGoogleStyle());
Daniel Jasper53e72cd2013-05-06 08:27:33 +00004102 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00004103 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();",
4104 getGoogleStyle());
Daniel Jasper53e72cd2013-05-06 08:27:33 +00004105 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
4106 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasper6ac431c2013-07-02 09:47:29 +00004107 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
4108 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasper53e72cd2013-05-06 08:27:33 +00004109
4110 // FIXME: Without the comment, this breaks after "(".
Manuel Klimeka9a7f102013-06-21 17:25:42 +00004111 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n"
4112 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();",
4113 getGoogleStyle());
Daniel Jasper53e72cd2013-05-06 08:27:33 +00004114
Daniel Jasper83f25ba2013-01-28 15:16:31 +00004115 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00004116 " int LoooooooooooooooooooongParam2) {}");
Daniel Jasper4dc41de2013-01-02 08:44:14 +00004117 verifyFormat(
Daniel Jasper1407bee2013-04-11 14:29:13 +00004118 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
4119 " SourceLocation L, IdentifierIn *II,\n"
4120 " Type *T) {}");
Daniel Jasper3c08a812013-02-24 18:54:32 +00004121 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
4122 "ReallyReallyLongFunctionName(\n"
4123 " const std::string &SomeParameter,\n"
4124 " const SomeType<string, SomeOtherTemplateParameter> &\n"
4125 " ReallyReallyLongParameterName,\n"
4126 " const SomeType<string, SomeOtherTemplateParameter> &\n"
4127 " AnotherLongParameterName) {}");
Daniel Jasper33f4b902013-05-15 09:35:08 +00004128 verifyFormat("template <typename A>\n"
4129 "SomeLoooooooooooooooooooooongType<\n"
4130 " typename some_namespace::SomeOtherType<A>::Type>\n"
4131 "Function() {}");
Daniel Jasper3c08a812013-02-24 18:54:32 +00004132
Daniel Jasperd75ff642013-01-28 15:40:20 +00004133 verifyGoogleFormat(
Daniel Jasper92495a82013-08-19 10:16:18 +00004134 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
4135 " aaaaaaaaaaaaaaaaaaaaaaa;");
4136 verifyGoogleFormat(
Daniel Jasperfaab0d32013-02-27 09:47:53 +00004137 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
4138 " SourceLocation L) {}");
Daniel Jaspera03ab102013-02-13 20:33:44 +00004139 verifyGoogleFormat(
4140 "some_namespace::LongReturnType\n"
4141 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00004142 " int first_long_parameter, int second_parameter) {}");
Daniel Jaspera03ab102013-02-13 20:33:44 +00004143
4144 verifyGoogleFormat("template <typename T>\n"
4145 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00004146 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
Daniel Jasperb6f02f32013-02-28 10:06:05 +00004147 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4148 " int aaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper4dc41de2013-01-02 08:44:14 +00004149}
4150
Daniel Jasper011c35d2013-07-12 11:19:37 +00004151TEST_F(FormatTest, FormatsArrays) {
4152 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
4153 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
4154 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4155 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
4156 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4157 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
4158 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4159 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
4160 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
4161 verifyFormat(
4162 "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
4163 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
4164 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
4165}
4166
Daniel Jasper3b5943f2012-12-06 09:56:08 +00004167TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
4168 verifyFormat("(a)->b();");
4169 verifyFormat("--a;");
4170}
4171
Daniel Jasper8822d3a2012-12-04 13:02:32 +00004172TEST_F(FormatTest, HandlesIncludeDirectives) {
Daniel Jasper2b9c10b2013-01-14 15:52:06 +00004173 verifyFormat("#include <string>\n"
4174 "#include <a/b/c.h>\n"
4175 "#include \"a/b/string\"\n"
4176 "#include \"string.h\"\n"
4177 "#include \"string.h\"\n"
Manuel Klimek407a31a2013-01-15 15:50:27 +00004178 "#include <a-a>\n"
Daniel Jasper3a204412013-02-23 07:46:38 +00004179 "#include < path with space >\n"
Daniel Jasper7ff96ed2013-05-06 10:24:51 +00004180 "#include \"abc.h\" // this is included for ABC\n"
Daniel Jasper5d5b4242013-05-16 12:59:13 +00004181 "#include \"some long include\" // with a comment\n"
Daniel Jasper3a204412013-02-23 07:46:38 +00004182 "#include \"some very long include paaaaaaaaaaaaaaaaaaaaaaath\"",
4183 getLLVMStyleWithColumns(35));
Nico Weberb23ae0c2012-12-21 18:21:56 +00004184
Daniel Jasper8134e1e2013-01-13 08:12:18 +00004185 verifyFormat("#import <string>");
4186 verifyFormat("#import <a/b/c.h>");
4187 verifyFormat("#import \"a/b/string\"");
4188 verifyFormat("#import \"string.h\"");
4189 verifyFormat("#import \"string.h\"");
Daniel Jaspera4dd9822013-08-28 08:24:04 +00004190 verifyFormat("#if __has_include(<strstream>)\n"
4191 "#include <strstream>\n"
4192 "#endif");
Daniel Jasper8822d3a2012-12-04 13:02:32 +00004193}
4194
Alexander Kornienko15757312012-12-06 18:03:27 +00004195//===----------------------------------------------------------------------===//
4196// Error recovery tests.
4197//===----------------------------------------------------------------------===//
4198
Daniel Jasperc5cfa492013-02-14 09:19:04 +00004199TEST_F(FormatTest, IncompleteParameterLists) {
Daniel Jasperfaab0d32013-02-27 09:47:53 +00004200 FormatStyle NoBinPacking = getLLVMStyle();
4201 NoBinPacking.BinPackParameters = false;
4202 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
4203 " double *min_x,\n"
4204 " double *max_x,\n"
4205 " double *min_y,\n"
4206 " double *max_y,\n"
4207 " double *min_z,\n"
4208 " double *max_z, ) {}",
4209 NoBinPacking);
Daniel Jasperc5cfa492013-02-14 09:19:04 +00004210}
4211
Daniel Jasper700e7102013-01-10 09:26:47 +00004212TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
Alexander Kornienko51c23fa2013-01-16 11:45:16 +00004213 verifyFormat("void f() { return; }\n42");
4214 verifyFormat("void f() {\n"
4215 " if (0)\n"
4216 " return;\n"
4217 "}\n"
4218 "42");
Alexander Kornienkod8818752013-01-16 11:43:46 +00004219 verifyFormat("void f() { return }\n42");
4220 verifyFormat("void f() {\n"
4221 " if (0)\n"
4222 " return\n"
4223 "}\n"
4224 "42");
4225}
4226
4227TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
4228 EXPECT_EQ("void f() { return }", format("void f ( ) { return }"));
4229 EXPECT_EQ("void f() {\n"
4230 " if (a)\n"
4231 " return\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004232 "}",
4233 format("void f ( ) { if ( a ) return }"));
Daniel Jasper5be59ba2013-05-15 14:09:55 +00004234 EXPECT_EQ("namespace N {\n"
4235 "void f()\n"
4236 "}",
4237 format("namespace N { void f() }"));
Alexander Kornienkod8818752013-01-16 11:43:46 +00004238 EXPECT_EQ("namespace N {\n"
4239 "void f() {}\n"
4240 "void g()\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004241 "}",
4242 format("namespace N { void f( ) { } void g( ) }"));
Daniel Jasper700e7102013-01-10 09:26:47 +00004243}
4244
Daniel Jasperceb99ab2013-01-09 10:16:05 +00004245TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
4246 verifyFormat("int aaaaaaaa =\n"
Alexander Kornienko5262dd92013-03-27 11:52:18 +00004247 " // Overlylongcomment\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004248 " b;",
4249 getLLVMStyleWithColumns(20));
Daniel Jasperceb99ab2013-01-09 10:16:05 +00004250 verifyFormat("function(\n"
4251 " ShortArgument,\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004252 " LoooooooooooongArgument);\n",
4253 getLLVMStyleWithColumns(20));
Daniel Jasperceb99ab2013-01-09 10:16:05 +00004254}
4255
Alexander Kornienko56e49c52012-12-10 16:34:48 +00004256TEST_F(FormatTest, IncorrectAccessSpecifier) {
4257 verifyFormat("public:");
4258 verifyFormat("class A {\n"
4259 "public\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +00004260 " void f() {}\n"
Alexander Kornienko56e49c52012-12-10 16:34:48 +00004261 "};");
4262 verifyFormat("public\n"
4263 "int qwerty;");
4264 verifyFormat("public\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +00004265 "B {}");
Alexander Kornienko56e49c52012-12-10 16:34:48 +00004266 verifyFormat("public\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +00004267 "{}");
Alexander Kornienko56e49c52012-12-10 16:34:48 +00004268 verifyFormat("public\n"
Manuel Klimek517e8942013-01-11 17:54:10 +00004269 "B { int x; }");
Alexander Kornienko56e49c52012-12-10 16:34:48 +00004270}
Daniel Jasperbac016b2012-12-03 18:12:45 +00004271
Daniel Jasper92f9faf2013-03-20 15:58:10 +00004272TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
4273 verifyFormat("{");
4274 verifyFormat("#})");
4275}
Alexander Kornienko393b0082012-12-04 15:40:36 +00004276
4277TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004278 verifyFormat("do {\n}");
4279 verifyFormat("do {\n}\n"
Alexander Kornienko393b0082012-12-04 15:40:36 +00004280 "f();");
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004281 verifyFormat("do {\n}\n"
Alexander Kornienko393b0082012-12-04 15:40:36 +00004282 "wheeee(fun);");
4283 verifyFormat("do {\n"
4284 " f();\n"
Manuel Klimekde768542013-01-07 18:10:23 +00004285 "}");
Alexander Kornienko393b0082012-12-04 15:40:36 +00004286}
4287
Manuel Klimek6eca03f2013-01-11 19:23:05 +00004288TEST_F(FormatTest, IncorrectCodeMissingParens) {
Manuel Klimekd4658432013-01-11 18:28:36 +00004289 verifyFormat("if {\n foo;\n foo();\n}");
Manuel Klimek6eca03f2013-01-11 19:23:05 +00004290 verifyFormat("switch {\n foo;\n foo();\n}");
4291 verifyFormat("for {\n foo;\n foo();\n}");
4292 verifyFormat("while {\n foo;\n foo();\n}");
4293 verifyFormat("do {\n foo;\n foo();\n} while;");
Manuel Klimekd4658432013-01-11 18:28:36 +00004294}
4295
Daniel Jasper1f42f112013-01-04 18:52:56 +00004296TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
4297 verifyFormat("namespace {\n"
Daniel Jasperf7ec1cc2013-05-31 14:56:29 +00004298 "class Foo { Foo (\n"
4299 "};\n"
4300 "} // comment");
Daniel Jasper1f42f112013-01-04 18:52:56 +00004301}
4302
Alexander Kornienkocff563c2012-12-04 17:27:50 +00004303TEST_F(FormatTest, IncorrectCodeErrorDetection) {
Manuel Klimek36fab8d2013-01-10 13:24:24 +00004304 EXPECT_EQ("{\n{}\n", format("{\n{\n}\n"));
4305 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n"));
4306 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n"));
4307 EXPECT_EQ("{\n {}\n }\n}\n", format("{\n {\n }\n }\n}\n"));
Alexander Kornienkocff563c2012-12-04 17:27:50 +00004308
Alexander Kornienkocff563c2012-12-04 17:27:50 +00004309 EXPECT_EQ("{\n"
4310 " {\n"
4311 " breakme(\n"
4312 " qwe);\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004313 "}\n",
4314 format("{\n"
4315 " {\n"
4316 " breakme(qwe);\n"
4317 "}\n",
4318 getLLVMStyleWithColumns(10)));
Alexander Kornienkocff563c2012-12-04 17:27:50 +00004319}
4320
Manuel Klimek2851c162013-01-10 14:36:46 +00004321TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004322 verifyFormat("int x = {\n"
4323 " avariable,\n"
4324 " b(alongervariable)\n"
4325 "};",
4326 getLLVMStyleWithColumns(25));
Manuel Klimek2851c162013-01-10 14:36:46 +00004327}
4328
Manuel Klimekc44ee892013-01-21 10:07:49 +00004329TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
4330 verifyFormat("return (a)(b) { 1, 2, 3 };");
4331}
4332
Manuel Klimek80829bd2013-05-23 09:41:43 +00004333TEST_F(FormatTest, LayoutCxx11ConstructorBraceInitializers) {
Daniel Jasper2424eef2013-05-23 10:15:45 +00004334 verifyFormat("vector<int> x{ 1, 2, 3, 4 };");
4335 verifyFormat("vector<T> x{ {}, {}, {}, {} };");
Manuel Klimek80829bd2013-05-23 09:41:43 +00004336 verifyFormat("f({ 1, 2 });");
Daniel Jasper2424eef2013-05-23 10:15:45 +00004337 verifyFormat("auto v = Foo{ 1 };");
Manuel Klimek80829bd2013-05-23 09:41:43 +00004338 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });");
Daniel Jasperde0d61f2013-05-23 18:29:16 +00004339 verifyFormat("Class::Class : member{ 1, 2, 3 } {}");
Daniel Jasperce933562013-05-23 21:35:49 +00004340 verifyFormat("new vector<int>{ 1, 2, 3 };");
4341 verifyFormat("new int[3]{ 1, 2, 3 };");
Daniel Jasperde0d61f2013-05-23 18:29:16 +00004342 verifyFormat("return { arg1, arg2 };");
Daniel Jasper88959b72013-05-28 18:50:02 +00004343 verifyFormat("return { arg1, SomeType{ parameter } };");
Daniel Jasperde0d61f2013-05-23 18:29:16 +00004344 verifyFormat("new T{ arg1, arg2 };");
Daniel Jasperac885cd2013-09-13 10:55:31 +00004345 verifyFormat("f(MyMap[{ composite, key }]);");
Daniel Jasperde0d61f2013-05-23 18:29:16 +00004346 verifyFormat("class Class {\n"
4347 " T member = { arg1, arg2 };\n"
4348 "};");
Daniel Jaspereb483662013-05-31 10:09:55 +00004349 verifyFormat(
4350 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4351 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
4352 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
4353 " bbbbbbbbbbbbbbbbbbbb, bbbbb };");
Daniel Jasper02eacc22013-07-01 09:15:46 +00004354 verifyFormat("DoSomethingWithVector({} /* No data */);");
Daniel Jasperf50dbfa2013-07-01 16:43:38 +00004355 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });");
Daniel Jasper0de1c4d2013-07-09 09:06:29 +00004356 verifyFormat(
4357 "someFunction(OtherParam, BracedList{\n"
Daniel Jasperb1491792013-07-09 11:57:27 +00004358 " // comment 1 (Forcing interesting break)\n"
Daniel Jasper0de1c4d2013-07-09 09:06:29 +00004359 " param1, param2,\n"
4360 " // comment 2\n"
4361 " param3, param4\n"
4362 " });");
Daniel Jasperf439dcb2013-08-28 07:50:37 +00004363 verifyFormat(
4364 "std::this_thread::sleep_for(\n"
4365 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);");
Daniel Jasper2424eef2013-05-23 10:15:45 +00004366
4367 FormatStyle NoSpaces = getLLVMStyle();
Daniel Jasperb5dc3f42013-07-16 18:22:10 +00004368 NoSpaces.Cpp11BracedListStyle = true;
Daniel Jasper2424eef2013-05-23 10:15:45 +00004369 verifyFormat("vector<int> x{1, 2, 3, 4};", NoSpaces);
4370 verifyFormat("vector<T> x{{}, {}, {}, {}};", NoSpaces);
4371 verifyFormat("f({1, 2});", NoSpaces);
Daniel Jasper1bee0732013-05-23 18:05:18 +00004372 verifyFormat("auto v = Foo{-1};", NoSpaces);
Daniel Jasper2424eef2013-05-23 10:15:45 +00004373 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});", NoSpaces);
Daniel Jasperde0d61f2013-05-23 18:29:16 +00004374 verifyFormat("Class::Class : member{1, 2, 3} {}", NoSpaces);
Daniel Jasperce933562013-05-23 21:35:49 +00004375 verifyFormat("new vector<int>{1, 2, 3};", NoSpaces);
4376 verifyFormat("new int[3]{1, 2, 3};", NoSpaces);
Daniel Jasperde0d61f2013-05-23 18:29:16 +00004377 verifyFormat("return {arg1, arg2};", NoSpaces);
Daniel Jasper88959b72013-05-28 18:50:02 +00004378 verifyFormat("return {arg1, SomeType{parameter}};", NoSpaces);
Daniel Jasperde0d61f2013-05-23 18:29:16 +00004379 verifyFormat("new T{arg1, arg2};", NoSpaces);
Daniel Jasperac885cd2013-09-13 10:55:31 +00004380 verifyFormat("f(MyMap[{composite, key}]);", NoSpaces);
Daniel Jasperde0d61f2013-05-23 18:29:16 +00004381 verifyFormat("class Class {\n"
4382 " T member = {arg1, arg2};\n"
4383 "};",
4384 NoSpaces);
Manuel Klimek80829bd2013-05-23 09:41:43 +00004385}
4386
Daniel Jasperd4a03db2013-08-22 15:00:41 +00004387TEST_F(FormatTest, FormatsBracedListsinColumnLayout) {
4388 verifyFormat("vector<int> x = { 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4389 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4390 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4391 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4392 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4393 " 1, 22, 333, 4444, 55555, 666666, 7777777 };");
4394 verifyFormat("vector<int> x = { 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4395 " // line comment\n"
4396 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4397 " 1, 22, 333, 4444, 55555,\n"
4398 " // line comment\n"
4399 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4400 " 1, 22, 333, 4444, 55555, 666666, 7777777 };");
4401 verifyFormat(
4402 "vector<int> x = { 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4403 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4404 " 1, 22, 333, 4444, 55555, 666666, // comment\n"
4405 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
4406 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
4407 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
4408 " 7777777 };");
4409 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
4410 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
4411 " X86::R8, X86::R9, X86::R10, X86::R11, 0\n"
4412 "};");
4413 verifyFormat("vector<int> x = { 1, 1, 1, 1,\n"
4414 " 1, 1, 1, 1 };",
4415 getLLVMStyleWithColumns(39));
4416 verifyFormat("vector<int> x = { 1, 1, 1, 1,\n"
4417 " 1, 1, 1, 1 };",
4418 getLLVMStyleWithColumns(38));
4419 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
4420 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1\n"
4421 "};",
4422 getLLVMStyleWithColumns(40));
Daniel Jaspered51c022013-08-23 10:05:49 +00004423
4424 // Trailing commas.
4425 verifyFormat("vector<int> x = { 1, 1, 1, 1,\n"
4426 " 1, 1, 1, 1, };",
4427 getLLVMStyleWithColumns(39));
4428 verifyFormat("vector<int> x = {\n"
4429 " 1, 1, 1, 1, 1, 1, 1, 1, //\n"
4430 "};",
4431 getLLVMStyleWithColumns(39));
Daniel Jasper332c6772013-08-26 08:10:17 +00004432 verifyFormat("vector<int> x = { 1, 1, 1, 1,\n"
4433 " 1, 1, 1, 1,\n"
4434 " /**/ /**/ };",
4435 getLLVMStyleWithColumns(39));
Daniel Jasper451f1e02013-08-27 08:43:47 +00004436 verifyFormat("return { { aaaaaaaaaaaaaaaaaaaaa }, { aaaaaaaaaaaaaaaaaaa },\n"
4437 " { aaaaaaaaaaaaaaaaaaaaa }, { aaaaaaaaaaaaaaaaa } };",
4438 getLLVMStyleWithColumns(60));
Daniel Jasperd4a03db2013-08-22 15:00:41 +00004439}
4440
Manuel Klimek517e8942013-01-11 17:54:10 +00004441TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
4442 verifyFormat("void f() { return 42; }");
4443 verifyFormat("void f() {\n"
4444 " // Comment\n"
4445 "}");
4446 verifyFormat("{\n"
4447 "#error {\n"
4448 " int a;\n"
4449 "}");
4450 verifyFormat("{\n"
4451 " int a;\n"
4452 "#error {\n"
4453 "}");
Daniel Jasper058f6f82013-05-16 10:17:39 +00004454 verifyFormat("void f() {} // comment");
4455 verifyFormat("void f() { int a; } // comment");
Daniel Jasper9e5b6c32013-05-16 16:54:34 +00004456 verifyFormat("void f() {\n"
4457 "} // comment",
4458 getLLVMStyleWithColumns(15));
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004459
4460 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
4461 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22));
4462
4463 verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
4464 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
Manuel Klimek517e8942013-01-11 17:54:10 +00004465}
4466
Manuel Klimek47ea7f62013-01-15 13:38:33 +00004467TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
4468 // Elaborate type variable declarations.
Manuel Klimek606e07e2013-01-11 18:13:04 +00004469 verifyFormat("struct foo a = { bar };\nint n;");
Manuel Klimek47ea7f62013-01-15 13:38:33 +00004470 verifyFormat("class foo a = { bar };\nint n;");
4471 verifyFormat("union foo a = { bar };\nint n;");
4472
4473 // Elaborate types inside function definitions.
4474 verifyFormat("struct foo f() {}\nint n;");
4475 verifyFormat("class foo f() {}\nint n;");
4476 verifyFormat("union foo f() {}\nint n;");
4477
4478 // Templates.
4479 verifyFormat("template <class X> void f() {}\nint n;");
4480 verifyFormat("template <struct X> void f() {}\nint n;");
4481 verifyFormat("template <union X> void f() {}\nint n;");
4482
4483 // Actual definitions...
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004484 verifyFormat("struct {\n} n;");
4485 verifyFormat(
4486 "template <template <class T, class Y>, class Z> class X {\n} n;");
Manuel Klimek47ea7f62013-01-15 13:38:33 +00004487 verifyFormat("union Z {\n int n;\n} x;");
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004488 verifyFormat("class MACRO Z {\n} n;");
4489 verifyFormat("class MACRO(X) Z {\n} n;");
4490 verifyFormat("class __attribute__(X) Z {\n} n;");
4491 verifyFormat("class __declspec(X) Z {\n} n;");
Manuel Klimekb8b1ce12013-02-06 15:57:54 +00004492 verifyFormat("class A##B##C {\n} n;");
Manuel Klimek3d712892013-10-07 09:15:41 +00004493 verifyFormat("class alignas(16) Z {\n} n;");
Manuel Klimek47ea7f62013-01-15 13:38:33 +00004494
Manuel Klimek7f5b0252013-01-21 10:17:14 +00004495 // Redefinition from nested context:
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004496 verifyFormat("class A::B::C {\n} n;");
Manuel Klimek7f5b0252013-01-21 10:17:14 +00004497
Manuel Klimek3a3408c2013-01-21 13:58:54 +00004498 // Template definitions.
Daniel Jasper5d823e32013-05-15 13:46:48 +00004499 verifyFormat(
4500 "template <typename F>\n"
4501 "Matcher(const Matcher<F> &Other,\n"
4502 " typename enable_if_c<is_base_of<F, T>::value &&\n"
4503 " !is_same<F, T>::value>::type * = 0)\n"
4504 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
4505
Manuel Klimek3a3408c2013-01-21 13:58:54 +00004506 // FIXME: This is still incorrectly handled at the formatter side.
Daniel Jasper0236dd02013-07-30 22:37:19 +00004507 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
Manuel Klimek3a3408c2013-01-21 13:58:54 +00004508
4509 // FIXME:
4510 // This now gets parsed incorrectly as class definition.
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004511 // verifyFormat("class A<int> f() {\n}\nint n;");
Manuel Klimek3a3408c2013-01-21 13:58:54 +00004512
Manuel Klimek47ea7f62013-01-15 13:38:33 +00004513 // Elaborate types where incorrectly parsing the structural element would
4514 // break the indent.
4515 verifyFormat("if (true)\n"
4516 " class X x;\n"
4517 "else\n"
4518 " f();\n");
Daniel Jasper6fe554e2013-03-20 15:12:38 +00004519
4520 // This is simply incomplete. Formatting is not important, but must not crash.
Daniel Jasper6315fec2013-08-13 10:58:30 +00004521 verifyFormat("class A:");
Manuel Klimek606e07e2013-01-11 18:13:04 +00004522}
4523
Manuel Klimek407a31a2013-01-15 15:50:27 +00004524TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
4525 verifyFormat("#error Leave all white!!!!! space* alone!\n");
4526 verifyFormat("#warning Leave all white!!!!! space* alone!\n");
4527 EXPECT_EQ("#error 1", format(" # error 1"));
4528 EXPECT_EQ("#warning 1", format(" # warning 1"));
4529}
4530
Daniel Jasperaae7bad2013-04-23 13:54:04 +00004531TEST_F(FormatTest, FormatHashIfExpressions) {
4532 // FIXME: Come up with a better indentation for #elif.
4533 verifyFormat(
4534 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n"
4535 " defined(BBBBBBBB)\n"
4536 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n"
4537 " defined(BBBBBBBB)\n"
4538 "#endif",
4539 getLLVMStyleWithColumns(65));
4540}
4541
Manuel Klimek525fe162013-01-18 14:04:34 +00004542TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
4543 FormatStyle AllowsMergedIf = getGoogleStyle();
4544 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true;
4545 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
4546 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
Manuel Klimek4c128122013-01-18 14:46:43 +00004547 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf);
4548 EXPECT_EQ("if (true) return 42;",
4549 format("if (true)\nreturn 42;", AllowsMergedIf));
4550 FormatStyle ShortMergedIf = AllowsMergedIf;
4551 ShortMergedIf.ColumnLimit = 25;
Daniel Jasper2972d042013-04-25 08:56:26 +00004552 verifyFormat("#define A \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004553 " if (true) return 42;",
4554 ShortMergedIf);
Daniel Jasper2972d042013-04-25 08:56:26 +00004555 verifyFormat("#define A \\\n"
4556 " f(); \\\n"
Manuel Klimek4c128122013-01-18 14:46:43 +00004557 " if (true)\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004558 "#define B",
4559 ShortMergedIf);
Daniel Jasper2972d042013-04-25 08:56:26 +00004560 verifyFormat("#define A \\\n"
4561 " f(); \\\n"
Manuel Klimek4c128122013-01-18 14:46:43 +00004562 " if (true)\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004563 "g();",
4564 ShortMergedIf);
Manuel Klimek0fbe0082013-01-21 14:16:56 +00004565 verifyFormat("{\n"
4566 "#ifdef A\n"
4567 " // Comment\n"
4568 " if (true) continue;\n"
4569 "#endif\n"
4570 " // Comment\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004571 " if (true) continue;",
4572 ShortMergedIf);
Manuel Klimek525fe162013-01-18 14:04:34 +00004573}
4574
Manuel Klimek86721d22013-01-22 16:31:55 +00004575TEST_F(FormatTest, BlockCommentsInControlLoops) {
4576 verifyFormat("if (0) /* a comment in a strange place */ {\n"
4577 " f();\n"
4578 "}");
4579 verifyFormat("if (0) /* a comment in a strange place */ {\n"
4580 " f();\n"
4581 "} /* another comment */ else /* comment #3 */ {\n"
4582 " g();\n"
4583 "}");
4584 verifyFormat("while (0) /* a comment in a strange place */ {\n"
4585 " f();\n"
4586 "}");
4587 verifyFormat("for (;;) /* a comment in a strange place */ {\n"
4588 " f();\n"
4589 "}");
4590 verifyFormat("do /* a comment in a strange place */ {\n"
4591 " f();\n"
4592 "} /* another comment */ while (0);");
4593}
4594
4595TEST_F(FormatTest, BlockComments) {
4596 EXPECT_EQ("/* */ /* */ /* */\n/* */ /* */ /* */",
4597 format("/* *//* */ /* */\n/* *//* */ /* */"));
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004598 EXPECT_EQ("/* */ a /* */ b;", format(" /* */ a/* */ b;"));
Daniel Jasperc9346c92013-08-28 09:07:32 +00004599 EXPECT_EQ("#define A /*123*/ \\\n"
Manuel Klimek86721d22013-01-22 16:31:55 +00004600 " b\n"
4601 "/* */\n"
4602 "someCall(\n"
4603 " parameter);",
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00004604 format("#define A /*123*/ b\n"
Manuel Klimek86721d22013-01-22 16:31:55 +00004605 "/* */\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004606 "someCall(parameter);",
4607 getLLVMStyleWithColumns(15)));
Manuel Klimek86721d22013-01-22 16:31:55 +00004608
4609 EXPECT_EQ("#define A\n"
4610 "/* */ someCall(\n"
4611 " parameter);",
4612 format("#define A\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004613 "/* */someCall(parameter);",
4614 getLLVMStyleWithColumns(15)));
Daniel Jaspere2c482f2013-05-30 06:40:07 +00004615 EXPECT_EQ("/*\n**\n*/", format("/*\n**\n*/"));
Daniel Jasper92092702013-05-30 15:20:29 +00004616 EXPECT_EQ("/*\n"
4617 "*\n"
4618 " * aaaaaa\n"
Alexander Kornienko1659ded2013-07-08 14:12:07 +00004619 "*aaaaaa\n"
Daniel Jasper92092702013-05-30 15:20:29 +00004620 "*/",
4621 format("/*\n"
4622 "*\n"
4623 " * aaaaaa aaaaaa\n"
4624 "*/",
4625 getLLVMStyleWithColumns(10)));
Daniel Jaspercb4b40b2013-05-30 17:27:48 +00004626 EXPECT_EQ("/*\n"
4627 "**\n"
4628 "* aaaaaa\n"
Alexander Kornienko1659ded2013-07-08 14:12:07 +00004629 "*aaaaaa\n"
Daniel Jaspercb4b40b2013-05-30 17:27:48 +00004630 "*/",
4631 format("/*\n"
4632 "**\n"
4633 "* aaaaaa aaaaaa\n"
4634 "*/",
4635 getLLVMStyleWithColumns(10)));
Daniel Jasper2752ff32013-02-04 07:32:14 +00004636
Daniel Jasperfaab0d32013-02-27 09:47:53 +00004637 FormatStyle NoBinPacking = getLLVMStyle();
4638 NoBinPacking.BinPackParameters = false;
Daniel Jasper2752ff32013-02-04 07:32:14 +00004639 EXPECT_EQ("someFunction(1, /* comment 1 */\n"
4640 " 2, /* comment 2 */\n"
4641 " 3, /* comment 3 */\n"
Daniel Jaspercda16502013-02-04 08:34:57 +00004642 " aaaa,\n"
4643 " bbbb);",
Daniel Jasper2752ff32013-02-04 07:32:14 +00004644 format("someFunction (1, /* comment 1 */\n"
4645 " 2, /* comment 2 */ \n"
4646 " 3, /* comment 3 */\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004647 "aaaa, bbbb );",
Daniel Jasperfaab0d32013-02-27 09:47:53 +00004648 NoBinPacking));
Daniel Jasper36ba0ff2013-02-06 15:23:09 +00004649 verifyFormat(
4650 "bool aaaaaaaaaaaaa = /* comment: */ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4651 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
4652 EXPECT_EQ(
4653 "bool aaaaaaaaaaaaa = /* trailing comment */\n"
4654 " aaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4655 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;",
4656 format(
4657 "bool aaaaaaaaaaaaa = /* trailing comment */\n"
4658 " aaaaaaaaaaaaaaaaaaaaaaaaaaa||aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4659 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;"));
Daniel Jasper15417ef2013-02-06 20:07:35 +00004660 EXPECT_EQ(
4661 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n"
4662 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n"
4663 "int cccccccccccccccccccccccccccccc; /* comment */\n",
4664 format("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n"
4665 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n"
4666 "int cccccccccccccccccccccccccccccc; /* comment */\n"));
Daniel Jasper3a1847e2013-07-01 09:34:09 +00004667
4668 verifyFormat("void f(int * /* unused */) {}");
Alexander Kornienko1659ded2013-07-08 14:12:07 +00004669
4670 EXPECT_EQ("/*\n"
4671 " **\n"
4672 " */",
4673 format("/*\n"
4674 " **\n"
4675 " */"));
4676 EXPECT_EQ("/*\n"
4677 " *q\n"
4678 " */",
4679 format("/*\n"
4680 " *q\n"
4681 " */"));
4682 EXPECT_EQ("/*\n"
4683 " * q\n"
4684 " */",
4685 format("/*\n"
4686 " * q\n"
4687 " */"));
4688 EXPECT_EQ("/*\n"
4689 " **/",
4690 format("/*\n"
4691 " **/"));
4692 EXPECT_EQ("/*\n"
4693 " ***/",
4694 format("/*\n"
4695 " ***/"));
Manuel Klimek86721d22013-01-22 16:31:55 +00004696}
4697
Manuel Klimekb3507cd2013-02-06 16:40:56 +00004698TEST_F(FormatTest, BlockCommentsInMacros) {
4699 EXPECT_EQ("#define A \\\n"
4700 " { \\\n"
4701 " /* one line */ \\\n"
4702 " someCall();",
4703 format("#define A { \\\n"
4704 " /* one line */ \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004705 " someCall();",
4706 getLLVMStyleWithColumns(20)));
Manuel Klimekb3507cd2013-02-06 16:40:56 +00004707 EXPECT_EQ("#define A \\\n"
4708 " { \\\n"
4709 " /* previous */ \\\n"
4710 " /* one line */ \\\n"
4711 " someCall();",
4712 format("#define A { \\\n"
4713 " /* previous */ \\\n"
4714 " /* one line */ \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004715 " someCall();",
4716 getLLVMStyleWithColumns(20)));
Manuel Klimekb3507cd2013-02-06 16:40:56 +00004717}
4718
Manuel Klimekbe9ed772013-05-29 22:06:18 +00004719TEST_F(FormatTest, BlockCommentsAtEndOfLine) {
4720 EXPECT_EQ("a = {\n"
4721 " 1111 /* */\n"
4722 "};",
Alexander Kornienkoe3f11972013-06-12 19:04:12 +00004723 format("a = {1111 /* */\n"
Manuel Klimekbe9ed772013-05-29 22:06:18 +00004724 "};",
4725 getLLVMStyleWithColumns(15)));
4726 EXPECT_EQ("a = {\n"
4727 " 1111 /* */\n"
4728 "};",
Alexander Kornienkoe3f11972013-06-12 19:04:12 +00004729 format("a = {1111 /* */\n"
Manuel Klimekbe9ed772013-05-29 22:06:18 +00004730 "};",
4731 getLLVMStyleWithColumns(15)));
4732
4733 // FIXME: The formatting is still wrong here.
4734 EXPECT_EQ("a = {\n"
4735 " 1111 /* a\n"
4736 " */\n"
4737 "};",
Alexander Kornienkoe3f11972013-06-12 19:04:12 +00004738 format("a = {1111 /* a */\n"
Manuel Klimekbe9ed772013-05-29 22:06:18 +00004739 "};",
4740 getLLVMStyleWithColumns(15)));
4741}
4742
Manuel Klimekb3507cd2013-02-06 16:40:56 +00004743TEST_F(FormatTest, IndentLineCommentsInStartOfBlockAtEndOfFile) {
4744 // FIXME: This is not what we want...
4745 verifyFormat("{\n"
4746 "// a"
4747 "// b");
4748}
4749
Manuel Klimek092a2c72013-01-23 10:09:28 +00004750TEST_F(FormatTest, FormatStarDependingOnContext) {
Manuel Klimek70b03f42013-01-23 09:32:48 +00004751 verifyFormat("void f(int *a);");
4752 verifyFormat("void f() { f(fint * b); }");
Manuel Klimek836b58f2013-01-23 11:03:04 +00004753 verifyFormat("class A {\n void f(int *a);\n};");
4754 verifyFormat("class A {\n int *a;\n};");
4755 verifyFormat("namespace a {\n"
4756 "namespace b {\n"
4757 "class A {\n"
4758 " void f() {}\n"
4759 " int *a;\n"
4760 "};\n"
4761 "}\n"
4762 "}");
Manuel Klimek70b03f42013-01-23 09:32:48 +00004763}
4764
Manuel Klimek092a2c72013-01-23 10:09:28 +00004765TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
4766 verifyFormat("while");
4767 verifyFormat("operator");
4768}
4769
Nico Webercf4a79c2013-01-08 17:56:31 +00004770//===----------------------------------------------------------------------===//
4771// Objective-C tests.
4772//===----------------------------------------------------------------------===//
4773
Fariborz Jahanian154120c2012-12-20 19:54:13 +00004774TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
4775 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
4776 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
4777 format("-(NSUInteger)indexOfObject:(id)anObject;"));
Daniel Jaspercd162382013-01-07 13:26:07 +00004778 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
Fariborz Jahanian154120c2012-12-20 19:54:13 +00004779 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
4780 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
4781 format("-(NSInteger)Method3:(id)anObject;"));
4782 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
4783 format("-(NSInteger)Method4:(id)anObject;"));
4784 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
4785 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
4786 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
4787 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
Daniel Jaspercd162382013-01-07 13:26:07 +00004788 EXPECT_EQ(
4789 "- (void)sendAction:(SEL)aSelector to:(id)anObject forAllCells:(BOOL)flag;",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004790 format(
4791 "- (void)sendAction:(SEL)aSelector to:(id)anObject forAllCells:(BOOL)flag;"));
Fariborz Jahanian9b3f02c2012-12-21 22:51:18 +00004792
4793 // Very long objectiveC method declaration.
Daniel Jasper63d7ced2013-02-05 10:07:47 +00004794 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
4795 " inRange:(NSRange)range\n"
4796 " outRange:(NSRange)out_range\n"
4797 " outRange1:(NSRange)out_range1\n"
4798 " outRange2:(NSRange)out_range2\n"
4799 " outRange3:(NSRange)out_range3\n"
4800 " outRange4:(NSRange)out_range4\n"
4801 " outRange5:(NSRange)out_range5\n"
4802 " outRange6:(NSRange)out_range6\n"
4803 " outRange7:(NSRange)out_range7\n"
4804 " outRange8:(NSRange)out_range8\n"
4805 " outRange9:(NSRange)out_range9;");
Nico Webere0fd4292013-01-10 20:18:33 +00004806
4807 verifyFormat("- (int)sum:(vector<int>)numbers;");
Nico Weberaab60052013-01-17 06:14:50 +00004808 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
Nico Webere0fd4292013-01-10 20:18:33 +00004809 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
4810 // protocol lists (but not for template classes):
4811 //verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
Nico Webercd52bda2013-01-10 23:11:41 +00004812
Daniel Jasper431f5912013-05-28 08:33:00 +00004813 verifyFormat("- (int (*)())foo:(int (*)())f;");
4814 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
Nico Webercd52bda2013-01-10 23:11:41 +00004815
4816 // If there's no return type (very rare in practice!), LLVM and Google style
4817 // agree.
Daniel Jasper627707b2013-03-22 16:55:40 +00004818 verifyFormat("- foo;");
Nico Webercd52bda2013-01-10 23:11:41 +00004819 verifyFormat("- foo:(int)f;");
4820 verifyGoogleFormat("- foo:(int)foo;");
Fariborz Jahanian154120c2012-12-20 19:54:13 +00004821}
4822
Daniel Jasper886568d2013-01-09 08:36:49 +00004823TEST_F(FormatTest, FormatObjCBlocks) {
Daniel Jasper46ef8522013-01-10 13:08:12 +00004824 verifyFormat("int (^Block)(int, int);");
4825 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)");
Daniel Jasper886568d2013-01-09 08:36:49 +00004826}
4827
Nico Weber27d13672013-01-09 20:25:35 +00004828TEST_F(FormatTest, FormatObjCInterface) {
Nico Weber5f500df2013-01-10 20:12:55 +00004829 verifyFormat("@interface Foo : NSObject <NSSomeDelegate> {\n"
Nico Weber27d13672013-01-09 20:25:35 +00004830 "@public\n"
4831 " int field1;\n"
4832 "@protected\n"
4833 " int field2;\n"
4834 "@private\n"
4835 " int field3;\n"
4836 "@package\n"
4837 " int field4;\n"
4838 "}\n"
4839 "+ (id)init;\n"
4840 "@end");
4841
Nico Weber27d13672013-01-09 20:25:35 +00004842 verifyGoogleFormat("@interface Foo : NSObject<NSSomeDelegate> {\n"
4843 " @public\n"
4844 " int field1;\n"
4845 " @protected\n"
4846 " int field2;\n"
4847 " @private\n"
4848 " int field3;\n"
4849 " @package\n"
4850 " int field4;\n"
4851 "}\n"
Nico Weberaab60052013-01-17 06:14:50 +00004852 "+ (id)init;\n"
Nico Weber27d13672013-01-09 20:25:35 +00004853 "@end");
4854
Nico Weberf5ecfa52013-01-22 16:53:59 +00004855 verifyFormat("@interface /* wait for it */ Foo\n"
Nico Weber27d13672013-01-09 20:25:35 +00004856 "+ (id)init;\n"
4857 "// Look, a comment!\n"
4858 "- (int)answerWith:(int)i;\n"
4859 "@end");
4860
4861 verifyFormat("@interface Foo\n"
Nico Weber049c4472013-01-09 21:42:32 +00004862 "@end\n"
4863 "@interface Bar\n"
Nico Weber27d13672013-01-09 20:25:35 +00004864 "@end");
4865
4866 verifyFormat("@interface Foo : Bar\n"
4867 "+ (id)init;\n"
4868 "@end");
4869
Nico Weberf5ecfa52013-01-22 16:53:59 +00004870 verifyFormat("@interface Foo : /**/ Bar /**/ <Baz, /**/ Quux>\n"
Nico Weber27d13672013-01-09 20:25:35 +00004871 "+ (id)init;\n"
4872 "@end");
4873
Nico Weber5f500df2013-01-10 20:12:55 +00004874 verifyGoogleFormat("@interface Foo : Bar<Baz, Quux>\n"
Nico Weberaab60052013-01-17 06:14:50 +00004875 "+ (id)init;\n"
Nico Weber5f500df2013-01-10 20:12:55 +00004876 "@end");
4877
Nico Webered91bba2013-01-10 19:19:14 +00004878 verifyFormat("@interface Foo (HackStuff)\n"
Nico Weber27d13672013-01-09 20:25:35 +00004879 "+ (id)init;\n"
4880 "@end");
4881
Nico Webered91bba2013-01-10 19:19:14 +00004882 verifyFormat("@interface Foo ()\n"
Nico Weber27d13672013-01-09 20:25:35 +00004883 "+ (id)init;\n"
4884 "@end");
4885
Nico Weber5f500df2013-01-10 20:12:55 +00004886 verifyFormat("@interface Foo (HackStuff) <MyProtocol>\n"
Nico Weber27d13672013-01-09 20:25:35 +00004887 "+ (id)init;\n"
4888 "@end");
4889
Nico Weber5f500df2013-01-10 20:12:55 +00004890 verifyGoogleFormat("@interface Foo (HackStuff)<MyProtocol>\n"
Nico Weberaab60052013-01-17 06:14:50 +00004891 "+ (id)init;\n"
Nico Weber5f500df2013-01-10 20:12:55 +00004892 "@end");
4893
Manuel Klimekd5688cf2013-01-11 19:17:44 +00004894 verifyFormat("@interface Foo {\n"
4895 " int _i;\n"
4896 "}\n"
Nico Weber27d13672013-01-09 20:25:35 +00004897 "+ (id)init;\n"
4898 "@end");
4899
Manuel Klimekd5688cf2013-01-11 19:17:44 +00004900 verifyFormat("@interface Foo : Bar {\n"
4901 " int _i;\n"
4902 "}\n"
Nico Weber27d13672013-01-09 20:25:35 +00004903 "+ (id)init;\n"
4904 "@end");
4905
Manuel Klimekd5688cf2013-01-11 19:17:44 +00004906 verifyFormat("@interface Foo : Bar <Baz, Quux> {\n"
4907 " int _i;\n"
4908 "}\n"
Nico Weber27d13672013-01-09 20:25:35 +00004909 "+ (id)init;\n"
4910 "@end");
4911
Manuel Klimekd5688cf2013-01-11 19:17:44 +00004912 verifyFormat("@interface Foo (HackStuff) {\n"
4913 " int _i;\n"
4914 "}\n"
Nico Weber27d13672013-01-09 20:25:35 +00004915 "+ (id)init;\n"
4916 "@end");
4917
Manuel Klimekd5688cf2013-01-11 19:17:44 +00004918 verifyFormat("@interface Foo () {\n"
4919 " int _i;\n"
4920 "}\n"
Nico Weber27d13672013-01-09 20:25:35 +00004921 "+ (id)init;\n"
4922 "@end");
4923
Manuel Klimekd5688cf2013-01-11 19:17:44 +00004924 verifyFormat("@interface Foo (HackStuff) <MyProtocol> {\n"
4925 " int _i;\n"
4926 "}\n"
Nico Weber27d13672013-01-09 20:25:35 +00004927 "+ (id)init;\n"
4928 "@end");
4929}
4930
Nico Weber50767d82013-01-09 23:25:37 +00004931TEST_F(FormatTest, FormatObjCImplementation) {
4932 verifyFormat("@implementation Foo : NSObject {\n"
4933 "@public\n"
4934 " int field1;\n"
4935 "@protected\n"
4936 " int field2;\n"
4937 "@private\n"
4938 " int field3;\n"
4939 "@package\n"
4940 " int field4;\n"
4941 "}\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004942 "+ (id)init {\n}\n"
Nico Weber50767d82013-01-09 23:25:37 +00004943 "@end");
4944
4945 verifyGoogleFormat("@implementation Foo : NSObject {\n"
4946 " @public\n"
4947 " int field1;\n"
4948 " @protected\n"
4949 " int field2;\n"
4950 " @private\n"
4951 " int field3;\n"
4952 " @package\n"
4953 " int field4;\n"
4954 "}\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004955 "+ (id)init {\n}\n"
Nico Weber50767d82013-01-09 23:25:37 +00004956 "@end");
4957
4958 verifyFormat("@implementation Foo\n"
4959 "+ (id)init {\n"
Daniel Jasper6f5bb2c2013-01-14 16:24:39 +00004960 " if (true)\n"
4961 " return nil;\n"
Nico Weber50767d82013-01-09 23:25:37 +00004962 "}\n"
4963 "// Look, a comment!\n"
Manuel Klimekd5688cf2013-01-11 19:17:44 +00004964 "- (int)answerWith:(int)i {\n"
4965 " return i;\n"
4966 "}\n"
Nico Weber67015ed2013-01-11 21:14:08 +00004967 "+ (int)answerWith:(int)i {\n"
4968 " return i;\n"
4969 "}\n"
Nico Weber50767d82013-01-09 23:25:37 +00004970 "@end");
4971
4972 verifyFormat("@implementation Foo\n"
4973 "@end\n"
4974 "@implementation Bar\n"
4975 "@end");
4976
4977 verifyFormat("@implementation Foo : Bar\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004978 "+ (id)init {\n}\n"
4979 "- (void)foo {\n}\n"
Nico Weber50767d82013-01-09 23:25:37 +00004980 "@end");
4981
Manuel Klimekd5688cf2013-01-11 19:17:44 +00004982 verifyFormat("@implementation Foo {\n"
4983 " int _i;\n"
4984 "}\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004985 "+ (id)init {\n}\n"
Nico Weber50767d82013-01-09 23:25:37 +00004986 "@end");
4987
Manuel Klimekd5688cf2013-01-11 19:17:44 +00004988 verifyFormat("@implementation Foo : Bar {\n"
4989 " int _i;\n"
4990 "}\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004991 "+ (id)init {\n}\n"
Nico Weber50767d82013-01-09 23:25:37 +00004992 "@end");
4993
Nico Webered91bba2013-01-10 19:19:14 +00004994 verifyFormat("@implementation Foo (HackStuff)\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004995 "+ (id)init {\n}\n"
Nico Weber50767d82013-01-09 23:25:37 +00004996 "@end");
Daniel Jasper7186ccc2013-08-28 08:04:23 +00004997 verifyFormat("@implementation ObjcClass\n"
4998 "- (void)method;\n"
4999 "{}\n"
5000 "@end");
Nico Weber50767d82013-01-09 23:25:37 +00005001}
5002
Nico Weber1abe6ea2013-01-09 21:15:03 +00005003TEST_F(FormatTest, FormatObjCProtocol) {
5004 verifyFormat("@protocol Foo\n"
5005 "@property(weak) id delegate;\n"
5006 "- (NSUInteger)numberOfThings;\n"
5007 "@end");
5008
Nico Weber5f500df2013-01-10 20:12:55 +00005009 verifyFormat("@protocol MyProtocol <NSObject>\n"
Nico Weber1abe6ea2013-01-09 21:15:03 +00005010 "- (NSUInteger)numberOfThings;\n"
5011 "@end");
5012
Nico Weber5f500df2013-01-10 20:12:55 +00005013 verifyGoogleFormat("@protocol MyProtocol<NSObject>\n"
Nico Weberaab60052013-01-17 06:14:50 +00005014 "- (NSUInteger)numberOfThings;\n"
Nico Weber5f500df2013-01-10 20:12:55 +00005015 "@end");
5016
Nico Weber1abe6ea2013-01-09 21:15:03 +00005017 verifyFormat("@protocol Foo;\n"
5018 "@protocol Bar;\n");
Nico Weber049c4472013-01-09 21:42:32 +00005019
5020 verifyFormat("@protocol Foo\n"
5021 "@end\n"
5022 "@protocol Bar\n"
5023 "@end");
Nico Weberb530fa32013-01-10 00:25:19 +00005024
5025 verifyFormat("@protocol myProtocol\n"
5026 "- (void)mandatoryWithInt:(int)i;\n"
5027 "@optional\n"
5028 "- (void)optional;\n"
5029 "@required\n"
5030 "- (void)required;\n"
Nico Weber880e5382013-01-10 00:42:07 +00005031 "@optional\n"
5032 "@property(assign) int madProp;\n"
Nico Weberb530fa32013-01-10 00:25:19 +00005033 "@end\n");
Daniel Jasperaa9e7b12013-08-01 13:46:58 +00005034
5035 verifyFormat("@property(nonatomic, assign, readonly)\n"
5036 " int *looooooooooooooooooooooooooooongNumber;\n"
5037 "@property(nonatomic, assign, readonly)\n"
5038 " NSString *looooooooooooooooooooooooooooongName;");
Nico Weber1abe6ea2013-01-09 21:15:03 +00005039}
5040
Daniel Jasper63d7ced2013-02-05 10:07:47 +00005041TEST_F(FormatTest, FormatObjCMethodDeclarations) {
5042 verifyFormat("- (void)doSomethingWith:(GTMFoo *)theFoo\n"
5043 " rect:(NSRect)theRect\n"
5044 " interval:(float)theInterval {\n"
5045 "}");
5046 verifyFormat("- (void)shortf:(GTMFoo *)theFoo\n"
5047 " longKeyword:(NSRect)theRect\n"
5048 " evenLongerKeyword:(float)theInterval\n"
5049 " error:(NSError **)theError {\n"
5050 "}");
5051}
5052
Nico Weberbcfdd262013-01-12 06:18:40 +00005053TEST_F(FormatTest, FormatObjCMethodExpr) {
5054 verifyFormat("[foo bar:baz];");
5055 verifyFormat("return [foo bar:baz];");
5056 verifyFormat("f([foo bar:baz]);");
5057 verifyFormat("f(2, [foo bar:baz]);");
5058 verifyFormat("f(2, a ? b : c);");
5059 verifyFormat("[[self initWithInt:4] bar:[baz quux:arrrr]];");
5060
Nico Weberee0feec2013-02-05 16:21:00 +00005061 // Unary operators.
5062 verifyFormat("int a = +[foo bar:baz];");
5063 verifyFormat("int a = -[foo bar:baz];");
5064 verifyFormat("int a = ![foo bar:baz];");
5065 verifyFormat("int a = ~[foo bar:baz];");
5066 verifyFormat("int a = ++[foo bar:baz];");
5067 verifyFormat("int a = --[foo bar:baz];");
5068 verifyFormat("int a = sizeof [foo bar:baz];");
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00005069 verifyFormat("int a = alignof [foo bar:baz];", getGoogleStyle());
Nico Webere8a97982013-02-06 06:20:11 +00005070 verifyFormat("int a = &[foo bar:baz];");
5071 verifyFormat("int a = *[foo bar:baz];");
Nico Weberee0feec2013-02-05 16:21:00 +00005072 // FIXME: Make casts work, without breaking f()[4].
Nico Weber4c2cc602013-02-13 03:48:27 +00005073 //verifyFormat("int a = (int)[foo bar:baz];");
Nico Webere0dc7c72013-02-13 04:40:03 +00005074 //verifyFormat("return (int)[foo bar:baz];");
5075 //verifyFormat("(void)[foo bar:baz];");
Nico Weber4c2cc602013-02-13 03:48:27 +00005076 verifyFormat("return (MyType *)[self.tableView cellForRowAtIndexPath:cell];");
Nico Weberee0feec2013-02-05 16:21:00 +00005077
5078 // Binary operators.
Nico Weberbcfdd262013-01-12 06:18:40 +00005079 verifyFormat("[foo bar:baz], [foo bar:baz];");
5080 verifyFormat("[foo bar:baz] = [foo bar:baz];");
5081 verifyFormat("[foo bar:baz] *= [foo bar:baz];");
5082 verifyFormat("[foo bar:baz] /= [foo bar:baz];");
5083 verifyFormat("[foo bar:baz] %= [foo bar:baz];");
5084 verifyFormat("[foo bar:baz] += [foo bar:baz];");
5085 verifyFormat("[foo bar:baz] -= [foo bar:baz];");
5086 verifyFormat("[foo bar:baz] <<= [foo bar:baz];");
5087 verifyFormat("[foo bar:baz] >>= [foo bar:baz];");
5088 verifyFormat("[foo bar:baz] &= [foo bar:baz];");
5089 verifyFormat("[foo bar:baz] ^= [foo bar:baz];");
5090 verifyFormat("[foo bar:baz] |= [foo bar:baz];");
5091 verifyFormat("[foo bar:baz] ? [foo bar:baz] : [foo bar:baz];");
5092 verifyFormat("[foo bar:baz] || [foo bar:baz];");
5093 verifyFormat("[foo bar:baz] && [foo bar:baz];");
5094 verifyFormat("[foo bar:baz] | [foo bar:baz];");
5095 verifyFormat("[foo bar:baz] ^ [foo bar:baz];");
5096 verifyFormat("[foo bar:baz] & [foo bar:baz];");
5097 verifyFormat("[foo bar:baz] == [foo bar:baz];");
5098 verifyFormat("[foo bar:baz] != [foo bar:baz];");
5099 verifyFormat("[foo bar:baz] >= [foo bar:baz];");
5100 verifyFormat("[foo bar:baz] <= [foo bar:baz];");
5101 verifyFormat("[foo bar:baz] > [foo bar:baz];");
5102 verifyFormat("[foo bar:baz] < [foo bar:baz];");
5103 verifyFormat("[foo bar:baz] >> [foo bar:baz];");
5104 verifyFormat("[foo bar:baz] << [foo bar:baz];");
5105 verifyFormat("[foo bar:baz] - [foo bar:baz];");
5106 verifyFormat("[foo bar:baz] + [foo bar:baz];");
5107 verifyFormat("[foo bar:baz] * [foo bar:baz];");
5108 verifyFormat("[foo bar:baz] / [foo bar:baz];");
5109 verifyFormat("[foo bar:baz] % [foo bar:baz];");
5110 // Whew!
5111
Nico Weberc2e6d2a2013-02-11 15:32:15 +00005112 verifyFormat("return in[42];");
5113 verifyFormat("for (id foo in [self getStuffFor:bla]) {\n"
5114 "}");
5115
Nico Weberbcfdd262013-01-12 06:18:40 +00005116 verifyFormat("[self stuffWithInt:(4 + 2) float:4.5];");
5117 verifyFormat("[self stuffWithInt:a ? b : c float:4.5];");
5118 verifyFormat("[self stuffWithInt:a ? [self foo:bar] : c];");
5119 verifyFormat("[self stuffWithInt:a ? (e ? f : g) : c];");
5120 verifyFormat("[cond ? obj1 : obj2 methodWithParam:param]");
Nico Weber6292dd42013-01-12 23:41:33 +00005121 verifyFormat("[button setAction:@selector(zoomOut:)];");
Nico Webercd458332013-01-12 23:48:49 +00005122 verifyFormat("[color getRed:&r green:&g blue:&b alpha:&a];");
Daniel Jasper63d7ced2013-02-05 10:07:47 +00005123
Nico Weberbcfdd262013-01-12 06:18:40 +00005124 verifyFormat("arr[[self indexForFoo:a]];");
5125 verifyFormat("throw [self errorFor:a];");
5126 verifyFormat("@throw [self errorFor:a];");
5127
Nico Weber465e8612013-06-25 00:55:57 +00005128 verifyFormat("[(id)foo bar:(id)baz quux:(id)snorf];");
5129 verifyFormat("[(id)foo bar:(id) ? baz : quux];");
5130 verifyFormat("4 > 4 ? (id)a : (id)baz;");
5131
Nico Webere8ccc812013-01-12 22:48:47 +00005132 // This tests that the formatter doesn't break after "backing" but before ":",
5133 // which would be at 80 columns.
Nico Weberbcfdd262013-01-12 06:18:40 +00005134 verifyFormat(
5135 "void f() {\n"
Daniel Jasper63d7ced2013-02-05 10:07:47 +00005136 " if ((self = [super initWithContentRect:contentRect\n"
Daniel Jasper1eaa9972013-08-01 23:13:03 +00005137 " styleMask:styleMask ?: otherMask\n"
Daniel Jasper63d7ced2013-02-05 10:07:47 +00005138 " backing:NSBackingStoreBuffered\n"
5139 " defer:YES]))");
5140
Daniel Jasper4e778092013-02-06 10:05:46 +00005141 verifyFormat(
5142 "[foo checkThatBreakingAfterColonWorksOk:\n"
Daniel Jasper1eaa9972013-08-01 23:13:03 +00005143 " [bar ifItDoes:reduceOverallLineLengthLikeInThisCase]];");
Daniel Jasper63d7ced2013-02-05 10:07:47 +00005144
5145 verifyFormat("[myObj short:arg1 // Force line break\n"
Daniel Jasper1eaa9972013-08-01 23:13:03 +00005146 " longKeyword:arg2 != nil ? arg2 : @\"longKeyword\"\n"
5147 " evenLongerKeyword:arg3 ?: @\"evenLongerKeyword\"\n"
Daniel Jasper63d7ced2013-02-05 10:07:47 +00005148 " error:arg4];");
5149 verifyFormat(
5150 "void f() {\n"
5151 " popup_window_.reset([[RenderWidgetPopupWindow alloc]\n"
5152 " initWithContentRect:NSMakeRect(origin_global.x, origin_global.y,\n"
5153 " pos.width(), pos.height())\n"
5154 " styleMask:NSBorderlessWindowMask\n"
5155 " backing:NSBackingStoreBuffered\n"
5156 " defer:NO]);\n"
5157 "}");
Daniel Jasper4e778092013-02-06 10:05:46 +00005158 verifyFormat("[contentsContainer replaceSubview:[subviews objectAtIndex:0]\n"
5159 " with:contentsNativeView];");
5160
5161 verifyFormat(
5162 "[pboard addTypes:[NSArray arrayWithObject:kBookmarkButtonDragType]\n"
5163 " owner:nillllll];");
5164
Daniel Jasper4e778092013-02-06 10:05:46 +00005165 verifyFormat(
Daniel Jasperce3d1a62013-02-08 08:22:00 +00005166 "[pboard setData:[NSData dataWithBytes:&button length:sizeof(button)]\n"
Daniel Jasper4e778092013-02-06 10:05:46 +00005167 " forType:kBookmarkButtonDragType];");
5168
5169 verifyFormat("[defaultCenter addObserver:self\n"
5170 " selector:@selector(willEnterFullscreen)\n"
5171 " name:kWillEnterFullscreenNotification\n"
5172 " object:nil];");
Daniel Jasper9e9e6e02013-02-06 16:00:26 +00005173 verifyFormat("[image_rep drawInRect:drawRect\n"
5174 " fromRect:NSZeroRect\n"
5175 " operation:NSCompositeCopy\n"
5176 " fraction:1.0\n"
5177 " respectFlipped:NO\n"
5178 " hints:nil];");
Nico Weber4ed7f3e2013-02-06 16:54:35 +00005179
5180 verifyFormat(
5181 "scoped_nsobject<NSTextField> message(\n"
5182 " // The frame will be fixed up when |-setMessageText:| is called.\n"
5183 " [[NSTextField alloc] initWithFrame:NSMakeRect(0, 0, 0, 0)]);");
Daniel Jasper1eaa9972013-08-01 23:13:03 +00005184 verifyFormat("[self aaaaaa:bbbbbbbbbbbbb\n"
5185 " aaaaaaaaaa:bbbbbbbbbbbbbbbbb\n"
5186 " aaaaa:bbbbbbbbbbb + bbbbbbbbbbbb\n"
5187 " aaaa:bbb];");
Nico Weberbcfdd262013-01-12 06:18:40 +00005188}
5189
Nico Weber581f5572013-01-07 15:56:25 +00005190TEST_F(FormatTest, ObjCAt) {
Nico Weber4a293a22013-01-07 16:07:07 +00005191 verifyFormat("@autoreleasepool");
Nico Weberd0af4b42013-01-07 16:14:28 +00005192 verifyFormat("@catch");
5193 verifyFormat("@class");
Nico Weber4a293a22013-01-07 16:07:07 +00005194 verifyFormat("@compatibility_alias");
5195 verifyFormat("@defs");
Nico Weberefcfe732013-01-07 15:17:23 +00005196 verifyFormat("@dynamic");
Nico Weber4a293a22013-01-07 16:07:07 +00005197 verifyFormat("@encode");
5198 verifyFormat("@end");
5199 verifyFormat("@finally");
5200 verifyFormat("@implementation");
5201 verifyFormat("@import");
5202 verifyFormat("@interface");
5203 verifyFormat("@optional");
5204 verifyFormat("@package");
Nico Weberd0af4b42013-01-07 16:14:28 +00005205 verifyFormat("@private");
Nico Weber4a293a22013-01-07 16:07:07 +00005206 verifyFormat("@property");
Nico Weberd0af4b42013-01-07 16:14:28 +00005207 verifyFormat("@protected");
Nico Weber4a293a22013-01-07 16:07:07 +00005208 verifyFormat("@protocol");
Nico Weberd0af4b42013-01-07 16:14:28 +00005209 verifyFormat("@public");
Nico Weber4a293a22013-01-07 16:07:07 +00005210 verifyFormat("@required");
5211 verifyFormat("@selector");
5212 verifyFormat("@synchronized");
5213 verifyFormat("@synthesize");
Nico Weberd0af4b42013-01-07 16:14:28 +00005214 verifyFormat("@throw");
5215 verifyFormat("@try");
Nico Weber4a293a22013-01-07 16:07:07 +00005216
Nico Weber581f5572013-01-07 15:56:25 +00005217 EXPECT_EQ("@interface", format("@ interface"));
5218
5219 // The precise formatting of this doesn't matter, nobody writes code like
5220 // this.
5221 verifyFormat("@ /*foo*/ interface");
Nico Weberefcfe732013-01-07 15:17:23 +00005222}
5223
Nico Weberc31689a2013-01-08 19:15:23 +00005224TEST_F(FormatTest, ObjCSnippets) {
Manuel Klimekd5688cf2013-01-11 19:17:44 +00005225 verifyFormat("@autoreleasepool {\n"
5226 " foo();\n"
5227 "}");
Nico Webercf4a79c2013-01-08 17:56:31 +00005228 verifyFormat("@class Foo, Bar;");
Nico Weberc31689a2013-01-08 19:15:23 +00005229 verifyFormat("@compatibility_alias AliasName ExistingClass;");
Nico Webercf4a79c2013-01-08 17:56:31 +00005230 verifyFormat("@dynamic textColor;");
Nico Weber5dfe9b42013-01-18 05:11:47 +00005231 verifyFormat("char *buf1 = @encode(int *);");
5232 verifyFormat("char *buf1 = @encode(typeof(4 * 5));");
Nico Weber95e8e462013-02-12 16:17:07 +00005233 verifyFormat("char *buf1 = @encode(int **);");
Nico Weber3a2673e2013-01-08 20:16:23 +00005234 verifyFormat("Protocol *proto = @protocol(p1);");
Nico Weber6a21a552013-01-18 02:43:57 +00005235 verifyFormat("SEL s = @selector(foo:);");
Manuel Klimekd5688cf2013-01-11 19:17:44 +00005236 verifyFormat("@synchronized(self) {\n"
5237 " f();\n"
5238 "}");
Nico Webercf4a79c2013-01-08 17:56:31 +00005239
Nico Weber70848232013-01-10 21:30:42 +00005240 verifyFormat("@synthesize dropArrowPosition = dropArrowPosition_;");
5241 verifyGoogleFormat("@synthesize dropArrowPosition = dropArrowPosition_;");
5242
Nico Webercf4a79c2013-01-08 17:56:31 +00005243 verifyFormat("@property(assign, nonatomic) CGFloat hoverAlpha;");
Nico Weber70848232013-01-10 21:30:42 +00005244 verifyFormat("@property(assign, getter=isEditable) BOOL editable;");
5245 verifyGoogleFormat("@property(assign, getter=isEditable) BOOL editable;");
Nico Weber10fc2c62013-06-25 00:25:40 +00005246
5247 verifyFormat("@import foo.bar;\n"
5248 "@import baz;");
Nico Webercf4a79c2013-01-08 17:56:31 +00005249}
5250
Nico Weber712f5b32013-02-07 00:19:29 +00005251TEST_F(FormatTest, ObjCLiterals) {
5252 verifyFormat("@\"String\"");
5253 verifyFormat("@1");
5254 verifyFormat("@+4.8");
5255 verifyFormat("@-4");
5256 verifyFormat("@1LL");
5257 verifyFormat("@.5");
5258 verifyFormat("@'c'");
5259 verifyFormat("@true");
5260
5261 verifyFormat("NSNumber *smallestInt = @(-INT_MAX - 1);");
5262 verifyFormat("NSNumber *piOverTwo = @(M_PI / 2);");
5263 verifyFormat("NSNumber *favoriteColor = @(Green);");
5264 verifyFormat("NSString *path = @(getenv(\"PATH\"));");
5265
Nico Weber712f5b32013-02-07 00:19:29 +00005266 verifyFormat("@[");
Nico Weber051860e2013-02-10 02:08:05 +00005267 verifyFormat("@[]");
5268 verifyFormat(
5269 "NSArray *array = @[ @\" Hey \", NSApp, [NSNumber numberWithInt:42] ];");
5270 verifyFormat("return @[ @3, @[], @[ @4, @5 ] ];");
5271
Nico Weber712f5b32013-02-07 00:19:29 +00005272 verifyFormat("@{");
Nico Weberd74fcdb2013-02-10 20:35:35 +00005273 verifyFormat("@{}");
5274 verifyFormat("@{ @\"one\" : @1 }");
5275 verifyFormat("return @{ @\"one\" : @1 };");
5276 verifyFormat("@{ @\"one\" : @1, }");
Manuel Klimek67d080d2013-04-12 14:13:36 +00005277
Daniel Jasper88959b72013-05-28 18:50:02 +00005278 verifyFormat("@{ @\"one\" : @{ @2 : @1 } }");
5279 verifyFormat("@{ @\"one\" : @{ @2 : @1 }, }");
Manuel Klimek67d080d2013-04-12 14:13:36 +00005280
Nico Weberd74fcdb2013-02-10 20:35:35 +00005281 verifyFormat("@{ 1 > 2 ? @\"one\" : @\"two\" : 1 > 2 ? @1 : @2 }");
5282 verifyFormat("[self setDict:@{}");
5283 verifyFormat("[self setDict:@{ @1 : @2 }");
5284 verifyFormat("NSLog(@\"%@\", @{ @1 : @2, @2 : @3 }[@1]);");
5285 verifyFormat(
5286 "NSDictionary *masses = @{ @\"H\" : @1.0078, @\"He\" : @4.0026 };");
Nico Webere6262002013-02-10 20:39:05 +00005287 verifyFormat(
5288 "NSDictionary *settings = @{ AVEncoderKey : @(AVAudioQualityMax) };");
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005289
Nico Weberd74fcdb2013-02-10 20:35:35 +00005290 // FIXME: Nested and multi-line array and dictionary literals need more work.
Nico Weber0ac717b2013-02-10 20:48:24 +00005291 verifyFormat(
5292 "NSDictionary *d = @{ @\"nam\" : NSUserNam(), @\"dte\" : [NSDate date],\n"
5293 " @\"processInfo\" : [NSProcessInfo processInfo] };");
Nico Weberf2ff8122013-05-26 05:39:26 +00005294 verifyFormat(
5295 "@{ NSFontAttributeNameeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee :\n"
5296 " regularFont, };");
5297
Nico Weber712f5b32013-02-07 00:19:29 +00005298}
5299
Manuel Klimek547d5db2013-02-08 17:38:27 +00005300TEST_F(FormatTest, ReformatRegionAdjustsIndent) {
5301 EXPECT_EQ("{\n"
5302 "{\n"
5303 "a;\n"
5304 "b;\n"
5305 "}\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005306 "}",
5307 format("{\n"
5308 "{\n"
5309 "a;\n"
5310 " b;\n"
5311 "}\n"
5312 "}",
5313 13, 2, getLLVMStyle()));
Manuel Klimek547d5db2013-02-08 17:38:27 +00005314 EXPECT_EQ("{\n"
5315 "{\n"
5316 " a;\n"
5317 "b;\n"
5318 "}\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005319 "}",
5320 format("{\n"
5321 "{\n"
5322 " a;\n"
5323 "b;\n"
5324 "}\n"
5325 "}",
5326 9, 2, getLLVMStyle()));
Manuel Klimek547d5db2013-02-08 17:38:27 +00005327 EXPECT_EQ("{\n"
5328 "{\n"
5329 "public:\n"
5330 " b;\n"
5331 "}\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005332 "}",
5333 format("{\n"
5334 "{\n"
5335 "public:\n"
5336 " b;\n"
5337 "}\n"
5338 "}",
5339 17, 2, getLLVMStyle()));
Manuel Klimek547d5db2013-02-08 17:38:27 +00005340 EXPECT_EQ("{\n"
5341 "{\n"
5342 "a;\n"
5343 "}\n"
5344 "{\n"
Daniel Jasper1fb8d882013-05-14 09:30:02 +00005345 " b; //\n"
Manuel Klimek547d5db2013-02-08 17:38:27 +00005346 "}\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005347 "}",
5348 format("{\n"
5349 "{\n"
5350 "a;\n"
5351 "}\n"
5352 "{\n"
Daniel Jasper1fb8d882013-05-14 09:30:02 +00005353 " b; //\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005354 "}\n"
5355 "}",
5356 22, 2, getLLVMStyle()));
Manuel Klimek52635ff2013-02-08 19:53:32 +00005357 EXPECT_EQ(" {\n"
Daniel Jasper1fb8d882013-05-14 09:30:02 +00005358 " a; //\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005359 " }",
5360 format(" {\n"
Daniel Jasper1fb8d882013-05-14 09:30:02 +00005361 "a; //\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005362 " }",
5363 4, 2, getLLVMStyle()));
Daniel Jasper9ece2bb2013-02-12 16:51:23 +00005364 EXPECT_EQ("void f() {}\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005365 "void g() {}",
5366 format("void f() {}\n"
5367 "void g() {}",
5368 13, 0, getLLVMStyle()));
Daniel Jasper83a90e52013-03-20 14:31:47 +00005369 EXPECT_EQ("int a; // comment\n"
5370 " // line 2\n"
5371 "int b;",
5372 format("int a; // comment\n"
5373 " // line 2\n"
5374 " int b;",
5375 35, 0, getLLVMStyle()));
Daniel Jasper15ec3a82013-07-11 21:27:40 +00005376 EXPECT_EQ(" int a;\n"
5377 " void\n"
5378 " ffffff() {\n"
5379 " }",
5380 format(" int a;\n"
5381 "void ffffff() {}",
5382 11, 0, getLLVMStyleWithColumns(11)));
Manuel Klimek52635ff2013-02-08 19:53:32 +00005383}
Manuel Klimek547d5db2013-02-08 17:38:27 +00005384
Manuel Klimek8092a942013-02-20 10:15:13 +00005385TEST_F(FormatTest, BreakStringLiterals) {
5386 EXPECT_EQ("\"some text \"\n"
5387 "\"other\";",
5388 format("\"some text other\";", getLLVMStyleWithColumns(12)));
Alexander Kornienko919398b2013-04-17 17:34:05 +00005389 EXPECT_EQ("\"some text \"\n"
5390 "\"other\";",
5391 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
Manuel Klimek8092a942013-02-20 10:15:13 +00005392 EXPECT_EQ(
5393 "#define A \\\n"
5394 " \"some \" \\\n"
5395 " \"text \" \\\n"
5396 " \"other\";",
5397 format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
5398 EXPECT_EQ(
5399 "#define A \\\n"
5400 " \"so \" \\\n"
5401 " \"text \" \\\n"
5402 " \"other\";",
5403 format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
5404
5405 EXPECT_EQ("\"some text\"",
5406 format("\"some text\"", getLLVMStyleWithColumns(1)));
5407 EXPECT_EQ("\"some text\"",
5408 format("\"some text\"", getLLVMStyleWithColumns(11)));
5409 EXPECT_EQ("\"some \"\n"
5410 "\"text\"",
5411 format("\"some text\"", getLLVMStyleWithColumns(10)));
5412 EXPECT_EQ("\"some \"\n"
5413 "\"text\"",
5414 format("\"some text\"", getLLVMStyleWithColumns(7)));
Manuel Klimekaf31fd72013-03-01 13:14:08 +00005415 EXPECT_EQ("\"some\"\n"
Alexander Kornienko70ce7882013-04-15 14:28:00 +00005416 "\" tex\"\n"
5417 "\"t\"",
Manuel Klimek8092a942013-02-20 10:15:13 +00005418 format("\"some text\"", getLLVMStyleWithColumns(6)));
Manuel Klimek00905912013-03-04 20:03:38 +00005419 EXPECT_EQ("\"some\"\n"
5420 "\" tex\"\n"
5421 "\" and\"",
5422 format("\"some tex and\"", getLLVMStyleWithColumns(6)));
5423 EXPECT_EQ("\"some\"\n"
5424 "\"/tex\"\n"
5425 "\"/and\"",
5426 format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
Manuel Klimek8092a942013-02-20 10:15:13 +00005427
5428 EXPECT_EQ("variable =\n"
5429 " \"long string \"\n"
5430 " \"literal\";",
5431 format("variable = \"long string literal\";",
5432 getLLVMStyleWithColumns(20)));
5433
5434 EXPECT_EQ("variable = f(\n"
5435 " \"long string \"\n"
Daniel Jasperfaab0d32013-02-27 09:47:53 +00005436 " \"literal\",\n"
5437 " short,\n"
Manuel Klimek8092a942013-02-20 10:15:13 +00005438 " loooooooooooooooooooong);",
5439 format("variable = f(\"long string literal\", short, "
5440 "loooooooooooooooooooong);",
5441 getLLVMStyleWithColumns(20)));
Alexander Kornienko22d0e292013-06-17 12:59:44 +00005442
5443 EXPECT_EQ("f(g(\"long string \"\n"
5444 " \"literal\"),\n"
5445 " b);",
5446 format("f(g(\"long string literal\"), b);",
5447 getLLVMStyleWithColumns(20)));
5448 EXPECT_EQ("f(g(\"long string \"\n"
5449 " \"literal\",\n"
5450 " a),\n"
5451 " b);",
5452 format("f(g(\"long string literal\", a), b);",
5453 getLLVMStyleWithColumns(20)));
Manuel Klimek8092a942013-02-20 10:15:13 +00005454 EXPECT_EQ(
5455 "f(\"one two\".split(\n"
Daniel Jasper13d2aa52013-08-30 08:29:25 +00005456 " variable));",
Manuel Klimek8092a942013-02-20 10:15:13 +00005457 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
5458 EXPECT_EQ("f(\"one two three four five six \"\n"
5459 " \"seven\".split(\n"
5460 " really_looooong_variable));",
5461 format("f(\"one two three four five six seven\"."
5462 "split(really_looooong_variable));",
5463 getLLVMStyleWithColumns(33)));
5464
5465 EXPECT_EQ("f(\"some \"\n"
5466 " \"text\",\n"
5467 " other);",
5468 format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
Daniel Jasper0fb382b2013-02-26 12:52:34 +00005469
5470 // Only break as a last resort.
5471 verifyFormat(
5472 "aaaaaaaaaaaaaaaaaaaa(\n"
5473 " aaaaaaaaaaaaaaaaaaaa,\n"
5474 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
Manuel Klimekaf31fd72013-03-01 13:14:08 +00005475
5476 EXPECT_EQ(
5477 "\"splitmea\"\n"
Manuel Klimekbc30c712013-03-01 13:29:19 +00005478 "\"trandomp\"\n"
5479 "\"oint\"",
Manuel Klimekaf31fd72013-03-01 13:14:08 +00005480 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
Manuel Klimekbc30c712013-03-01 13:29:19 +00005481
5482 EXPECT_EQ(
5483 "\"split/\"\n"
5484 "\"pathat/\"\n"
5485 "\"slashes\"",
5486 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
Daniel Jasper2972d042013-04-25 08:56:26 +00005487
Alexander Kornienkof2b2c7d2013-06-19 14:22:47 +00005488 EXPECT_EQ(
5489 "\"split/\"\n"
5490 "\"pathat/\"\n"
5491 "\"slashes\"",
5492 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
5493 EXPECT_EQ("\"split at \"\n"
5494 "\"spaces/at/\"\n"
5495 "\"slashes.at.any$\"\n"
5496 "\"non-alphanumeric%\"\n"
5497 "\"1111111111characte\"\n"
5498 "\"rs\"",
5499 format("\"split at "
5500 "spaces/at/"
5501 "slashes.at."
5502 "any$non-"
5503 "alphanumeric%"
5504 "1111111111characte"
5505 "rs\"",
5506 getLLVMStyleWithColumns(20)));
5507
Daniel Jasper0fde9502013-07-12 11:37:05 +00005508 // Verify that splitting the strings understands
5509 // Style::AlwaysBreakBeforeMultilineStrings.
5510 EXPECT_EQ("aaaaaaaaaaaa(aaaaaaaaaaaaa,\n"
5511 " \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
5512 " \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
5513 format("aaaaaaaaaaaa(aaaaaaaaaaaaa, \"aaaaaaaaaaaaaaaaaaaaaa "
5514 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa "
5515 "aaaaaaaaaaaaaaaaaaaaaa\");",
5516 getGoogleStyle()));
Daniel Jasper75e58bb2013-08-02 11:01:15 +00005517 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
5518 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
5519 format("llvm::outs() << "
5520 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
5521 "aaaaaaaaaaaaaaaaaaa\";"));
Daniel Jasper4df1ff92013-08-23 11:57:34 +00005522 EXPECT_EQ("ffff(\n"
5523 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
5524 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
5525 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
5526 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
5527 getGoogleStyle()));
Daniel Jasper0fde9502013-07-12 11:37:05 +00005528
Daniel Jasper2972d042013-04-25 08:56:26 +00005529 FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
5530 AlignLeft.AlignEscapedNewlinesLeft = true;
5531 EXPECT_EQ(
5532 "#define A \\\n"
5533 " \"some \" \\\n"
5534 " \"text \" \\\n"
5535 " \"other\";",
5536 format("#define A \"some text other\";", AlignLeft));
Manuel Klimek8092a942013-02-20 10:15:13 +00005537}
5538
Alexander Kornienko2c2f7292013-09-16 20:20:49 +00005539TEST_F(FormatTest, BreaksWideStringLiterals) {
5540 EXPECT_EQ(
5541 "u8\"utf8 string \"\n"
5542 "u8\"literal\";",
5543 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
5544 EXPECT_EQ(
5545 "u\"utf16 string \"\n"
5546 "u\"literal\";",
5547 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
5548 EXPECT_EQ(
5549 "U\"utf32 string \"\n"
5550 "U\"literal\";",
5551 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
5552 EXPECT_EQ("L\"wide string \"\n"
5553 "L\"literal\";",
5554 format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
5555}
5556
5557TEST_F(FormatTest, BreaksRawStringLiterals) {
5558 EXPECT_EQ("R\"x(raw )x\"\n"
5559 "R\"x(literal)x\";",
5560 format("R\"x(raw literal)x\";", getGoogleStyleWithColumns(15)));
5561 EXPECT_EQ("uR\"x(raw )x\"\n"
5562 "uR\"x(literal)x\";",
5563 format("uR\"x(raw literal)x\";", getGoogleStyleWithColumns(16)));
5564 EXPECT_EQ("u8R\"x(raw )x\"\n"
5565 "u8R\"x(literal)x\";",
5566 format("u8R\"x(raw literal)x\";", getGoogleStyleWithColumns(17)));
5567 EXPECT_EQ("LR\"x(raw )x\"\n"
5568 "LR\"x(literal)x\";",
5569 format("LR\"x(raw literal)x\";", getGoogleStyleWithColumns(16)));
5570 EXPECT_EQ("UR\"x(raw )x\"\n"
5571 "UR\"x(literal)x\";",
5572 format("UR\"x(raw literal)x\";", getGoogleStyleWithColumns(16)));
5573}
5574
5575TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
5576 FormatStyle Style = getLLVMStyleWithColumns(20);
5577 EXPECT_EQ(
5578 "_T(\"aaaaaaaaaaaaaa\")\n"
5579 "_T(\"aaaaaaaaaaaaaa\")\n"
5580 "_T(\"aaaaaaaaaaaa\")",
5581 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
5582 EXPECT_EQ("f(x, _T(\"aaaaaaaaa\")\n"
5583 " _T(\"aaaaaa\"),\n"
5584 " z);",
5585 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
5586
5587 // FIXME: Handle embedded spaces in one iteration.
5588 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
5589 // "_T(\"aaaaaaaaaaaaa\")\n"
5590 // "_T(\"aaaaaaaaaaaaa\")\n"
5591 // "_T(\"a\")",
5592 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
5593 // getLLVMStyleWithColumns(20)));
5594 EXPECT_EQ(
5595 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
5596 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
5597}
5598
Alexander Kornienko10c26b22013-07-16 21:06:13 +00005599TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
Alexander Kornienkodcc0c5b2013-08-29 17:32:57 +00005600 EXPECT_EQ(
5601 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
5602 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
5603 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
5604 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
5605 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
5606 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
5607}
5608
5609TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
5610 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
5611 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle()));
5612 EXPECT_EQ("fffffffffff(g(R\"x(\n"
5613 "multiline raw string literal xxxxxxxxxxxxxx\n"
5614 ")x\",\n"
5615 " a),\n"
5616 " b);",
5617 format("fffffffffff(g(R\"x(\n"
5618 "multiline raw string literal xxxxxxxxxxxxxx\n"
5619 ")x\", a), b);",
5620 getGoogleStyleWithColumns(20)));
5621 EXPECT_EQ("fffffffffff(\n"
5622 " g(R\"x(qqq\n"
5623 "multiline raw string literal xxxxxxxxxxxxxx\n"
5624 ")x\",\n"
5625 " a),\n"
5626 " b);",
5627 format("fffffffffff(g(R\"x(qqq\n"
5628 "multiline raw string literal xxxxxxxxxxxxxx\n"
5629 ")x\", a), b);",
5630 getGoogleStyleWithColumns(20)));
5631
5632 EXPECT_EQ("fffffffffff(R\"x(\n"
5633 "multiline raw string literal xxxxxxxxxxxxxx\n"
5634 ")x\");",
5635 format("fffffffffff(R\"x(\n"
5636 "multiline raw string literal xxxxxxxxxxxxxx\n"
5637 ")x\");",
5638 getGoogleStyleWithColumns(20)));
5639 EXPECT_EQ("fffffffffff(R\"x(\n"
5640 "multiline raw string literal xxxxxxxxxxxxxx\n"
5641 ")x\" +\n"
5642 " bbbbbb);",
5643 format("fffffffffff(R\"x(\n"
5644 "multiline raw string literal xxxxxxxxxxxxxx\n"
5645 ")x\" + bbbbbb);",
5646 getGoogleStyleWithColumns(20)));
Alexander Kornienko10c26b22013-07-16 21:06:13 +00005647}
5648
Alexander Kornienko16a0ec62013-06-14 11:46:10 +00005649TEST_F(FormatTest, SkipsUnknownStringLiterals) {
Daniel Jasper561211d2013-07-16 20:28:33 +00005650 verifyFormat("string a = \"unterminated;");
5651 EXPECT_EQ("function(\"unterminated,\n"
5652 " OtherParameter);",
5653 format("function( \"unterminated,\n"
5654 " OtherParameter);"));
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00005655}
5656
5657TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
5658 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
5659 format("#define x(_a) printf(\"foo\"_a);", getLLVMStyle()));
Alexander Kornienko16a0ec62013-06-14 11:46:10 +00005660}
5661
Manuel Klimek2a9805d2013-05-14 09:04:24 +00005662TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
5663 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
5664 " \"ddeeefff\");",
5665 format("someFunction(\"aaabbbcccdddeeefff\");",
5666 getLLVMStyleWithColumns(25)));
5667 EXPECT_EQ("someFunction1234567890(\n"
5668 " \"aaabbbcccdddeeefff\");",
5669 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
5670 getLLVMStyleWithColumns(26)));
5671 EXPECT_EQ("someFunction1234567890(\n"
5672 " \"aaabbbcccdddeeeff\"\n"
5673 " \"f\");",
5674 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
5675 getLLVMStyleWithColumns(25)));
5676 EXPECT_EQ("someFunction1234567890(\n"
5677 " \"aaabbbcccdddeeeff\"\n"
5678 " \"f\");",
5679 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
5680 getLLVMStyleWithColumns(24)));
Daniel Jasperf5461782013-08-28 10:03:58 +00005681 EXPECT_EQ("someFunction(\"aaabbbcc \"\n"
5682 " \"ddde \"\n"
5683 " \"efff\");",
5684 format("someFunction(\"aaabbbcc ddde efff\");",
Manuel Klimek2a9805d2013-05-14 09:04:24 +00005685 getLLVMStyleWithColumns(25)));
5686 EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
5687 " \"ddeeefff\");",
5688 format("someFunction(\"aaabbbccc ddeeefff\");",
5689 getLLVMStyleWithColumns(25)));
5690 EXPECT_EQ("someFunction1234567890(\n"
5691 " \"aaabb \"\n"
5692 " \"cccdddeeefff\");",
5693 format("someFunction1234567890(\"aaabb cccdddeeefff\");",
5694 getLLVMStyleWithColumns(25)));
5695 EXPECT_EQ("#define A \\\n"
5696 " string s = \\\n"
5697 " \"123456789\" \\\n"
5698 " \"0\"; \\\n"
5699 " int i;",
5700 format("#define A string s = \"1234567890\"; int i;",
5701 getLLVMStyleWithColumns(20)));
Daniel Jasperf5461782013-08-28 10:03:58 +00005702 // FIXME: Put additional penalties on breaking at non-whitespace locations.
5703 EXPECT_EQ("someFunction(\"aaabbbcc \"\n"
5704 " \"dddeeeff\"\n"
5705 " \"f\");",
5706 format("someFunction(\"aaabbbcc dddeeefff\");",
5707 getLLVMStyleWithColumns(25)));
Manuel Klimek2a9805d2013-05-14 09:04:24 +00005708}
5709
Manuel Klimekaa62d0c2013-03-08 18:59:48 +00005710TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
5711 EXPECT_EQ("\"\\a\"",
5712 format("\"\\a\"", getLLVMStyleWithColumns(3)));
5713 EXPECT_EQ("\"\\\"",
5714 format("\"\\\"", getLLVMStyleWithColumns(2)));
5715 EXPECT_EQ("\"test\"\n"
5716 "\"\\n\"",
5717 format("\"test\\n\"", getLLVMStyleWithColumns(7)));
5718 EXPECT_EQ("\"tes\\\\\"\n"
5719 "\"n\"",
5720 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
5721 EXPECT_EQ("\"\\\\\\\\\"\n"
5722 "\"\\n\"",
5723 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
5724 EXPECT_EQ("\"\\uff01\"",
5725 format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
5726 EXPECT_EQ("\"\\uff01\"\n"
5727 "\"test\"",
5728 format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
5729 EXPECT_EQ("\"\\Uff01ff02\"",
5730 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
5731 EXPECT_EQ("\"\\x000000000001\"\n"
5732 "\"next\"",
5733 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
5734 EXPECT_EQ("\"\\x000000000001next\"",
5735 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
5736 EXPECT_EQ("\"\\x000000000001\"",
5737 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
5738 EXPECT_EQ("\"test\"\n"
5739 "\"\\000000\"\n"
5740 "\"000001\"",
5741 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
5742 EXPECT_EQ("\"test\\000\"\n"
Alexander Kornienko70ce7882013-04-15 14:28:00 +00005743 "\"00000000\"\n"
5744 "\"1\"",
Manuel Klimekaa62d0c2013-03-08 18:59:48 +00005745 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
Alexander Kornienko2c2f7292013-09-16 20:20:49 +00005746 // FIXME: We probably don't need to care about escape sequences in raw
5747 // literals.
5748 EXPECT_EQ("R\"(\\x)\"\n"
5749 "R\"(\\x00)\"\n",
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00005750 format("R\"(\\x\\x00)\"\n", getGoogleStyleWithColumns(7)));
Manuel Klimekaa62d0c2013-03-08 18:59:48 +00005751}
5752
Manuel Klimek423dd932013-04-10 09:52:05 +00005753TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
5754 verifyFormat("void f() {\n"
5755 " return g() {}\n"
5756 " void h() {}");
5757 verifyFormat("if (foo)\n"
5758 " return { forgot_closing_brace();\n"
5759 "test();");
Daniel Jasper88959b72013-05-28 18:50:02 +00005760 verifyFormat("int a[] = { void forgot_closing_brace() { f();\n"
5761 "g();\n"
Manuel Klimek423dd932013-04-10 09:52:05 +00005762 "}");
5763}
5764
Manuel Klimek07a64ec2013-05-13 08:42:42 +00005765TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
5766 verifyFormat("class X {\n"
5767 " void f() {\n"
5768 " }\n"
5769 "};",
5770 getLLVMStyleWithColumns(12));
5771}
5772
5773TEST_F(FormatTest, ConfigurableIndentWidth) {
5774 FormatStyle EightIndent = getLLVMStyleWithColumns(18);
5775 EightIndent.IndentWidth = 8;
5776 verifyFormat("void f() {\n"
5777 " someFunction();\n"
5778 " if (true) {\n"
5779 " f();\n"
5780 " }\n"
5781 "}",
5782 EightIndent);
5783 verifyFormat("class X {\n"
5784 " void f() {\n"
5785 " }\n"
5786 "};",
5787 EightIndent);
5788 verifyFormat("int x[] = {\n"
5789 " call(),\n"
5790 " call(),\n"
5791 "};",
5792 EightIndent);
5793}
5794
Alexander Kornienkoc1c76252013-06-22 01:35:36 +00005795TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
Manuel Klimeka9a7f102013-06-21 17:25:42 +00005796 verifyFormat("void\n"
5797 "f();",
5798 getLLVMStyleWithColumns(8));
5799}
5800
Manuel Klimek7c9a93e2013-05-13 09:22:11 +00005801TEST_F(FormatTest, ConfigurableUseOfTab) {
5802 FormatStyle Tab = getLLVMStyleWithColumns(42);
5803 Tab.IndentWidth = 8;
Alexander Kornienko3d9ffcf2013-09-27 16:14:22 +00005804 Tab.UseTab = FormatStyle::UT_Always;
Manuel Klimek7c9a93e2013-05-13 09:22:11 +00005805 Tab.AlignEscapedNewlinesLeft = true;
Alexander Kornienkoacf8e902013-09-27 09:45:40 +00005806
5807 EXPECT_EQ("if (aaaaaaaa && // q\n"
5808 " bb)\t\t// w\n"
5809 "\t;",
5810 format("if (aaaaaaaa &&// q\n"
5811 "bb)// w\n"
5812 ";",
5813 Tab));
5814 EXPECT_EQ("if (aaa && bbb) // w\n"
5815 "\t;",
5816 format("if(aaa&&bbb)// w\n"
5817 ";",
5818 Tab));
5819
Manuel Klimek7c9a93e2013-05-13 09:22:11 +00005820 verifyFormat("class X {\n"
5821 "\tvoid f() {\n"
5822 "\t\tsomeFunction(parameter1,\n"
5823 "\t\t\t parameter2);\n"
5824 "\t}\n"
5825 "};",
5826 Tab);
5827 verifyFormat("#define A \\\n"
5828 "\tvoid f() { \\\n"
5829 "\t\tsomeFunction( \\\n"
5830 "\t\t parameter1, \\\n"
5831 "\t\t parameter2); \\\n"
5832 "\t}",
5833 Tab);
Manuel Klimekc41e8192013-08-29 15:21:40 +00005834 EXPECT_EQ("void f() {\n"
5835 "\tf();\n"
5836 "\tg();\n"
5837 "}",
5838 format("void f() {\n"
5839 "\tf();\n"
5840 "\tg();\n"
5841 "}",
5842 0, 0, Tab));
5843 EXPECT_EQ("void f() {\n"
5844 "\tf();\n"
5845 "\tg();\n"
5846 "}",
5847 format("void f() {\n"
5848 "\tf();\n"
5849 "\tg();\n"
5850 "}",
5851 16, 0, Tab));
5852 EXPECT_EQ("void f() {\n"
5853 " \tf();\n"
5854 "\tg();\n"
5855 "}",
5856 format("void f() {\n"
5857 " \tf();\n"
5858 " \tg();\n"
5859 "}",
5860 21, 0, Tab));
Manuel Klimekd63312b2013-05-28 10:01:59 +00005861
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00005862 Tab.TabWidth = 4;
5863 Tab.IndentWidth = 8;
5864 verifyFormat("class TabWidth4Indent8 {\n"
5865 "\t\tvoid f() {\n"
5866 "\t\t\t\tsomeFunction(parameter1,\n"
5867 "\t\t\t\t\t\t\t parameter2);\n"
5868 "\t\t}\n"
5869 "};",
5870 Tab);
5871
5872 Tab.TabWidth = 4;
5873 Tab.IndentWidth = 4;
5874 verifyFormat("class TabWidth4Indent4 {\n"
5875 "\tvoid f() {\n"
5876 "\t\tsomeFunction(parameter1,\n"
5877 "\t\t\t\t\t parameter2);\n"
5878 "\t}\n"
5879 "};",
5880 Tab);
5881
5882 Tab.TabWidth = 8;
5883 Tab.IndentWidth = 4;
5884 verifyFormat("class TabWidth8Indent4 {\n"
5885 " void f() {\n"
5886 "\tsomeFunction(parameter1,\n"
5887 "\t\t parameter2);\n"
5888 " }\n"
5889 "};",
5890 Tab);
5891
Alexander Kornienko83a7dcd2013-09-10 09:38:25 +00005892 Tab.TabWidth = 8;
5893 Tab.IndentWidth = 8;
5894 EXPECT_EQ("/*\n"
5895 "\t a\t\tcomment\n"
5896 "\t in multiple lines\n"
5897 " */",
5898 format(" /*\t \t \n"
5899 " \t \t a\t\tcomment\t \t\n"
5900 " \t \t in multiple lines\t\n"
5901 " \t */",
5902 Tab));
Alexander Kornienkoacf8e902013-09-27 09:45:40 +00005903
Alexander Kornienko3d9ffcf2013-09-27 16:14:22 +00005904 Tab.UseTab = FormatStyle::UT_ForIndentation;
5905 EXPECT_EQ("if (aaaaaaaa && // q\n"
5906 " bb) // w\n"
5907 "\t;",
5908 format("if (aaaaaaaa &&// q\n"
5909 "bb)// w\n"
5910 ";",
5911 Tab));
5912 verifyFormat("class X {\n"
5913 "\tvoid f() {\n"
5914 "\t\tsomeFunction(parameter1,\n"
5915 "\t\t parameter2);\n"
5916 "\t}\n"
5917 "};",
5918 Tab);
5919 verifyFormat("{\n"
5920 "\tQ({\n"
5921 "\t\t int a;\n"
5922 "\t\t someFunction(aaaaaaaaaa,\n"
5923 "\t\t bbbbbbbbb);\n"
5924 "\t },\n"
5925 "\t p);\n"
5926 "}",
5927 Tab);
5928 EXPECT_EQ("{\n"
5929 "\t/* aaaa\n"
5930 "\t bbbb */\n"
5931 "}",
5932 format("{\n"
5933 "/* aaaa\n"
5934 " bbbb */\n"
5935 "}",
5936 Tab));
5937 EXPECT_EQ("{\n"
5938 "\t/*\n"
5939 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5940 "\t bbbbbbbbbbbbb\n"
5941 "\t*/\n"
5942 "}",
5943 format("{\n"
5944 "/*\n"
5945 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
5946 "*/\n"
5947 "}",
5948 Tab));
5949 EXPECT_EQ("{\n"
5950 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5951 "\t// bbbbbbbbbbbbb\n"
5952 "}",
5953 format("{\n"
5954 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
5955 "}",
5956 Tab));
5957 EXPECT_EQ("{\n"
5958 "\t/*\n"
5959 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5960 "\t bbbbbbbbbbbbb\n"
5961 "\t*/\n"
5962 "}",
5963 format("{\n"
5964 "\t/*\n"
5965 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
5966 "\t*/\n"
5967 "}",
5968 Tab));
5969 EXPECT_EQ("{\n"
5970 "\t/*\n"
5971 "\n"
5972 "\t*/\n"
5973 "}",
5974 format("{\n"
5975 "\t/*\n"
5976 "\n"
5977 "\t*/\n"
Alexander Kornienko6967e782013-09-27 16:40:11 +00005978 "}",
5979 Tab));
5980 EXPECT_EQ("{\n"
5981 "\t/*\n"
5982 " asdf\n"
5983 "\t*/\n"
5984 "}",
5985 format("{\n"
5986 "\t/*\n"
5987 " asdf\n"
5988 "\t*/\n"
5989 "}",
5990 Tab));
Alexander Kornienko3d9ffcf2013-09-27 16:14:22 +00005991
5992 Tab.UseTab = FormatStyle::UT_Never;
Alexander Kornienko83a7dcd2013-09-10 09:38:25 +00005993 EXPECT_EQ("/*\n"
5994 " a\t\tcomment\n"
5995 " in multiple lines\n"
5996 " */",
5997 format(" /*\t \t \n"
5998 " \t \t a\t\tcomment\t \t\n"
5999 " \t \t in multiple lines\t\n"
6000 " \t */",
6001 Tab));
6002 EXPECT_EQ("/* some\n"
6003 " comment */",
6004 format(" \t \t /* some\n"
6005 " \t \t comment */",
6006 Tab));
6007 EXPECT_EQ("int a; /* some\n"
6008 " comment */",
6009 format(" \t \t int a; /* some\n"
6010 " \t \t comment */",
6011 Tab));
Manuel Klimekd63312b2013-05-28 10:01:59 +00006012
Alexander Kornienko83a7dcd2013-09-10 09:38:25 +00006013 EXPECT_EQ("int a; /* some\n"
6014 "comment */",
6015 format(" \t \t int\ta; /* some\n"
6016 " \t \t comment */",
6017 Tab));
6018 EXPECT_EQ("f(\"\t\t\"); /* some\n"
6019 " comment */",
6020 format(" \t \t f(\"\t\t\"); /* some\n"
6021 " \t \t comment */",
6022 Tab));
Manuel Klimekd63312b2013-05-28 10:01:59 +00006023 EXPECT_EQ("{\n"
6024 " /*\n"
6025 " * Comment\n"
6026 " */\n"
6027 " int i;\n"
6028 "}",
6029 format("{\n"
6030 "\t/*\n"
6031 "\t * Comment\n"
6032 "\t */\n"
6033 "\t int i;\n"
6034 "}"));
Manuel Klimek7c9a93e2013-05-13 09:22:11 +00006035}
6036
Alexander Kornienko6f6154c2013-09-10 12:29:48 +00006037TEST_F(FormatTest, CalculatesOriginalColumn) {
6038 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
6039 "q\"; /* some\n"
6040 " comment */",
6041 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
6042 "q\"; /* some\n"
6043 " comment */",
6044 getLLVMStyle()));
6045 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
6046 "/* some\n"
6047 " comment */",
6048 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
6049 " /* some\n"
6050 " comment */",
6051 getLLVMStyle()));
6052 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
6053 "qqq\n"
6054 "/* some\n"
6055 " comment */",
6056 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
6057 "qqq\n"
6058 " /* some\n"
6059 " comment */",
6060 getLLVMStyle()));
6061 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
6062 "wwww; /* some\n"
6063 " comment */",
6064 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
6065 "wwww; /* some\n"
6066 " comment */",
6067 getLLVMStyle()));
6068}
6069
Daniel Jasper7df56bf2013-08-20 12:36:34 +00006070TEST_F(FormatTest, ConfigurableSpaceAfterControlStatementKeyword) {
6071 FormatStyle NoSpace = getLLVMStyle();
6072 NoSpace.SpaceAfterControlStatementKeyword = false;
6073
6074 verifyFormat("while(true)\n"
6075 " continue;", NoSpace);
6076 verifyFormat("for(;;)\n"
6077 " continue;", NoSpace);
6078 verifyFormat("if(true)\n"
6079 " f();\n"
6080 "else if(true)\n"
6081 " f();", NoSpace);
6082 verifyFormat("do {\n"
6083 " do_something();\n"
6084 "} while(something());", NoSpace);
6085 verifyFormat("switch(x) {\n"
6086 "default:\n"
6087 " break;\n"
6088 "}", NoSpace);
6089}
6090
6091TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
6092 FormatStyle Spaces = getLLVMStyle();
6093
6094 Spaces.SpacesInParentheses = true;
6095 verifyFormat("call( x, y, z );", Spaces);
6096 verifyFormat("while ( (bool)1 )\n"
6097 " continue;", Spaces);
6098 verifyFormat("for ( ;; )\n"
6099 " continue;", Spaces);
6100 verifyFormat("if ( true )\n"
6101 " f();\n"
6102 "else if ( true )\n"
6103 " f();", Spaces);
6104 verifyFormat("do {\n"
6105 " do_something( (int)i );\n"
6106 "} while ( something() );", Spaces);
6107 verifyFormat("switch ( x ) {\n"
6108 "default:\n"
6109 " break;\n"
6110 "}", Spaces);
6111
6112 Spaces.SpacesInParentheses = false;
6113 Spaces.SpacesInCStyleCastParentheses = true;
6114 verifyFormat("Type *A = ( Type * )P;", Spaces);
6115 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
6116 verifyFormat("x = ( int32 )y;", Spaces);
6117 verifyFormat("int a = ( int )(2.0f);", Spaces);
6118 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
6119 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
6120 verifyFormat("#define x (( int )-1)", Spaces);
6121
6122 Spaces.SpacesInParentheses = false;
6123 Spaces.SpaceInEmptyParentheses = true;
6124 verifyFormat("call(x, y, z);", Spaces);
6125 verifyFormat("call( )", Spaces);
6126
6127 // Run the first set of tests again with
6128 // Spaces.SpacesInParentheses = false,
6129 // Spaces.SpaceInEmptyParentheses = true and
6130 // Spaces.SpacesInCStyleCastParentheses = true
6131 Spaces.SpacesInParentheses = false,
6132 Spaces.SpaceInEmptyParentheses = true;
6133 Spaces.SpacesInCStyleCastParentheses = true;
6134 verifyFormat("call(x, y, z);", Spaces);
6135 verifyFormat("while (( bool )1)\n"
6136 " continue;", Spaces);
6137 verifyFormat("for (;;)\n"
6138 " continue;", Spaces);
6139 verifyFormat("if (true)\n"
6140 " f( );\n"
6141 "else if (true)\n"
6142 " f( );", Spaces);
6143 verifyFormat("do {\n"
6144 " do_something(( int )i);\n"
6145 "} while (something( ));", Spaces);
6146 verifyFormat("switch (x) {\n"
6147 "default:\n"
6148 " break;\n"
6149 "}", Spaces);
6150}
6151
Daniel Jasper9b4de852013-09-25 15:15:02 +00006152TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
6153 verifyFormat("int a = 5;");
6154 verifyFormat("a += 42;");
6155 verifyFormat("a or_eq 8;");
6156
6157 FormatStyle Spaces = getLLVMStyle();
6158 Spaces.SpaceBeforeAssignmentOperators = false;
6159 verifyFormat("int a= 5;", Spaces);
6160 verifyFormat("a+= 42;", Spaces);
6161 verifyFormat("a or_eq 8;", Spaces);
6162}
6163
Manuel Klimek44135b82013-05-13 12:51:40 +00006164TEST_F(FormatTest, LinuxBraceBreaking) {
6165 FormatStyle BreakBeforeBrace = getLLVMStyle();
6166 BreakBeforeBrace.BreakBeforeBraces = FormatStyle::BS_Linux;
6167 verifyFormat("namespace a\n"
6168 "{\n"
6169 "class A\n"
6170 "{\n"
6171 " void f()\n"
6172 " {\n"
6173 " if (true) {\n"
6174 " a();\n"
6175 " b();\n"
6176 " }\n"
6177 " }\n"
Daniel Jasper9f321612013-05-15 08:30:06 +00006178 " void g()\n"
6179 " {\n"
6180 " return;\n"
6181 " }\n"
Manuel Klimek44135b82013-05-13 12:51:40 +00006182 "}\n"
6183 "}",
6184 BreakBeforeBrace);
6185}
6186
6187TEST_F(FormatTest, StroustrupBraceBreaking) {
6188 FormatStyle BreakBeforeBrace = getLLVMStyle();
6189 BreakBeforeBrace.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
6190 verifyFormat("namespace a {\n"
6191 "class A {\n"
6192 " void f()\n"
6193 " {\n"
6194 " if (true) {\n"
6195 " a();\n"
6196 " b();\n"
6197 " }\n"
6198 " }\n"
Daniel Jasper9f321612013-05-15 08:30:06 +00006199 " void g()\n"
6200 " {\n"
6201 " return;\n"
6202 " }\n"
Manuel Klimek44135b82013-05-13 12:51:40 +00006203 "}\n"
6204 "}",
6205 BreakBeforeBrace);
6206}
6207
Manuel Klimeke4907052013-08-02 21:31:59 +00006208TEST_F(FormatTest, AllmanBraceBreaking) {
6209 FormatStyle BreakBeforeBrace = getLLVMStyle();
6210 BreakBeforeBrace.BreakBeforeBraces = FormatStyle::BS_Allman;
6211 verifyFormat("namespace a\n"
6212 "{\n"
6213 "class A\n"
6214 "{\n"
6215 " void f()\n"
6216 " {\n"
6217 " if (true)\n"
6218 " {\n"
6219 " a();\n"
6220 " b();\n"
6221 " }\n"
6222 " }\n"
6223 " void g()\n"
6224 " {\n"
6225 " return;\n"
6226 " }\n"
6227 "}\n"
6228 "}",
6229 BreakBeforeBrace);
6230
6231 verifyFormat("void f()\n"
6232 "{\n"
6233 " if (true)\n"
6234 " {\n"
6235 " a();\n"
6236 " }\n"
6237 " else if (false)\n"
6238 " {\n"
6239 " b();\n"
6240 " }\n"
6241 " else\n"
6242 " {\n"
6243 " c();\n"
6244 " }\n"
6245 "}\n",
6246 BreakBeforeBrace);
6247
6248 verifyFormat("void f()\n"
6249 "{\n"
6250 " for (int i = 0; i < 10; ++i)\n"
6251 " {\n"
6252 " a();\n"
6253 " }\n"
6254 " while (false)\n"
6255 " {\n"
6256 " b();\n"
6257 " }\n"
6258 " do\n"
6259 " {\n"
6260 " c();\n"
6261 " } while (false)\n"
6262 "}\n",
6263 BreakBeforeBrace);
6264
6265 verifyFormat("void f(int a)\n"
6266 "{\n"
6267 " switch (a)\n"
6268 " {\n"
6269 " case 0:\n"
6270 " break;\n"
6271 " case 1:\n"
6272 " {\n"
6273 " break;\n"
6274 " }\n"
6275 " case 2:\n"
6276 " {\n"
6277 " }\n"
6278 " break;\n"
6279 " default:\n"
6280 " break;\n"
6281 " }\n"
6282 "}\n",
6283 BreakBeforeBrace);
Manuel Klimekd3a247c2013-08-07 19:20:45 +00006284
6285 verifyFormat("enum X\n"
6286 "{\n"
6287 " Y = 0,\n"
6288 "}\n",
6289 BreakBeforeBrace);
6290
6291 FormatStyle BreakBeforeBraceShortIfs = BreakBeforeBrace;
6292 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = true;
6293 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
6294 verifyFormat("void f(bool b)\n"
6295 "{\n"
6296 " if (b)\n"
6297 " {\n"
6298 " return;\n"
6299 " }\n"
6300 "}\n",
6301 BreakBeforeBraceShortIfs);
6302 verifyFormat("void f(bool b)\n"
6303 "{\n"
6304 " if (b) return;\n"
6305 "}\n",
6306 BreakBeforeBraceShortIfs);
6307 verifyFormat("void f(bool b)\n"
6308 "{\n"
6309 " while (b)\n"
6310 " {\n"
6311 " return;\n"
6312 " }\n"
6313 "}\n",
6314 BreakBeforeBraceShortIfs);
Manuel Klimeke4907052013-08-02 21:31:59 +00006315}
6316
Manuel Klimek2530fd52013-08-12 03:51:17 +00006317TEST_F(FormatTest, CatchExceptionReferenceBinding) {
6318 verifyFormat("void f() {\n"
6319 " try {\n"
6320 " }\n"
6321 " catch (const Exception &e) {\n"
6322 " }\n"
6323 "}\n",
6324 getLLVMStyle());
6325}
6326
Daniel Jasper1dc6f742013-08-07 16:29:23 +00006327TEST_F(FormatTest, UnderstandsPragmas) {
6328 verifyFormat("#pragma omp reduction(| : var)");
6329 verifyFormat("#pragma omp reduction(+ : var)");
6330}
6331
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006332bool allStylesEqual(ArrayRef<FormatStyle> Styles) {
6333 for (size_t i = 1; i < Styles.size(); ++i)
6334 if (!(Styles[0] == Styles[i]))
6335 return false;
6336 return true;
6337}
6338
6339TEST_F(FormatTest, GetsPredefinedStyleByName) {
Alexander Kornienko885f87b2013-05-19 00:53:30 +00006340 FormatStyle Styles[3];
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006341
Alexander Kornienko885f87b2013-05-19 00:53:30 +00006342 Styles[0] = getLLVMStyle();
6343 EXPECT_TRUE(getPredefinedStyle("LLVM", &Styles[1]));
6344 EXPECT_TRUE(getPredefinedStyle("lLvM", &Styles[2]));
6345 EXPECT_TRUE(allStylesEqual(Styles));
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006346
Alexander Kornienko885f87b2013-05-19 00:53:30 +00006347 Styles[0] = getGoogleStyle();
6348 EXPECT_TRUE(getPredefinedStyle("Google", &Styles[1]));
6349 EXPECT_TRUE(getPredefinedStyle("gOOgle", &Styles[2]));
6350 EXPECT_TRUE(allStylesEqual(Styles));
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006351
Alexander Kornienko885f87b2013-05-19 00:53:30 +00006352 Styles[0] = getChromiumStyle();
6353 EXPECT_TRUE(getPredefinedStyle("Chromium", &Styles[1]));
6354 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", &Styles[2]));
6355 EXPECT_TRUE(allStylesEqual(Styles));
6356
6357 Styles[0] = getMozillaStyle();
6358 EXPECT_TRUE(getPredefinedStyle("Mozilla", &Styles[1]));
6359 EXPECT_TRUE(getPredefinedStyle("moZILla", &Styles[2]));
6360 EXPECT_TRUE(allStylesEqual(Styles));
6361
Daniel Jaspere05dc6d2013-07-24 13:10:59 +00006362 Styles[0] = getWebKitStyle();
6363 EXPECT_TRUE(getPredefinedStyle("WebKit", &Styles[1]));
6364 EXPECT_TRUE(getPredefinedStyle("wEbKit", &Styles[2]));
6365 EXPECT_TRUE(allStylesEqual(Styles));
6366
Alexander Kornienko885f87b2013-05-19 00:53:30 +00006367 EXPECT_FALSE(getPredefinedStyle("qwerty", &Styles[0]));
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006368}
6369
6370TEST_F(FormatTest, ParsesConfiguration) {
6371 FormatStyle Style = {};
6372#define CHECK_PARSE(TEXT, FIELD, VALUE) \
6373 EXPECT_NE(VALUE, Style.FIELD); \
6374 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \
6375 EXPECT_EQ(VALUE, Style.FIELD)
6376
6377#define CHECK_PARSE_BOOL(FIELD) \
6378 Style.FIELD = false; \
6379 EXPECT_EQ(0, parseConfiguration(#FIELD ": true", &Style).value()); \
Alexander Kornienko885f87b2013-05-19 00:53:30 +00006380 EXPECT_TRUE(Style.FIELD); \
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006381 EXPECT_EQ(0, parseConfiguration(#FIELD ": false", &Style).value()); \
Patrik Hagglund33717112013-05-14 07:53:53 +00006382 EXPECT_FALSE(Style.FIELD);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006383
6384 CHECK_PARSE_BOOL(AlignEscapedNewlinesLeft);
Daniel Jasper893ea8d2013-07-31 23:55:15 +00006385 CHECK_PARSE_BOOL(AlignTrailingComments);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006386 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
6387 CHECK_PARSE_BOOL(AllowShortIfStatementsOnASingleLine);
Daniel Jasper2a2579a2013-05-16 12:16:23 +00006388 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
Daniel Jasperbbc87762013-05-29 12:07:31 +00006389 CHECK_PARSE_BOOL(AlwaysBreakTemplateDeclarations);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006390 CHECK_PARSE_BOOL(BinPackParameters);
Daniel Jaspere8b10d32013-07-26 16:56:36 +00006391 CHECK_PARSE_BOOL(BreakBeforeBinaryOperators);
6392 CHECK_PARSE_BOOL(BreakConstructorInitializersBeforeComma);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006393 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
6394 CHECK_PARSE_BOOL(DerivePointerBinding);
6395 CHECK_PARSE_BOOL(IndentCaseLabels);
6396 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
6397 CHECK_PARSE_BOOL(PointerBindsToType);
Daniel Jasperb5dc3f42013-07-16 18:22:10 +00006398 CHECK_PARSE_BOOL(Cpp11BracedListStyle);
Manuel Klimeka9a7f102013-06-21 17:25:42 +00006399 CHECK_PARSE_BOOL(IndentFunctionDeclarationAfterType);
Daniel Jasper7df56bf2013-08-20 12:36:34 +00006400 CHECK_PARSE_BOOL(SpacesInParentheses);
6401 CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
6402 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
6403 CHECK_PARSE_BOOL(SpaceAfterControlStatementKeyword);
Daniel Jasper9b4de852013-09-25 15:15:02 +00006404 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006405
6406 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
Daniel Jasper6315fec2013-08-13 10:58:30 +00006407 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
6408 ConstructorInitializerIndentWidth, 1234u);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006409 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
6410 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
6411 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
6412 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
6413 PenaltyReturnTypeOnItsOwnLine, 1234u);
6414 CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
6415 SpacesBeforeTrailingComments, 1234u);
Manuel Klimek07a64ec2013-05-13 08:42:42 +00006416 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006417
6418 Style.Standard = FormatStyle::LS_Auto;
Alexander Kornienko9321e872013-09-04 14:09:13 +00006419 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
6420 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Cpp11);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006421 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
6422 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
6423 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
6424
Alexander Kornienko3d9ffcf2013-09-27 16:14:22 +00006425 Style.UseTab = FormatStyle::UT_ForIndentation;
6426 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
6427 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
6428 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
6429 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
6430 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
6431
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006432 Style.ColumnLimit = 123;
6433 FormatStyle BaseStyle = getLLVMStyle();
6434 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
6435 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
6436
Manuel Klimek44135b82013-05-13 12:51:40 +00006437 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
6438 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
6439 FormatStyle::BS_Attach);
6440 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
6441 FormatStyle::BS_Linux);
6442 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
6443 FormatStyle::BS_Stroustrup);
6444
Daniel Jaspereff18b92013-07-31 23:16:02 +00006445 Style.NamespaceIndentation = FormatStyle::NI_All;
6446 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
6447 FormatStyle::NI_None);
6448 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
6449 FormatStyle::NI_Inner);
6450 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
6451 FormatStyle::NI_All);
6452
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006453#undef CHECK_PARSE
6454#undef CHECK_PARSE_BOOL
6455}
6456
6457TEST_F(FormatTest, ConfigurationRoundTripTest) {
6458 FormatStyle Style = getLLVMStyle();
6459 std::string YAML = configurationAsText(Style);
6460 FormatStyle ParsedStyle = {};
6461 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
6462 EXPECT_EQ(Style, ParsedStyle);
6463}
6464
Alexander Kornienko00895102013-06-05 14:09:10 +00006465TEST_F(FormatTest, WorksFor8bitEncodings) {
6466 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
6467 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
6468 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
6469 "\"\xef\xee\xf0\xf3...\"",
6470 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
6471 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
6472 "\xef\xee\xf0\xf3...\"",
6473 getLLVMStyleWithColumns(12)));
6474}
6475
NAKAMURA Takumi07eda942013-06-06 01:14:58 +00006476// FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
6477#if !defined(_MSC_VER)
6478
Alexander Kornienko00895102013-06-05 14:09:10 +00006479TEST_F(FormatTest, CountsUTF8CharactersProperly) {
6480 verifyFormat("\"Однажды в студёную зимнюю пору...\"",
6481 getLLVMStyleWithColumns(35));
6482 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00006483 getLLVMStyleWithColumns(31));
Alexander Kornienko00895102013-06-05 14:09:10 +00006484 verifyFormat("// Однажды в студёную зимнюю пору...",
6485 getLLVMStyleWithColumns(36));
6486 verifyFormat("// 一 二 三 四 五 六 七 八 九 十",
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00006487 getLLVMStyleWithColumns(32));
Alexander Kornienko00895102013-06-05 14:09:10 +00006488 verifyFormat("/* Однажды в студёную зимнюю пору... */",
6489 getLLVMStyleWithColumns(39));
6490 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00006491 getLLVMStyleWithColumns(35));
Alexander Kornienko00895102013-06-05 14:09:10 +00006492}
6493
6494TEST_F(FormatTest, SplitsUTF8Strings) {
6495 EXPECT_EQ(
6496 "\"Однажды, в \"\n"
6497 "\"студёную \"\n"
6498 "\"зимнюю \"\n"
6499 "\"пору,\"",
6500 format("\"Однажды, в студёную зимнюю пору,\"",
6501 getLLVMStyleWithColumns(13)));
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00006502 EXPECT_EQ("\"一 二 三 \"\n"
6503 "\"四 五六 \"\n"
6504 "\"七 八 九 \"\n"
6505 "\"十\"",
6506 format("\"一 二 三 四 五六 七 八 九 十\"",
6507 getLLVMStyleWithColumns(11)));
6508 EXPECT_EQ("\"一\t二 \"\n"
6509 "\"\t三 \"\n"
6510 "\"四 五\t六 \"\n"
6511 "\"\t七 \"\n"
6512 "\"八九十\tqq\"",
6513 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
6514 getLLVMStyleWithColumns(11)));
6515}
6516
6517
6518TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
6519 EXPECT_EQ("const char *sssss =\n"
6520 " \"一二三四五六七八\\\n"
6521 " 九 十\";",
6522 format("const char *sssss = \"一二三四五六七八\\\n"
6523 " 九 十\";",
6524 getLLVMStyleWithColumns(30)));
Alexander Kornienko00895102013-06-05 14:09:10 +00006525}
6526
6527TEST_F(FormatTest, SplitsUTF8LineComments) {
6528 EXPECT_EQ("// Я из лесу\n"
6529 "// вышел; был\n"
6530 "// сильный\n"
6531 "// мороз.",
6532 format("// Я из лесу вышел; был сильный мороз.",
6533 getLLVMStyleWithColumns(13)));
6534 EXPECT_EQ("// 一二三\n"
6535 "// 四五六七\n"
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00006536 "// 八 九\n"
6537 "// 十",
6538 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9)));
Alexander Kornienko00895102013-06-05 14:09:10 +00006539}
6540
6541TEST_F(FormatTest, SplitsUTF8BlockComments) {
6542 EXPECT_EQ("/* Гляжу,\n"
6543 " * поднимается\n"
6544 " * медленно в\n"
6545 " * гору\n"
6546 " * Лошадка,\n"
6547 " * везущая\n"
6548 " * хворосту\n"
6549 " * воз. */",
6550 format("/* Гляжу, поднимается медленно в гору\n"
6551 " * Лошадка, везущая хворосту воз. */",
6552 getLLVMStyleWithColumns(13)));
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00006553 EXPECT_EQ(
6554 "/* 一二三\n"
6555 " * 四五六七\n"
6556 " * 八 九\n"
6557 " * 十 */",
6558 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9)));
Alexander Kornienkodda770b2013-06-05 15:08:20 +00006559 EXPECT_EQ("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯\n"
6560 " * 𝕓𝕪𝕥𝕖\n"
6561 " * 𝖀𝕿𝕱-𝟠 */",
6562 format("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯 𝕓𝕪𝕥𝕖 𝖀𝕿𝕱-𝟠 */", getLLVMStyleWithColumns(12)));
Alexander Kornienko00895102013-06-05 14:09:10 +00006563}
6564
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00006565#endif // _MSC_VER
6566
Daniel Jasper6315fec2013-08-13 10:58:30 +00006567TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
6568 FormatStyle Style = getLLVMStyle();
6569
6570 Style.ConstructorInitializerIndentWidth = 4;
6571 verifyFormat(
6572 "SomeClass::Constructor()\n"
6573 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
6574 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
6575 Style);
6576
6577 Style.ConstructorInitializerIndentWidth = 2;
6578 verifyFormat(
6579 "SomeClass::Constructor()\n"
6580 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
6581 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
6582 Style);
6583
6584 Style.ConstructorInitializerIndentWidth = 0;
6585 verifyFormat(
6586 "SomeClass::Constructor()\n"
6587 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
6588 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
6589 Style);
6590
6591 Style.BreakConstructorInitializersBeforeComma = true;
6592 Style.ConstructorInitializerIndentWidth = 4;
6593 verifyFormat("SomeClass::Constructor()\n"
6594 " : a(a)\n"
6595 " , b(b)\n"
6596 " , c(c) {}",
6597 Style);
6598
6599 Style.ConstructorInitializerIndentWidth = 2;
6600 verifyFormat("SomeClass::Constructor()\n"
6601 " : a(a)\n"
6602 " , b(b)\n"
6603 " , c(c) {}",
6604 Style);
6605
6606 Style.ConstructorInitializerIndentWidth = 0;
6607 verifyFormat("SomeClass::Constructor()\n"
6608 ": a(a)\n"
6609 ", b(b)\n"
6610 ", c(c) {}",
6611 Style);
Daniel Jasper19ccb122013-10-08 05:11:18 +00006612
6613 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
6614 Style.ConstructorInitializerIndentWidth = 4;
6615 verifyFormat(
6616 "SomeClass::Constructor()\n"
6617 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
6618 Style);
6619 Style.ConstructorInitializerIndentWidth = 4;
6620 Style.ColumnLimit = 60;
6621 verifyFormat("SomeClass::Constructor()\n"
6622 " : aaaaaaaa(aaaaaaaa)\n"
6623 " , aaaaaaaa(aaaaaaaa)\n"
6624 " , aaaaaaaa(aaaaaaaa) {}",
6625 Style);
Daniel Jasper6315fec2013-08-13 10:58:30 +00006626}
6627
Daniel Jaspere05dc6d2013-07-24 13:10:59 +00006628TEST_F(FormatTest, FormatsWithWebKitStyle) {
6629 FormatStyle Style = getWebKitStyle();
6630
6631 // Don't indent in outer namespaces.
6632 verifyFormat("namespace outer {\n"
6633 "int i;\n"
6634 "namespace inner {\n"
Daniel Jaspereff18b92013-07-31 23:16:02 +00006635 " int i;\n"
Daniel Jaspere05dc6d2013-07-24 13:10:59 +00006636 "} // namespace inner\n"
6637 "} // namespace outer\n"
6638 "namespace other_outer {\n"
6639 "int i;\n"
6640 "}",
6641 Style);
6642
6643 // Don't indent case labels.
6644 verifyFormat("switch (variable) {\n"
6645 "case 1:\n"
6646 "case 2:\n"
6647 " doSomething();\n"
6648 " break;\n"
6649 "default:\n"
6650 " ++variable;\n"
6651 "}",
6652 Style);
6653
6654 // Wrap before binary operators.
6655 EXPECT_EQ(
6656 "void f()\n"
6657 "{\n"
6658 " if (aaaaaaaaaaaaaaaa\n"
6659 " && bbbbbbbbbbbbbbbbbbbbbbbb\n"
6660 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
6661 " return;\n"
6662 "}",
6663 format(
6664 "void f() {\n"
6665 "if (aaaaaaaaaaaaaaaa\n"
6666 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
6667 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
6668 "return;\n"
6669 "}",
6670 Style));
6671
6672 // Constructor initializers are formatted one per line with the "," on the
6673 // new line.
Daniel Jaspere8b10d32013-07-26 16:56:36 +00006674 verifyFormat("Constructor()\n"
6675 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6676 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
6677 " aaaaaaaaaaaaaa)\n"
6678 " , aaaaaaaaaaaaaaaaaaaaaaa()\n{\n}",
6679 Style);
Daniel Jaspere05dc6d2013-07-24 13:10:59 +00006680
Daniel Jaspereff18b92013-07-31 23:16:02 +00006681 // Access specifiers should be aligned left.
6682 verifyFormat("class C {\n"
6683 "public:\n"
6684 " int i;\n"
6685 "};",
6686 Style);
6687
Daniel Jaspere05dc6d2013-07-24 13:10:59 +00006688 // Do not align comments.
Daniel Jasper893ea8d2013-07-31 23:55:15 +00006689 verifyFormat("int a; // Do not\n"
6690 "double b; // align comments.",
6691 Style);
Daniel Jaspere05dc6d2013-07-24 13:10:59 +00006692
6693 // Accept input's line breaks.
6694 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
6695 " || bbbbbbbbbbbbbbb) {\n"
6696 " i++;\n"
6697 "}",
6698 format("if (aaaaaaaaaaaaaaa\n"
6699 "|| bbbbbbbbbbbbbbb) { i++; }",
6700 Style));
6701 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
6702 " i++;\n"
6703 "}",
6704 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
6705}
6706
Daniel Jasperec172262013-08-30 10:36:58 +00006707TEST_F(FormatTest, FormatsProtocolBufferDefinitions) {
6708 // It seems that clang-format can format protocol buffer definitions
6709 // (see https://code.google.com/p/protobuf/).
6710 verifyFormat("message SomeMessage {\n"
6711 " required int32 field1 = 1;\n"
6712 " optional string field2 = 2 [default = \"2\"]\n"
6713 "}");
6714}
6715
Manuel Klimekb61a8af2013-09-03 15:10:01 +00006716TEST_F(FormatTest, FormatsLambdas) {
Daniel Jasper567dcf92013-09-05 09:29:45 +00006717 verifyFormat("int c = [b]() mutable {\n"
6718 " return [&b] { return b++; }();\n"
6719 "}();\n");
6720 verifyFormat("int c = [&] {\n"
6721 " [=] { return b++; }();\n"
6722 "}();\n");
6723 verifyFormat("int c = [&, &a, a] {\n"
6724 " [=, c, &d] { return b++; }();\n"
6725 "}();\n");
6726 verifyFormat("int c = [&a, &a, a] {\n"
6727 " [=, a, b, &c] { return b++; }();\n"
6728 "}();\n");
6729 verifyFormat("auto c = { [&a, &a, a] {\n"
6730 " [=, a, b, &c] { return b++; }();\n"
6731 "} }\n");
Daniel Jasper14e25c02013-09-08 14:07:57 +00006732 verifyFormat("auto c = { [&a, &a, a] { [=, a, b, &c] {}(); } }\n");
Daniel Jasper567dcf92013-09-05 09:29:45 +00006733 verifyFormat("void f() {\n"
6734 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
6735 "}\n");
Daniel Jasper567dcf92013-09-05 09:29:45 +00006736 verifyFormat("void f() {\n"
6737 " other(x.begin(), //\n"
6738 " x.end(), //\n"
Daniel Jasperac2c9742013-09-05 10:04:31 +00006739 " [&](int, int) { return 1; });\n"
Daniel Jasper567dcf92013-09-05 09:29:45 +00006740 "}\n");
Daniel Jasper2d657052013-09-05 11:49:39 +00006741
6742 // Not lambdas.
6743 verifyFormat("constexpr char hello[]{ \"hello\" };");
Daniel Jasper520cca82013-09-06 21:25:51 +00006744 verifyFormat("double &operator[](int i) { return 0; }\n"
6745 "int i;");
Manuel Klimekb61a8af2013-09-03 15:10:01 +00006746}
6747
Manuel Klimek753a5112013-09-04 13:25:30 +00006748TEST_F(FormatTest, FormatsBlocks) {
6749 // FIXME: Make whitespace formatting consistent. Ask a ObjC dev how
6750 // it would ideally look.
Daniel Jasper567dcf92013-09-05 09:29:45 +00006751 verifyFormat("[operation setCompletionBlock:^{ [self onOperationDone]; }];");
6752 verifyFormat("int i = {[operation setCompletionBlock : ^{ [self "
6753 "onOperationDone]; }] };");
Manuel Klimek753a5112013-09-04 13:25:30 +00006754}
6755
Alexander Kornienko73d845c2013-09-11 12:25:57 +00006756TEST_F(FormatTest, SupportsCRLF) {
6757 EXPECT_EQ("int a;\r\n"
6758 "int b;\r\n"
6759 "int c;\r\n",
6760 format("int a;\r\n"
6761 " int b;\r\n"
6762 " int c;\r\n",
6763 getLLVMStyle()));
6764 EXPECT_EQ("int a;\r\n"
6765 "int b;\r\n"
6766 "int c;\r\n",
6767 format("int a;\r\n"
6768 " int b;\n"
6769 " int c;\r\n",
6770 getLLVMStyle()));
6771 EXPECT_EQ("int a;\n"
6772 "int b;\n"
6773 "int c;\n",
6774 format("int a;\r\n"
6775 " int b;\n"
6776 " int c;\n",
6777 getLLVMStyle()));
6778 EXPECT_EQ("\"aaaaaaa \"\r\n"
6779 "\"bbbbbbb\";\r\n",
6780 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
6781 EXPECT_EQ("#define A \\\r\n"
6782 " b; \\\r\n"
6783 " c; \\\r\n"
6784 " d;\r\n",
6785 format("#define A \\\r\n"
6786 " b; \\\r\n"
6787 " c; d; \r\n",
6788 getGoogleStyle()));
6789}
6790
Daniel Jaspercd162382013-01-07 13:26:07 +00006791} // end namespace tooling
6792} // end namespace clang