blob: f80dc6fc34be45c45335dd2643f7293239519ffd [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");
Manuel Klimekae76f7f2013-10-11 21:25:45 +000025 DEBUG(llvm::errs() << Code << "\n\n");
Daniel Jasper8a999452013-05-16 10:40:07 +000026 std::vector<tooling::Range> Ranges(1, tooling::Range(Offset, Length));
27 tooling::Replacements Replaces = reformat(Style, Code, Ranges);
28 ReplacementCount = Replaces.size();
29 std::string Result = applyAllReplacements(Code, Replaces);
30 EXPECT_NE("", Result);
31 DEBUG(llvm::errs() << "\n" << Result << "\n\n");
32 return Result;
Daniel Jasperbac016b2012-12-03 18:12:45 +000033 }
34
Daniel Jasper66d19bd2013-02-18 11:59:17 +000035 std::string
36 format(llvm::StringRef Code, const FormatStyle &Style = getLLVMStyle()) {
Daniel Jasperbac016b2012-12-03 18:12:45 +000037 return format(Code, 0, Code.size(), Style);
38 }
39
Daniel Jaspere35ec2b2012-12-18 19:56:56 +000040 std::string messUp(llvm::StringRef Code) {
41 std::string MessedUp(Code.str());
42 bool InComment = false;
Manuel Klimek526ed112013-01-09 15:25:02 +000043 bool InPreprocessorDirective = false;
Daniel Jaspere35ec2b2012-12-18 19:56:56 +000044 bool JustReplacedNewline = false;
45 for (unsigned i = 0, e = MessedUp.size() - 1; i != e; ++i) {
46 if (MessedUp[i] == '/' && MessedUp[i + 1] == '/') {
47 if (JustReplacedNewline)
48 MessedUp[i - 1] = '\n';
49 InComment = true;
Daniel Jaspere0b15ea2013-01-14 15:40:57 +000050 } else if (MessedUp[i] == '#' && (JustReplacedNewline || i == 0)) {
Daniel Jasper66d19bd2013-02-18 11:59:17 +000051 if (i != 0)
52 MessedUp[i - 1] = '\n';
Manuel Klimek526ed112013-01-09 15:25:02 +000053 InPreprocessorDirective = true;
Manuel Klimekd4397b92013-01-04 23:34:14 +000054 } else if (MessedUp[i] == '\\' && MessedUp[i + 1] == '\n') {
55 MessedUp[i] = ' ';
Manuel Klimek526ed112013-01-09 15:25:02 +000056 MessedUp[i + 1] = ' ';
Daniel Jaspere35ec2b2012-12-18 19:56:56 +000057 } else if (MessedUp[i] == '\n') {
58 if (InComment) {
59 InComment = false;
Manuel Klimek526ed112013-01-09 15:25:02 +000060 } else if (InPreprocessorDirective) {
61 InPreprocessorDirective = false;
Daniel Jaspere35ec2b2012-12-18 19:56:56 +000062 } else {
63 JustReplacedNewline = true;
64 MessedUp[i] = ' ';
65 }
Manuel Klimekd4397b92013-01-04 23:34:14 +000066 } else if (MessedUp[i] != ' ') {
67 JustReplacedNewline = false;
Daniel Jaspere35ec2b2012-12-18 19:56:56 +000068 }
Daniel Jasperbac016b2012-12-03 18:12:45 +000069 }
Manuel Klimekae76f7f2013-10-11 21:25:45 +000070 std::string WithoutWhitespace;
71 if (MessedUp[0] != ' ')
72 WithoutWhitespace.push_back(MessedUp[0]);
73 for (unsigned i = 1, e = MessedUp.size(); i != e; ++i) {
74 if (MessedUp[i] != ' ' || MessedUp[i - 1] != ' ')
75 WithoutWhitespace.push_back(MessedUp[i]);
76 }
77 return WithoutWhitespace;
Daniel Jaspere35ec2b2012-12-18 19:56:56 +000078 }
79
Manuel Klimek060143e2013-01-02 18:33:23 +000080 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) {
81 FormatStyle Style = getLLVMStyle();
82 Style.ColumnLimit = ColumnLimit;
83 return Style;
84 }
85
Daniel Jasper6f5bb2c2013-01-14 16:24:39 +000086 FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) {
87 FormatStyle Style = getGoogleStyle();
88 Style.ColumnLimit = ColumnLimit;
89 return Style;
90 }
91
Manuel Klimek060143e2013-01-02 18:33:23 +000092 void verifyFormat(llvm::StringRef Code,
93 const FormatStyle &Style = getLLVMStyle()) {
94 EXPECT_EQ(Code.str(), format(messUp(Code), Style));
Daniel Jasperbac016b2012-12-03 18:12:45 +000095 }
96
97 void verifyGoogleFormat(llvm::StringRef Code) {
Manuel Klimek060143e2013-01-02 18:33:23 +000098 verifyFormat(Code, getGoogleStyle());
Daniel Jasperbac016b2012-12-03 18:12:45 +000099 }
Daniel Jasper4bfc65a2013-01-23 12:10:53 +0000100
101 void verifyIndependentOfContext(llvm::StringRef text) {
102 verifyFormat(text);
103 verifyFormat(llvm::Twine("void f() { " + text + " }").str());
104 }
Daniel Jasperafcbd852013-01-30 09:46:12 +0000105
106 int ReplacementCount;
Daniel Jasperbac016b2012-12-03 18:12:45 +0000107};
108
Manuel Klimek526ed112013-01-09 15:25:02 +0000109TEST_F(FormatTest, MessUp) {
110 EXPECT_EQ("1 2 3", messUp("1 2 3"));
111 EXPECT_EQ("1 2 3\n", messUp("1\n2\n3\n"));
112 EXPECT_EQ("a\n//b\nc", messUp("a\n//b\nc"));
113 EXPECT_EQ("a\n#b\nc", messUp("a\n#b\nc"));
Manuel Klimekae76f7f2013-10-11 21:25:45 +0000114 EXPECT_EQ("a\n#b c d\ne", messUp("a\n#b\\\nc\\\nd\ne"));
Manuel Klimek526ed112013-01-09 15:25:02 +0000115}
116
Alexander Kornienko15757312012-12-06 18:03:27 +0000117//===----------------------------------------------------------------------===//
118// Basic function tests.
119//===----------------------------------------------------------------------===//
120
Daniel Jasper567dcf92013-09-05 09:29:45 +0000121TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) {
Daniel Jasperbac016b2012-12-03 18:12:45 +0000122 EXPECT_EQ(";", format(";"));
123}
124
125TEST_F(FormatTest, FormatsGlobalStatementsAt0) {
126 EXPECT_EQ("int i;", format(" int i;"));
Alexander Kornienko73d845c2013-09-11 12:25:57 +0000127 EXPECT_EQ("\nint i;", format(" \n\t \v \f int i;"));
Daniel Jasperbac016b2012-12-03 18:12:45 +0000128 EXPECT_EQ("int i;\nint j;", format(" int i; int j;"));
129 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;"));
130}
131
132TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) {
133 EXPECT_EQ("int i;", format("int\ni;"));
134}
135
136TEST_F(FormatTest, FormatsNestedBlockStatements) {
Manuel Klimek36fab8d2013-01-10 13:24:24 +0000137 EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}"));
Daniel Jasperbac016b2012-12-03 18:12:45 +0000138}
139
Alexander Kornienko15757312012-12-06 18:03:27 +0000140TEST_F(FormatTest, FormatsNestedCall) {
141 verifyFormat("Method(f1, f2(f3));");
142 verifyFormat("Method(f1(f2, f3()));");
Daniel Jasper4e9008a2013-01-13 08:19:51 +0000143 verifyFormat("Method(f1(f2, (f3())));");
Alexander Kornienko15757312012-12-06 18:03:27 +0000144}
145
Daniel Jasperdaf1a152013-02-07 21:08:36 +0000146TEST_F(FormatTest, NestedNameSpecifiers) {
Daniel Jasper6b825c22013-01-16 07:19:28 +0000147 verifyFormat("vector< ::Type> v;");
Daniel Jasperdaf1a152013-02-07 21:08:36 +0000148 verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())");
Daniel Jasper081fc172013-08-28 07:07:07 +0000149 verifyFormat("static constexpr bool Bar = decltype(bar())::value;");
Daniel Jasper6b825c22013-01-16 07:19:28 +0000150}
151
Daniel Jasperafcbd852013-01-30 09:46:12 +0000152TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) {
153 EXPECT_EQ("if (a) {\n"
154 " f();\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000155 "}",
156 format("if(a){f();}"));
Daniel Jasperafcbd852013-01-30 09:46:12 +0000157 EXPECT_EQ(4, ReplacementCount);
158 EXPECT_EQ("if (a) {\n"
159 " f();\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000160 "}",
161 format("if (a) {\n"
162 " f();\n"
163 "}"));
Daniel Jasperafcbd852013-01-30 09:46:12 +0000164 EXPECT_EQ(0, ReplacementCount);
165}
166
Daniel Jasperc78c6b32013-02-14 09:58:41 +0000167TEST_F(FormatTest, RemovesTrailingWhitespaceOfFormattedLine) {
168 EXPECT_EQ("int a;\nint b;", format("int a; \nint b;", 0, 0, getLLVMStyle()));
Daniel Jasper516fb312013-03-01 18:11:39 +0000169 EXPECT_EQ("int a;", format("int a; "));
170 EXPECT_EQ("int a;\n", format("int a; \n \n \n "));
171 EXPECT_EQ("int a;\nint b; ",
172 format("int a; \nint b; ", 0, 0, getLLVMStyle()));
Daniel Jasperc78c6b32013-02-14 09:58:41 +0000173}
174
Daniel Jasper1eee6c42013-03-04 13:43:19 +0000175TEST_F(FormatTest, FormatsCorrectRegionForLeadingWhitespace) {
176 EXPECT_EQ("int b;\nint a;",
177 format("int b;\n int a;", 7, 0, getLLVMStyle()));
178 EXPECT_EQ("int b;\n int a;",
179 format("int b;\n int a;", 6, 0, getLLVMStyle()));
180
181 EXPECT_EQ("#define A \\\n"
182 " int a; \\\n"
183 " int b;",
184 format("#define A \\\n"
185 " int a; \\\n"
186 " int b;",
187 26, 0, getLLVMStyleWithColumns(12)));
188 EXPECT_EQ("#define A \\\n"
189 " int a; \\\n"
190 " int b;",
191 format("#define A \\\n"
192 " int a; \\\n"
193 " int b;",
194 25, 0, getLLVMStyleWithColumns(12)));
195}
196
Daniel Jasperf3023542013-03-07 20:50:00 +0000197TEST_F(FormatTest, RemovesWhitespaceWhenTriggeredOnEmptyLine) {
198 EXPECT_EQ("int a;\n\n int b;",
199 format("int a;\n \n\n int b;", 7, 0, getLLVMStyle()));
200 EXPECT_EQ("int a;\n\n int b;",
201 format("int a;\n \n\n int b;", 9, 0, getLLVMStyle()));
202}
203
Daniel Jasper15f33f02013-06-03 16:16:41 +0000204TEST_F(FormatTest, RemovesEmptyLines) {
205 EXPECT_EQ("class C {\n"
206 " int i;\n"
207 "};",
208 format("class C {\n"
209 " int i;\n"
210 "\n"
211 "};"));
212
213 // Don't remove empty lines in more complex control statements.
214 EXPECT_EQ("void f() {\n"
215 " if (a) {\n"
216 " f();\n"
217 "\n"
218 " } else if (b) {\n"
219 " f();\n"
220 " }\n"
221 "}",
222 format("void f() {\n"
223 " if (a) {\n"
224 " f();\n"
225 "\n"
226 " } else if (b) {\n"
227 " f();\n"
228 "\n"
229 " }\n"
230 "\n"
231 "}"));
232
233 // FIXME: This is slightly inconsistent.
234 EXPECT_EQ("namespace {\n"
235 "int i;\n"
236 "}",
237 format("namespace {\n"
238 "int i;\n"
239 "\n"
240 "}"));
241 EXPECT_EQ("namespace {\n"
242 "int i;\n"
243 "\n"
244 "} // namespace",
245 format("namespace {\n"
246 "int i;\n"
247 "\n"
248 "} // namespace"));
249}
250
Daniel Jasper29333162013-02-18 13:08:03 +0000251TEST_F(FormatTest, ReformatsMovedLines) {
252 EXPECT_EQ(
253 "template <typename T> T *getFETokenInfo() const {\n"
254 " return static_cast<T *>(FETokenInfo);\n"
255 "}\n"
256 " int a; // <- Should not be formatted",
257 format(
258 "template<typename T>\n"
259 "T *getFETokenInfo() const { return static_cast<T*>(FETokenInfo); }\n"
260 " int a; // <- Should not be formatted",
261 9, 5, getLLVMStyle()));
262}
263
Alexander Kornienko15757312012-12-06 18:03:27 +0000264//===----------------------------------------------------------------------===//
265// Tests for control statements.
266//===----------------------------------------------------------------------===//
267
Daniel Jasper84f5ddf2013-05-14 10:31:09 +0000268TEST_F(FormatTest, FormatIfWithoutCompoundStatement) {
Daniel Jasper6f5bb2c2013-01-14 16:24:39 +0000269 verifyFormat("if (true)\n f();\ng();");
270 verifyFormat("if (a)\n if (b)\n if (c)\n g();\nh();");
Alexander Kornienko15757312012-12-06 18:03:27 +0000271 verifyFormat("if (a)\n if (b) {\n f();\n }\ng();");
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000272
Daniel Jasperf11bbb92013-05-16 12:12:21 +0000273 FormatStyle AllowsMergedIf = getLLVMStyle();
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000274 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true;
275 verifyFormat("if (a)\n"
276 " // comment\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000277 " f();",
278 AllowsMergedIf);
Daniel Jasperf11bbb92013-05-16 12:12:21 +0000279 verifyFormat("if (a)\n"
280 " ;",
281 AllowsMergedIf);
282 verifyFormat("if (a)\n"
283 " if (b) return;",
284 AllowsMergedIf);
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000285
Daniel Jasperf11bbb92013-05-16 12:12:21 +0000286 verifyFormat("if (a) // Can't merge this\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000287 " f();\n",
288 AllowsMergedIf);
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000289 verifyFormat("if (a) /* still don't merge */\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000290 " f();",
291 AllowsMergedIf);
Daniel Jasperf11bbb92013-05-16 12:12:21 +0000292 verifyFormat("if (a) { // Never merge this\n"
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000293 " f();\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000294 "}",
295 AllowsMergedIf);
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000296 verifyFormat("if (a) { /* Never merge this */\n"
297 " f();\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000298 "}",
299 AllowsMergedIf);
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000300
Daniel Jasper1fb8d882013-05-14 09:30:02 +0000301 EXPECT_EQ("if (a) return;", format("if(a)\nreturn;", 7, 1, AllowsMergedIf));
Daniel Jasperf11bbb92013-05-16 12:12:21 +0000302 EXPECT_EQ("if (a) return; // comment",
Daniel Jasper84f5ddf2013-05-14 10:31:09 +0000303 format("if(a)\nreturn; // comment", 20, 1, AllowsMergedIf));
Daniel Jasper1fb8d882013-05-14 09:30:02 +0000304
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000305 AllowsMergedIf.ColumnLimit = 14;
306 verifyFormat("if (a) return;", AllowsMergedIf);
Daniel Jasperfd0ca972013-01-14 16:02:06 +0000307 verifyFormat("if (aaaaaaaaa)\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000308 " return;",
309 AllowsMergedIf);
Daniel Jasperdf3736a2013-01-16 15:44:34 +0000310
311 AllowsMergedIf.ColumnLimit = 13;
312 verifyFormat("if (a)\n return;", AllowsMergedIf);
Alexander Kornienko15757312012-12-06 18:03:27 +0000313}
314
Daniel Jasperf11bbb92013-05-16 12:12:21 +0000315TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) {
316 FormatStyle AllowsMergedLoops = getLLVMStyle();
317 AllowsMergedLoops.AllowShortLoopsOnASingleLine = true;
318 verifyFormat("while (true) continue;", AllowsMergedLoops);
319 verifyFormat("for (;;) continue;", AllowsMergedLoops);
320 verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops);
321 verifyFormat("while (true)\n"
322 " ;",
323 AllowsMergedLoops);
324 verifyFormat("for (;;)\n"
325 " ;",
326 AllowsMergedLoops);
327 verifyFormat("for (;;)\n"
328 " for (;;) continue;",
329 AllowsMergedLoops);
330 verifyFormat("for (;;) // Can't merge this\n"
331 " continue;",
332 AllowsMergedLoops);
333 verifyFormat("for (;;) /* still don't merge */\n"
334 " continue;",
335 AllowsMergedLoops);
336}
337
Alexander Kornienko15757312012-12-06 18:03:27 +0000338TEST_F(FormatTest, ParseIfElse) {
339 verifyFormat("if (true)\n"
340 " if (true)\n"
341 " if (true)\n"
342 " f();\n"
343 " else\n"
344 " g();\n"
345 " else\n"
346 " h();\n"
347 "else\n"
348 " i();");
349 verifyFormat("if (true)\n"
350 " if (true)\n"
351 " if (true) {\n"
Daniel Jasper6f5bb2c2013-01-14 16:24:39 +0000352 " if (true)\n"
353 " f();\n"
Alexander Kornienko15757312012-12-06 18:03:27 +0000354 " } else {\n"
355 " g();\n"
356 " }\n"
357 " else\n"
358 " h();\n"
359 "else {\n"
360 " i();\n"
361 "}");
Daniel Jaspere63a48a2013-09-17 08:28:05 +0000362 verifyFormat("void f() {\n"
363 " if (a) {\n"
364 " } else {\n"
365 " }\n"
366 "}");
Alexander Kornienko15757312012-12-06 18:03:27 +0000367}
368
369TEST_F(FormatTest, ElseIf) {
Manuel Klimek2f1ac412013-01-21 16:42:44 +0000370 verifyFormat("if (a) {\n} else if (b) {\n}");
Alexander Kornienko15757312012-12-06 18:03:27 +0000371 verifyFormat("if (a)\n"
372 " f();\n"
373 "else if (b)\n"
374 " g();\n"
375 "else\n"
376 " h();");
377}
378
Daniel Jasperbac016b2012-12-03 18:12:45 +0000379TEST_F(FormatTest, FormatsForLoop) {
380 verifyFormat(
381 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n"
Alexander Kornienko2e97cfc2012-12-05 15:06:06 +0000382 " ++VeryVeryLongLoopVariable)\n"
383 " ;");
384 verifyFormat("for (;;)\n"
385 " f();");
Manuel Klimek2f1ac412013-01-21 16:42:44 +0000386 verifyFormat("for (;;) {\n}");
Alexander Kornienko2e97cfc2012-12-05 15:06:06 +0000387 verifyFormat("for (;;) {\n"
388 " f();\n"
389 "}");
Daniel Jasper454cb702013-05-03 14:50:50 +0000390 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}");
Daniel Jaspera324a0e2012-12-21 14:37:20 +0000391
392 verifyFormat(
393 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
394 " E = UnwrappedLines.end();\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +0000395 " I != E; ++I) {\n}");
Daniel Jaspera324a0e2012-12-21 14:37:20 +0000396
397 verifyFormat(
398 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +0000399 " ++IIIII) {\n}");
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +0000400 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n"
401 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000402 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}");
Daniel Jasper7d812812013-02-21 15:00:29 +0000403 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n"
404 " I = FD->getDeclsInPrototypeScope().begin(),\n"
405 " E = FD->getDeclsInPrototypeScope().end();\n"
406 " I != E; ++I) {\n}");
Daniel Jasper75223182013-01-28 17:30:17 +0000407
408 // FIXME: Not sure whether we want extra identation in line 3 here:
409 verifyFormat(
410 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
411 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n"
Daniel Jasperf9955d32013-03-20 12:37:50 +0000412 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
413 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
Daniel Jasper75223182013-01-28 17:30:17 +0000414 " ++aaaaaaaaaaa) {\n}");
Daniel Jasperfaab0d32013-02-27 09:47:53 +0000415 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n"
416 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
417 "}");
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +0000418 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n"
419 " aaaaaaaaaa);\n"
420 " iter; ++iter) {\n"
421 "}");
Daniel Jasper8159d2f2013-02-04 07:30:30 +0000422
Daniel Jasperfaab0d32013-02-27 09:47:53 +0000423 FormatStyle NoBinPacking = getLLVMStyle();
424 NoBinPacking.BinPackParameters = false;
425 verifyFormat("for (int aaaaaaaaaaa = 1;\n"
426 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n"
427 " aaaaaaaaaaaaaaaa,\n"
428 " aaaaaaaaaaaaaaaa,\n"
429 " aaaaaaaaaaaaaaaa);\n"
430 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
431 "}",
432 NoBinPacking);
433 verifyFormat(
Daniel Jasper237d4c12013-02-23 21:01:55 +0000434 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
435 " E = UnwrappedLines.end();\n"
436 " I != E;\n"
Daniel Jasperfaab0d32013-02-27 09:47:53 +0000437 " ++I) {\n}",
438 NoBinPacking);
Daniel Jasperbac016b2012-12-03 18:12:45 +0000439}
440
Daniel Jasper3b9a8fc2013-01-28 13:21:16 +0000441TEST_F(FormatTest, RangeBasedForLoops) {
442 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
443 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
444 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n"
445 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}");
Daniel Jasper84a1a632013-02-26 13:18:08 +0000446 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n"
447 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasper3b9a8fc2013-01-28 13:21:16 +0000448}
449
Daniel Jasperbac016b2012-12-03 18:12:45 +0000450TEST_F(FormatTest, FormatsWhileLoop) {
Manuel Klimek2f1ac412013-01-21 16:42:44 +0000451 verifyFormat("while (true) {\n}");
Alexander Kornienko2e97cfc2012-12-05 15:06:06 +0000452 verifyFormat("while (true)\n"
453 " f();");
Manuel Klimek2f1ac412013-01-21 16:42:44 +0000454 verifyFormat("while () {\n}");
Alexander Kornienko2e97cfc2012-12-05 15:06:06 +0000455 verifyFormat("while () {\n"
456 " f();\n"
457 "}");
Daniel Jasperbac016b2012-12-03 18:12:45 +0000458}
459
Alexander Kornienko15757312012-12-06 18:03:27 +0000460TEST_F(FormatTest, FormatsDoWhile) {
461 verifyFormat("do {\n"
462 " do_something();\n"
463 "} while (something());");
464 verifyFormat("do\n"
465 " do_something();\n"
466 "while (something());");
Daniel Jasperbac016b2012-12-03 18:12:45 +0000467}
468
Alexander Kornienko15757312012-12-06 18:03:27 +0000469TEST_F(FormatTest, FormatsSwitchStatement) {
Daniel Jasperbac016b2012-12-03 18:12:45 +0000470 verifyFormat("switch (x) {\n"
471 "case 1:\n"
472 " f();\n"
473 " break;\n"
474 "case kFoo:\n"
475 "case ns::kBar:\n"
476 "case kBaz:\n"
477 " break;\n"
478 "default:\n"
479 " g();\n"
480 " break;\n"
481 "}");
482 verifyFormat("switch (x) {\n"
483 "case 1: {\n"
484 " f();\n"
485 " break;\n"
486 "}\n"
487 "}");
Nico Weber94fb7292013-01-18 05:50:57 +0000488 verifyFormat("switch (x) {\n"
489 "case 1: {\n"
490 " f();\n"
491 " {\n"
492 " g();\n"
493 " h();\n"
494 " }\n"
495 " break;\n"
496 "}\n"
497 "}");
498 verifyFormat("switch (x) {\n"
499 "case 1: {\n"
500 " f();\n"
501 " if (foo) {\n"
502 " g();\n"
503 " h();\n"
504 " }\n"
505 " break;\n"
506 "}\n"
507 "}");
508 verifyFormat("switch (x) {\n"
509 "case 1: {\n"
510 " f();\n"
511 " g();\n"
512 "} break;\n"
513 "}");
Daniel Jasperbac016b2012-12-03 18:12:45 +0000514 verifyFormat("switch (test)\n"
515 " ;");
Daniel Jasper4ba9bfd2013-03-12 12:26:55 +0000516 verifyFormat("switch (x) {\n"
517 "default: {\n"
518 " // Do nothing.\n"
Manuel Klimek67d080d2013-04-12 14:13:36 +0000519 "}\n"
Daniel Jasper4ba9bfd2013-03-12 12:26:55 +0000520 "}");
Daniel Jasper6050a1e2013-03-13 15:53:12 +0000521 verifyFormat("switch (x) {\n"
Daniel Jasper5999f762013-04-09 17:46:55 +0000522 "// comment\n"
Daniel Jasper6050a1e2013-03-13 15:53:12 +0000523 "// if 1, do f()\n"
524 "case 1:\n"
525 " f();\n"
526 "}");
Daniel Jasperc30eb512013-03-19 18:33:58 +0000527 verifyFormat("switch (x) {\n"
528 "case 1:\n"
529 " // Do amazing stuff\n"
530 " {\n"
531 " f();\n"
532 " g();\n"
533 " }\n"
534 " break;\n"
535 "}");
Daniel Jasperbcca7e42013-03-20 10:23:53 +0000536 verifyFormat("#define A \\\n"
537 " switch (x) { \\\n"
538 " case a: \\\n"
539 " foo = b; \\\n"
540 " }", getLLVMStyleWithColumns(20));
Daniel Jasper67cf1db2013-09-02 08:26:29 +0000541 verifyFormat("#define OPERATION_CASE(name) \\\n"
542 " case OP_name: \\\n"
543 " return operations::Operation##name\n",
544 getLLVMStyleWithColumns(40));
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000545
Alexander Kornienko15757312012-12-06 18:03:27 +0000546 verifyGoogleFormat("switch (x) {\n"
547 " case 1:\n"
548 " f();\n"
549 " break;\n"
550 " case kFoo:\n"
551 " case ns::kBar:\n"
552 " case kBaz:\n"
553 " break;\n"
554 " default:\n"
555 " g();\n"
556 " break;\n"
557 "}");
558 verifyGoogleFormat("switch (x) {\n"
559 " case 1: {\n"
560 " f();\n"
561 " break;\n"
562 " }\n"
563 "}");
564 verifyGoogleFormat("switch (test)\n"
Daniel Jaspere865cc52013-07-25 11:31:57 +0000565 " ;");
566
567 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n"
568 " case OP_name: \\\n"
569 " return operations::Operation##name\n");
570 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n"
571 " // Get the correction operation class.\n"
572 " switch (OpCode) {\n"
573 " CASE(Add);\n"
574 " CASE(Subtract);\n"
575 " default:\n"
576 " return operations::Unknown;\n"
577 " }\n"
578 "#undef OPERATION_CASE\n"
579 "}");
Daniel Jasperb77d7412013-09-06 07:54:20 +0000580 verifyFormat("DEBUG({\n"
581 " switch (x) {\n"
582 " case A:\n"
583 " f();\n"
584 " break;\n"
585 " // On B:\n"
586 " case B:\n"
587 " g();\n"
588 " break;\n"
589 " }\n"
590 "});");
Daniel Jasperbac016b2012-12-03 18:12:45 +0000591}
592
Alexander Kornienko15757312012-12-06 18:03:27 +0000593TEST_F(FormatTest, FormatsLabels) {
Daniel Jasperbac016b2012-12-03 18:12:45 +0000594 verifyFormat("void f() {\n"
595 " some_code();\n"
596 "test_label:\n"
597 " some_other_code();\n"
598 " {\n"
599 " some_more_code();\n"
600 " another_label:\n"
601 " some_more_code();\n"
602 " }\n"
603 "}");
604 verifyFormat("some_code();\n"
605 "test_label:\n"
606 "some_other_code();");
607}
608
Alexander Kornienko15757312012-12-06 18:03:27 +0000609//===----------------------------------------------------------------------===//
610// Tests for comments.
611//===----------------------------------------------------------------------===//
612
613TEST_F(FormatTest, UnderstandsSingleLineComments) {
Daniel Jasperb64eca02013-03-22 10:01:29 +0000614 verifyFormat("//* */");
Daniel Jaspere35ec2b2012-12-18 19:56:56 +0000615 verifyFormat("// line 1\n"
616 "// line 2\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +0000617 "void f() {}\n");
Alexander Kornienko15757312012-12-06 18:03:27 +0000618
Daniel Jaspere35ec2b2012-12-18 19:56:56 +0000619 verifyFormat("void f() {\n"
620 " // Doesn't do anything\n"
621 "}");
Daniel Jaspere1f9a8e2013-07-11 13:48:16 +0000622 verifyFormat("SomeObject\n"
623 " // Calling someFunction on SomeObject\n"
624 " .someFunction();");
Daniel Jasperdcc2a622013-01-18 08:44:07 +0000625 verifyFormat("void f(int i, // some comment (probably for i)\n"
626 " int j, // some comment (probably for j)\n"
Daniel Jasper487f64b2013-01-13 16:10:20 +0000627 " int k); // some comment (probably for k)");
628 verifyFormat("void f(int i,\n"
629 " // some comment (probably for j)\n"
630 " int j,\n"
631 " // some comment (probably for k)\n"
632 " int k);");
Alexander Kornienko15757312012-12-06 18:03:27 +0000633
Daniel Jasperdcc2a622013-01-18 08:44:07 +0000634 verifyFormat("int i // This is a fancy variable\n"
635 " = 5; // with nicely aligned comment.");
636
637 verifyFormat("// Leading comment.\n"
638 "int a; // Trailing comment.");
639 verifyFormat("int a; // Trailing comment\n"
640 " // on 2\n"
641 " // or 3 lines.\n"
642 "int b;");
643 verifyFormat("int a; // Trailing comment\n"
644 "\n"
645 "// Leading comment.\n"
646 "int b;");
647 verifyFormat("int a; // Comment.\n"
648 " // More details.\n"
649 "int bbbb; // Another comment.");
650 verifyFormat(
651 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; // comment\n"
652 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; // comment\n"
653 "int cccccccccccccccccccccccccccccc; // comment\n"
654 "int ddd; // looooooooooooooooooooooooong comment\n"
655 "int aaaaaaaaaaaaaaaaaaaaaaa; // comment\n"
656 "int bbbbbbbbbbbbbbbbbbbbb; // comment\n"
657 "int ccccccccccccccccccc; // comment");
658
Daniel Jasper7d1185d2013-01-18 09:19:33 +0000659 verifyFormat("#include \"a\" // comment\n"
660 "#include \"a/b/c\" // comment");
661 verifyFormat("#include <a> // comment\n"
662 "#include <a/b/c> // comment");
Manuel Klimekad3094b2013-05-23 10:56:37 +0000663 EXPECT_EQ("#include \\\n"
664 " \"a\" // comment\n"
665 "#include \"a/b/c\" // comment",
666 format("#include \\\n"
667 " \"a\" // comment\n"
668 "#include \"a/b/c\" // comment"));
Alexander Kornienko15757312012-12-06 18:03:27 +0000669
Daniel Jaspere35ec2b2012-12-18 19:56:56 +0000670 verifyFormat("enum E {\n"
671 " // comment\n"
Daniel Jasper7ad4eff2013-01-07 11:09:06 +0000672 " VAL_A, // comment\n"
Daniel Jaspere35ec2b2012-12-18 19:56:56 +0000673 " VAL_B\n"
674 "};");
Daniel Jasper05b1ac82012-12-17 11:29:41 +0000675
676 verifyFormat(
677 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Daniel Jasper7ad4eff2013-01-07 11:09:06 +0000678 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; // Trailing comment");
Daniel Jasper043835a2013-01-09 09:33:39 +0000679 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
680 " // Comment inside a statement.\n"
681 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
Daniel Jasper36ba0ff2013-02-06 15:23:09 +0000682 verifyFormat(
683 "bool aaaaaaaaaaaaa = // comment\n"
684 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
685 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Manuel Klimek6cf58142013-01-07 08:54:53 +0000686
Daniel Jasper42f458d2013-02-13 19:25:54 +0000687 verifyFormat("int aaaa; // aaaaa\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +0000688 "int aa; // aaaaaaa",
689 getLLVMStyleWithColumns(20));
Daniel Jasper42f458d2013-02-13 19:25:54 +0000690
Daniel Jasper821627e2013-01-21 22:49:20 +0000691 EXPECT_EQ("void f() { // This does something ..\n"
692 "}\n"
693 "int a; // This is unrelated",
694 format("void f() { // This does something ..\n"
695 " }\n"
696 "int a; // This is unrelated"));
Daniel Jaspercbe86cc2013-07-01 11:22:57 +0000697 EXPECT_EQ("class C {\n"
698 " void f() { // This does something ..\n"
699 " } // awesome..\n"
Daniel Jasper821627e2013-01-21 22:49:20 +0000700 "\n"
Daniel Jaspercbe86cc2013-07-01 11:22:57 +0000701 " int a; // This is unrelated\n"
702 "};",
703 format("class C{void f() { // This does something ..\n"
Daniel Jasper821627e2013-01-21 22:49:20 +0000704 " } // awesome..\n"
705 " \n"
Daniel Jaspercbe86cc2013-07-01 11:22:57 +0000706 "int a; // This is unrelated\n"
707 "};"));
Daniel Jasper821627e2013-01-21 22:49:20 +0000708
Daniel Jasper7ad4eff2013-01-07 11:09:06 +0000709 EXPECT_EQ("int i; // single line trailing comment",
Manuel Klimek6cf58142013-01-07 08:54:53 +0000710 format("int i;\\\n// single line trailing comment"));
Daniel Jasper7ad4eff2013-01-07 11:09:06 +0000711
712 verifyGoogleFormat("int a; // Trailing comment.");
Daniel Jasperd4f2c2e2013-01-29 19:41:55 +0000713
714 verifyFormat("someFunction(anotherFunction( // Force break.\n"
715 " parameter));");
Daniel Jasper5b7e7b02013-02-05 09:34:14 +0000716
717 verifyGoogleFormat("#endif // HEADER_GUARD");
Daniel Jasper474e4622013-02-06 22:04:05 +0000718
719 verifyFormat("const char *test[] = {\n"
720 " // A\n"
721 " \"aaaa\",\n"
722 " // B\n"
723 " \"aaaaa\",\n"
724 "};");
Daniel Jasper729a7432013-02-11 12:36:37 +0000725 verifyGoogleFormat(
726 "aaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Alexander Kornienko2785b9a2013-06-07 16:02:52 +0000727 " aaaaaaaaaaaaaaaaaaaaaa); // 81_cols_with_this_comment");
Alexander Kornienko4128e192013-04-03 12:38:53 +0000728 EXPECT_EQ("D(a, {\n"
729 " // test\n"
730 " int a;\n"
731 "});",
732 format("D(a, {\n"
733 "// test\n"
734 "int a;\n"
735 "});"));
Manuel Klimekebfb88c2013-05-23 11:42:52 +0000736
737 EXPECT_EQ("lineWith(); // comment\n"
738 "// at start\n"
739 "otherLine();",
740 format("lineWith(); // comment\n"
741 "// at start\n"
742 "otherLine();"));
743 EXPECT_EQ("lineWith(); // comment\n"
744 " // at start\n"
745 "otherLine();",
746 format("lineWith(); // comment\n"
747 " // at start\n"
748 "otherLine();"));
Manuel Klimek23ad3392013-05-23 19:54:43 +0000749
750 EXPECT_EQ("lineWith(); // comment\n"
751 "// at start\n"
752 "otherLine(); // comment",
753 format("lineWith(); // comment\n"
754 "// at start\n"
755 "otherLine(); // comment"));
Manuel Klimek854ca792013-05-23 20:46:07 +0000756 EXPECT_EQ("lineWith();\n"
757 "// at start\n"
758 "otherLine(); // comment",
759 format("lineWith();\n"
760 " // at start\n"
761 "otherLine(); // comment"));
762 EXPECT_EQ("// first\n"
763 "// at start\n"
764 "otherLine(); // comment",
765 format("// first\n"
766 " // at start\n"
767 "otherLine(); // comment"));
768 EXPECT_EQ("f();\n"
769 "// first\n"
770 "// at start\n"
771 "otherLine(); // comment",
772 format("f();\n"
773 "// first\n"
774 " // at start\n"
775 "otherLine(); // comment"));
Daniel Jasper05b1ac82012-12-17 11:29:41 +0000776}
777
Daniel Jasperc363dbb2013-03-22 16:25:51 +0000778TEST_F(FormatTest, CanFormatCommentsLocally) {
779 EXPECT_EQ("int a; // comment\n"
780 "int b; // comment",
781 format("int a; // comment\n"
782 "int b; // comment",
783 0, 0, getLLVMStyle()));
784 EXPECT_EQ("int a; // comment\n"
785 " // line 2\n"
786 "int b;",
787 format("int a; // comment\n"
788 " // line 2\n"
789 "int b;",
790 28, 0, getLLVMStyle()));
Daniel Jasperaf849762013-04-24 06:33:59 +0000791 EXPECT_EQ("int aaaaaa; // comment\n"
792 "int b;\n"
793 "int c; // unrelated comment",
794 format("int aaaaaa; // comment\n"
795 "int b;\n"
796 "int c; // unrelated comment",
797 31, 0, getLLVMStyle()));
Daniel Jasperc363dbb2013-03-22 16:25:51 +0000798}
799
Daniel Jasper812c0452013-03-01 16:45:59 +0000800TEST_F(FormatTest, RemovesTrailingWhitespaceOfComments) {
801 EXPECT_EQ("// comment", format("// comment "));
802 EXPECT_EQ("int aaaaaaa, bbbbbbb; // comment",
803 format("int aaaaaaa, bbbbbbb; // comment ",
804 getLLVMStyleWithColumns(33)));
Alexander Kornienko51bb5d92013-09-06 17:24:54 +0000805 EXPECT_EQ("// comment\\\n", format("// comment\\\n \t \v \f "));
806 EXPECT_EQ("// comment \\\n", format("// comment \\\n \t \v \f "));
Daniel Jasper812c0452013-03-01 16:45:59 +0000807}
808
Alexander Kornienkoc36c5c22013-06-19 19:50:11 +0000809TEST_F(FormatTest, UnderstandsBlockComments) {
Nico Weber861576b2013-06-26 00:15:19 +0000810 verifyFormat("f(/*noSpaceAfterParameterNamingComment=*/true);");
Daniel Jasper2c6cc482013-01-17 12:53:34 +0000811 EXPECT_EQ(
812 "f(aaaaaaaaaaaaaaaaaaaaaaaaa, /* Trailing comment for aa... */\n"
813 " bbbbbbbbbbbbbbbbbbbbbbbbb);",
Alexander Kornienko919398b2013-04-17 17:34:05 +0000814 format("f(aaaaaaaaaaaaaaaaaaaaaaaaa , \\\n/* Trailing comment for aa... */\n"
Daniel Jasper2c6cc482013-01-17 12:53:34 +0000815 " bbbbbbbbbbbbbbbbbbbbbbbbb);"));
816 EXPECT_EQ(
817 "f(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
818 " /* Leading comment for bb... */ bbbbbbbbbbbbbbbbbbbbbbbbb);",
819 format("f(aaaaaaaaaaaaaaaaaaaaaaaaa , \n"
820 "/* Leading comment for bb... */ bbbbbbbbbbbbbbbbbbbbbbbbb);"));
Daniel Jasper65d2c382013-06-06 16:08:57 +0000821 EXPECT_EQ(
822 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
823 " aaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper88cc5622013-07-08 14:25:23 +0000824 " aaaaaaaaaaaaaaaaaa) { /*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*/\n"
Daniel Jasper65d2c382013-06-06 16:08:57 +0000825 "}",
826 format("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
827 " aaaaaaaaaaaaaaaaaa ,\n"
Daniel Jasper88cc5622013-07-08 14:25:23 +0000828 " aaaaaaaaaaaaaaaaaa) { /*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*/\n"
Daniel Jasper65d2c382013-06-06 16:08:57 +0000829 "}"));
Daniel Jasperd4f2c2e2013-01-29 19:41:55 +0000830
Daniel Jasperfaab0d32013-02-27 09:47:53 +0000831 FormatStyle NoBinPacking = getLLVMStyle();
832 NoBinPacking.BinPackParameters = false;
833 verifyFormat("aaaaaaaa(/* parameter 1 */ aaaaaa,\n"
834 " /* parameter 2 */ aaaaaa,\n"
835 " /* parameter 3 */ aaaaaa,\n"
836 " /* parameter 4 */ aaaaaa);",
837 NoBinPacking);
Daniel Jasper2c6cc482013-01-17 12:53:34 +0000838}
839
Alexander Kornienkoc36c5c22013-06-19 19:50:11 +0000840TEST_F(FormatTest, AlignsBlockComments) {
Alexander Kornienkof7536152013-03-14 16:10:54 +0000841 EXPECT_EQ("/*\n"
842 " * Really multi-line\n"
843 " * comment.\n"
844 " */\n"
845 "void f() {}",
846 format(" /*\n"
847 " * Really multi-line\n"
848 " * comment.\n"
849 " */\n"
850 " void f() {}"));
Alexander Kornienkof7536152013-03-14 16:10:54 +0000851 EXPECT_EQ("class C {\n"
852 " /*\n"
853 " * Another multi-line\n"
854 " * comment.\n"
855 " */\n"
856 " void f() {}\n"
857 "};",
858 format("class C {\n"
859 "/*\n"
860 " * Another multi-line\n"
861 " * comment.\n"
862 " */\n"
863 "void f() {}\n"
864 "};"));
Alexander Kornienko1fdd8b32013-03-15 13:42:02 +0000865 EXPECT_EQ("/*\n"
866 " 1. This is a comment with non-trivial formatting.\n"
867 " 1.1. We have to indent/outdent all lines equally\n"
868 " 1.1.1. to keep the formatting.\n"
869 " */",
870 format(" /*\n"
871 " 1. This is a comment with non-trivial formatting.\n"
872 " 1.1. We have to indent/outdent all lines equally\n"
873 " 1.1.1. to keep the formatting.\n"
874 " */"));
875 EXPECT_EQ("/*\n"
Daniel Jaspereff18b92013-07-31 23:16:02 +0000876 "Don't try to outdent if there's not enough indentation.\n"
Manuel Klimekde008c02013-05-27 15:23:34 +0000877 "*/",
Alexander Kornienko1fdd8b32013-03-15 13:42:02 +0000878 format(" /*\n"
Daniel Jaspereff18b92013-07-31 23:16:02 +0000879 " Don't try to outdent if there's not enough indentation.\n"
Alexander Kornienko1fdd8b32013-03-15 13:42:02 +0000880 " */"));
Manuel Klimekc5cc4bf2013-05-28 08:55:01 +0000881
882 EXPECT_EQ("int i; /* Comment with empty...\n"
883 " *\n"
884 " * line. */",
885 format("int i; /* Comment with empty...\n"
886 " *\n"
887 " * line. */"));
Alexander Kornienkof7536152013-03-14 16:10:54 +0000888}
889
Alexander Kornienkoc36c5c22013-06-19 19:50:11 +0000890TEST_F(FormatTest, CorrectlyHandlesLengthOfBlockComments) {
891 EXPECT_EQ("double *x; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
892 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */",
893 format("double *x; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
894 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */"));
Alexander Kornienkod446f732013-07-01 13:42:42 +0000895 EXPECT_EQ(
896 "void ffffffffffff(\n"
897 " int aaaaaaaa, int bbbbbbbb,\n"
898 " int cccccccccccc) { /*\n"
899 " aaaaaaaaaa\n"
900 " aaaaaaaaaaaaa\n"
901 " bbbbbbbbbbbbbb\n"
902 " bbbbbbbbbb\n"
903 " */\n"
904 "}",
905 format("void ffffffffffff(int aaaaaaaa, int bbbbbbbb, int cccccccccccc)\n"
906 "{ /*\n"
907 " aaaaaaaaaa aaaaaaaaaaaaa\n"
908 " bbbbbbbbbbbbbb bbbbbbbbbb\n"
909 " */\n"
910 "}",
911 getLLVMStyleWithColumns(40)));
Alexander Kornienkoc36c5c22013-06-19 19:50:11 +0000912}
913
Alexander Kornienkob4b4a522013-07-16 23:47:22 +0000914TEST_F(FormatTest, DontBreakNonTrailingBlockComments) {
915 EXPECT_EQ("void\n"
916 "ffffffffff(int aaaaa /* test */);",
917 format("void ffffffffff(int aaaaa /* test */);",
918 getLLVMStyleWithColumns(35)));
919}
920
Alexander Kornienko5262dd92013-03-27 11:52:18 +0000921TEST_F(FormatTest, SplitsLongCxxComments) {
922 EXPECT_EQ("// A comment that\n"
923 "// doesn't fit on\n"
924 "// one line",
925 format("// A comment that doesn't fit on one line",
926 getLLVMStyleWithColumns(20)));
Alexander Kornienko919398b2013-04-17 17:34:05 +0000927 EXPECT_EQ("// a b c d\n"
928 "// e f g\n"
929 "// h i j k",
930 format("// a b c d e f g h i j k",
931 getLLVMStyleWithColumns(10)));
932 EXPECT_EQ("// a b c d\n"
933 "// e f g\n"
934 "// h i j k",
935 format("\\\n// a b c d e f g h i j k",
936 getLLVMStyleWithColumns(10)));
Alexander Kornienko5262dd92013-03-27 11:52:18 +0000937 EXPECT_EQ("if (true) // A comment that\n"
938 " // doesn't fit on\n"
939 " // one line",
940 format("if (true) // A comment that doesn't fit on one line ",
941 getLLVMStyleWithColumns(30)));
942 EXPECT_EQ("// Don't_touch_leading_whitespace",
943 format("// Don't_touch_leading_whitespace",
944 getLLVMStyleWithColumns(20)));
Alexander Kornienko2b2faa52013-06-11 16:01:49 +0000945 EXPECT_EQ("// Add leading\n"
946 "// whitespace",
947 format("//Add leading whitespace", getLLVMStyleWithColumns(20)));
948 EXPECT_EQ("// whitespace", format("//whitespace", getLLVMStyle()));
949 EXPECT_EQ("// Even if it makes the line exceed the column\n"
950 "// limit",
951 format("//Even if it makes the line exceed the column limit",
952 getLLVMStyleWithColumns(51)));
953 EXPECT_EQ("//--But not here", format("//--But not here", getLLVMStyle()));
Alexander Kornienko9fdc00a2013-03-28 18:40:55 +0000954 EXPECT_EQ("// A comment before\n"
955 "// a macro\n"
956 "// definition\n"
957 "#define a b",
958 format("// A comment before a macro definition\n"
959 "#define a b",
960 getLLVMStyleWithColumns(20)));
Alexander Kornienko22d0e292013-06-17 12:59:44 +0000961 EXPECT_EQ("void ffffff(int aaaaaaaaa, // wwww\n"
962 " int a, int bbb, // xxxxxxx\n"
963 " // yyyyyyyyy\n"
964 " int c, int d, int e) {}",
965 format("void ffffff(\n"
966 " int aaaaaaaaa, // wwww\n"
967 " int a,\n"
968 " int bbb, // xxxxxxx yyyyyyyyy\n"
969 " int c, int d, int e) {}",
970 getLLVMStyleWithColumns(40)));
Alexander Kornienko8afa39b2013-06-20 13:58:37 +0000971 EXPECT_EQ("//\t aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
972 format("//\t aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
973 getLLVMStyleWithColumns(20)));
Alexander Kornienko2785b9a2013-06-07 16:02:52 +0000974}
Manuel Klimekde008c02013-05-27 15:23:34 +0000975
Alexander Kornienko10c26b22013-07-16 21:06:13 +0000976TEST_F(FormatTest, DontSplitLineCommentsWithEscapedNewlines) {
977 EXPECT_EQ("// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
978 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
979 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
980 format("// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
981 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
982 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
983 EXPECT_EQ("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
984 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
985 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
986 format("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
987 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
988 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
989 getLLVMStyleWithColumns(50)));
990 // FIXME: One day we might want to implement adjustment of leading whitespace
991 // of the consecutive lines in this kind of comment:
992 EXPECT_EQ("int\n"
993 "a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
994 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
995 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
996 format("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
997 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
998 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
999 getLLVMStyleWithColumns(49)));
1000}
1001
Alexander Kornienko2785b9a2013-06-07 16:02:52 +00001002TEST_F(FormatTest, PriorityOfCommentBreaking) {
Daniel Jasperf5461782013-08-28 10:03:58 +00001003 EXPECT_EQ("if (xxx ==\n"
1004 " yyy && // aaaaaaaaaaaa bbbbbbbbb\n"
Alexander Kornienko2785b9a2013-06-07 16:02:52 +00001005 " zzz)\n"
1006 " q();",
1007 format("if (xxx == yyy && // aaaaaaaaaaaa bbbbbbbbb\n"
1008 " zzz) q();",
1009 getLLVMStyleWithColumns(40)));
1010 EXPECT_EQ("if (xxxxxxxxxx ==\n"
1011 " yyy && // aaaaaa bbbbbbbb cccc\n"
1012 " zzz)\n"
1013 " q();",
1014 format("if (xxxxxxxxxx == yyy && // aaaaaa bbbbbbbb cccc\n"
1015 " zzz) q();",
1016 getLLVMStyleWithColumns(40)));
1017 EXPECT_EQ("if (xxxxxxxxxx &&\n"
1018 " yyy || // aaaaaa bbbbbbbb cccc\n"
1019 " zzz)\n"
1020 " q();",
1021 format("if (xxxxxxxxxx && yyy || // aaaaaa bbbbbbbb cccc\n"
1022 " zzz) q();",
1023 getLLVMStyleWithColumns(40)));
1024 EXPECT_EQ("fffffffff(&xxx, // aaaaaaaaaaaa\n"
1025 " // bbbbbbbbbbb\n"
1026 " zzz);",
1027 format("fffffffff(&xxx, // aaaaaaaaaaaa bbbbbbbbbbb\n"
1028 " zzz);",
1029 getLLVMStyleWithColumns(40)));
Manuel Klimekde008c02013-05-27 15:23:34 +00001030}
1031
1032TEST_F(FormatTest, MultiLineCommentsInDefines) {
Alexander Kornienkoc36c5c22013-06-19 19:50:11 +00001033 EXPECT_EQ("#define A(x) /* \\\n"
1034 " a comment \\\n"
1035 " inside */ \\\n"
Manuel Klimekde008c02013-05-27 15:23:34 +00001036 " f();",
1037 format("#define A(x) /* \\\n"
1038 " a comment \\\n"
1039 " inside */ \\\n"
1040 " f();",
1041 getLLVMStyleWithColumns(17)));
Alexander Kornienkoc36c5c22013-06-19 19:50:11 +00001042 EXPECT_EQ("#define A( \\\n"
1043 " x) /* \\\n"
1044 " a comment \\\n"
1045 " inside */ \\\n"
Manuel Klimekde008c02013-05-27 15:23:34 +00001046 " f();",
1047 format("#define A( \\\n"
1048 " x) /* \\\n"
1049 " a comment \\\n"
1050 " inside */ \\\n"
1051 " f();",
1052 getLLVMStyleWithColumns(17)));
Alexander Kornienko5262dd92013-03-27 11:52:18 +00001053}
1054
Alexander Kornienkof52d5272013-04-02 13:04:06 +00001055TEST_F(FormatTest, ParsesCommentsAdjacentToPPDirectives) {
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001056 EXPECT_EQ("namespace {}\n// Test\n#define A",
Alexander Kornienkof52d5272013-04-02 13:04:06 +00001057 format("namespace {}\n // Test\n#define A"));
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001058 EXPECT_EQ("namespace {}\n/* Test */\n#define A",
Alexander Kornienkof52d5272013-04-02 13:04:06 +00001059 format("namespace {}\n /* Test */\n#define A"));
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001060 EXPECT_EQ("namespace {}\n/* Test */ #define A",
Alexander Kornienkof52d5272013-04-02 13:04:06 +00001061 format("namespace {}\n /* Test */ #define A"));
1062}
1063
Alexander Kornienko052685c2013-03-19 17:41:36 +00001064TEST_F(FormatTest, SplitsLongLinesInComments) {
1065 EXPECT_EQ("/* This is a long\n"
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001066 " * comment that\n"
1067 " * doesn't\n"
1068 " * fit on one line.\n"
1069 " */",
Alexander Kornienko052685c2013-03-19 17:41:36 +00001070 format("/* "
1071 "This is a long "
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001072 "comment that "
1073 "doesn't "
Alexander Kornienko052685c2013-03-19 17:41:36 +00001074 "fit on one line. */",
1075 getLLVMStyleWithColumns(20)));
Alexander Kornienko919398b2013-04-17 17:34:05 +00001076 EXPECT_EQ("/* a b c d\n"
1077 " * e f g\n"
1078 " * h i j k\n"
1079 " */",
1080 format("/* a b c d e f g h i j k */",
1081 getLLVMStyleWithColumns(10)));
1082 EXPECT_EQ("/* a b c d\n"
1083 " * e f g\n"
1084 " * h i j k\n"
1085 " */",
1086 format("\\\n/* a b c d e f g h i j k */",
1087 getLLVMStyleWithColumns(10)));
Alexander Kornienko052685c2013-03-19 17:41:36 +00001088 EXPECT_EQ("/*\n"
1089 "This is a long\n"
1090 "comment that doesn't\n"
1091 "fit on one line.\n"
1092 "*/",
1093 format("/*\n"
1094 "This is a long "
1095 "comment that doesn't "
1096 "fit on one line. \n"
1097 "*/", getLLVMStyleWithColumns(20)));
1098 EXPECT_EQ("/*\n"
1099 " * This is a long\n"
1100 " * comment that\n"
1101 " * doesn't fit on\n"
1102 " * one line.\n"
1103 " */",
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001104 format("/* \n"
Alexander Kornienko052685c2013-03-19 17:41:36 +00001105 " * This is a long "
1106 " comment that "
1107 " doesn't fit on "
1108 " one line. \n"
1109 " */", getLLVMStyleWithColumns(20)));
1110 EXPECT_EQ("/*\n"
1111 " * This_is_a_comment_with_words_that_dont_fit_on_one_line\n"
1112 " * so_it_should_be_broken\n"
1113 " * wherever_a_space_occurs\n"
1114 " */",
1115 format("/*\n"
1116 " * This_is_a_comment_with_words_that_dont_fit_on_one_line "
1117 " so_it_should_be_broken "
1118 " wherever_a_space_occurs \n"
1119 " */",
1120 getLLVMStyleWithColumns(20)));
1121 EXPECT_EQ("/*\n"
Alexander Kornienko5262dd92013-03-27 11:52:18 +00001122 " * This_comment_can_not_be_broken_into_lines\n"
Alexander Kornienko052685c2013-03-19 17:41:36 +00001123 " */",
1124 format("/*\n"
Alexander Kornienko5262dd92013-03-27 11:52:18 +00001125 " * This_comment_can_not_be_broken_into_lines\n"
Alexander Kornienko052685c2013-03-19 17:41:36 +00001126 " */",
1127 getLLVMStyleWithColumns(20)));
1128 EXPECT_EQ("{\n"
1129 " /*\n"
1130 " This is another\n"
1131 " long comment that\n"
1132 " doesn't fit on one\n"
1133 " line 1234567890\n"
1134 " */\n"
1135 "}",
1136 format("{\n"
1137 "/*\n"
1138 "This is another "
1139 " long comment that "
1140 " doesn't fit on one"
1141 " line 1234567890\n"
1142 "*/\n"
1143 "}", getLLVMStyleWithColumns(20)));
1144 EXPECT_EQ("{\n"
1145 " /*\n"
1146 " * This i s\n"
1147 " * another comment\n"
1148 " * t hat doesn' t\n"
1149 " * fit on one l i\n"
1150 " * n e\n"
1151 " */\n"
1152 "}",
1153 format("{\n"
1154 "/*\n"
1155 " * This i s"
1156 " another comment"
1157 " t hat doesn' t"
1158 " fit on one l i"
1159 " n e\n"
1160 " */\n"
1161 "}", getLLVMStyleWithColumns(20)));
1162 EXPECT_EQ("/*\n"
1163 " * This is a long\n"
1164 " * comment that\n"
1165 " * doesn't fit on\n"
1166 " * one line\n"
1167 " */",
1168 format(" /*\n"
1169 " * This is a long comment that doesn't fit on one line\n"
1170 " */", getLLVMStyleWithColumns(20)));
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001171 EXPECT_EQ("{\n"
1172 " if (something) /* This is a\n"
Manuel Klimekde008c02013-05-27 15:23:34 +00001173 " long\n"
1174 " comment */\n"
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001175 " ;\n"
1176 "}",
1177 format("{\n"
1178 " if (something) /* This is a long comment */\n"
1179 " ;\n"
1180 "}",
1181 getLLVMStyleWithColumns(30)));
Alexander Kornienko2785b9a2013-06-07 16:02:52 +00001182
1183 EXPECT_EQ("/* A comment before\n"
1184 " * a macro\n"
1185 " * definition */\n"
1186 "#define a b",
1187 format("/* A comment before a macro definition */\n"
1188 "#define a b",
1189 getLLVMStyleWithColumns(20)));
1190
1191 EXPECT_EQ("/* some comment\n"
1192 " * a comment\n"
1193 "* that we break\n"
1194 " * another comment\n"
1195 "* we have to break\n"
1196 "* a left comment\n"
1197 " */",
1198 format(" /* some comment\n"
1199 " * a comment that we break\n"
1200 " * another comment we have to break\n"
1201 "* a left comment\n"
1202 " */",
1203 getLLVMStyleWithColumns(20)));
1204
1205 EXPECT_EQ("/*\n"
1206 "\n"
1207 "\n"
1208 " */\n",
1209 format(" /* \n"
1210 " \n"
1211 " \n"
1212 " */\n"));
Alexander Kornienko052685c2013-03-19 17:41:36 +00001213}
1214
1215TEST_F(FormatTest, SplitsLongLinesInCommentsInPreprocessor) {
1216 EXPECT_EQ("#define X \\\n"
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001217 " /* \\\n"
1218 " Test \\\n"
Alexander Kornienko052685c2013-03-19 17:41:36 +00001219 " Macro comment \\\n"
1220 " with a long \\\n"
1221 " line \\\n"
Alexander Kornienko70ce7882013-04-15 14:28:00 +00001222 " */ \\\n"
Alexander Kornienko052685c2013-03-19 17:41:36 +00001223 " A + B",
1224 format("#define X \\\n"
1225 " /*\n"
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001226 " Test\n"
Alexander Kornienko052685c2013-03-19 17:41:36 +00001227 " Macro comment with a long line\n"
1228 " */ \\\n"
1229 " A + B",
1230 getLLVMStyleWithColumns(20)));
1231 EXPECT_EQ("#define X \\\n"
1232 " /* Macro comment \\\n"
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001233 " with a long \\\n"
Alexander Kornienko70ce7882013-04-15 14:28:00 +00001234 " line */ \\\n"
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00001235 " A + B",
1236 format("#define X \\\n"
1237 " /* Macro comment with a long\n"
1238 " line */ \\\n"
1239 " A + B",
1240 getLLVMStyleWithColumns(20)));
1241 EXPECT_EQ("#define X \\\n"
1242 " /* Macro comment \\\n"
1243 " * with a long \\\n"
Alexander Kornienko70ce7882013-04-15 14:28:00 +00001244 " * line */ \\\n"
Alexander Kornienko052685c2013-03-19 17:41:36 +00001245 " A + B",
1246 format("#define X \\\n"
1247 " /* Macro comment with a long line */ \\\n"
1248 " A + B",
1249 getLLVMStyleWithColumns(20)));
1250}
1251
Daniel Jasper2c6cc482013-01-17 12:53:34 +00001252TEST_F(FormatTest, CommentsInStaticInitializers) {
1253 EXPECT_EQ(
1254 "static SomeType type = { aaaaaaaaaaaaaaaaaaaa, /* comment */\n"
1255 " aaaaaaaaaaaaaaaaaaaa /* comment */,\n"
1256 " /* comment */ aaaaaaaaaaaaaaaaaaaa,\n"
1257 " aaaaaaaaaaaaaaaaaaaa, // comment\n"
1258 " aaaaaaaaaaaaaaaaaaaa };",
1259 format("static SomeType type = { aaaaaaaaaaaaaaaaaaaa , /* comment */\n"
1260 " aaaaaaaaaaaaaaaaaaaa /* comment */ ,\n"
1261 " /* comment */ aaaaaaaaaaaaaaaaaaaa ,\n"
1262 " aaaaaaaaaaaaaaaaaaaa , // comment\n"
1263 " aaaaaaaaaaaaaaaaaaaa };"));
1264 verifyFormat("static SomeType type = { aaaaaaaaaaa, // comment for aa...\n"
1265 " bbbbbbbbbbb, ccccccccccc };");
1266 verifyFormat("static SomeType type = { aaaaaaaaaaa,\n"
1267 " // comment for bb....\n"
1268 " bbbbbbbbbbb, ccccccccccc };");
1269 verifyGoogleFormat(
Daniel Jasper2424eef2013-05-23 10:15:45 +00001270 "static SomeType type = {aaaaaaaaaaa, // comment for aa...\n"
1271 " bbbbbbbbbbb, ccccccccccc};");
1272 verifyGoogleFormat("static SomeType type = {aaaaaaaaaaa,\n"
1273 " // comment for bb....\n"
1274 " bbbbbbbbbbb, ccccccccccc};");
Daniel Jasper2c6cc482013-01-17 12:53:34 +00001275
Daniel Jasperf343cab2013-01-31 14:59:26 +00001276 verifyFormat("S s = { { a, b, c }, // Group #1\n"
1277 " { d, e, f }, // Group #2\n"
1278 " { g, h, i } }; // Group #3");
1279 verifyFormat("S s = { { // Group #1\n"
1280 " a, b, c },\n"
1281 " { // Group #2\n"
1282 " d, e, f },\n"
1283 " { // Group #3\n"
1284 " g, h, i } };");
Daniel Jasperc4615b72013-02-20 12:56:39 +00001285
1286 EXPECT_EQ("S s = {\n"
1287 " // Some comment\n"
Daniel Jasper1ef81d52013-02-26 13:10:34 +00001288 " a,\n"
Daniel Jasperc4615b72013-02-20 12:56:39 +00001289 "\n"
1290 " // Comment after empty line\n"
1291 " b\n"
Daniel Jasper1ef81d52013-02-26 13:10:34 +00001292 "}",
1293 format("S s = {\n"
1294 " // Some comment\n"
1295 " a,\n"
1296 " \n"
1297 " // Comment after empty line\n"
1298 " b\n"
1299 "}"));
Alexander Kornienkoe3f11972013-06-12 19:04:12 +00001300 EXPECT_EQ("S s = {\n"
1301 " /* Some comment */\n"
1302 " a,\n"
1303 "\n"
1304 " /* Comment after empty line */\n"
1305 " b\n"
1306 "}",
1307 format("S s = {\n"
1308 " /* Some comment */\n"
1309 " a,\n"
1310 " \n"
1311 " /* Comment after empty line */\n"
1312 " b\n"
1313 "}"));
Daniel Jasper25e81b22013-02-28 15:04:12 +00001314 verifyFormat("const uint8_t aaaaaaaaaaaaaaaaaaaaaa[0] = {\n"
1315 " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n"
1316 " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n"
1317 " 0x00, 0x00, 0x00, 0x00 // comment\n"
1318 "};");
Alexander Kornienko15757312012-12-06 18:03:27 +00001319}
1320
Alexander Kornienko6fb46b02013-05-24 18:24:24 +00001321TEST_F(FormatTest, IgnoresIf0Contents) {
1322 EXPECT_EQ("#if 0\n"
1323 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n"
1324 "#endif\n"
1325 "void f() {}",
1326 format("#if 0\n"
1327 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n"
1328 "#endif\n"
1329 "void f( ) { }"));
1330 EXPECT_EQ("#if false\n"
1331 "void f( ) { }\n"
1332 "#endif\n"
1333 "void g() {}\n",
1334 format("#if false\n"
1335 "void f( ) { }\n"
1336 "#endif\n"
1337 "void g( ) { }\n"));
1338 EXPECT_EQ("enum E {\n"
1339 " One,\n"
1340 " Two,\n"
1341 "#if 0\n"
1342 "Three,\n"
1343 " Four,\n"
1344 "#endif\n"
1345 " Five\n"
1346 "};",
1347 format("enum E {\n"
1348 " One,Two,\n"
1349 "#if 0\n"
1350 "Three,\n"
1351 " Four,\n"
1352 "#endif\n"
1353 " Five};"));
1354 EXPECT_EQ("enum F {\n"
1355 " One,\n"
1356 "#if 1\n"
1357 " Two,\n"
1358 "#if 0\n"
1359 "Three,\n"
1360 " Four,\n"
1361 "#endif\n"
1362 " Five\n"
1363 "#endif\n"
1364 "};",
1365 format("enum F {\n"
1366 "One,\n"
1367 "#if 1\n"
1368 "Two,\n"
1369 "#if 0\n"
1370 "Three,\n"
1371 " Four,\n"
1372 "#endif\n"
1373 "Five\n"
1374 "#endif\n"
1375 "};"));
1376 EXPECT_EQ("enum G {\n"
1377 " One,\n"
1378 "#if 0\n"
1379 "Two,\n"
1380 "#else\n"
1381 " Three,\n"
1382 "#endif\n"
1383 " Four\n"
1384 "};",
1385 format("enum G {\n"
1386 "One,\n"
1387 "#if 0\n"
1388 "Two,\n"
1389 "#else\n"
1390 "Three,\n"
1391 "#endif\n"
1392 "Four\n"
1393 "};"));
1394 EXPECT_EQ("enum H {\n"
1395 " One,\n"
1396 "#if 0\n"
1397 "#ifdef Q\n"
1398 "Two,\n"
1399 "#else\n"
1400 "Three,\n"
1401 "#endif\n"
1402 "#endif\n"
1403 " Four\n"
1404 "};",
1405 format("enum H {\n"
1406 "One,\n"
1407 "#if 0\n"
1408 "#ifdef Q\n"
1409 "Two,\n"
1410 "#else\n"
1411 "Three,\n"
1412 "#endif\n"
1413 "#endif\n"
1414 "Four\n"
1415 "};"));
1416 EXPECT_EQ("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 format("enum I {\n"
1425 "One,\n"
1426 "#if /* test */ 0 || 1\n"
1427 "Two,\n"
1428 "Three,\n"
1429 "#endif\n"
1430 "Four\n"
1431 "};"));
1432 EXPECT_EQ("enum J {\n"
1433 " One,\n"
1434 "#if 0\n"
1435 "#if 0\n"
1436 "Two,\n"
1437 "#else\n"
1438 "Three,\n"
1439 "#endif\n"
1440 "Four,\n"
1441 "#endif\n"
1442 " Five\n"
1443 "};",
1444 format("enum J {\n"
1445 "One,\n"
1446 "#if 0\n"
1447 "#if 0\n"
1448 "Two,\n"
1449 "#else\n"
1450 "Three,\n"
1451 "#endif\n"
1452 "Four,\n"
1453 "#endif\n"
1454 "Five\n"
1455 "};"));
1456
1457}
1458
Alexander Kornienko15757312012-12-06 18:03:27 +00001459//===----------------------------------------------------------------------===//
1460// Tests for classes, namespaces, etc.
1461//===----------------------------------------------------------------------===//
1462
1463TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) {
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001464 verifyFormat("class A {};");
Alexander Kornienko15757312012-12-06 18:03:27 +00001465}
1466
1467TEST_F(FormatTest, UnderstandsAccessSpecifiers) {
1468 verifyFormat("class A {\n"
1469 "public:\n"
Daniel Jasperac3223e2013-04-10 09:49:49 +00001470 "public: // comment\n"
Alexander Kornienko15757312012-12-06 18:03:27 +00001471 "protected:\n"
1472 "private:\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +00001473 " void f() {}\n"
Alexander Kornienko15757312012-12-06 18:03:27 +00001474 "};");
1475 verifyGoogleFormat("class A {\n"
1476 " public:\n"
1477 " protected:\n"
1478 " private:\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +00001479 " void f() {}\n"
Alexander Kornienko15757312012-12-06 18:03:27 +00001480 "};");
1481}
1482
Alexander Kornienko94b748f2013-03-27 17:08:02 +00001483TEST_F(FormatTest, SeparatesLogicalBlocks) {
1484 EXPECT_EQ("class A {\n"
1485 "public:\n"
1486 " void f();\n"
1487 "\n"
1488 "private:\n"
1489 " void g() {}\n"
1490 " // test\n"
1491 "protected:\n"
1492 " int h;\n"
1493 "};",
1494 format("class A {\n"
1495 "public:\n"
1496 "void f();\n"
1497 "private:\n"
1498 "void g() {}\n"
1499 "// test\n"
1500 "protected:\n"
1501 "int h;\n"
1502 "};"));
Daniel Jasper63cfb892013-10-06 11:40:08 +00001503 EXPECT_EQ("class A {\n"
1504 "protected:\n"
1505 "public:\n"
1506 " void f();\n"
1507 "};",
1508 format("class A {\n"
1509 "protected:\n"
1510 "\n"
1511 "public:\n"
1512 "\n"
1513 " void f();\n"
1514 "};"));
Alexander Kornienko94b748f2013-03-27 17:08:02 +00001515}
1516
Daniel Jasper6b119d62013-04-05 17:22:09 +00001517TEST_F(FormatTest, FormatsClasses) {
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001518 verifyFormat("class A : public B {};");
1519 verifyFormat("class A : public ::B {};");
Daniel Jasper6cabab42013-02-14 08:42:54 +00001520
1521 verifyFormat(
1522 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001523 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
Daniel Jasperc194c952013-05-06 06:45:09 +00001524 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
1525 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001526 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
Daniel Jasper6cabab42013-02-14 08:42:54 +00001527 verifyFormat(
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001528 "class A : public B, public C, public D, public E, public F {};");
Daniel Jasper6cabab42013-02-14 08:42:54 +00001529 verifyFormat("class AAAAAAAAAAAA : public B,\n"
1530 " public C,\n"
1531 " public D,\n"
1532 " public E,\n"
1533 " public F,\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001534 " public G {};");
Daniel Jasper6b119d62013-04-05 17:22:09 +00001535
1536 verifyFormat("class\n"
Daniel Jasper567dcf92013-09-05 09:29:45 +00001537 " ReallyReallyLongClassName {\n"
1538 " int i;\n"
1539 "};",
Daniel Jasper6b119d62013-04-05 17:22:09 +00001540 getLLVMStyleWithColumns(32));
Daniel Jaspercea014b2013-10-08 16:24:07 +00001541 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n"
1542 " aaaaaaaaaaaaaaaa> {};");
1543 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n"
1544 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n"
1545 " aaaaaaaaaaaaaaaaaaaaaa> {};");
Daniel Jasperbac016b2012-12-03 18:12:45 +00001546}
1547
Manuel Klimekde768542013-01-07 18:10:23 +00001548TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) {
Manuel Klimek2f1ac412013-01-21 16:42:44 +00001549 verifyFormat("class A {\n} a, b;");
1550 verifyFormat("struct A {\n} a, b;");
1551 verifyFormat("union A {\n} a;");
Manuel Klimekde768542013-01-07 18:10:23 +00001552}
1553
Alexander Kornienko15757312012-12-06 18:03:27 +00001554TEST_F(FormatTest, FormatsEnum) {
Alexander Kornienkoa166e732012-12-04 14:46:19 +00001555 verifyFormat("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 Jasper57981202013-09-13 09:20:45 +00001563 verifyGoogleFormat("enum {\n"
1564 " Zero,\n"
1565 " One = 1,\n"
1566 " Two = One + 1,\n"
1567 " Three = (One + Two),\n"
1568 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1569 " Five = (One, Two, Three, Four, 5)\n"
1570 "};");
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001571 verifyFormat("enum Enum {};");
1572 verifyFormat("enum {};");
Daniel Jasper57981202013-09-13 09:20:45 +00001573 verifyFormat("enum X E {} d;");
1574 verifyFormat("enum __attribute__((...)) E {} d;");
1575 verifyFormat("enum __declspec__((...)) E {} d;");
Manuel Klimek308232c2013-01-21 19:17:52 +00001576 verifyFormat("enum X f() {\n a();\n return 42;\n}");
Daniel Jasper57981202013-09-13 09:20:45 +00001577 verifyFormat("enum {\n"
1578 " Bar = Foo<int, int>::value\n"
1579 "};");
Alexander Kornienkoa166e732012-12-04 14:46:19 +00001580}
1581
Daniel Jasper4b434cf2013-08-30 10:10:19 +00001582TEST_F(FormatTest, FormatsEnumsWithErrors) {
1583 verifyFormat("enum Type {\n"
1584 " One = 0;\n" // These semicolons should be commas.
1585 " Two = 1;\n"
1586 "};");
1587 verifyFormat("namespace n {\n"
1588 "enum Type {\n"
1589 " One,\n"
1590 " Two,\n" // missing };
1591 " int i;\n"
1592 "}\n"
1593 "void g() {}");
1594}
1595
Daniel Jaspercbeb1c62013-08-20 12:42:50 +00001596TEST_F(FormatTest, FormatsEnumStruct) {
1597 verifyFormat("enum struct {\n"
1598 " Zero,\n"
1599 " One = 1,\n"
1600 " Two = One + 1,\n"
1601 " Three = (One + Two),\n"
1602 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1603 " Five = (One, Two, Three, Four, 5)\n"
1604 "};");
1605 verifyFormat("enum struct Enum {};");
1606 verifyFormat("enum struct {};");
Daniel Jasper57981202013-09-13 09:20:45 +00001607 verifyFormat("enum struct X E {} d;");
1608 verifyFormat("enum struct __attribute__((...)) E {} d;");
1609 verifyFormat("enum struct __declspec__((...)) E {} d;");
Daniel Jaspercbeb1c62013-08-20 12:42:50 +00001610 verifyFormat("enum struct X f() {\n a();\n return 42;\n}");
1611}
1612
1613TEST_F(FormatTest, FormatsEnumClass) {
1614 verifyFormat("enum class {\n"
1615 " Zero,\n"
1616 " One = 1,\n"
1617 " Two = One + 1,\n"
1618 " Three = (One + Two),\n"
1619 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1620 " Five = (One, Two, Three, Four, 5)\n"
1621 "};");
1622 verifyFormat("enum class Enum {};");
1623 verifyFormat("enum class {};");
Daniel Jasper57981202013-09-13 09:20:45 +00001624 verifyFormat("enum class X E {} d;");
1625 verifyFormat("enum class __attribute__((...)) E {} d;");
1626 verifyFormat("enum class __declspec__((...)) E {} d;");
Daniel Jaspercbeb1c62013-08-20 12:42:50 +00001627 verifyFormat("enum class X f() {\n a();\n return 42;\n}");
1628}
1629
Manuel Klimeke11e45f2013-09-05 15:34:55 +00001630TEST_F(FormatTest, FormatsEnumTypes) {
1631 verifyFormat("enum X : int {\n"
1632 " A,\n"
1633 " B\n"
1634 "};");
Daniel Jaspere27dc5d2013-09-06 21:32:35 +00001635 verifyFormat("enum X : std::uint32_t {\n"
1636 " A,\n"
1637 " B\n"
1638 "};");
Manuel Klimeke11e45f2013-09-05 15:34:55 +00001639}
1640
Nico Weberefaddc02013-01-14 05:49:49 +00001641TEST_F(FormatTest, FormatsBitfields) {
1642 verifyFormat("struct Bitfields {\n"
1643 " unsigned sClass : 8;\n"
1644 " unsigned ValueKind : 2;\n"
1645 "};");
Alexander Kornienko01fe9f92013-10-10 13:36:20 +00001646 verifyFormat("struct A {\n"
1647 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n"
1648 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n"
1649 "};");
Nico Weberefaddc02013-01-14 05:49:49 +00001650}
1651
Alexander Kornienko15757312012-12-06 18:03:27 +00001652TEST_F(FormatTest, FormatsNamespaces) {
1653 verifyFormat("namespace some_namespace {\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001654 "class A {};\n"
Manuel Klimek517e8942013-01-11 17:54:10 +00001655 "void f() { f(); }\n"
Alexander Kornienko15757312012-12-06 18:03:27 +00001656 "}");
1657 verifyFormat("namespace {\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001658 "class A {};\n"
Manuel Klimek517e8942013-01-11 17:54:10 +00001659 "void f() { f(); }\n"
Alexander Kornienko15757312012-12-06 18:03:27 +00001660 "}");
Dmitri Gribenko1f94f2b2012-12-30 21:27:25 +00001661 verifyFormat("inline namespace X {\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001662 "class A {};\n"
Manuel Klimek517e8942013-01-11 17:54:10 +00001663 "void f() { f(); }\n"
Dmitri Gribenko1f94f2b2012-12-30 21:27:25 +00001664 "}");
Alexander Kornienko15757312012-12-06 18:03:27 +00001665 verifyFormat("using namespace some_namespace;\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001666 "class A {};\n"
Manuel Klimek517e8942013-01-11 17:54:10 +00001667 "void f() { f(); }");
Manuel Klimek7fc2db02013-02-06 16:08:09 +00001668
1669 // This code is more common than we thought; if we
1670 // layout this correctly the semicolon will go into
1671 // its own line, which is undesireable.
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001672 verifyFormat("namespace {};");
Manuel Klimek7fc2db02013-02-06 16:08:09 +00001673 verifyFormat("namespace {\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00001674 "class A {};\n"
Manuel Klimek7fc2db02013-02-06 16:08:09 +00001675 "};");
Daniel Jaspercbe86cc2013-07-01 11:22:57 +00001676
1677 verifyFormat("namespace {\n"
1678 "int SomeVariable = 0; // comment\n"
1679 "} // namespace");
1680 EXPECT_EQ("#ifndef HEADER_GUARD\n"
1681 "#define HEADER_GUARD\n"
1682 "namespace my_namespace {\n"
1683 "int i;\n"
1684 "} // my_namespace\n"
1685 "#endif // HEADER_GUARD",
1686 format("#ifndef HEADER_GUARD\n"
1687 " #define HEADER_GUARD\n"
1688 " namespace my_namespace {\n"
1689 "int i;\n"
1690 "} // my_namespace\n"
1691 "#endif // HEADER_GUARD"));
Daniel Jaspereff18b92013-07-31 23:16:02 +00001692
1693 FormatStyle Style = getLLVMStyle();
1694 Style.NamespaceIndentation = FormatStyle::NI_All;
1695 EXPECT_EQ("namespace out {\n"
1696 " int i;\n"
1697 " namespace in {\n"
1698 " int i;\n"
1699 " } // namespace\n"
1700 "} // namespace",
1701 format("namespace out {\n"
1702 "int i;\n"
1703 "namespace in {\n"
1704 "int i;\n"
1705 "} // namespace\n"
1706 "} // namespace",
1707 Style));
1708
1709 Style.NamespaceIndentation = FormatStyle::NI_Inner;
1710 EXPECT_EQ("namespace out {\n"
1711 "int i;\n"
1712 "namespace in {\n"
1713 " int i;\n"
1714 "} // namespace\n"
1715 "} // namespace",
1716 format("namespace out {\n"
1717 "int i;\n"
1718 "namespace in {\n"
1719 "int i;\n"
1720 "} // namespace\n"
1721 "} // namespace",
1722 Style));
Alexander Kornienko15757312012-12-06 18:03:27 +00001723}
1724
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001725TEST_F(FormatTest, FormatsExternC) { verifyFormat("extern \"C\" {\nint a;"); }
Manuel Klimekd19dc2d2013-01-21 14:32:05 +00001726
Daniel Jasper923ebef2013-03-14 13:45:21 +00001727TEST_F(FormatTest, FormatsInlineASM) {
1728 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));");
1729 verifyFormat(
1730 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
1731 " \"cpuid\\n\\t\"\n"
1732 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
Daniel Jaspera8fda852013-05-15 07:51:51 +00001733 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n"
Daniel Jasper923ebef2013-03-14 13:45:21 +00001734 " : \"a\"(value));");
1735}
1736
Nico Webera9ccdd12013-01-07 16:36:17 +00001737TEST_F(FormatTest, FormatTryCatch) {
Manuel Klimek517e8942013-01-11 17:54:10 +00001738 // FIXME: Handle try-catch explicitly in the UnwrappedLineParser, then we'll
1739 // also not create single-line-blocks.
Nico Webera9ccdd12013-01-07 16:36:17 +00001740 verifyFormat("try {\n"
1741 " throw a * b;\n"
1742 "}\n"
1743 "catch (int a) {\n"
1744 " // Do nothing.\n"
1745 "}\n"
1746 "catch (...) {\n"
1747 " exit(42);\n"
1748 "}");
1749
1750 // Function-level try statements.
Manuel Klimek517e8942013-01-11 17:54:10 +00001751 verifyFormat("int f() try { return 4; }\n"
Nico Webera9ccdd12013-01-07 16:36:17 +00001752 "catch (...) {\n"
1753 " return 5;\n"
1754 "}");
1755 verifyFormat("class A {\n"
1756 " int a;\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +00001757 " A() try : a(0) {}\n"
Nico Webera9ccdd12013-01-07 16:36:17 +00001758 " catch (...) {\n"
1759 " throw;\n"
1760 " }\n"
1761 "};\n");
1762}
1763
1764TEST_F(FormatTest, FormatObjCTryCatch) {
Manuel Klimekd5688cf2013-01-11 19:17:44 +00001765 verifyFormat("@try {\n"
1766 " f();\n"
1767 "}\n"
1768 "@catch (NSException e) {\n"
1769 " @throw;\n"
1770 "}\n"
1771 "@finally {\n"
1772 " exit(42);\n"
1773 "}");
Nico Webera9ccdd12013-01-07 16:36:17 +00001774}
1775
Daniel Jasper05b1ac82012-12-17 11:29:41 +00001776TEST_F(FormatTest, StaticInitializers) {
1777 verifyFormat("static SomeClass SC = { 1, 'a' };");
1778
Daniel Jasper05b1ac82012-12-17 11:29:41 +00001779 verifyFormat(
Daniel Jasper9cda8002013-01-07 13:08:40 +00001780 "static SomeClass WithALoooooooooooooooooooongName = {\n"
Manuel Klimekc8c8a472013-01-10 15:58:26 +00001781 " 100000000, \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
1782 "};");
1783
Daniel Jasper399914b2013-05-17 09:35:01 +00001784 // Here, everything other than the "}" would fit on a line.
1785 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
1786 " 100000000000000000000000\n"
1787 "};");
Alexander Kornienkoe3f11972013-06-12 19:04:12 +00001788 EXPECT_EQ("S s = { a, b };", format("S s = {\n"
1789 " a,\n"
1790 "\n"
1791 " b\n"
1792 "};"));
Daniel Jasper399914b2013-05-17 09:35:01 +00001793
1794 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first
1795 // line. However, the formatting looks a bit off and this probably doesn't
1796 // happen often in practice.
1797 verifyFormat("static int Variable[1] = {\n"
1798 " { 1000000000000000000000000000000000000 }\n"
1799 "};",
1800 getLLVMStyleWithColumns(40));
Daniel Jasper05b1ac82012-12-17 11:29:41 +00001801}
1802
Daniel Jasper5ad390d2013-05-28 11:30:49 +00001803TEST_F(FormatTest, DesignatedInitializers) {
1804 verifyFormat("const struct A a = { .a = 1, .b = 2 };");
1805 verifyFormat("const struct A a = { .aaaaaaaaaa = 1,\n"
1806 " .bbbbbbbbbb = 2,\n"
1807 " .cccccccccc = 3,\n"
1808 " .dddddddddd = 4,\n"
1809 " .eeeeeeeeee = 5 };");
1810 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
1811 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n"
1812 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n"
1813 " .ccccccccccccccccccccccccccc = 3,\n"
1814 " .ddddddddddddddddddddddddddd = 4,\n"
1815 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5\n"
1816 "};");
1817
1818 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};");
1819}
1820
Manuel Klimek2c7739e2013-01-14 16:41:43 +00001821TEST_F(FormatTest, NestedStaticInitializers) {
1822 verifyFormat("static A x = { { {} } };\n");
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001823 verifyFormat("static A x = { { { init1, init2, init3, init4 },\n"
1824 " { init1, init2, init3, init4 } } };");
Daniel Jasper0df6acd2013-01-16 14:59:02 +00001825
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001826 verifyFormat("somes Status::global_reps[3] = {\n"
1827 " { kGlobalRef, OK_CODE, NULL, NULL, NULL },\n"
1828 " { kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL },\n"
1829 " { kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL }\n"
1830 "};");
Daniel Jasper2424eef2013-05-23 10:15:45 +00001831 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n"
Daniel Jasperb5dc3f42013-07-16 18:22:10 +00001832 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
1833 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
1834 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};");
Manuel Klimek2c7739e2013-01-14 16:41:43 +00001835 verifyFormat(
1836 "CGRect cg_rect = { { rect.fLeft, rect.fTop },\n"
1837 " { rect.fRight - rect.fLeft, rect.fBottom - rect.fTop"
1838 " } };");
1839
Daniel Jasperf343cab2013-01-31 14:59:26 +00001840 verifyFormat(
1841 "SomeArrayOfSomeType a = { { { 1, 2, 3 }, { 1, 2, 3 },\n"
1842 " { 111111111111111111111111111111,\n"
1843 " 222222222222222222222222222222,\n"
1844 " 333333333333333333333333333333 },\n"
1845 " { 1, 2, 3 }, { 1, 2, 3 } } };");
Daniel Jasper6bd02322013-02-03 18:07:15 +00001846 verifyFormat(
1847 "SomeArrayOfSomeType a = { { { 1, 2, 3 } }, { { 1, 2, 3 } },\n"
1848 " { { 111111111111111111111111111111,\n"
1849 " 222222222222222222222222222222,\n"
1850 " 333333333333333333333333333333 } },\n"
1851 " { { 1, 2, 3 } }, { { 1, 2, 3 } } };");
Daniel Jasper2424eef2013-05-23 10:15:45 +00001852 verifyGoogleFormat(
Daniel Jasperb5dc3f42013-07-16 18:22:10 +00001853 "SomeArrayOfSomeType a = {\n"
1854 " {{1, 2, 3}}, {{1, 2, 3}},\n"
1855 " {{111111111111111111111111111111, 222222222222222222222222222222,\n"
1856 " 333333333333333333333333333333}},\n"
1857 " {{1, 2, 3}}, {{1, 2, 3}}};");
Daniel Jasperf343cab2013-01-31 14:59:26 +00001858
Nico Weber6a21a552013-01-18 02:43:57 +00001859 // FIXME: We might at some point want to handle this similar to parameter
Manuel Klimek2c7739e2013-01-14 16:41:43 +00001860 // lists, where we have an option to put each on a single line.
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001861 verifyFormat(
1862 "struct {\n"
1863 " unsigned bit;\n"
1864 " const char *const name;\n"
Daniel Jasperd4a03db2013-08-22 15:00:41 +00001865 "} kBitsToOs[] = { { kOsMac, \"Mac\" }, { kOsWin, \"Windows\" },\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001866 " { kOsLinux, \"Linux\" }, { kOsCrOS, \"Chrome OS\" } };");
Manuel Klimek2c7739e2013-01-14 16:41:43 +00001867}
1868
Manuel Klimeka080a182013-01-02 16:30:12 +00001869TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) {
1870 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("
1871 " \\\n"
1872 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)");
1873}
1874
Daniel Jasper71607512013-01-07 10:48:50 +00001875TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) {
Alexander Kornienkob18c2582013-10-11 21:43:05 +00001876 verifyFormat("virtual void write(ELFWriter *writerrr,\n"
1877 " OwningPtr<FileOutputBuffer> &buffer) = 0;");
1878}
1879
1880TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) {
1881 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3",
1882 getLLVMStyleWithColumns(40));
1883 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
1884 getLLVMStyleWithColumns(40));
1885 EXPECT_EQ("#define Q \\\n"
1886 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n"
1887 " \"aaaaaaaa.cpp\"",
1888 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
1889 getLLVMStyleWithColumns(40)));
1890}
1891
1892TEST_F(FormatTest, UnderstandsLinePPDirective) {
1893 EXPECT_EQ("# 123 \"A string literal\"",
1894 format(" # 123 \"A string literal\""));
Daniel Jasper71607512013-01-07 10:48:50 +00001895}
1896
Manuel Klimekbd04f2a2013-01-31 15:58:48 +00001897TEST_F(FormatTest, LayoutUnknownPPDirective) {
Manuel Klimekbd04f2a2013-01-31 15:58:48 +00001898 EXPECT_EQ("#;", format("#;"));
Manuel Klimekdd5b1012013-01-07 10:03:37 +00001899 verifyFormat("#\n;\n;\n;");
Manuel Klimeka080a182013-01-02 16:30:12 +00001900}
1901
1902TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) {
1903 EXPECT_EQ("#line 42 \"test\"\n",
1904 format("# \\\n line \\\n 42 \\\n \"test\"\n"));
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001905 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n",
1906 getLLVMStyleWithColumns(12)));
Manuel Klimeka080a182013-01-02 16:30:12 +00001907}
1908
1909TEST_F(FormatTest, EndOfFileEndsPPDirective) {
1910 EXPECT_EQ("#line 42 \"test\"",
1911 format("# \\\n line \\\n 42 \\\n \"test\""));
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001912 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B"));
Manuel Klimeka080a182013-01-02 16:30:12 +00001913}
1914
Daniel Jasper1d82b1a2013-10-11 19:45:02 +00001915TEST_F(FormatTest, DoesntRemoveUnknownTokens) {
1916 verifyFormat("#define A \\x20");
1917 verifyFormat("#define A \\ x20");
1918 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20"));
1919 verifyFormat("#define A ''");
1920 verifyFormat("#define A ''qqq");
1921 verifyFormat("#define A `qqq");
1922 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");
1923}
1924
Manuel Klimek060143e2013-01-02 18:33:23 +00001925TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {
Daniel Jaspera4d46212013-02-28 11:05:57 +00001926 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
1927 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12));
Manuel Klimek060143e2013-01-02 18:33:23 +00001928 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12));
Daniel Jaspera4d46212013-02-28 11:05:57 +00001929 // FIXME: We never break before the macro name.
Daniel Jasperc9346c92013-08-28 09:07:32 +00001930 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12));
Daniel Jaspere0b15ea2013-01-14 15:40:57 +00001931
1932 verifyFormat("#define A A\n#define A A");
1933 verifyFormat("#define A(X) A\n#define A A");
1934
Daniel Jaspera4d46212013-02-28 11:05:57 +00001935 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
1936 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22));
Manuel Klimek060143e2013-01-02 18:33:23 +00001937}
1938
1939TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {
Alexander Kornienko9fdc00a2013-03-28 18:40:55 +00001940 EXPECT_EQ("// somecomment\n"
Manuel Klimekd4397b92013-01-04 23:34:14 +00001941 "#include \"a.h\"\n"
Daniel Jaspera4d46212013-02-28 11:05:57 +00001942 "#define A( \\\n"
1943 " A, B)\n"
Manuel Klimekd4397b92013-01-04 23:34:14 +00001944 "#include \"b.h\"\n"
Alexander Kornienko5262dd92013-03-27 11:52:18 +00001945 "// somecomment\n",
Alexander Kornienko9fdc00a2013-03-28 18:40:55 +00001946 format(" // somecomment\n"
Manuel Klimekd4397b92013-01-04 23:34:14 +00001947 " #include \"a.h\"\n"
1948 "#define A(A,\\\n"
1949 " B)\n"
1950 " #include \"b.h\"\n"
Alexander Kornienko5262dd92013-03-27 11:52:18 +00001951 " // somecomment\n",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001952 getLLVMStyleWithColumns(13)));
Manuel Klimek060143e2013-01-02 18:33:23 +00001953}
1954
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001955TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
Manuel Klimekd4397b92013-01-04 23:34:14 +00001956
1957TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
1958 EXPECT_EQ("#define A \\\n"
1959 " c; \\\n"
1960 " e;\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001961 "f;",
1962 format("#define A c; e;\n"
1963 "f;",
1964 getLLVMStyleWithColumns(14)));
Manuel Klimekd4397b92013-01-04 23:34:14 +00001965}
1966
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001967TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
Manuel Klimekd4397b92013-01-04 23:34:14 +00001968
Daniel Jasper89b3a7f2013-05-10 13:00:49 +00001969TEST_F(FormatTest, AlwaysFormatsEntireMacroDefinitions) {
1970 EXPECT_EQ("int i;\n"
1971 "#define A \\\n"
1972 " int i; \\\n"
1973 " int j\n"
1974 "int k;",
1975 format("int i;\n"
1976 "#define A \\\n"
1977 " int i ; \\\n"
1978 " int j\n"
1979 "int k;",
1980 8, 0, getGoogleStyle())); // 8: position of "#define".
1981 EXPECT_EQ("int i;\n"
1982 "#define A \\\n"
1983 " int i; \\\n"
1984 " int j\n"
1985 "int k;",
1986 format("int i;\n"
1987 "#define A \\\n"
1988 " int i ; \\\n"
1989 " int j\n"
1990 "int k;",
1991 45, 0, getGoogleStyle())); // 45: position of "j".
Manuel Klimekd4397b92013-01-04 23:34:14 +00001992}
1993
1994TEST_F(FormatTest, MacroDefinitionInsideStatement) {
Manuel Klimek526ed112013-01-09 15:25:02 +00001995 EXPECT_EQ("int x,\n"
1996 "#define A\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001997 " y;",
1998 format("int x,\n#define A\ny;"));
Manuel Klimekd4397b92013-01-04 23:34:14 +00001999}
2000
Manuel Klimek6f8424b2013-01-05 21:34:55 +00002001TEST_F(FormatTest, HashInMacroDefinition) {
Alexander Kornienkodaa07e92013-09-10 13:41:43 +00002002 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle()));
Manuel Klimek6f8424b2013-01-05 21:34:55 +00002003 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11));
Daniel Jasperc9346c92013-08-28 09:07:32 +00002004 verifyFormat("#define A \\\n"
2005 " { \\\n"
2006 " f(#c); \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002007 " }",
2008 getLLVMStyleWithColumns(11));
Daniel Jasper765561f2013-01-08 16:17:54 +00002009
2010 verifyFormat("#define A(X) \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002011 " void function##X()",
2012 getLLVMStyleWithColumns(22));
Daniel Jasper765561f2013-01-08 16:17:54 +00002013
2014 verifyFormat("#define A(a, b, c) \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002015 " void a##b##c()",
2016 getLLVMStyleWithColumns(22));
Daniel Jasper765561f2013-01-08 16:17:54 +00002017
Daniel Jaspere0b15ea2013-01-14 15:40:57 +00002018 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
Manuel Klimek6f8424b2013-01-05 21:34:55 +00002019}
2020
Manuel Klimek7ccbc212013-01-23 14:37:36 +00002021TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) {
2022 verifyFormat("#define A (1)");
2023}
2024
Manuel Klimeka28fc062013-02-11 12:33:24 +00002025TEST_F(FormatTest, EmptyLinesInMacroDefinitions) {
2026 EXPECT_EQ("#define A b;", format("#define A \\\n"
2027 " \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002028 " b;",
2029 getLLVMStyleWithColumns(25)));
Manuel Klimeka28fc062013-02-11 12:33:24 +00002030 EXPECT_EQ("#define A \\\n"
2031 " \\\n"
2032 " a; \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002033 " b;",
2034 format("#define A \\\n"
2035 " \\\n"
2036 " a; \\\n"
2037 " b;",
2038 getLLVMStyleWithColumns(11)));
Manuel Klimeka28fc062013-02-11 12:33:24 +00002039 EXPECT_EQ("#define A \\\n"
2040 " a; \\\n"
2041 " \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002042 " b;",
2043 format("#define A \\\n"
2044 " a; \\\n"
2045 " \\\n"
2046 " b;",
2047 getLLVMStyleWithColumns(11)));
Manuel Klimeka28fc062013-02-11 12:33:24 +00002048}
2049
Daniel Jasper34511fb2013-02-19 17:14:38 +00002050TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
Daniel Jaspercf6d76a2013-03-18 12:50:26 +00002051 verifyFormat("#define A :");
Daniel Jasper34511fb2013-02-19 17:14:38 +00002052 verifyFormat("#define SOMECASES \\\n"
Daniel Jasperbcca7e42013-03-20 10:23:53 +00002053 " case 1: \\\n"
Daniel Jasper34511fb2013-02-19 17:14:38 +00002054 " case 2\n",
2055 getLLVMStyleWithColumns(20));
Daniel Jasper34511fb2013-02-19 17:14:38 +00002056 verifyFormat("#define A template <typename T>");
Daniel Jasper03628b82013-02-19 20:05:41 +00002057 verifyFormat("#define STR(x) #x\n"
2058 "f(STR(this_is_a_string_literal{));");
Daniel Jasper7143a212013-08-28 09:17:37 +00002059 verifyFormat("#pragma omp threadprivate( \\\n"
2060 " y)), // expected-warning",
2061 getLLVMStyleWithColumns(28));
Daniel Jasper34511fb2013-02-19 17:14:38 +00002062}
2063
Daniel Jasper7e70f4c2013-05-29 13:16:10 +00002064TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) {
2065 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
2066 EXPECT_EQ("class A : public QObject {\n"
2067 " Q_OBJECT\n"
2068 "\n"
2069 " A() {}\n"
2070 "};",
2071 format("class A : public QObject {\n"
2072 " Q_OBJECT\n"
2073 "\n"
2074 " A() {\n}\n"
2075 "} ;"));
Daniel Jasperc76d59d2013-05-29 14:09:17 +00002076 EXPECT_EQ("SOME_MACRO\n"
2077 "namespace {\n"
2078 "void f();\n"
2079 "}",
2080 format("SOME_MACRO\n"
2081 " namespace {\n"
2082 "void f( );\n"
2083 "}"));
Daniel Jasper7e70f4c2013-05-29 13:16:10 +00002084 // Only if the identifier contains at least 5 characters.
2085 EXPECT_EQ("HTTP f();",
2086 format("HTTP\nf();"));
2087 EXPECT_EQ("MACRO\nf();",
2088 format("MACRO\nf();"));
2089 // Only if everything is upper case.
2090 EXPECT_EQ("class A : public QObject {\n"
2091 " Q_Object A() {}\n"
2092 "};",
2093 format("class A : public QObject {\n"
2094 " Q_Object\n"
2095 "\n"
2096 " A() {\n}\n"
2097 "} ;"));
2098}
2099
Alexander Kornienko3d713a72013-04-08 22:16:06 +00002100TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) {
2101 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
2102 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
2103 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00002104 "class X {};\n"
Alexander Kornienko3d713a72013-04-08 22:16:06 +00002105 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
2106 "int *createScopDetectionPass() { return 0; }",
2107 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
2108 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
2109 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
2110 " class X {};\n"
2111 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
2112 " int *createScopDetectionPass() { return 0; }"));
Alexander Kornienko99b0e142013-04-09 16:15:19 +00002113 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as
2114 // braces, so that inner block is indented one level more.
2115 EXPECT_EQ("int q() {\n"
2116 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
2117 " IPC_MESSAGE_HANDLER(xxx, qqq)\n"
2118 " IPC_END_MESSAGE_MAP()\n"
2119 "}",
2120 format("int q() {\n"
2121 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
2122 " IPC_MESSAGE_HANDLER(xxx, qqq)\n"
2123 " IPC_END_MESSAGE_MAP()\n"
2124 "}"));
Daniel Jasper42ff2632013-09-17 09:26:07 +00002125
2126 // These must not be recognized as macros.
Alexander Kornienko99b0e142013-04-09 16:15:19 +00002127 EXPECT_EQ("int q() {\n"
2128 " f(x);\n"
2129 " f(x) {}\n"
2130 " f(x)->g();\n"
2131 " f(x)->*g();\n"
2132 " f(x).g();\n"
2133 " f(x) = x;\n"
2134 " f(x) += x;\n"
2135 " f(x) -= x;\n"
2136 " f(x) *= x;\n"
2137 " f(x) /= x;\n"
2138 " f(x) %= x;\n"
2139 " f(x) &= x;\n"
2140 " f(x) |= x;\n"
2141 " f(x) ^= x;\n"
2142 " f(x) >>= x;\n"
2143 " f(x) <<= x;\n"
2144 " f(x)[y].z();\n"
2145 " LOG(INFO) << x;\n"
2146 " ifstream(x) >> x;\n"
2147 "}\n",
2148 format("int q() {\n"
2149 " f(x)\n;\n"
2150 " f(x)\n {}\n"
2151 " f(x)\n->g();\n"
2152 " f(x)\n->*g();\n"
2153 " f(x)\n.g();\n"
2154 " f(x)\n = x;\n"
2155 " f(x)\n += x;\n"
2156 " f(x)\n -= x;\n"
2157 " f(x)\n *= x;\n"
2158 " f(x)\n /= x;\n"
2159 " f(x)\n %= x;\n"
2160 " f(x)\n &= x;\n"
2161 " f(x)\n |= x;\n"
2162 " f(x)\n ^= x;\n"
2163 " f(x)\n >>= x;\n"
2164 " f(x)\n <<= x;\n"
2165 " f(x)\n[y].z();\n"
2166 " LOG(INFO)\n << x;\n"
2167 " ifstream(x)\n >> x;\n"
2168 "}\n"));
2169 EXPECT_EQ("int q() {\n"
2170 " f(x)\n"
2171 " if (1) {\n"
2172 " }\n"
2173 " f(x)\n"
2174 " while (1) {\n"
2175 " }\n"
2176 " f(x)\n"
2177 " g(x);\n"
2178 " f(x)\n"
2179 " try {\n"
2180 " q();\n"
2181 " }\n"
2182 " catch (...) {\n"
2183 " }\n"
2184 "}\n",
2185 format("int q() {\n"
2186 "f(x)\n"
2187 "if (1) {}\n"
2188 "f(x)\n"
2189 "while (1) {}\n"
2190 "f(x)\n"
2191 "g(x);\n"
2192 "f(x)\n"
2193 "try { q(); } catch (...) {}\n"
2194 "}\n"));
2195 EXPECT_EQ("class A {\n"
2196 " A() : t(0) {}\n"
2197 " A(X x)\n" // FIXME: function-level try blocks are broken.
2198 " try : t(0) {\n"
2199 " }\n"
2200 " catch (...) {\n"
2201 " }\n"
2202 "};",
2203 format("class A {\n"
2204 " A()\n : t(0) {}\n"
2205 " A(X x)\n"
2206 " try : t(0) {} catch (...) {}\n"
2207 "};"));
Alexander Kornienko3d713a72013-04-08 22:16:06 +00002208}
2209
Manuel Klimeke573c3f2013-05-22 12:51:29 +00002210TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) {
2211 verifyFormat("#define A \\\n"
2212 " f({ \\\n"
2213 " g(); \\\n"
2214 " });", getLLVMStyleWithColumns(11));
2215}
2216
Manuel Klimekc37b4d62013-01-05 22:14:16 +00002217TEST_F(FormatTest, IndentPreprocessorDirectivesAtZero) {
2218 EXPECT_EQ("{\n {\n#define A\n }\n}", format("{{\n#define A\n}}"));
2219}
2220
Manuel Klimekf6fd00b2013-01-05 22:56:06 +00002221TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) {
Manuel Klimek517e8942013-01-11 17:54:10 +00002222 verifyFormat("{\n { a #c; }\n}");
Manuel Klimekf6fd00b2013-01-05 22:56:06 +00002223}
2224
Manuel Klimeka5342db2013-01-06 20:07:31 +00002225TEST_F(FormatTest, FormatUnbalancedStructuralElements) {
2226 EXPECT_EQ("#define A \\\n { \\\n {\nint i;",
2227 format("#define A { {\nint i;", getLLVMStyleWithColumns(11)));
2228 EXPECT_EQ("#define A \\\n } \\\n }\nint i;",
2229 format("#define A } }\nint i;", getLLVMStyleWithColumns(11)));
2230}
Manuel Klimekd4397b92013-01-04 23:34:14 +00002231
Alexander Kornienko54e6c9d2013-06-07 17:45:07 +00002232TEST_F(FormatTest, EscapedNewlineAtStartOfToken) {
Daniel Jaspercd162382013-01-07 13:26:07 +00002233 EXPECT_EQ(
2234 "#define A \\\n int i; \\\n int j;",
2235 format("#define A \\\nint i;\\\n int j;", getLLVMStyleWithColumns(11)));
Alexander Kornienko54e6c9d2013-06-07 17:45:07 +00002236 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
Manuel Klimek95419382013-01-07 07:56:50 +00002237}
2238
Alexander Kornienko16a0ec62013-06-14 11:46:10 +00002239TEST_F(FormatTest, NoEscapedNewlineHandlingInBlockComments) {
2240 EXPECT_EQ("/* \\ \\ \\\n*/", format("\\\n/* \\ \\ \\\n*/"));
2241}
2242
Manuel Klimekd544c572013-01-07 09:24:17 +00002243TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) {
2244 verifyFormat("#define A \\\n"
2245 " int v( \\\n"
2246 " a); \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002247 " int i;",
2248 getLLVMStyleWithColumns(11));
Manuel Klimekd544c572013-01-07 09:24:17 +00002249}
2250
Manuel Klimeka080a182013-01-02 16:30:12 +00002251TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) {
Manuel Klimekd4397b92013-01-04 23:34:14 +00002252 EXPECT_EQ(
2253 "#define ALooooooooooooooooooooooooooooooooooooooongMacro("
2254 " \\\n"
2255 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
2256 "\n"
2257 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
2258 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n",
2259 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro("
2260 "\\\n"
2261 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
2262 " \n"
2263 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
2264 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n"));
Manuel Klimeka080a182013-01-02 16:30:12 +00002265}
2266
Manuel Klimek526ed112013-01-09 15:25:02 +00002267TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {
2268 EXPECT_EQ("int\n"
2269 "#define A\n"
Daniel Jasper53e72cd2013-05-06 08:27:33 +00002270 " a;",
Manuel Klimeka9a7f102013-06-21 17:25:42 +00002271 format("int\n#define A\na;", getGoogleStyle()));
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002272 verifyFormat("functionCallTo(\n"
2273 " someOtherFunction(\n"
2274 " withSomeParameters, whichInSequence,\n"
2275 " areLongerThanALine(andAnotherCall,\n"
2276 "#define A B\n"
2277 " withMoreParamters,\n"
2278 " whichStronglyInfluenceTheLayout),\n"
Daniel Jasper7d812812013-02-21 15:00:29 +00002279 " andMoreParameters),\n"
2280 " trailing);",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002281 getLLVMStyleWithColumns(69));
Daniel Jasperebaa1712013-09-17 09:52:48 +00002282 verifyFormat("Foo::Foo()\n"
2283 "#ifdef BAR\n"
2284 " : baz(0)\n"
2285 "#endif\n"
2286 "{\n"
2287 "}");
Manuel Klimekae76f7f2013-10-11 21:25:45 +00002288 verifyFormat("void f() {\n"
2289 " if (true)\n"
2290 "#ifdef A\n"
2291 " f(42);\n"
2292 " x();\n"
2293 "#else\n"
2294 " g();\n"
2295 " x();\n"
2296 "#endif\n"
2297 "}");
2298 verifyFormat("void f(param1, param2,\n"
2299 " param3,\n"
2300 "#ifdef A\n"
2301 " param4(param5,\n"
2302 "#ifdef A1\n"
2303 " param6,\n"
2304 "#ifdef A2\n"
2305 " param7),\n"
2306 "#else\n"
2307 " param8),\n"
2308 " param9,\n"
2309 "#endif\n"
2310 " param10,\n"
2311 "#endif\n"
2312 " param11)\n"
2313 "#else\n"
2314 " param12)\n"
2315 "#endif\n"
2316 "{\n"
2317 " x();\n"
2318 "}",
2319 getLLVMStyleWithColumns(28));
Manuel Klimek526ed112013-01-09 15:25:02 +00002320}
2321
Manuel Klimekbb42bf12013-01-10 11:52:21 +00002322TEST_F(FormatTest, LayoutBlockInsideParens) {
Daniel Jasper567dcf92013-09-05 09:29:45 +00002323 EXPECT_EQ("functionCall({ int i; });", format(" functionCall ( {int i;} );"));
Manuel Klimekbb42bf12013-01-10 11:52:21 +00002324 EXPECT_EQ("functionCall({\n"
2325 " int i;\n"
Daniel Jasper567dcf92013-09-05 09:29:45 +00002326 " int j;\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002327 "});",
Daniel Jasper567dcf92013-09-05 09:29:45 +00002328 format(" functionCall ( {int i;int j;} );"));
Daniel Jasperf7ec1cc2013-05-31 14:56:29 +00002329 EXPECT_EQ("functionCall({\n"
Daniel Jasper567dcf92013-09-05 09:29:45 +00002330 " int i;\n"
2331 " int j;\n"
2332 " },\n"
Daniel Jasperf7ec1cc2013-05-31 14:56:29 +00002333 " aaaa, bbbb, cccc);",
Daniel Jasper567dcf92013-09-05 09:29:45 +00002334 format(" functionCall ( {int i;int j;}, aaaa, bbbb, cccc);"));
2335 EXPECT_EQ("functionCall(aaaa, bbbb, { int i; });",
2336 format(" functionCall (aaaa, bbbb, {int i;});"));
2337 EXPECT_EQ("functionCall(aaaa, bbbb, {\n"
2338 " int i;\n"
2339 " int j;\n"
2340 "});",
2341 format(" functionCall (aaaa, bbbb, {int i;int j;});"));
2342 EXPECT_EQ("functionCall(aaaa, bbbb, { int i; });",
2343 format(" functionCall (aaaa, bbbb, {int i;});"));
Daniel Jasperf7ec1cc2013-05-31 14:56:29 +00002344 verifyFormat(
2345 "Aaa({\n"
Daniel Jasper567dcf92013-09-05 09:29:45 +00002346 " int i; // break\n"
2347 " },\n"
Daniel Jasperf7ec1cc2013-05-31 14:56:29 +00002348 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
2349 " ccccccccccccccccc));");
Daniel Jasper567dcf92013-09-05 09:29:45 +00002350 verifyFormat("DEBUG({\n"
2351 " if (a)\n"
2352 " f();\n"
2353 "});");
Manuel Klimekbb42bf12013-01-10 11:52:21 +00002354}
2355
2356TEST_F(FormatTest, LayoutBlockInsideStatement) {
Manuel Klimek517e8942013-01-11 17:54:10 +00002357 EXPECT_EQ("SOME_MACRO { int i; }\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002358 "int i;",
2359 format(" SOME_MACRO {int i;} int i;"));
Manuel Klimekbb42bf12013-01-10 11:52:21 +00002360}
2361
2362TEST_F(FormatTest, LayoutNestedBlocks) {
2363 verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
2364 " struct s {\n"
2365 " int i;\n"
2366 " };\n"
2367 " s kBitsToOs[] = { { 10 } };\n"
2368 " for (int i = 0; i < 10; ++i)\n"
2369 " return;\n"
2370 "}");
Daniel Jasperb77d7412013-09-06 07:54:20 +00002371 verifyFormat("call(parameter, {\n"
2372 " something();\n"
2373 " // Comment using all columns.\n"
2374 " somethingelse();\n"
2375 "});",
2376 getLLVMStyleWithColumns(40));
2377 EXPECT_EQ("call(parameter, {\n"
2378 " something();\n"
2379 " // Comment too\n"
2380 " // looooooooooong.\n"
2381 " somethingElse();\n"
2382 "});",
2383 format("call(parameter, {\n"
2384 " something();\n"
2385 " // Comment too looooooooooong.\n"
2386 " somethingElse();\n"
2387 "});",
2388 getLLVMStyleWithColumns(29)));
Daniel Jasper14e25c02013-09-08 14:07:57 +00002389 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });"));
2390 EXPECT_EQ("DEBUG({\n"
2391 " int i;\n"
2392 "\n"
2393 " // comment\n"
2394 " int j;\n"
2395 "});",
2396 format("DEBUG({\n"
2397 " int i;\n"
2398 "\n"
2399 " // comment\n"
2400 " int j;\n"
2401 "});"));
Manuel Klimekbb42bf12013-01-10 11:52:21 +00002402}
2403
Manuel Klimek36fab8d2013-01-10 13:24:24 +00002404TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) {
2405 EXPECT_EQ("{}", format("{}"));
Daniel Jasper8893b8a2013-05-31 14:56:20 +00002406 verifyFormat("enum E {};");
Manuel Klimek2f1ac412013-01-21 16:42:44 +00002407 verifyFormat("enum E {}");
Manuel Klimek36fab8d2013-01-10 13:24:24 +00002408}
2409
Alexander Kornienko15757312012-12-06 18:03:27 +00002410//===----------------------------------------------------------------------===//
2411// Line break tests.
2412//===----------------------------------------------------------------------===//
2413
Daniel Jasper13d2aa52013-08-30 08:29:25 +00002414TEST_F(FormatTest, PreventConfusingIndents) {
Alexander Kornienko15757312012-12-06 18:03:27 +00002415 verifyFormat(
Daniel Jasper986e17f2013-01-28 07:35:34 +00002416 "SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n"
2417 " parameter, parameter, parameter)),\n"
Daniel Jaspera4974cf2012-12-24 16:43:00 +00002418 " SecondLongCall(parameter));");
Daniel Jasper986e17f2013-01-28 07:35:34 +00002419 verifyFormat(
2420 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2421 " aaaaaaaaaaaaaaaaaaaaaaaa(\n"
2422 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
2423 " aaaaaaaaaaaaaaaaaaaaaaaa);");
2424 verifyFormat(
Daniel Jasper011c35d2013-07-12 11:19:37 +00002425 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2426 " [aaaaaaaaaaaaaaaaaaaaaaaa\n"
2427 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
2428 " [aaaaaaaaaaaaaaaaaaaaaaaa]];");
Daniel Jasper986e17f2013-01-28 07:35:34 +00002429 verifyFormat(
2430 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
2431 " aaaaaaaaaaaaaaaaaaaaaaaa<\n"
2432 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n"
2433 " aaaaaaaaaaaaaaaaaaaaaaaa>;");
Daniel Jasperae8699b2013-01-28 09:35:24 +00002434 verifyFormat("int a = bbbb && ccc && fffff(\n"
2435 "#define A Just forcing a new line\n"
2436 " ddd);");
Daniel Jasper986e17f2013-01-28 07:35:34 +00002437}
2438
Daniel Jasper11e13802013-05-08 14:12:04 +00002439TEST_F(FormatTest, LineBreakingInBinaryExpressions) {
2440 verifyFormat(
2441 "bool aaaaaaa =\n"
2442 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n"
2443 " bbbbbbbb();");
2444 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
2445 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n"
2446 " ccccccccc == ddddddddddd;");
2447
2448 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
2449 " aaaaaa) &&\n"
2450 " bbbbbb && cccccc;");
Daniel Jasper69c43712013-05-28 07:42:44 +00002451 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
2452 " aaaaaa) >>\n"
2453 " bbbbbb;");
Daniel Jasper11e13802013-05-08 14:12:04 +00002454 verifyFormat("Whitespaces.addUntouchableComment(\n"
2455 " SourceMgr.getSpellingColumnNumber(\n"
2456 " TheLine.Last->FormatTok.Tok.getLocation()) -\n"
2457 " 1);");
Daniel Jasperd741f022013-05-14 20:39:56 +00002458
Daniel Jasper5ef8aac2013-06-03 08:42:05 +00002459 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
2460 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n"
2461 " cccccc) {\n}");
2462
Daniel Jasper6df7a2d2013-07-03 10:34:47 +00002463 // If the LHS of a comparison is not a binary expression itself, the
2464 // additional linebreak confuses many people.
2465 verifyFormat(
2466 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2467 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n"
2468 "}");
2469 verifyFormat(
2470 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2471 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
2472 "}");
Daniel Jasperdb4813a2013-09-06 08:08:14 +00002473 verifyFormat(
2474 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n"
2475 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
2476 "}");
Daniel Jasper6df7a2d2013-07-03 10:34:47 +00002477 // Even explicit parentheses stress the precedence enough to make the
2478 // additional break unnecessary.
2479 verifyFormat(
2480 "if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2481 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
2482 "}");
2483 // This cases is borderline, but with the indentation it is still readable.
2484 verifyFormat(
2485 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2486 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2487 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
2488 "}",
2489 getLLVMStyleWithColumns(75));
2490
2491 // If the LHS is a binary expression, we should still use the additional break
2492 // as otherwise the formatting hides the operator precedence.
2493 verifyFormat(
2494 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2495 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2496 " 5) {\n"
2497 "}");
2498
Daniel Jasperd741f022013-05-14 20:39:56 +00002499 FormatStyle OnePerLine = getLLVMStyle();
2500 OnePerLine.BinPackParameters = false;
2501 verifyFormat(
2502 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
2503 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
2504 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}",
2505 OnePerLine);
Daniel Jasper11e13802013-05-08 14:12:04 +00002506}
2507
Daniel Jasperbf71ba22013-04-08 20:33:42 +00002508TEST_F(FormatTest, ExpressionIndentation) {
2509 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2510 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2511 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2512 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2513 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
2514 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n"
2515 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2516 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n"
2517 " ccccccccccccccccccccccccccccccccccccccccc;");
2518 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2519 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2520 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2521 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
2522 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2523 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2524 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2525 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
2526 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2527 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2528 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2529 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
Daniel Jasper9acb8b42013-06-06 09:11:58 +00002530 verifyFormat("if () {\n"
2531 "} else if (aaaaa && bbbbb > // break\n"
2532 " ccccc) {\n"
2533 "}");
Alexander Kornienkod71b15b2013-06-17 13:19:53 +00002534
2535 // Presence of a trailing comment used to change indentation of b.
2536 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
2537 " b;\n"
2538 "return aaaaaaaaaaaaaaaaaaa +\n"
2539 " b; //",
2540 getLLVMStyleWithColumns(30));
Daniel Jasperbf71ba22013-04-08 20:33:42 +00002541}
2542
Daniel Jaspere8b10d32013-07-26 16:56:36 +00002543TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) {
2544 // Not sure what the best system is here. Like this, the LHS can be found
2545 // immediately above an operator (everything with the same or a higher
2546 // indent). The RHS is aligned right of the operator and so compasses
2547 // everything until something with the same indent as the operator is found.
2548 // FIXME: Is this a good system?
2549 FormatStyle Style = getLLVMStyle();
2550 Style.BreakBeforeBinaryOperators = true;
2551 verifyFormat(
2552 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2553 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2554 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2555 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2556 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
2557 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
2558 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2559 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2560 " > ccccccccccccccccccccccccccccccccccccccccc;",
2561 Style);
2562 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2563 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2564 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2565 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
2566 Style);
2567 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2568 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2569 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2570 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
2571 Style);
2572 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2573 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2574 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2575 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
2576 Style);
2577 verifyFormat("if () {\n"
2578 "} else if (aaaaa && bbbbb // break\n"
2579 " > ccccc) {\n"
2580 "}",
2581 Style);
2582}
2583
Daniel Jasper1321eb52012-12-18 21:05:13 +00002584TEST_F(FormatTest, ConstructorInitializers) {
Manuel Klimek36fab8d2013-01-10 13:24:24 +00002585 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
Daniel Jasper7e9bf8c2013-01-11 11:37:55 +00002586 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
2587 getLLVMStyleWithColumns(45));
Daniel Jasperf11a7052013-02-21 21:33:55 +00002588 verifyFormat("Constructor()\n"
2589 " : Inttializer(FitsOnTheLine) {}",
Daniel Jasper7e9bf8c2013-01-11 11:37:55 +00002590 getLLVMStyleWithColumns(44));
Manuel Klimek2f1ac412013-01-21 16:42:44 +00002591 verifyFormat("Constructor()\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002592 " : Inttializer(FitsOnTheLine) {}",
Manuel Klimek2f1ac412013-01-21 16:42:44 +00002593 getLLVMStyleWithColumns(43));
Daniel Jasper1321eb52012-12-18 21:05:13 +00002594
2595 verifyFormat(
2596 "SomeClass::Constructor()\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002597 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
Daniel Jasper1321eb52012-12-18 21:05:13 +00002598
2599 verifyFormat(
2600 "SomeClass::Constructor()\n"
Daniel Jasper7e9bf8c2013-01-11 11:37:55 +00002601 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002602 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}");
Daniel Jasper7e9bf8c2013-01-11 11:37:55 +00002603 verifyFormat(
2604 "SomeClass::Constructor()\n"
Daniel Jasper1321eb52012-12-18 21:05:13 +00002605 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002606 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
Daniel Jasper1321eb52012-12-18 21:05:13 +00002607
2608 verifyFormat("Constructor()\n"
2609 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
2610 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2611 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002612 " aaaaaaaaaaaaaaaaaaaaaaa() {}");
Daniel Jasper1321eb52012-12-18 21:05:13 +00002613
Daniel Jasper02b771e2013-01-28 13:31:35 +00002614 verifyFormat("Constructor()\n"
2615 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002616 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasper02b771e2013-01-28 13:31:35 +00002617
Daniel Jasper9c3e71a2013-02-25 15:59:54 +00002618 verifyFormat("Constructor(int Parameter = 0)\n"
2619 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
2620 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}");
Daniel Jasper00e0f432013-09-06 21:46:41 +00002621 verifyFormat("Constructor()\n"
2622 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
2623 "}",
2624 getLLVMStyleWithColumns(60));
Daniel Jasper9c3e71a2013-02-25 15:59:54 +00002625
Daniel Jasper1321eb52012-12-18 21:05:13 +00002626 // Here a line could be saved by splitting the second initializer onto two
2627 // lines, but that is not desireable.
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002628 verifyFormat("Constructor()\n"
2629 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
2630 " aaaaaaaaaaa(aaaaaaaaaaa),\n"
2631 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasper1321eb52012-12-18 21:05:13 +00002632
Daniel Jasperb130a542013-02-15 16:49:44 +00002633 FormatStyle OnePerLine = getLLVMStyle();
2634 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
2635 verifyFormat("SomeClass::Constructor()\n"
2636 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
2637 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002638 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002639 OnePerLine);
Daniel Jasperb130a542013-02-15 16:49:44 +00002640 verifyFormat("SomeClass::Constructor()\n"
2641 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
2642 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002643 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002644 OnePerLine);
Daniel Jasperb130a542013-02-15 16:49:44 +00002645 verifyFormat("MyClass::MyClass(int var)\n"
2646 " : some_var_(var), // 4 space indent\n"
2647 " some_other_var_(var + 1) { // lined up\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002648 "}",
2649 OnePerLine);
Daniel Jasper3a39ac72013-02-28 09:39:12 +00002650 verifyFormat("Constructor()\n"
2651 " : aaaaa(aaaaaa),\n"
2652 " aaaaa(aaaaaa),\n"
2653 " aaaaa(aaaaaa),\n"
2654 " aaaaa(aaaaaa),\n"
2655 " aaaaa(aaaaaa) {}",
2656 OnePerLine);
Daniel Jasper001bf4e2013-04-22 07:59:53 +00002657 verifyFormat("Constructor()\n"
2658 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
2659 " aaaaaaaaaaaaaaaaaaaaaa) {}",
2660 OnePerLine);
Daniel Jasperfca24bc2013-04-25 13:31:51 +00002661}
2662
2663TEST_F(FormatTest, MemoizationTests) {
2664 // This breaks if the memoization lookup does not take \c Indent and
2665 // \c LastSpace into account.
2666 verifyFormat(
2667 "extern CFRunLoopTimerRef\n"
2668 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
2669 " CFTimeInterval interval, CFOptionFlags flags,\n"
2670 " CFIndex order, CFRunLoopTimerCallBack callout,\n"
Daniel Jasper53e72cd2013-05-06 08:27:33 +00002671 " CFRunLoopTimerContext *context) {}");
Daniel Jasperfca24bc2013-04-25 13:31:51 +00002672
2673 // Deep nesting somewhat works around our memoization.
2674 verifyFormat(
2675 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
2676 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
2677 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
2678 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
2679 " aaaaa())))))))))))))))))))))))))))))))))))))));",
2680 getLLVMStyleWithColumns(65));
Daniel Jasperc3df5ff2013-05-13 09:19:24 +00002681 verifyFormat(
2682 "aaaaa(\n"
2683 " aaaaa,\n"
2684 " aaaaa(\n"
2685 " aaaaa,\n"
2686 " aaaaa(\n"
2687 " aaaaa,\n"
2688 " aaaaa(\n"
2689 " aaaaa,\n"
2690 " aaaaa(\n"
2691 " aaaaa,\n"
2692 " aaaaa(\n"
2693 " aaaaa,\n"
2694 " aaaaa(\n"
2695 " aaaaa,\n"
2696 " aaaaa(\n"
2697 " aaaaa,\n"
2698 " aaaaa(\n"
2699 " aaaaa,\n"
2700 " aaaaa(\n"
2701 " aaaaa,\n"
2702 " aaaaa(\n"
2703 " aaaaa,\n"
2704 " aaaaa(\n"
2705 " aaaaa,\n"
2706 " aaaaa))))))))))));",
2707 getLLVMStyleWithColumns(65));
Daniel Jasper54b4e442013-05-22 05:27:42 +00002708 verifyFormat(
2709 "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"
2710 " a),\n"
2711 " a),\n"
2712 " a),\n"
2713 " a),\n"
2714 " a),\n"
2715 " a),\n"
2716 " a),\n"
2717 " a),\n"
2718 " a),\n"
2719 " a),\n"
2720 " a),\n"
2721 " a),\n"
2722 " a),\n"
2723 " a),\n"
2724 " a),\n"
2725 " a),\n"
2726 " a)",
2727 getLLVMStyleWithColumns(65));
Daniel Jasperb3123142013-01-12 07:36:22 +00002728
2729 // This test takes VERY long when memoization is broken.
Daniel Jasperfca24bc2013-04-25 13:31:51 +00002730 FormatStyle OnePerLine = getLLVMStyle();
2731 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002732 OnePerLine.BinPackParameters = false;
Daniel Jasper0df6acd2013-01-16 14:59:02 +00002733 std::string input = "Constructor()\n"
Daniel Jasper3499dda2013-01-25 15:43:32 +00002734 " : aaaa(a,\n";
Daniel Jasper0df6acd2013-01-16 14:59:02 +00002735 for (unsigned i = 0, e = 80; i != e; ++i) {
2736 input += " a,\n";
2737 }
Daniel Jasperf11a7052013-02-21 21:33:55 +00002738 input += " a) {}";
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002739 verifyFormat(input, OnePerLine);
Daniel Jasper1321eb52012-12-18 21:05:13 +00002740}
2741
Alexander Kornienko15757312012-12-06 18:03:27 +00002742TEST_F(FormatTest, BreaksAsHighAsPossible) {
2743 verifyFormat(
Alexander Kornienko3fd9ccd2013-03-12 16:28:18 +00002744 "void f() {\n"
2745 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
2746 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
2747 " f();\n"
2748 "}");
Daniel Jasper518ee342013-02-26 13:59:14 +00002749 verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
Daniel Jasperbf71ba22013-04-08 20:33:42 +00002750 " Intervals[i - 1].getRange().getLast()) {\n}");
Alexander Kornienko15757312012-12-06 18:03:27 +00002751}
2752
Daniel Jasper1407bee2013-04-11 14:29:13 +00002753TEST_F(FormatTest, BreaksFunctionDeclarations) {
2754 // Principially, we break function declarations in a certain order:
2755 // 1) break amongst arguments.
2756 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
2757 " Cccccccccccccc cccccccccccccc);");
Daniel Jasper92495a82013-08-19 10:16:18 +00002758 verifyFormat(
2759 "template <class TemplateIt>\n"
2760 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n"
2761 " TemplateIt *stop) {}");
Daniel Jasper1407bee2013-04-11 14:29:13 +00002762
2763 // 2) break after return type.
Daniel Jasper53e72cd2013-05-06 08:27:33 +00002764 verifyFormat(
Manuel Klimeka9a7f102013-06-21 17:25:42 +00002765 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2766 " bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);",
2767 getGoogleStyle());
Daniel Jasper1407bee2013-04-11 14:29:13 +00002768
2769 // 3) break after (.
2770 verifyFormat(
2771 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00002772 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);",
2773 getGoogleStyle());
Daniel Jasper1407bee2013-04-11 14:29:13 +00002774
2775 // 4) break before after nested name specifiers.
2776 verifyFormat(
2777 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper53e72cd2013-05-06 08:27:33 +00002778 " SomeClasssssssssssssssssssssssssssssssssssssss::\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00002779 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);",
2780 getGoogleStyle());
Daniel Jasper1407bee2013-04-11 14:29:13 +00002781
2782 // However, there are exceptions, if a sufficient amount of lines can be
2783 // saved.
2784 // FIXME: The precise cut-offs wrt. the number of saved lines might need some
2785 // more adjusting.
2786 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
2787 " Cccccccccccccc cccccccccc,\n"
2788 " Cccccccccccccc cccccccccc,\n"
2789 " Cccccccccccccc cccccccccc,\n"
2790 " Cccccccccccccc cccccccccc);");
2791 verifyFormat(
Manuel Klimeka9a7f102013-06-21 17:25:42 +00002792 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper53e72cd2013-05-06 08:27:33 +00002793 " bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
2794 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00002795 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);",
2796 getGoogleStyle());
Daniel Jasper1407bee2013-04-11 14:29:13 +00002797 verifyFormat(
2798 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
2799 " Cccccccccccccc cccccccccc,\n"
2800 " Cccccccccccccc cccccccccc,\n"
2801 " Cccccccccccccc cccccccccc,\n"
2802 " Cccccccccccccc cccccccccc,\n"
2803 " Cccccccccccccc cccccccccc,\n"
2804 " Cccccccccccccc cccccccccc);");
2805 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
2806 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
2807 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
2808 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
2809 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
Daniel Jasper01218ff2013-04-15 22:36:37 +00002810
2811 // Break after multi-line parameters.
2812 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2813 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2814 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2815 " bbbb bbbb);");
Daniel Jasper6561f6a2013-07-09 07:43:55 +00002816
2817 // Treat overloaded operators like other functions.
2818 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
2819 "operator>(const SomeLoooooooooooooooooooooooooogType &other);");
Daniel Jasperc476ea92013-08-28 07:27:35 +00002820 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
2821 "operator>>(const SomeLooooooooooooooooooooooooogType &other);");
Daniel Jasper6561f6a2013-07-09 07:43:55 +00002822 verifyGoogleFormat(
2823 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n"
2824 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
Daniel Jasper1407bee2013-04-11 14:29:13 +00002825}
2826
Daniel Jasper2ca37412013-07-09 14:36:48 +00002827TEST_F(FormatTest, TrailingReturnType) {
2828 verifyFormat("auto foo() -> int;\n");
2829 verifyFormat("struct S {\n"
2830 " auto bar() const -> int;\n"
2831 "};");
2832 verifyFormat("template <size_t Order, typename T>\n"
2833 "auto load_img(const std::string &filename)\n"
2834 " -> alias::tensor<Order, T, mem::tag::cpu> {}");
Daniel Jasper3262f4c2013-07-11 14:33:06 +00002835
2836 // Not trailing return types.
2837 verifyFormat("void f() { auto a = b->c(); }");
Daniel Jasper2ca37412013-07-09 14:36:48 +00002838}
2839
Daniel Jaspere033e872013-05-21 09:16:31 +00002840TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) {
Daniel Jasper20a0f8c2013-07-11 21:02:56 +00002841 // Avoid breaking before trailing 'const'.
Daniel Jasper5ad72bb2013-05-22 08:28:26 +00002842 verifyFormat("void someLongFunction(\n"
2843 " int someLongParameter) const {}",
2844 getLLVMStyleWithColumns(46));
2845 FormatStyle Style = getGoogleStyle();
2846 Style.ColumnLimit = 47;
2847 verifyFormat("void\n"
2848 "someLongFunction(int someLongParameter) const {\n}",
2849 getLLVMStyleWithColumns(47));
2850 verifyFormat("void someLongFunction(\n"
2851 " int someLongParameter) const {}",
2852 Style);
2853 verifyFormat("LoooooongReturnType\n"
2854 "someLoooooooongFunction() const {}",
2855 getLLVMStyleWithColumns(47));
2856 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
2857 " const {}",
2858 Style);
Daniel Jaspere033e872013-05-21 09:16:31 +00002859
Daniel Jasper20a0f8c2013-07-11 21:02:56 +00002860 // Avoid breaking before other trailing annotations, if they are not
2861 // function-like.
2862 verifyFormat("void SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2863 " aaaaaaaaaaaaaaaaaaaaaaaaaa) OVERRIDE;");
Daniel Jasper6b3ff8c2013-09-27 08:29:16 +00002864 verifyFormat("void SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2865 " aaaaaaaaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;");
2866 verifyFormat("void SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2867 " aaaaaaaaaaaaaaaaaaaaaaaaaa) override final;");
Daniel Jasper20a0f8c2013-07-11 21:02:56 +00002868
2869 // Breaking before function-like trailing annotations is fine to keep them
2870 // close to their arguments.
Daniel Jaspere033e872013-05-21 09:16:31 +00002871 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
2872 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
2873 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
2874 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
2875 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
2876 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}");
2877
2878 verifyFormat(
2879 "void aaaaaaaaaaaaaaaaaa()\n"
2880 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
2881 " aaaaaaaaaaaaaaaaaaaaaaaaa));");
2882 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2883 " __attribute__((unused));");
2884 verifyFormat(
Manuel Klimeka9a7f102013-06-21 17:25:42 +00002885 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2886 " GUARDED_BY(aaaaaaaaaaaa);",
2887 getGoogleStyle());
Daniel Jasperc18cff32013-07-11 12:34:23 +00002888 verifyFormat(
2889 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2890 " GUARDED_BY(aaaaaaaaaaaa);",
2891 getGoogleStyle());
Daniel Jaspere033e872013-05-21 09:16:31 +00002892}
2893
Daniel Jasperbac016b2012-12-03 18:12:45 +00002894TEST_F(FormatTest, BreaksDesireably) {
2895 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
2896 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00002897 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
Daniel Jaspere438bac2013-01-23 20:41:06 +00002898 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2899 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
2900 "}");
Daniel Jasperbac016b2012-12-03 18:12:45 +00002901
2902 verifyFormat(
2903 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002904 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasperbac016b2012-12-03 18:12:45 +00002905
2906 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2907 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2908 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jaspera88bb452012-12-04 10:50:12 +00002909
2910 verifyFormat(
2911 "aaaaaaaa(aaaaaaaaaaaaa, aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2912 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
2913 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2914 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));");
Daniel Jasper33182dd2012-12-05 14:57:28 +00002915
2916 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
2917 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
2918
Daniel Jasper723f0302013-01-02 14:40:02 +00002919 verifyFormat(
Alexander Kornienko3fd9ccd2013-03-12 16:28:18 +00002920 "void f() {\n"
2921 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
2922 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
2923 "}");
Daniel Jasper3499dda2013-01-25 15:43:32 +00002924 verifyFormat(
2925 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2926 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
2927 verifyFormat(
2928 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2929 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jasper64f09282013-03-20 13:53:11 +00002930 verifyFormat(
2931 "aaaaaaaaaaaaaaaaa(\n"
2932 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2933 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper723f0302013-01-02 14:40:02 +00002934
Daniel Jasper13d2aa52013-08-30 08:29:25 +00002935 // Indent consistently indenpendent of call expression.
2936 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
2937 " dddddddddddddddddddddddddddddd));\n"
2938 "aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
2939 " dddddddddddddddddddddddddddddd));");
2940
Daniel Jasper33182dd2012-12-05 14:57:28 +00002941 // This test case breaks on an incorrect memoization, i.e. an optimization not
2942 // taking into account the StopAt value.
2943 verifyFormat(
2944 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
Daniel Jaspercf225b62012-12-24 13:43:52 +00002945 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
2946 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
2947 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jaspera4974cf2012-12-24 16:43:00 +00002948
Daniel Jaspercd162382013-01-07 13:26:07 +00002949 verifyFormat("{\n {\n {\n"
2950 " Annotation.SpaceRequiredBefore =\n"
2951 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
2952 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
2953 " }\n }\n}");
Alexander Kornienko22d0e292013-06-17 12:59:44 +00002954
2955 // Break on an outer level if there was a break on an inner level.
2956 EXPECT_EQ("f(g(h(a, // comment\n"
2957 " b, c),\n"
2958 " d, e),\n"
2959 " x, y);",
2960 format("f(g(h(a, // comment\n"
2961 " b, c), d, e), x, y);"));
Daniel Jasper88cc5622013-07-08 14:25:23 +00002962
2963 // Prefer breaking similar line breaks.
2964 verifyFormat(
2965 "const int kTrackingOptions = NSTrackingMouseMoved |\n"
2966 " NSTrackingMouseEnteredAndExited |\n"
2967 " NSTrackingActiveAlways;");
Daniel Jasperbac016b2012-12-03 18:12:45 +00002968}
2969
Daniel Jasper0df6acd2013-01-16 14:59:02 +00002970TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +00002971 FormatStyle NoBinPacking = getGoogleStyle();
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002972 NoBinPacking.BinPackParameters = false;
2973 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
2974 " aaaaaaaaaaaaaaaaaaaa,\n"
2975 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);",
2976 NoBinPacking);
2977 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
2978 " aaaaaaaaaaaaa,\n"
2979 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));",
2980 NoBinPacking);
2981 verifyFormat(
Daniel Jasper0df6acd2013-01-16 14:59:02 +00002982 "aaaaaaaa(aaaaaaaaaaaaa,\n"
2983 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2984 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
2985 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002986 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));",
2987 NoBinPacking);
2988 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
2989 " .aaaaaaaaaaaaaaaaaa();",
2990 NoBinPacking);
2991 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2992 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);",
2993 NoBinPacking);
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002994
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002995 verifyFormat(
Daniel Jasper8f4bd7a2013-01-23 10:08:28 +00002996 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2997 " aaaaaaaaaaaa,\n"
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002998 " aaaaaaaaaaaa);",
2999 NoBinPacking);
3000 verifyFormat(
Daniel Jasper0df6acd2013-01-16 14:59:02 +00003001 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
3002 " ddddddddddddddddddddddddddddd),\n"
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003003 " test);",
3004 NoBinPacking);
Daniel Jasper0df6acd2013-01-16 14:59:02 +00003005
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003006 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
3007 " aaaaaaaaaaaaaaaaaaaaaaa,\n"
3008 " aaaaaaaaaaaaaaaaaaaaaaa> aaaaaaaaaaaaaaaaaa;",
3009 NoBinPacking);
3010 verifyFormat("a(\"a\"\n"
3011 " \"a\",\n"
3012 " a);");
Daniel Jasper8f4bd7a2013-01-23 10:08:28 +00003013
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003014 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
Daniel Jasperf1579602013-01-29 16:03:49 +00003015 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
Daniel Jasper8f4bd7a2013-01-23 10:08:28 +00003016 " aaaaaaaaa,\n"
Daniel Jasperf1579602013-01-29 16:03:49 +00003017 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003018 NoBinPacking);
Daniel Jasperfc759082013-02-14 14:26:07 +00003019 verifyFormat(
3020 "void f() {\n"
3021 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
3022 " .aaaaaaa();\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003023 "}",
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003024 NoBinPacking);
Daniel Jasper24e19e42013-05-22 08:55:55 +00003025 verifyFormat(
3026 "template <class SomeType, class SomeOtherType>\n"
3027 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
3028 NoBinPacking);
Daniel Jasper0df6acd2013-01-16 14:59:02 +00003029}
3030
Daniel Jasperc7bd68f2013-07-10 14:02:49 +00003031TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
3032 FormatStyle Style = getLLVMStyleWithColumns(15);
3033 Style.ExperimentalAutoDetectBinPacking = true;
3034 EXPECT_EQ("aaa(aaaa,\n"
3035 " aaaa,\n"
3036 " aaaa);\n"
3037 "aaa(aaaa,\n"
3038 " aaaa,\n"
3039 " aaaa);",
3040 format("aaa(aaaa,\n" // one-per-line
3041 " aaaa,\n"
3042 " aaaa );\n"
3043 "aaa(aaaa, aaaa, aaaa);", // inconclusive
3044 Style));
3045 EXPECT_EQ("aaa(aaaa, aaaa,\n"
3046 " aaaa);\n"
3047 "aaa(aaaa, aaaa,\n"
3048 " aaaa);",
3049 format("aaa(aaaa, aaaa,\n" // bin-packed
3050 " aaaa );\n"
3051 "aaa(aaaa, aaaa, aaaa);", // inconclusive
3052 Style));
3053}
3054
Daniel Jasperc79afda2013-01-18 10:56:38 +00003055TEST_F(FormatTest, FormatsBuilderPattern) {
3056 verifyFormat(
3057 "return llvm::StringSwitch<Reference::Kind>(name)\n"
Daniel Jasper29082452013-08-30 07:27:13 +00003058 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
3059 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
3060 " .StartsWith(\".init\", ORDER_INIT)\n"
3061 " .StartsWith(\".fini\", ORDER_FINI)\n"
3062 " .StartsWith(\".hash\", ORDER_HASH)\n"
3063 " .Default(ORDER_TEXT);\n");
Daniel Jasper33f4b902013-05-15 09:35:08 +00003064
Daniel Jasper4a544e52013-02-15 20:33:06 +00003065 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
Daniel Jasperbf71ba22013-04-08 20:33:42 +00003066 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
Daniel Jasper515f65d2013-02-18 13:24:21 +00003067 verifyFormat(
Daniel Jasperefed6872013-08-07 05:34:02 +00003068 "aaaaaaa->aaaaaaa->aaaaaaaaaaaaaaaa(\n"
3069 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
Daniel Jasper515f65d2013-02-18 13:24:21 +00003070 " ->aaaaaaaa(aaaaaaaaaaaaaaa);");
Daniel Jasper82282dc2013-02-18 13:52:06 +00003071 verifyFormat(
3072 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
Daniel Jasper24849712013-03-01 16:48:32 +00003073 " aaaaaaaaaaaaaa);");
Daniel Jasper82282dc2013-02-18 13:52:06 +00003074 verifyFormat(
Daniel Jasperd489f8c2013-08-27 11:09:05 +00003075 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n"
3076 " aaaaaa->aaaaaaaaaaaa()\n"
3077 " ->aaaaaaaaaaaaaaaa(\n"
3078 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3079 " ->aaaaaaaaaaaaaaaaa();");
3080 verifyFormat(
3081 "someobj->Add((new util::filetools::Handler(dir))\n"
3082 " ->OnEvent1(NewPermanentCallback(\n"
3083 " this, &HandlerHolderClass::EventHandlerCBA))\n"
3084 " ->OnEvent2(NewPermanentCallback(\n"
3085 " this, &HandlerHolderClass::EventHandlerCBB))\n"
3086 " ->OnEvent3(NewPermanentCallback(\n"
3087 " this, &HandlerHolderClass::EventHandlerCBC))\n"
3088 " ->OnEvent5(NewPermanentCallback(\n"
3089 " this, &HandlerHolderClass::EventHandlerCBD))\n"
3090 " ->OnEvent6(NewPermanentCallback(\n"
3091 " this, &HandlerHolderClass::EventHandlerCBE)));");
Daniel Jasperd3fef0f2013-08-27 14:24:43 +00003092
3093 verifyFormat(
3094 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();");
3095 verifyFormat("aaaaaaaaaaaaaaa()\n"
3096 " .aaaaaaaaaaaaaaa()\n"
3097 " .aaaaaaaaaaaaaaa()\n"
3098 " .aaaaaaaaaaaaaaa()\n"
3099 " .aaaaaaaaaaaaaaa();");
3100 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
3101 " .aaaaaaaaaaaaaaa()\n"
3102 " .aaaaaaaaaaaaaaa()\n"
3103 " .aaaaaaaaaaaaaaa();");
3104 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
3105 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
3106 " .aaaaaaaaaaaaaaa();");
Daniel Jaspereb331832013-08-30 07:12:40 +00003107 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
3108 " ->aaaaaaaaaaaaaae(0)\n"
3109 " ->aaaaaaaaaaaaaaa();");
Daniel Jasper2f0a0202013-09-06 08:54:24 +00003110
3111 // Prefer not to break after empty parentheses.
3112 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
3113 " First->LastNewlineOffset);");
Daniel Jasperc79afda2013-01-18 10:56:38 +00003114}
3115
Daniel Jaspere2c7acf2012-12-24 00:13:23 +00003116TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) {
3117 verifyFormat(
3118 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003119 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
Daniel Jaspercd162382013-01-07 13:26:07 +00003120 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003121 " ccccccccccccccccccccccccc) {\n}");
Daniel Jaspercd162382013-01-07 13:26:07 +00003122 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003123 " ccccccccccccccccccccccccc) {\n}");
Daniel Jaspere2c7acf2012-12-24 00:13:23 +00003124 verifyFormat(
3125 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003126 " ccccccccccccccccccccccccc) {\n}");
Daniel Jasper29f123b2013-02-08 15:28:42 +00003127 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
3128 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
3129 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
3130 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
3131 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
3132 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
3133 " aaaaaaaaaaaaaaa != aa) {\n}");
Daniel Jaspere2c7acf2012-12-24 00:13:23 +00003134}
3135
Daniel Jasper7006e7e2013-01-23 12:27:43 +00003136TEST_F(FormatTest, BreaksAfterAssignments) {
Daniel Jasper9cda8002013-01-07 13:08:40 +00003137 verifyFormat(
Daniel Jasper7006e7e2013-01-23 12:27:43 +00003138 "unsigned Cost =\n"
3139 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
3140 " SI->getPointerAddressSpaceee());\n");
Daniel Jasper9cda8002013-01-07 13:08:40 +00003141 verifyFormat(
Daniel Jasper13cb7c22013-01-23 15:55:19 +00003142 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
3143 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
Daniel Jasperf39c8852013-01-23 16:58:21 +00003144
3145 verifyFormat(
Daniel Jasperd489f8c2013-08-27 11:09:05 +00003146 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
3147 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper512843a2013-05-27 12:45:09 +00003148 verifyFormat("unsigned OriginalStartColumn =\n"
3149 " SourceMgr.getSpellingColumnNumber(\n"
3150 " Current.FormatTok.getStartOfNonWhitespace()) -\n"
3151 " 1;");
Daniel Jasper9cda8002013-01-07 13:08:40 +00003152}
3153
Daniel Jaspercf225b62012-12-24 13:43:52 +00003154TEST_F(FormatTest, AlignsAfterAssignments) {
3155 verifyFormat(
3156 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper9cda8002013-01-07 13:08:40 +00003157 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jaspercf225b62012-12-24 13:43:52 +00003158 verifyFormat(
3159 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper9cda8002013-01-07 13:08:40 +00003160 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jaspercf225b62012-12-24 13:43:52 +00003161 verifyFormat(
3162 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper9cda8002013-01-07 13:08:40 +00003163 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jaspercf225b62012-12-24 13:43:52 +00003164 verifyFormat(
3165 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper9cda8002013-01-07 13:08:40 +00003166 " aaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper88cc5622013-07-08 14:25:23 +00003167 verifyFormat(
3168 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n"
3169 " aaaaaaaaaaaaaaaaaaaaaaaa +\n"
3170 " aaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jaspercf225b62012-12-24 13:43:52 +00003171}
3172
3173TEST_F(FormatTest, AlignsAfterReturn) {
3174 verifyFormat(
3175 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3176 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
3177 verifyFormat(
3178 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3179 " aaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper37911302013-04-02 14:33:13 +00003180 verifyFormat(
3181 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
Daniel Jasperbf71ba22013-04-08 20:33:42 +00003182 " aaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper37911302013-04-02 14:33:13 +00003183 verifyFormat(
3184 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
Daniel Jasperbf71ba22013-04-08 20:33:42 +00003185 " aaaaaaaaaaaaaaaaaaaaaa());");
3186 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3187 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
3188 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3189 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
3190 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasperf78bf4a2013-09-30 08:29:03 +00003191 verifyFormat("return\n"
3192 " // true if code is one of a or b.\n"
3193 " code == a || code == b;");
Daniel Jaspercf225b62012-12-24 13:43:52 +00003194}
3195
Daniel Jasper9c837d02013-01-09 07:06:56 +00003196TEST_F(FormatTest, BreaksConditionalExpressions) {
3197 verifyFormat(
Daniel Jasper88cc5622013-07-08 14:25:23 +00003198 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3199 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3200 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper1f2b0782013-01-16 16:23:19 +00003201 verifyFormat(
Daniel Jasperbfe6fd42013-01-28 12:45:14 +00003202 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3203 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
3204 verifyFormat(
3205 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
3206 " : aaaaaaaaaaaaa);");
3207 verifyFormat(
3208 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper64f09282013-03-20 13:53:11 +00003209 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasperbfe6fd42013-01-28 12:45:14 +00003210 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3211 " aaaaaaaaaaaaa);");
Daniel Jasperab3ce592013-08-01 22:05:00 +00003212 verifyFormat(
3213 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3214 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3215 " aaaaaaaaaaaaa);");
Daniel Jasperbfe6fd42013-01-28 12:45:14 +00003216 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3217 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3218 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3219 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3220 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
3221 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3222 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3223 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3224 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3225 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3226 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3227 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperab3ce592013-08-01 22:05:00 +00003228 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3229 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3230 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3231 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3232 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper7878a7b2013-02-15 11:07:25 +00003233 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3234 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3235 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper37911302013-04-02 14:33:13 +00003236 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
3237 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3238 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3239 " : aaaaaaaaaaaaaaaa;");
Daniel Jasper237d4c12013-02-23 21:01:55 +00003240 verifyFormat(
3241 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3242 " ? aaaaaaaaaaaaaaa\n"
3243 " : aaaaaaaaaaaaaaa;");
3244 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
Daniel Jasperbf71ba22013-04-08 20:33:42 +00003245 " aaaaaaaaa\n"
Daniel Jasper65622aa2013-04-08 10:45:44 +00003246 " ? b\n"
3247 " : c);");
Daniel Jasper087387a2013-02-08 16:49:27 +00003248 verifyFormat(
Daniel Jasper7878a7b2013-02-15 11:07:25 +00003249 "unsigned Indent =\n"
3250 " format(TheLine.First, IndentForLevel[TheLine.Level] >= 0\n"
3251 " ? IndentForLevel[TheLine.Level]\n"
Daniel Jasper7d812812013-02-21 15:00:29 +00003252 " : TheLine * 2,\n"
3253 " TheLine.InPPDirective, PreviousEndOfLineColumn);",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003254 getLLVMStyleWithColumns(70));
Daniel Jasperc01897c2013-05-31 14:56:12 +00003255 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
3256 " ? aaaaaaaaaaaaaaa\n"
3257 " : bbbbbbbbbbbbbbb //\n"
3258 " ? ccccccccccccccc\n"
3259 " : ddddddddddddddd;");
3260 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
3261 " ? aaaaaaaaaaaaaaa\n"
3262 " : (bbbbbbbbbbbbbbb //\n"
3263 " ? ccccccccccccccc\n"
3264 " : ddddddddddddddd);");
Daniel Jasper7878a7b2013-02-15 11:07:25 +00003265
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003266 FormatStyle NoBinPacking = getLLVMStyle();
3267 NoBinPacking.BinPackParameters = false;
3268 verifyFormat(
Daniel Jasper237d4c12013-02-23 21:01:55 +00003269 "void f() {\n"
3270 " g(aaa,\n"
3271 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
3272 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3273 " ? aaaaaaaaaaaaaaa\n"
3274 " : aaaaaaaaaaaaaaa);\n"
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003275 "}",
3276 NoBinPacking);
Daniel Jasperab3ce592013-08-01 22:05:00 +00003277 verifyFormat(
3278 "void f() {\n"
3279 " g(aaa,\n"
3280 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
3281 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3282 " ?: aaaaaaaaaaaaaaa);\n"
3283 "}",
3284 NoBinPacking);
Daniel Jasper9c837d02013-01-09 07:06:56 +00003285}
3286
Daniel Jasper2e603772013-01-29 11:21:01 +00003287TEST_F(FormatTest, DeclarationsOfMultipleVariables) {
3288 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
3289 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();");
3290 verifyFormat("bool a = true, b = false;");
3291
Daniel Jasper2e603772013-01-29 11:21:01 +00003292 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +00003293 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
Daniel Jasper2e603772013-01-29 11:21:01 +00003294 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
Daniel Jasper37911302013-04-02 14:33:13 +00003295 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);");
Daniel Jasper2e603772013-01-29 11:21:01 +00003296 verifyFormat(
Daniel Jasper7d812812013-02-21 15:00:29 +00003297 "bool aaaaaaaaaaaaaaaaaaaaa =\n"
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +00003298 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
Daniel Jasper7d812812013-02-21 15:00:29 +00003299 " d = e && f;");
Daniel Jasperadc0f092013-04-05 09:38:50 +00003300 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
3301 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;");
3302 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
3303 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;");
3304 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
3305 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;");
3306 // FIXME: If multiple variables are defined, the "*" needs to move to the new
3307 // line. Also fix indent for breaking after the type, this looks bad.
Manuel Klimeka9a7f102013-06-21 17:25:42 +00003308 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
Daniel Jasper53e72cd2013-05-06 08:27:33 +00003309 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00003310 " *b = bbbbbbbbbbbbbbbbbbb;",
3311 getGoogleStyle());
Daniel Jasper2e603772013-01-29 11:21:01 +00003312
Daniel Jasperadc0f092013-04-05 09:38:50 +00003313 // Not ideal, but pointer-with-type does not allow much here.
3314 verifyGoogleFormat(
3315 "aaaaaaaaa* a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
3316 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;");
Daniel Jasper2e603772013-01-29 11:21:01 +00003317}
3318
Nico Weber7d37b8b2013-01-12 01:28:06 +00003319TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
3320 verifyFormat("arr[foo ? bar : baz];");
3321 verifyFormat("f()[foo ? bar : baz];");
3322 verifyFormat("(a + b)[foo ? bar : baz];");
3323 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
3324}
3325
Daniel Jasperbac016b2012-12-03 18:12:45 +00003326TEST_F(FormatTest, AlignsStringLiterals) {
3327 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
3328 " \"short literal\");");
3329 verifyFormat(
3330 "looooooooooooooooooooooooongFunction(\n"
3331 " \"short literal\"\n"
3332 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003333 verifyFormat("someFunction(\"Always break between multi-line\"\n"
3334 " \" string literals\",\n"
3335 " and, other, parameters);");
Manuel Klimekb56b6d12013-02-20 15:25:48 +00003336 EXPECT_EQ("fun + \"1243\" /* comment */\n"
3337 " \"5678\";",
3338 format("fun + \"1243\" /* comment */\n"
3339 " \"5678\";",
3340 getLLVMStyleWithColumns(28)));
3341 EXPECT_EQ(
3342 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
3343 " \"aaaaaaaaaaaaaaaaaaaaa\"\n"
3344 " \"aaaaaaaaaaaaaaaa\";",
3345 format("aaaaaa ="
3346 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
3347 "aaaaaaaaaaaaaaaaaaaaa\" "
3348 "\"aaaaaaaaaaaaaaaa\";"));
Manuel Klimeke9a62262013-02-20 15:32:58 +00003349 verifyFormat("a = a + \"a\"\n"
3350 " \"a\"\n"
3351 " \"a\";");
Daniel Jasper9a2f8d02013-05-16 04:26:02 +00003352 verifyFormat("f(\"a\", \"b\"\n"
3353 " \"c\");");
Daniel Jasper3a204412013-02-23 07:46:38 +00003354
3355 verifyFormat(
3356 "#define LL_FORMAT \"ll\"\n"
3357 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
3358 " \"d, ddddddddd: %\" LL_FORMAT \"d\");");
Daniel Jasper27c7f542013-05-13 20:50:15 +00003359
3360 verifyFormat("#define A(X) \\\n"
3361 " \"aaaaa\" #X \"bbbbbb\" \\\n"
3362 " \"ccccc\"",
3363 getLLVMStyleWithColumns(23));
3364 verifyFormat("#define A \"def\"\n"
3365 "f(\"abc\" A \"ghi\"\n"
3366 " \"jkl\");");
Daniel Jasperbac016b2012-12-03 18:12:45 +00003367}
3368
Alexander Kornienko56312022013-07-04 12:02:44 +00003369TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) {
3370 FormatStyle NoBreak = getLLVMStyle();
3371 NoBreak.AlwaysBreakBeforeMultilineStrings = false;
3372 FormatStyle Break = getLLVMStyle();
3373 Break.AlwaysBreakBeforeMultilineStrings = true;
Daniel Jasper215c57f2013-07-17 15:38:19 +00003374 verifyFormat("aaaa = \"bbbb\"\n"
3375 " \"cccc\";",
3376 NoBreak);
3377 verifyFormat("aaaa =\n"
3378 " \"bbbb\"\n"
3379 " \"cccc\";",
3380 Break);
3381 verifyFormat("aaaa(\"bbbb\"\n"
3382 " \"cccc\");",
3383 NoBreak);
3384 verifyFormat("aaaa(\n"
3385 " \"bbbb\"\n"
3386 " \"cccc\");",
3387 Break);
3388 verifyFormat("aaaa(qqq, \"bbbb\"\n"
3389 " \"cccc\");",
3390 NoBreak);
3391 verifyFormat("aaaa(qqq,\n"
3392 " \"bbbb\"\n"
3393 " \"cccc\");",
3394 Break);
3395
3396 // Don't break if there is no column gain.
3397 verifyFormat("f(\"aaaa\"\n"
3398 " \"bbbb\");",
3399 Break);
3400
3401 // Treat literals with escaped newlines like multi-line string literals.
Alexander Kornienko10c26b22013-07-16 21:06:13 +00003402 EXPECT_EQ("x = \"a\\\n"
3403 "b\\\n"
3404 "c\";",
3405 format("x = \"a\\\n"
3406 "b\\\n"
3407 "c\";",
3408 NoBreak));
3409 EXPECT_EQ("x =\n"
3410 " \"a\\\n"
3411 "b\\\n"
3412 "c\";",
3413 format("x = \"a\\\n"
3414 "b\\\n"
3415 "c\";",
3416 Break));
Alexander Kornienko56312022013-07-04 12:02:44 +00003417}
3418
Alexander Kornienko15757312012-12-06 18:03:27 +00003419TEST_F(FormatTest, AlignsPipes) {
3420 verifyFormat(
3421 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3422 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3423 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
3424 verifyFormat(
3425 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
3426 " << aaaaaaaaaaaaaaaaaaaa;");
3427 verifyFormat(
3428 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3429 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
3430 verifyFormat(
3431 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
3432 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
3433 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";");
3434 verifyFormat(
3435 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3436 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3437 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasperfa543ac2013-02-04 07:34:48 +00003438
3439 verifyFormat("return out << \"somepacket = {\\n\"\n"
Manuel Klimekae76f7f2013-10-11 21:25:45 +00003440 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
3441 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
3442 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
3443 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
Daniel Jasperfa543ac2013-02-04 07:34:48 +00003444 " << \"}\";");
Daniel Jasper4e8a7b42013-02-06 21:04:05 +00003445
Daniel Jasper3e12e872013-07-15 14:12:30 +00003446 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
3447 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
3448 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;");
Daniel Jasper4e8a7b42013-02-06 21:04:05 +00003449 verifyFormat(
3450 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
3451 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
3452 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
3453 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
3454 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;");
Daniel Jasperbfa1edd2013-03-14 14:00:17 +00003455 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
3456 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
Daniel Jasper9637dda2013-07-15 14:33:14 +00003457 verifyFormat(
3458 "void f() {\n"
3459 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n"
3460 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
3461 "}");
Daniel Jasper37911302013-04-02 14:33:13 +00003462
Daniel Jasperfaec47b2013-07-11 20:41:21 +00003463 // Breaking before the first "<<" is generally not desirable.
3464 verifyFormat(
3465 "llvm::errs()\n"
3466 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3467 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3468 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3469 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
3470 getLLVMStyleWithColumns(70));
3471 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
3472 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3473 " << \"aaaaaaaaaaaaaaaaaaa: \"\n"
3474 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3475 " << \"aaaaaaaaaaaaaaaaaaa: \"\n"
3476 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
3477 getLLVMStyleWithColumns(70));
3478
Daniel Jasperb349a782013-08-12 12:58:05 +00003479 // But sometimes, breaking before the first "<<" is desirable.
Daniel Jaspera0740f52013-07-12 15:14:05 +00003480 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
3481 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3482 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasperb349a782013-08-12 12:58:05 +00003483 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
3484 " << BEF << IsTemplate << Description << E->getType();");
Daniel Jaspera0740f52013-07-12 15:14:05 +00003485
Daniel Jasper37911302013-04-02 14:33:13 +00003486 verifyFormat(
3487 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3488 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper20376982013-09-29 12:02:57 +00003489
3490 // Incomplete string literal.
3491 EXPECT_EQ("llvm::errs() << \"\n"
3492 " << a;",
3493 format("llvm::errs() << \"\n<<a;"));
Alexander Kornienko15757312012-12-06 18:03:27 +00003494}
3495
Daniel Jasperbac016b2012-12-03 18:12:45 +00003496TEST_F(FormatTest, UnderstandsEquals) {
3497 verifyFormat(
3498 "aaaaaaaaaaaaaaaaa =\n"
3499 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
3500 verifyFormat(
3501 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003502 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasperbac016b2012-12-03 18:12:45 +00003503 verifyFormat(
3504 "if (a) {\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +00003505 " f();\n"
Daniel Jasperbac016b2012-12-03 18:12:45 +00003506 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003507 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
3508 "}");
Daniel Jasperbac016b2012-12-03 18:12:45 +00003509
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003510 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
3511 " 100000000 + 10000000) {\n}");
Daniel Jasperbac016b2012-12-03 18:12:45 +00003512}
3513
Daniel Jasper9a0b4942012-12-17 14:34:14 +00003514TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
Daniel Jasper1321eb52012-12-18 21:05:13 +00003515 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
3516 " .looooooooooooooooooooooooooooooooooooooongFunction();");
Daniel Jasper9a0b4942012-12-17 14:34:14 +00003517
Daniel Jasper1321eb52012-12-18 21:05:13 +00003518 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
3519 " ->looooooooooooooooooooooooooooooooooooooongFunction();");
Daniel Jasper9a0b4942012-12-17 14:34:14 +00003520
3521 verifyFormat(
3522 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
3523 " Parameter2);");
3524
3525 verifyFormat(
3526 "ShortObject->shortFunction(\n"
3527 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
3528 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);");
3529
3530 verifyFormat("loooooooooooooongFunction(\n"
3531 " LoooooooooooooongObject->looooooooooooooooongFunction());");
3532
3533 verifyFormat(
3534 "function(LoooooooooooooooooooooooooooooooooooongObject\n"
3535 " ->loooooooooooooooooooooooooooooooooooooooongFunction());");
3536
Daniel Jasperfc759082013-02-14 14:26:07 +00003537 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
3538 " .WillRepeatedly(Return(SomeValue));");
3539 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)]\n"
3540 " .insert(ccccccccccccccccccccccc);");
Daniel Jasper259a0382013-05-27 11:50:16 +00003541 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3542 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa).aaaaa(aaaaa),\n"
3543 " aaaaaaaaaaaaaaaaaaaaa);");
Daniel Jaspere60084d2013-08-13 06:50:04 +00003544 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3545 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());");
Daniel Jasper3af59ce2013-03-15 14:57:30 +00003546 verifyFormat(
3547 "aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3548 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
Daniel Jasper88cc5622013-07-08 14:25:23 +00003549 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3550 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3551 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jasper37911302013-04-02 14:33:13 +00003552 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3553 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3554 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3555 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
3556 "}");
Daniel Jasperfc759082013-02-14 14:26:07 +00003557
Daniel Jasper46a46a22013-01-07 07:13:20 +00003558 // Here, it is not necessary to wrap at "." or "->".
Daniel Jasper1321eb52012-12-18 21:05:13 +00003559 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003560 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasper46a46a22013-01-07 07:13:20 +00003561 verifyFormat(
3562 "aaaaaaaaaaa->aaaaaaaaa(\n"
3563 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3564 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
Daniel Jasper9fc56f22013-02-14 15:01:34 +00003565
3566 verifyFormat(
3567 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3568 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
Daniel Jasper8d0d19a2013-03-13 15:37:48 +00003569 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
3570 " aaaaaaaaa()->aaaaaa()->aaaaa());");
3571 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
3572 " aaaaaaaaa()->aaaaaa()->aaaaa());");
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003573
Daniel Jasper3af59ce2013-03-15 14:57:30 +00003574 // FIXME: Should we break before .a()?
3575 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3576 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa).a();");
3577
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003578 FormatStyle NoBinPacking = getLLVMStyle();
3579 NoBinPacking.BinPackParameters = false;
3580 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
3581 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
3582 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
3583 " aaaaaaaaaaaaaaaaaaa,\n"
3584 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
3585 NoBinPacking);
Daniel Jasperb1491792013-07-09 11:57:27 +00003586
3587 // If there is a subsequent call, change to hanging indentation.
3588 verifyFormat(
3589 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3590 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n"
3591 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
3592 verifyFormat(
3593 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3594 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));");
Daniel Jasper9a0b4942012-12-17 14:34:14 +00003595}
3596
Daniel Jasper9a64fb52013-01-02 15:08:56 +00003597TEST_F(FormatTest, WrapsTemplateDeclarations) {
3598 verifyFormat("template <typename T>\n"
3599 "virtual void loooooooooooongFunction(int Param1, int Param2);");
Daniel Jasper48c099f2013-09-27 07:49:08 +00003600 verifyFormat("template <typename T>\n"
3601 "// T should be one of {A, B}.\n"
3602 "virtual void loooooooooooongFunction(int Param1, int Param2);");
Daniel Jasper9a64fb52013-01-02 15:08:56 +00003603 verifyFormat(
Daniel Jasperc79afda2013-01-18 10:56:38 +00003604 "template <typename T>\n"
Daniel Jasper29f123b2013-02-08 15:28:42 +00003605 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;");
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003606 verifyFormat("template <typename T>\n"
3607 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
3608 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);");
Daniel Jasper9a64fb52013-01-02 15:08:56 +00003609 verifyFormat(
3610 "template <typename T>\n"
3611 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
3612 " int Paaaaaaaaaaaaaaaaaaaaram2);");
Daniel Jasper5eda31e2013-01-02 18:30:06 +00003613 verifyFormat(
3614 "template <typename T>\n"
3615 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
3616 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
3617 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperd64f7382013-01-09 09:50:48 +00003618 verifyFormat("template <typename T>\n"
3619 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +00003620 " int aaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper3fc0bb72013-01-09 10:40:23 +00003621 verifyFormat(
3622 "template <typename T1, typename T2 = char, typename T3 = char,\n"
3623 " typename T4 = char>\n"
3624 "void f();");
Daniel Jasper3499dda2013-01-25 15:43:32 +00003625 verifyFormat(
3626 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
3627 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper01786732013-02-04 07:21:18 +00003628
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003629 verifyFormat("a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
3630 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));");
Daniel Jasperbbc87762013-05-29 12:07:31 +00003631
Daniel Jasper8893b8a2013-05-31 14:56:20 +00003632 verifyFormat("template <typename T> class C {};");
Daniel Jasperbbc87762013-05-29 12:07:31 +00003633 verifyFormat("template <typename T> void f();");
3634 verifyFormat("template <typename T> void f() {}");
Daniel Jasper07ca5472013-07-05 09:14:35 +00003635 verifyFormat(
3636 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
3637 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3638 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
3639 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
3640 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3641 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
3642 " bbbbbbbbbbbbbbbbbbbbbbbb);",
3643 getLLVMStyleWithColumns(72));
Daniel Jasperd3d9e0f2013-09-14 08:13:22 +00003644
3645 FormatStyle AlwaysBreak = getLLVMStyle();
3646 AlwaysBreak.AlwaysBreakTemplateDeclarations = true;
3647 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
3648 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
3649 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
3650 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3651 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
3652 " ccccccccccccccccccccccccccccccccccccccccccccccc);");
3653 verifyFormat("template <template <typename> class Fooooooo,\n"
3654 " template <typename> class Baaaaaaar>\n"
3655 "struct C {};",
3656 AlwaysBreak);
Daniel Jasper6e7f1932013-10-09 15:06:17 +00003657 verifyFormat("template <typename T> // T can be A, B or C.\n"
3658 "struct C {};",
3659 AlwaysBreak);
Daniel Jasper9a64fb52013-01-02 15:08:56 +00003660}
3661
Daniel Jasper63f00362013-01-25 10:57:27 +00003662TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
3663 verifyFormat(
3664 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
3665 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
3666 verifyFormat(
3667 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
3668 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3669 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
3670
Daniel Jasperb2f063a2013-05-08 10:00:18 +00003671 // FIXME: Should we have the extra indent after the second break?
Daniel Jasper63f00362013-01-25 10:57:27 +00003672 verifyFormat(
3673 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
3674 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
Daniel Jasperb2f063a2013-05-08 10:00:18 +00003675 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper63f00362013-01-25 10:57:27 +00003676
Daniel Jasper63f00362013-01-25 10:57:27 +00003677 verifyFormat(
3678 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
Daniel Jasper5f2173e2013-01-28 07:43:15 +00003679 " cccccccccccccccccccccccccccccccccccccccccccccc());");
Daniel Jasper63f00362013-01-25 10:57:27 +00003680
3681 // Breaking at nested name specifiers is generally not desirable.
3682 verifyFormat(
3683 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3684 " aaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperbfe6fd42013-01-28 12:45:14 +00003685
3686 verifyFormat(
3687 "aaaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
3688 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3689 " aaaaaaaaaaaaaaaaaaaaa);",
3690 getLLVMStyleWithColumns(74));
Daniel Jasper37911302013-04-02 14:33:13 +00003691
3692 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
3693 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3694 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper63f00362013-01-25 10:57:27 +00003695}
3696
Daniel Jasperbac016b2012-12-03 18:12:45 +00003697TEST_F(FormatTest, UnderstandsTemplateParameters) {
3698 verifyFormat("A<int> a;");
3699 verifyFormat("A<A<A<int> > > a;");
3700 verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
3701 verifyFormat("bool x = a < 1 || 2 > a;");
3702 verifyFormat("bool x = 5 < f<int>();");
3703 verifyFormat("bool x = f<int>() > 5;");
3704 verifyFormat("bool x = 5 < a<int>::x;");
3705 verifyFormat("bool x = a < 4 ? a > 2 : false;");
3706 verifyFormat("bool x = f() ? a < 2 : a > 2;");
3707
3708 verifyGoogleFormat("A<A<int>> a;");
3709 verifyGoogleFormat("A<A<A<int>>> a;");
3710 verifyGoogleFormat("A<A<A<A<int>>>> a;");
Daniel Jasper8ff690a2013-02-06 14:22:40 +00003711 verifyGoogleFormat("A<A<int> > a;");
3712 verifyGoogleFormat("A<A<A<int> > > a;");
3713 verifyGoogleFormat("A<A<A<A<int> > > > a;");
3714 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
3715 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
Daniel Jasperbac016b2012-12-03 18:12:45 +00003716
3717 verifyFormat("test >> a >> b;");
3718 verifyFormat("test << a >> b;");
3719
3720 verifyFormat("f<int>();");
Manuel Klimek36fab8d2013-01-10 13:24:24 +00003721 verifyFormat("template <typename T> void f() {}");
Daniel Jasper0348be02013-06-01 18:56:00 +00003722
3723 // Not template parameters.
3724 verifyFormat("return a < b && c > d;");
3725 verifyFormat("void f() {\n"
3726 " while (a < b && c > d) {\n"
3727 " }\n"
3728 "}");
Daniel Jasper0236dd02013-07-30 22:37:19 +00003729 verifyFormat("template <typename... Types>\n"
3730 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}");
Daniel Jasper26356cc2013-09-17 08:15:46 +00003731
3732 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3733 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);",
3734 getLLVMStyleWithColumns(60));
Daniel Jasperbac016b2012-12-03 18:12:45 +00003735}
3736
Daniel Jasper807809c2013-02-28 09:21:10 +00003737TEST_F(FormatTest, UnderstandsBinaryOperators) {
3738 verifyFormat("COMPARE(a, ==, b);");
Alexander Kornienko54a38bd2013-03-20 16:41:56 +00003739}
3740
3741TEST_F(FormatTest, UnderstandsPointersToMembers) {
3742 verifyFormat("int A::*x;");
Daniel Jasper395228f2013-05-08 14:58:20 +00003743 verifyFormat("int (S::*func)(void *);");
Daniel Jasper431f5912013-05-28 08:33:00 +00003744 verifyFormat("void f() { int (S::*func)(void *); }");
Daniel Jasper4b7b1042013-05-08 15:06:58 +00003745 verifyFormat("typedef bool *(Class::*Member)() const;");
Daniel Jasper395228f2013-05-08 14:58:20 +00003746 verifyFormat("void f() {\n"
3747 " (a->*f)();\n"
3748 " a->*x;\n"
3749 " (a.*f)();\n"
3750 " ((*a).*f)();\n"
3751 " a.*x;\n"
3752 "}");
Daniel Jasper5e2169f2013-07-18 14:46:07 +00003753 verifyFormat("void f() {\n"
3754 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
3755 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n"
3756 "}");
Daniel Jasper4b7b1042013-05-08 15:06:58 +00003757 FormatStyle Style = getLLVMStyle();
3758 Style.PointerBindsToType = true;
3759 verifyFormat("typedef bool* (Class::*Member)() const;", Style);
Daniel Jasper807809c2013-02-28 09:21:10 +00003760}
3761
Daniel Jasper98e6b4a2012-12-21 09:41:31 +00003762TEST_F(FormatTest, UnderstandsUnaryOperators) {
Daniel Jasperbac016b2012-12-03 18:12:45 +00003763 verifyFormat("int a = -2;");
Daniel Jasper8822d3a2012-12-04 13:02:32 +00003764 verifyFormat("f(-1, -2, -3);");
3765 verifyFormat("a[-1] = 5;");
3766 verifyFormat("int a = 5 + -2;");
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003767 verifyFormat("if (i == -1) {\n}");
3768 verifyFormat("if (i != -1) {\n}");
3769 verifyFormat("if (i > -1) {\n}");
3770 verifyFormat("if (i < -1) {\n}");
Daniel Jasperd56a7372012-12-06 13:16:39 +00003771 verifyFormat("++(a->f());");
3772 verifyFormat("--(a->f());");
Daniel Jasper4abbb532013-01-14 12:18:19 +00003773 verifyFormat("(a->f())++;");
3774 verifyFormat("a[42]++;");
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003775 verifyFormat("if (!(a->f())) {\n}");
Daniel Jasper98e6b4a2012-12-21 09:41:31 +00003776
3777 verifyFormat("a-- > b;");
3778 verifyFormat("b ? -a : c;");
3779 verifyFormat("n * sizeof char16;");
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00003780 verifyFormat("n * alignof char16;", getGoogleStyle());
Daniel Jasper98e6b4a2012-12-21 09:41:31 +00003781 verifyFormat("sizeof(char);");
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00003782 verifyFormat("alignof(char);", getGoogleStyle());
Daniel Jasper1f0754b2013-01-02 15:26:16 +00003783
3784 verifyFormat("return -1;");
3785 verifyFormat("switch (a) {\n"
3786 "case -1:\n"
3787 " break;\n"
3788 "}");
Daniel Jasperb5985422013-03-22 10:44:43 +00003789 verifyFormat("#define X -1");
3790 verifyFormat("#define X -kConstant");
Nico Webercc191d12013-01-12 05:41:23 +00003791
3792 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = { -5, +3 };");
3793 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = { +5, -3 };");
Daniel Jasperb369c2c2013-01-15 14:27:39 +00003794
3795 verifyFormat("int a = /* confusing comment */ -1;");
3796 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case.
3797 verifyFormat("int a = i /* confusing comment */++;");
Daniel Jasperbac016b2012-12-03 18:12:45 +00003798}
3799
Daniel Jasper34f3d052013-08-21 08:39:01 +00003800TEST_F(FormatTest, IndentsRelativeToUnaryOperators) {
3801 verifyFormat("if (!aaaaaaaaaa( // break\n"
3802 " aaaaa)) {\n"
3803 "}");
3804 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
3805 " aaaaa));");
Daniel Jasper3618e6f2013-08-23 15:14:03 +00003806
3807 // Only indent relative to unary operators if the expression is nested.
3808 verifyFormat("*aaa = aaaaaaa( // break\n"
3809 " bbbbbb);");
Daniel Jasper34f3d052013-08-21 08:39:01 +00003810}
3811
Daniel Jasper332c6772013-08-26 08:10:17 +00003812TEST_F(FormatTest, UnderstandsOverloadedOperators) {
Daniel Jasperf6aef6a2012-12-24 10:56:04 +00003813 verifyFormat("bool operator<();");
3814 verifyFormat("bool operator>();");
3815 verifyFormat("bool operator=();");
3816 verifyFormat("bool operator==();");
3817 verifyFormat("bool operator!=();");
3818 verifyFormat("int operator+();");
3819 verifyFormat("int operator++();");
3820 verifyFormat("bool operator();");
3821 verifyFormat("bool operator()();");
3822 verifyFormat("bool operator[]();");
3823 verifyFormat("operator bool();");
Daniel Jasper2b4c9242013-02-11 08:01:18 +00003824 verifyFormat("operator int();");
3825 verifyFormat("operator void *();");
Daniel Jasperf6aef6a2012-12-24 10:56:04 +00003826 verifyFormat("operator SomeType<int>();");
Daniel Jasper2b4c9242013-02-11 08:01:18 +00003827 verifyFormat("operator SomeType<int, int>();");
3828 verifyFormat("operator SomeType<SomeType<int> >();");
Daniel Jasperf6aef6a2012-12-24 10:56:04 +00003829 verifyFormat("void *operator new(std::size_t size);");
3830 verifyFormat("void *operator new[](std::size_t size);");
3831 verifyFormat("void operator delete(void *ptr);");
3832 verifyFormat("void operator delete[](void *ptr);");
Daniel Jasper6ea933c2013-05-10 07:59:58 +00003833 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
3834 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);");
Daniel Jasper2b4c9242013-02-11 08:01:18 +00003835
Daniel Jasperdc2efa12013-02-15 19:24:08 +00003836 verifyFormat(
3837 "ostream &operator<<(ostream &OutputStream,\n"
3838 " SomeReallyLongType WithSomeReallyLongValue);");
Daniel Jasper27b91cc2013-04-05 17:21:59 +00003839 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
3840 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
3841 " return left.group < right.group;\n"
3842 "}");
Daniel Jasper2eb23b72013-04-11 08:48:20 +00003843 verifyFormat("SomeType &operator=(const SomeType &S);");
Daniel Jasperdc2efa12013-02-15 19:24:08 +00003844
Daniel Jasper2b4c9242013-02-11 08:01:18 +00003845 verifyGoogleFormat("operator void*();");
3846 verifyGoogleFormat("operator SomeType<SomeType<int>>();");
Daniel Jasper174f60f2013-09-02 09:20:39 +00003847
3848 verifyFormat("using A::operator+;");
Daniel Jasperbac016b2012-12-03 18:12:45 +00003849}
3850
Daniel Jasper088dab52013-01-11 16:09:04 +00003851TEST_F(FormatTest, UnderstandsNewAndDelete) {
Daniel Jasper37eff832013-02-23 08:07:18 +00003852 verifyFormat("void f() {\n"
3853 " A *a = new A;\n"
3854 " A *a = new (placement) A;\n"
3855 " delete a;\n"
3856 " delete (A *)a;\n"
3857 "}");
Daniel Jasper088dab52013-01-11 16:09:04 +00003858}
3859
Daniel Jasper5d334402013-01-02 08:57:10 +00003860TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
Manuel Klimek36fab8d2013-01-10 13:24:24 +00003861 verifyFormat("int *f(int *a) {}");
Manuel Klimek36fab8d2013-01-10 13:24:24 +00003862 verifyFormat("int main(int argc, char **argv) {}");
Daniel Jasperd0f349b2013-02-18 12:44:35 +00003863 verifyFormat("Test::Test(int b) : a(b * b) {}");
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003864 verifyIndependentOfContext("f(a, *a);");
Daniel Jasper8a5d7cd2013-03-01 17:13:29 +00003865 verifyFormat("void g() { f(*a); }");
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003866 verifyIndependentOfContext("int a = b * 10;");
3867 verifyIndependentOfContext("int a = 10 * b;");
3868 verifyIndependentOfContext("int a = b * c;");
3869 verifyIndependentOfContext("int a += b * c;");
3870 verifyIndependentOfContext("int a -= b * c;");
3871 verifyIndependentOfContext("int a *= b * c;");
3872 verifyIndependentOfContext("int a /= b * c;");
3873 verifyIndependentOfContext("int a = *b;");
3874 verifyIndependentOfContext("int a = *b * c;");
3875 verifyIndependentOfContext("int a = b * *c;");
3876 verifyIndependentOfContext("return 10 * b;");
3877 verifyIndependentOfContext("return *b * *c;");
3878 verifyIndependentOfContext("return a & ~b;");
3879 verifyIndependentOfContext("f(b ? *c : *d);");
3880 verifyIndependentOfContext("int a = b ? *c : *d;");
3881 verifyIndependentOfContext("*b = a;");
3882 verifyIndependentOfContext("a * ~b;");
3883 verifyIndependentOfContext("a * !b;");
3884 verifyIndependentOfContext("a * +b;");
3885 verifyIndependentOfContext("a * -b;");
3886 verifyIndependentOfContext("a * ++b;");
3887 verifyIndependentOfContext("a * --b;");
3888 verifyIndependentOfContext("a[4] * b;");
Daniel Jasper9c65b062013-02-27 11:43:50 +00003889 verifyIndependentOfContext("a[a * a] = 1;");
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003890 verifyIndependentOfContext("f() * b;");
3891 verifyIndependentOfContext("a * [self dostuff];");
Daniel Jasper81d2d382013-04-01 17:13:26 +00003892 verifyIndependentOfContext("int x = a * (a + b);");
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003893 verifyIndependentOfContext("(a *)(a + b);");
3894 verifyIndependentOfContext("int *pa = (int *)&a;");
Nico Weber95e8e462013-02-12 16:17:07 +00003895 verifyIndependentOfContext("return sizeof(int **);");
3896 verifyIndependentOfContext("return sizeof(int ******);");
3897 verifyIndependentOfContext("return (int **&)a;");
Daniel Jasper3ff4a2f2013-05-28 15:27:10 +00003898 verifyIndependentOfContext("f((*PointerToArray)[10]);");
Daniel Jasper8a5d7cd2013-03-01 17:13:29 +00003899 verifyFormat("void f(Type (*parameter)[10]) {}");
Nico Weber95e8e462013-02-12 16:17:07 +00003900 verifyGoogleFormat("return sizeof(int**);");
3901 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);");
3902 verifyGoogleFormat("Type** A = static_cast<Type**>(P);");
Daniel Jasper567dcf92013-09-05 09:29:45 +00003903 verifyFormat("auto a = [](int **&, int ***) {};");
Daniel Jasperdb8afe42013-09-10 10:26:38 +00003904 verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
Daniel Jasperc74e2792012-12-07 09:52:15 +00003905
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003906 verifyIndependentOfContext("InvalidRegions[*R] = 0;");
Daniel Jasper9bb0d282013-01-04 20:46:38 +00003907
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003908 verifyIndependentOfContext("A<int *> a;");
3909 verifyIndependentOfContext("A<int **> a;");
3910 verifyIndependentOfContext("A<int *, int *> a;");
Daniel Jasper4e778092013-02-06 10:05:46 +00003911 verifyIndependentOfContext(
3912 "const char *const p = reinterpret_cast<const char *const>(q);");
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003913 verifyIndependentOfContext("A<int **, int **> a;");
Daniel Jasper6b5ba8b2013-02-06 10:57:42 +00003914 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);");
Daniel Jasperd3cf17b2013-03-14 10:50:25 +00003915 verifyFormat("for (char **a = b; *a; ++a) {\n}");
Daniel Jasper16a69ef2013-05-03 14:41:24 +00003916 verifyFormat("for (; a && b;) {\n}");
Daniel Jasper8b39c662012-12-10 18:59:13 +00003917
Daniel Jasper2db356d2013-01-08 20:03:18 +00003918 verifyFormat(
3919 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3920 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
3921
Manuel Klimek36fab8d2013-01-10 13:24:24 +00003922 verifyGoogleFormat("int main(int argc, char** argv) {}");
Daniel Jasper8b39c662012-12-10 18:59:13 +00003923 verifyGoogleFormat("A<int*> a;");
3924 verifyGoogleFormat("A<int**> a;");
3925 verifyGoogleFormat("A<int*, int*> a;");
3926 verifyGoogleFormat("A<int**, int**> a;");
Daniel Jasper5d334402013-01-02 08:57:10 +00003927 verifyGoogleFormat("f(b ? *c : *d);");
3928 verifyGoogleFormat("int a = b ? *c : *d;");
Daniel Jasper48bd7b72013-01-16 16:04:06 +00003929 verifyGoogleFormat("Type* t = **x;");
3930 verifyGoogleFormat("Type* t = *++*x;");
3931 verifyGoogleFormat("*++*x;");
3932 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);");
3933 verifyGoogleFormat("Type* t = x++ * y;");
Daniel Jasper4e778092013-02-06 10:05:46 +00003934 verifyGoogleFormat(
3935 "const char* const p = reinterpret_cast<const char* const>(q);");
Manuel Klimek1b6f4bd2013-01-14 10:58:01 +00003936
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003937 verifyIndependentOfContext("a = *(x + y);");
3938 verifyIndependentOfContext("a = &(x + y);");
3939 verifyIndependentOfContext("*(x + y).call();");
3940 verifyIndependentOfContext("&(x + y)->call();");
Daniel Jasper8a5d7cd2013-03-01 17:13:29 +00003941 verifyFormat("void f() { &(*I).first; }");
Daniel Jasperb369c2c2013-01-15 14:27:39 +00003942
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003943 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
Daniel Jasperb369c2c2013-01-15 14:27:39 +00003944 verifyFormat(
3945 "int *MyValues = {\n"
3946 " *A, // Operator detection might be confused by the '{'\n"
3947 " *BB // Operator detection might be confused by previous comment\n"
3948 "};");
Nico Weber5096a442013-01-17 17:17:19 +00003949
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003950 verifyIndependentOfContext("if (int *a = &b)");
3951 verifyIndependentOfContext("if (int &a = *b)");
3952 verifyIndependentOfContext("if (a & b[i])");
3953 verifyIndependentOfContext("if (a::b::c::d & b[i])");
3954 verifyIndependentOfContext("if (*b[i])");
3955 verifyIndependentOfContext("if (int *a = (&b))");
3956 verifyIndependentOfContext("while (int *a = &b)");
Daniel Jasper65da8e92013-09-21 17:31:51 +00003957 verifyIndependentOfContext("size = sizeof *a;");
Daniel Jasper20d35832013-01-23 12:58:14 +00003958 verifyFormat("void f() {\n"
3959 " for (const int &v : Values) {\n"
3960 " }\n"
3961 "}");
Daniel Jasperd0f349b2013-02-18 12:44:35 +00003962 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
3963 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
Daniel Jasper7e274002013-09-11 20:37:10 +00003964 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}");
Daniel Jasperffee1712013-01-22 11:46:26 +00003965
Daniel Jasper378d93d2013-05-13 07:14:40 +00003966 verifyFormat("#define MACRO \\\n"
3967 " int *i = a * b; \\\n"
3968 " void f(a *b);",
3969 getLLVMStyleWithColumns(19));
3970
Daniel Jasper6f21a982013-03-13 07:49:51 +00003971 verifyIndependentOfContext("A = new SomeType *[Length];");
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003972 verifyIndependentOfContext("A = new SomeType *[Length]();");
Daniel Jasperd6104f62013-07-05 13:30:40 +00003973 verifyIndependentOfContext("T **t = new T *;");
3974 verifyIndependentOfContext("T **t = new T *();");
Daniel Jasperffee1712013-01-22 11:46:26 +00003975 verifyGoogleFormat("A = new SomeType* [Length]();");
Daniel Jasper6f21a982013-03-13 07:49:51 +00003976 verifyGoogleFormat("A = new SomeType* [Length];");
Daniel Jasperd6104f62013-07-05 13:30:40 +00003977 verifyGoogleFormat("T** t = new T*;");
3978 verifyGoogleFormat("T** t = new T*();");
Daniel Jasper378d93d2013-05-13 07:14:40 +00003979
Daniel Jasperdbef71e2013-05-07 14:17:18 +00003980 FormatStyle PointerLeft = getLLVMStyle();
3981 PointerLeft.PointerBindsToType = true;
3982 verifyFormat("delete *x;", PointerLeft);
Daniel Jasper8a5d7cd2013-03-01 17:13:29 +00003983}
Daniel Jasper8ff690a2013-02-06 14:22:40 +00003984
Daniel Jaspere0fa4c52013-07-17 20:25:02 +00003985TEST_F(FormatTest, UnderstandsAttributes) {
3986 verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
3987}
3988
Daniel Jasperf0220182013-05-06 06:35:44 +00003989TEST_F(FormatTest, UnderstandsEllipsis) {
3990 verifyFormat("int printf(const char *fmt, ...);");
3991 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
Daniel Jasperc47d7f12013-07-01 09:47:25 +00003992 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}");
3993
3994 FormatStyle PointersLeft = getLLVMStyle();
3995 PointersLeft.PointerBindsToType = true;
3996 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft);
Daniel Jasperf0220182013-05-06 06:35:44 +00003997}
3998
Daniel Jasper8a5d7cd2013-03-01 17:13:29 +00003999TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
Daniel Jasper8ff690a2013-02-06 14:22:40 +00004000 EXPECT_EQ("int *a;\n"
4001 "int *a;\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004002 "int *a;",
4003 format("int *a;\n"
4004 "int* a;\n"
4005 "int *a;",
4006 getGoogleStyle()));
Daniel Jasper8ff690a2013-02-06 14:22:40 +00004007 EXPECT_EQ("int* a;\n"
4008 "int* a;\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004009 "int* a;",
4010 format("int* a;\n"
4011 "int* a;\n"
4012 "int *a;",
4013 getGoogleStyle()));
Daniel Jasper8ff690a2013-02-06 14:22:40 +00004014 EXPECT_EQ("int *a;\n"
4015 "int *a;\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004016 "int *a;",
4017 format("int *a;\n"
4018 "int * a;\n"
4019 "int * a;",
4020 getGoogleStyle()));
Daniel Jasperbac016b2012-12-03 18:12:45 +00004021}
4022
Alexander Kornienko3fd9ccd2013-03-12 16:28:18 +00004023TEST_F(FormatTest, UnderstandsRvalueReferences) {
4024 verifyFormat("int f(int &&a) {}");
4025 verifyFormat("int f(int a, char &&b) {}");
4026 verifyFormat("void f() { int &&a = b; }");
4027 verifyGoogleFormat("int f(int a, char&& b) {}");
4028 verifyGoogleFormat("void f() { int&& a = b; }");
4029
Daniel Jasper131884a2013-05-27 16:36:33 +00004030 verifyIndependentOfContext("A<int &&> a;");
4031 verifyIndependentOfContext("A<int &&, int &&> a;");
4032 verifyGoogleFormat("A<int&&> a;");
4033 verifyGoogleFormat("A<int&&, int&&> a;");
Daniel Jasperb7000ca2013-08-01 17:58:23 +00004034
4035 // Not rvalue references:
4036 verifyFormat("template <bool B, bool C> class A {\n"
4037 " static_assert(B && C, \"Something is wrong\");\n"
4038 "};");
Daniel Jasperb644dd62013-08-13 09:09:09 +00004039 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))");
4040 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))");
Alexander Kornienko3fd9ccd2013-03-12 16:28:18 +00004041}
4042
Manuel Klimeka32a7fd2013-01-23 14:08:21 +00004043TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
4044 verifyFormat("void f() {\n"
4045 " x[aaaaaaaaa -\n"
Daniel Jasperbf71ba22013-04-08 20:33:42 +00004046 " b] = 23;\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004047 "}",
4048 getLLVMStyleWithColumns(15));
Manuel Klimeka32a7fd2013-01-23 14:08:21 +00004049}
4050
Daniel Jasper4981bd02013-01-13 08:01:36 +00004051TEST_F(FormatTest, FormatsCasts) {
4052 verifyFormat("Type *A = static_cast<Type *>(P);");
4053 verifyFormat("Type *A = (Type *)P;");
4054 verifyFormat("Type *A = (vector<Type *, int *>)P;");
4055 verifyFormat("int a = (int)(2.0f);");
Daniel Jasperb8b42952013-05-31 16:14:28 +00004056 verifyFormat("int a = (int)2.0f;");
4057 verifyFormat("x[(int32)y];");
4058 verifyFormat("x = (int32)y;");
4059 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
4060 verifyFormat("int a = (int)*b;");
4061 verifyFormat("int a = (int)2.0f;");
4062 verifyFormat("int a = (int)~0;");
4063 verifyFormat("int a = (int)++a;");
4064 verifyFormat("int a = (int)sizeof(int);");
4065 verifyFormat("int a = (int)+2;");
4066 verifyFormat("my_int a = (my_int)2.0f;");
4067 verifyFormat("my_int a = (my_int)sizeof(int);");
Daniel Jasperff1a2e52013-06-06 08:20:20 +00004068 verifyFormat("return (my_int)aaa;");
Daniel Jasper0c368782013-07-15 15:04:42 +00004069 verifyFormat("#define x ((int)-1)");
4070 verifyFormat("#define p(q) ((int *)&q)");
Daniel Jasper4981bd02013-01-13 08:01:36 +00004071
Daniel Jasperb8b42952013-05-31 16:14:28 +00004072 // FIXME: Without type knowledge, this can still fall apart miserably.
4073 verifyFormat("void f() { my_int a = (my_int) * b; }");
Alexander Kornienko2785b9a2013-06-07 16:02:52 +00004074 verifyFormat("void f() { return P ? (my_int) * P : (my_int)0; }");
Daniel Jasperb8b42952013-05-31 16:14:28 +00004075 verifyFormat("my_int a = (my_int) ~0;");
4076 verifyFormat("my_int a = (my_int)++ a;");
4077 verifyFormat("my_int a = (my_int) + 2;");
Daniel Jasper4981bd02013-01-13 08:01:36 +00004078
Daniel Jasper5e2169f2013-07-18 14:46:07 +00004079 // Don't break after a cast's
4080 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
4081 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
4082 " bbbbbbbbbbbbbbbbbbbbbb);");
4083
Daniel Jasper4981bd02013-01-13 08:01:36 +00004084 // These are not casts.
4085 verifyFormat("void f(int *) {}");
Nico Weber6fa7e742013-02-13 04:32:57 +00004086 verifyFormat("f(foo)->b;");
4087 verifyFormat("f(foo).b;");
4088 verifyFormat("f(foo)(b);");
4089 verifyFormat("f(foo)[b];");
Daniel Jasper567dcf92013-09-05 09:29:45 +00004090 verifyFormat("[](foo) { return 4; }(bar);");
Nico Weber6fa7e742013-02-13 04:32:57 +00004091 verifyFormat("(*funptr)(foo)[4];");
4092 verifyFormat("funptrs[4](foo)[4];");
Daniel Jasper4981bd02013-01-13 08:01:36 +00004093 verifyFormat("void f(int *);");
4094 verifyFormat("void f(int *) = 0;");
4095 verifyFormat("void f(SmallVector<int>) {}");
4096 verifyFormat("void f(SmallVector<int>);");
4097 verifyFormat("void f(SmallVector<int>) = 0;");
Nico Weber77280572013-02-09 18:02:07 +00004098 verifyFormat("void f(int i = (kValue) * kMask) {}");
4099 verifyFormat("void f(int i = (kA * kB) & kMask) {}");
Nico Weber6fa7e742013-02-13 04:32:57 +00004100 verifyFormat("int a = sizeof(int) * b;");
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00004101 verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
Daniel Jasperff1a2e52013-06-06 08:20:20 +00004102 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
4103 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
Daniel Jasper526df0f2013-07-08 14:58:01 +00004104 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
Daniel Jasperfaab0d32013-02-27 09:47:53 +00004105
Daniel Jasper37eff832013-02-23 08:07:18 +00004106 // These are not casts, but at some point were confused with casts.
4107 verifyFormat("virtual void foo(int *) override;");
4108 verifyFormat("virtual void foo(char &) const;");
4109 verifyFormat("virtual void foo(int *a, char *) const;");
Daniel Jasper6a365aa2013-03-13 17:13:53 +00004110 verifyFormat("int a = sizeof(int *) + b;");
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00004111 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
Daniel Jasper198c8bf2013-07-05 07:58:34 +00004112
4113 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
4114 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
Daniel Jasper011c35d2013-07-12 11:19:37 +00004115 // FIXME: The indentation here is not ideal.
Daniel Jasper07ca5472013-07-05 09:14:35 +00004116 verifyFormat(
Daniel Jasper011c35d2013-07-12 11:19:37 +00004117 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4118 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
4119 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];");
Daniel Jasper4981bd02013-01-13 08:01:36 +00004120}
4121
Daniel Jasper46ef8522013-01-10 13:08:12 +00004122TEST_F(FormatTest, FormatsFunctionTypes) {
Daniel Jasper46ef8522013-01-10 13:08:12 +00004123 verifyFormat("A<bool()> a;");
4124 verifyFormat("A<SomeType()> a;");
Daniel Jasper431f5912013-05-28 08:33:00 +00004125 verifyFormat("A<void (*)(int, std::string)> a;");
Daniel Jasper9322aae2013-03-20 09:53:18 +00004126 verifyFormat("A<void *(int)>;");
Daniel Jasper81d2d382013-04-01 17:13:26 +00004127 verifyFormat("void *(*a)(int *, SomeType *);");
Daniel Jasper8a5d7cd2013-03-01 17:13:29 +00004128 verifyFormat("int (*func)(void *);");
Daniel Jasper431f5912013-05-28 08:33:00 +00004129 verifyFormat("void f() { int (*func)(void *); }");
Daniel Jasper53352602013-08-12 12:16:34 +00004130 verifyFormat("template <class CallbackClass>\n"
4131 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);");
Daniel Jasper9322aae2013-03-20 09:53:18 +00004132
Daniel Jasper81d2d382013-04-01 17:13:26 +00004133 verifyGoogleFormat("A<void*(int*, SomeType*)>;");
4134 verifyGoogleFormat("void* (*a)(int);");
Daniel Jasper53352602013-08-12 12:16:34 +00004135 verifyGoogleFormat(
4136 "template <class CallbackClass>\n"
4137 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);");
Daniel Jasper7424d792013-05-14 08:34:47 +00004138
Daniel Jaspera8fda852013-05-15 07:51:51 +00004139 // Other constructs can look somewhat like function types:
Daniel Jasper7424d792013-05-14 08:34:47 +00004140 verifyFormat("A<sizeof(*x)> a;");
Daniel Jaspera8fda852013-05-15 07:51:51 +00004141 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
Daniel Jaspere7d3bff2013-07-16 11:37:21 +00004142 verifyFormat("some_var = function(*some_pointer_var)[0];");
4143 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
Daniel Jasper46ef8522013-01-10 13:08:12 +00004144}
4145
Daniel Jasper3c08a812013-02-24 18:54:32 +00004146TEST_F(FormatTest, BreaksLongDeclarations) {
Daniel Jasper53e72cd2013-05-06 08:27:33 +00004147 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00004148 " AnotherNameForTheLongType;",
4149 getGoogleStyle());
Daniel Jasper53e72cd2013-05-06 08:27:33 +00004150 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00004151 " LoooooooooooooooooooooooooooooooooooooooongVariable;",
4152 getGoogleStyle());
Daniel Jasper6ac431c2013-07-02 09:47:29 +00004153 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
4154 " LoooooooooooooooooooooooooooooooooooooooongVariable;",
4155 getGoogleStyle());
Daniel Jasper53e72cd2013-05-06 08:27:33 +00004156 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00004157 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();",
4158 getGoogleStyle());
Daniel Jasper53e72cd2013-05-06 08:27:33 +00004159 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
4160 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasper6ac431c2013-07-02 09:47:29 +00004161 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
4162 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasper53e72cd2013-05-06 08:27:33 +00004163
4164 // FIXME: Without the comment, this breaks after "(".
Manuel Klimeka9a7f102013-06-21 17:25:42 +00004165 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n"
4166 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();",
4167 getGoogleStyle());
Daniel Jasper53e72cd2013-05-06 08:27:33 +00004168
Daniel Jasper83f25ba2013-01-28 15:16:31 +00004169 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00004170 " int LoooooooooooooooooooongParam2) {}");
Daniel Jasper4dc41de2013-01-02 08:44:14 +00004171 verifyFormat(
Daniel Jasper1407bee2013-04-11 14:29:13 +00004172 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
4173 " SourceLocation L, IdentifierIn *II,\n"
4174 " Type *T) {}");
Daniel Jasper3c08a812013-02-24 18:54:32 +00004175 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
4176 "ReallyReallyLongFunctionName(\n"
4177 " const std::string &SomeParameter,\n"
4178 " const SomeType<string, SomeOtherTemplateParameter> &\n"
4179 " ReallyReallyLongParameterName,\n"
4180 " const SomeType<string, SomeOtherTemplateParameter> &\n"
4181 " AnotherLongParameterName) {}");
Daniel Jasper33f4b902013-05-15 09:35:08 +00004182 verifyFormat("template <typename A>\n"
4183 "SomeLoooooooooooooooooooooongType<\n"
4184 " typename some_namespace::SomeOtherType<A>::Type>\n"
4185 "Function() {}");
Daniel Jasper3c08a812013-02-24 18:54:32 +00004186
Daniel Jasperd75ff642013-01-28 15:40:20 +00004187 verifyGoogleFormat(
Daniel Jasper92495a82013-08-19 10:16:18 +00004188 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
4189 " aaaaaaaaaaaaaaaaaaaaaaa;");
4190 verifyGoogleFormat(
Daniel Jasperfaab0d32013-02-27 09:47:53 +00004191 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
4192 " SourceLocation L) {}");
Daniel Jaspera03ab102013-02-13 20:33:44 +00004193 verifyGoogleFormat(
4194 "some_namespace::LongReturnType\n"
4195 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00004196 " int first_long_parameter, int second_parameter) {}");
Daniel Jaspera03ab102013-02-13 20:33:44 +00004197
4198 verifyGoogleFormat("template <typename T>\n"
4199 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00004200 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
Daniel Jasperb6f02f32013-02-28 10:06:05 +00004201 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4202 " int aaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper4dc41de2013-01-02 08:44:14 +00004203}
4204
Daniel Jasper011c35d2013-07-12 11:19:37 +00004205TEST_F(FormatTest, FormatsArrays) {
4206 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
4207 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
4208 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4209 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
4210 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4211 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
4212 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4213 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
4214 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
4215 verifyFormat(
4216 "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
4217 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
4218 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
4219}
4220
Daniel Jasper3b5943f2012-12-06 09:56:08 +00004221TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
4222 verifyFormat("(a)->b();");
4223 verifyFormat("--a;");
4224}
4225
Daniel Jasper8822d3a2012-12-04 13:02:32 +00004226TEST_F(FormatTest, HandlesIncludeDirectives) {
Daniel Jasper2b9c10b2013-01-14 15:52:06 +00004227 verifyFormat("#include <string>\n"
4228 "#include <a/b/c.h>\n"
4229 "#include \"a/b/string\"\n"
4230 "#include \"string.h\"\n"
4231 "#include \"string.h\"\n"
Manuel Klimek407a31a2013-01-15 15:50:27 +00004232 "#include <a-a>\n"
Daniel Jasper3a204412013-02-23 07:46:38 +00004233 "#include < path with space >\n"
Daniel Jasper7ff96ed2013-05-06 10:24:51 +00004234 "#include \"abc.h\" // this is included for ABC\n"
Daniel Jasper5d5b4242013-05-16 12:59:13 +00004235 "#include \"some long include\" // with a comment\n"
Daniel Jasper3a204412013-02-23 07:46:38 +00004236 "#include \"some very long include paaaaaaaaaaaaaaaaaaaaaaath\"",
4237 getLLVMStyleWithColumns(35));
Nico Weberb23ae0c2012-12-21 18:21:56 +00004238
Daniel Jasper8134e1e2013-01-13 08:12:18 +00004239 verifyFormat("#import <string>");
4240 verifyFormat("#import <a/b/c.h>");
4241 verifyFormat("#import \"a/b/string\"");
4242 verifyFormat("#import \"string.h\"");
4243 verifyFormat("#import \"string.h\"");
Daniel Jaspera4dd9822013-08-28 08:24:04 +00004244 verifyFormat("#if __has_include(<strstream>)\n"
4245 "#include <strstream>\n"
4246 "#endif");
Daniel Jasper8822d3a2012-12-04 13:02:32 +00004247}
4248
Alexander Kornienko15757312012-12-06 18:03:27 +00004249//===----------------------------------------------------------------------===//
4250// Error recovery tests.
4251//===----------------------------------------------------------------------===//
4252
Daniel Jasperc5cfa492013-02-14 09:19:04 +00004253TEST_F(FormatTest, IncompleteParameterLists) {
Daniel Jasperfaab0d32013-02-27 09:47:53 +00004254 FormatStyle NoBinPacking = getLLVMStyle();
4255 NoBinPacking.BinPackParameters = false;
4256 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
4257 " double *min_x,\n"
4258 " double *max_x,\n"
4259 " double *min_y,\n"
4260 " double *max_y,\n"
4261 " double *min_z,\n"
4262 " double *max_z, ) {}",
4263 NoBinPacking);
Daniel Jasperc5cfa492013-02-14 09:19:04 +00004264}
4265
Daniel Jasper700e7102013-01-10 09:26:47 +00004266TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
Alexander Kornienko51c23fa2013-01-16 11:45:16 +00004267 verifyFormat("void f() { return; }\n42");
4268 verifyFormat("void f() {\n"
4269 " if (0)\n"
4270 " return;\n"
4271 "}\n"
4272 "42");
Alexander Kornienkod8818752013-01-16 11:43:46 +00004273 verifyFormat("void f() { return }\n42");
4274 verifyFormat("void f() {\n"
4275 " if (0)\n"
4276 " return\n"
4277 "}\n"
4278 "42");
4279}
4280
4281TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
4282 EXPECT_EQ("void f() { return }", format("void f ( ) { return }"));
4283 EXPECT_EQ("void f() {\n"
4284 " if (a)\n"
4285 " return\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004286 "}",
4287 format("void f ( ) { if ( a ) return }"));
Daniel Jasper5be59ba2013-05-15 14:09:55 +00004288 EXPECT_EQ("namespace N {\n"
4289 "void f()\n"
4290 "}",
4291 format("namespace N { void f() }"));
Alexander Kornienkod8818752013-01-16 11:43:46 +00004292 EXPECT_EQ("namespace N {\n"
4293 "void f() {}\n"
4294 "void g()\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004295 "}",
4296 format("namespace N { void f( ) { } void g( ) }"));
Daniel Jasper700e7102013-01-10 09:26:47 +00004297}
4298
Daniel Jasperceb99ab2013-01-09 10:16:05 +00004299TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
4300 verifyFormat("int aaaaaaaa =\n"
Alexander Kornienko5262dd92013-03-27 11:52:18 +00004301 " // Overlylongcomment\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004302 " b;",
4303 getLLVMStyleWithColumns(20));
Daniel Jasperceb99ab2013-01-09 10:16:05 +00004304 verifyFormat("function(\n"
4305 " ShortArgument,\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004306 " LoooooooooooongArgument);\n",
4307 getLLVMStyleWithColumns(20));
Daniel Jasperceb99ab2013-01-09 10:16:05 +00004308}
4309
Alexander Kornienko56e49c52012-12-10 16:34:48 +00004310TEST_F(FormatTest, IncorrectAccessSpecifier) {
4311 verifyFormat("public:");
4312 verifyFormat("class A {\n"
4313 "public\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +00004314 " void f() {}\n"
Alexander Kornienko56e49c52012-12-10 16:34:48 +00004315 "};");
4316 verifyFormat("public\n"
4317 "int qwerty;");
4318 verifyFormat("public\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +00004319 "B {}");
Alexander Kornienko56e49c52012-12-10 16:34:48 +00004320 verifyFormat("public\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +00004321 "{}");
Alexander Kornienko56e49c52012-12-10 16:34:48 +00004322 verifyFormat("public\n"
Manuel Klimek517e8942013-01-11 17:54:10 +00004323 "B { int x; }");
Alexander Kornienko56e49c52012-12-10 16:34:48 +00004324}
Daniel Jasperbac016b2012-12-03 18:12:45 +00004325
Daniel Jasper92f9faf2013-03-20 15:58:10 +00004326TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
4327 verifyFormat("{");
4328 verifyFormat("#})");
4329}
Alexander Kornienko393b0082012-12-04 15:40:36 +00004330
4331TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004332 verifyFormat("do {\n}");
4333 verifyFormat("do {\n}\n"
Alexander Kornienko393b0082012-12-04 15:40:36 +00004334 "f();");
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004335 verifyFormat("do {\n}\n"
Alexander Kornienko393b0082012-12-04 15:40:36 +00004336 "wheeee(fun);");
4337 verifyFormat("do {\n"
4338 " f();\n"
Manuel Klimekde768542013-01-07 18:10:23 +00004339 "}");
Alexander Kornienko393b0082012-12-04 15:40:36 +00004340}
4341
Manuel Klimek6eca03f2013-01-11 19:23:05 +00004342TEST_F(FormatTest, IncorrectCodeMissingParens) {
Manuel Klimekd4658432013-01-11 18:28:36 +00004343 verifyFormat("if {\n foo;\n foo();\n}");
Manuel Klimek6eca03f2013-01-11 19:23:05 +00004344 verifyFormat("switch {\n foo;\n foo();\n}");
4345 verifyFormat("for {\n foo;\n foo();\n}");
4346 verifyFormat("while {\n foo;\n foo();\n}");
4347 verifyFormat("do {\n foo;\n foo();\n} while;");
Manuel Klimekd4658432013-01-11 18:28:36 +00004348}
4349
Daniel Jasper1f42f112013-01-04 18:52:56 +00004350TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
4351 verifyFormat("namespace {\n"
Manuel Klimekae76f7f2013-10-11 21:25:45 +00004352 "class Foo { Foo (\n"
Daniel Jasperf7ec1cc2013-05-31 14:56:29 +00004353 "};\n"
4354 "} // comment");
Daniel Jasper1f42f112013-01-04 18:52:56 +00004355}
4356
Alexander Kornienkocff563c2012-12-04 17:27:50 +00004357TEST_F(FormatTest, IncorrectCodeErrorDetection) {
Manuel Klimek36fab8d2013-01-10 13:24:24 +00004358 EXPECT_EQ("{\n{}\n", format("{\n{\n}\n"));
4359 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n"));
4360 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n"));
4361 EXPECT_EQ("{\n {}\n }\n}\n", format("{\n {\n }\n }\n}\n"));
Alexander Kornienkocff563c2012-12-04 17:27:50 +00004362
Alexander Kornienkocff563c2012-12-04 17:27:50 +00004363 EXPECT_EQ("{\n"
4364 " {\n"
4365 " breakme(\n"
4366 " qwe);\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004367 "}\n",
4368 format("{\n"
4369 " {\n"
4370 " breakme(qwe);\n"
4371 "}\n",
4372 getLLVMStyleWithColumns(10)));
Alexander Kornienkocff563c2012-12-04 17:27:50 +00004373}
4374
Manuel Klimek2851c162013-01-10 14:36:46 +00004375TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004376 verifyFormat("int x = {\n"
4377 " avariable,\n"
4378 " b(alongervariable)\n"
4379 "};",
4380 getLLVMStyleWithColumns(25));
Manuel Klimek2851c162013-01-10 14:36:46 +00004381}
4382
Manuel Klimekc44ee892013-01-21 10:07:49 +00004383TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
4384 verifyFormat("return (a)(b) { 1, 2, 3 };");
4385}
4386
Manuel Klimek80829bd2013-05-23 09:41:43 +00004387TEST_F(FormatTest, LayoutCxx11ConstructorBraceInitializers) {
Daniel Jasper2424eef2013-05-23 10:15:45 +00004388 verifyFormat("vector<int> x{ 1, 2, 3, 4 };");
4389 verifyFormat("vector<T> x{ {}, {}, {}, {} };");
Manuel Klimek80829bd2013-05-23 09:41:43 +00004390 verifyFormat("f({ 1, 2 });");
Daniel Jasper2424eef2013-05-23 10:15:45 +00004391 verifyFormat("auto v = Foo{ 1 };");
Manuel Klimek80829bd2013-05-23 09:41:43 +00004392 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });");
Daniel Jasperde0d61f2013-05-23 18:29:16 +00004393 verifyFormat("Class::Class : member{ 1, 2, 3 } {}");
Daniel Jasperce933562013-05-23 21:35:49 +00004394 verifyFormat("new vector<int>{ 1, 2, 3 };");
4395 verifyFormat("new int[3]{ 1, 2, 3 };");
Daniel Jasperde0d61f2013-05-23 18:29:16 +00004396 verifyFormat("return { arg1, arg2 };");
Daniel Jasper88959b72013-05-28 18:50:02 +00004397 verifyFormat("return { arg1, SomeType{ parameter } };");
Daniel Jasperde0d61f2013-05-23 18:29:16 +00004398 verifyFormat("new T{ arg1, arg2 };");
Daniel Jasperac885cd2013-09-13 10:55:31 +00004399 verifyFormat("f(MyMap[{ composite, key }]);");
Daniel Jasperde0d61f2013-05-23 18:29:16 +00004400 verifyFormat("class Class {\n"
4401 " T member = { arg1, arg2 };\n"
4402 "};");
Daniel Jaspereb483662013-05-31 10:09:55 +00004403 verifyFormat(
4404 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4405 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
4406 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
4407 " bbbbbbbbbbbbbbbbbbbb, bbbbb };");
Daniel Jasper02eacc22013-07-01 09:15:46 +00004408 verifyFormat("DoSomethingWithVector({} /* No data */);");
Daniel Jasperf50dbfa2013-07-01 16:43:38 +00004409 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });");
Daniel Jasper0de1c4d2013-07-09 09:06:29 +00004410 verifyFormat(
4411 "someFunction(OtherParam, BracedList{\n"
Daniel Jasperb1491792013-07-09 11:57:27 +00004412 " // comment 1 (Forcing interesting break)\n"
Daniel Jasper0de1c4d2013-07-09 09:06:29 +00004413 " param1, param2,\n"
4414 " // comment 2\n"
4415 " param3, param4\n"
4416 " });");
Daniel Jasperf439dcb2013-08-28 07:50:37 +00004417 verifyFormat(
4418 "std::this_thread::sleep_for(\n"
4419 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);");
Daniel Jasper2424eef2013-05-23 10:15:45 +00004420
4421 FormatStyle NoSpaces = getLLVMStyle();
Daniel Jasperb5dc3f42013-07-16 18:22:10 +00004422 NoSpaces.Cpp11BracedListStyle = true;
Daniel Jasper2424eef2013-05-23 10:15:45 +00004423 verifyFormat("vector<int> x{1, 2, 3, 4};", NoSpaces);
4424 verifyFormat("vector<T> x{{}, {}, {}, {}};", NoSpaces);
4425 verifyFormat("f({1, 2});", NoSpaces);
Daniel Jasper1bee0732013-05-23 18:05:18 +00004426 verifyFormat("auto v = Foo{-1};", NoSpaces);
Daniel Jasper2424eef2013-05-23 10:15:45 +00004427 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});", NoSpaces);
Daniel Jasperde0d61f2013-05-23 18:29:16 +00004428 verifyFormat("Class::Class : member{1, 2, 3} {}", NoSpaces);
Daniel Jasperce933562013-05-23 21:35:49 +00004429 verifyFormat("new vector<int>{1, 2, 3};", NoSpaces);
4430 verifyFormat("new int[3]{1, 2, 3};", NoSpaces);
Daniel Jasperde0d61f2013-05-23 18:29:16 +00004431 verifyFormat("return {arg1, arg2};", NoSpaces);
Daniel Jasper88959b72013-05-28 18:50:02 +00004432 verifyFormat("return {arg1, SomeType{parameter}};", NoSpaces);
Daniel Jasperde0d61f2013-05-23 18:29:16 +00004433 verifyFormat("new T{arg1, arg2};", NoSpaces);
Daniel Jasperac885cd2013-09-13 10:55:31 +00004434 verifyFormat("f(MyMap[{composite, key}]);", NoSpaces);
Daniel Jasperde0d61f2013-05-23 18:29:16 +00004435 verifyFormat("class Class {\n"
4436 " T member = {arg1, arg2};\n"
4437 "};",
4438 NoSpaces);
Manuel Klimek80829bd2013-05-23 09:41:43 +00004439}
4440
Daniel Jasperd4a03db2013-08-22 15:00:41 +00004441TEST_F(FormatTest, FormatsBracedListsinColumnLayout) {
4442 verifyFormat("vector<int> x = { 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4443 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4444 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4445 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4446 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4447 " 1, 22, 333, 4444, 55555, 666666, 7777777 };");
4448 verifyFormat("vector<int> x = { 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4449 " // line comment\n"
4450 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4451 " 1, 22, 333, 4444, 55555,\n"
4452 " // line comment\n"
4453 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4454 " 1, 22, 333, 4444, 55555, 666666, 7777777 };");
4455 verifyFormat(
4456 "vector<int> x = { 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4457 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4458 " 1, 22, 333, 4444, 55555, 666666, // comment\n"
4459 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
4460 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
4461 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
4462 " 7777777 };");
4463 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
4464 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
4465 " X86::R8, X86::R9, X86::R10, X86::R11, 0\n"
4466 "};");
4467 verifyFormat("vector<int> x = { 1, 1, 1, 1,\n"
4468 " 1, 1, 1, 1 };",
4469 getLLVMStyleWithColumns(39));
4470 verifyFormat("vector<int> x = { 1, 1, 1, 1,\n"
4471 " 1, 1, 1, 1 };",
4472 getLLVMStyleWithColumns(38));
4473 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
4474 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1\n"
4475 "};",
4476 getLLVMStyleWithColumns(40));
Daniel Jaspered51c022013-08-23 10:05:49 +00004477
4478 // Trailing commas.
4479 verifyFormat("vector<int> x = { 1, 1, 1, 1,\n"
4480 " 1, 1, 1, 1, };",
4481 getLLVMStyleWithColumns(39));
4482 verifyFormat("vector<int> x = {\n"
4483 " 1, 1, 1, 1, 1, 1, 1, 1, //\n"
4484 "};",
4485 getLLVMStyleWithColumns(39));
Daniel Jasper332c6772013-08-26 08:10:17 +00004486 verifyFormat("vector<int> x = { 1, 1, 1, 1,\n"
4487 " 1, 1, 1, 1,\n"
4488 " /**/ /**/ };",
4489 getLLVMStyleWithColumns(39));
Daniel Jasper451f1e02013-08-27 08:43:47 +00004490 verifyFormat("return { { aaaaaaaaaaaaaaaaaaaaa }, { aaaaaaaaaaaaaaaaaaa },\n"
4491 " { aaaaaaaaaaaaaaaaaaaaa }, { aaaaaaaaaaaaaaaaa } };",
4492 getLLVMStyleWithColumns(60));
Daniel Jasperd4a03db2013-08-22 15:00:41 +00004493}
4494
Manuel Klimek517e8942013-01-11 17:54:10 +00004495TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
4496 verifyFormat("void f() { return 42; }");
4497 verifyFormat("void f() {\n"
4498 " // Comment\n"
4499 "}");
4500 verifyFormat("{\n"
4501 "#error {\n"
4502 " int a;\n"
4503 "}");
4504 verifyFormat("{\n"
4505 " int a;\n"
4506 "#error {\n"
4507 "}");
Daniel Jasper058f6f82013-05-16 10:17:39 +00004508 verifyFormat("void f() {} // comment");
4509 verifyFormat("void f() { int a; } // comment");
Daniel Jasper9e5b6c32013-05-16 16:54:34 +00004510 verifyFormat("void f() {\n"
4511 "} // comment",
4512 getLLVMStyleWithColumns(15));
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004513
4514 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
4515 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22));
4516
4517 verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
4518 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
Manuel Klimek517e8942013-01-11 17:54:10 +00004519}
4520
Manuel Klimek47ea7f62013-01-15 13:38:33 +00004521TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
4522 // Elaborate type variable declarations.
Manuel Klimek606e07e2013-01-11 18:13:04 +00004523 verifyFormat("struct foo a = { bar };\nint n;");
Manuel Klimek47ea7f62013-01-15 13:38:33 +00004524 verifyFormat("class foo a = { bar };\nint n;");
4525 verifyFormat("union foo a = { bar };\nint n;");
4526
4527 // Elaborate types inside function definitions.
4528 verifyFormat("struct foo f() {}\nint n;");
4529 verifyFormat("class foo f() {}\nint n;");
4530 verifyFormat("union foo f() {}\nint n;");
4531
4532 // Templates.
4533 verifyFormat("template <class X> void f() {}\nint n;");
4534 verifyFormat("template <struct X> void f() {}\nint n;");
4535 verifyFormat("template <union X> void f() {}\nint n;");
4536
4537 // Actual definitions...
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004538 verifyFormat("struct {\n} n;");
4539 verifyFormat(
4540 "template <template <class T, class Y>, class Z> class X {\n} n;");
Manuel Klimek47ea7f62013-01-15 13:38:33 +00004541 verifyFormat("union Z {\n int n;\n} x;");
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004542 verifyFormat("class MACRO Z {\n} n;");
4543 verifyFormat("class MACRO(X) Z {\n} n;");
4544 verifyFormat("class __attribute__(X) Z {\n} n;");
4545 verifyFormat("class __declspec(X) Z {\n} n;");
Manuel Klimekb8b1ce12013-02-06 15:57:54 +00004546 verifyFormat("class A##B##C {\n} n;");
Manuel Klimek3d712892013-10-07 09:15:41 +00004547 verifyFormat("class alignas(16) Z {\n} n;");
Manuel Klimek47ea7f62013-01-15 13:38:33 +00004548
Manuel Klimek7f5b0252013-01-21 10:17:14 +00004549 // Redefinition from nested context:
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004550 verifyFormat("class A::B::C {\n} n;");
Manuel Klimek7f5b0252013-01-21 10:17:14 +00004551
Manuel Klimek3a3408c2013-01-21 13:58:54 +00004552 // Template definitions.
Daniel Jasper5d823e32013-05-15 13:46:48 +00004553 verifyFormat(
4554 "template <typename F>\n"
4555 "Matcher(const Matcher<F> &Other,\n"
4556 " typename enable_if_c<is_base_of<F, T>::value &&\n"
4557 " !is_same<F, T>::value>::type * = 0)\n"
4558 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
4559
Manuel Klimek3a3408c2013-01-21 13:58:54 +00004560 // FIXME: This is still incorrectly handled at the formatter side.
Daniel Jasper0236dd02013-07-30 22:37:19 +00004561 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
Manuel Klimek3a3408c2013-01-21 13:58:54 +00004562
4563 // FIXME:
4564 // This now gets parsed incorrectly as class definition.
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004565 // verifyFormat("class A<int> f() {\n}\nint n;");
Manuel Klimek3a3408c2013-01-21 13:58:54 +00004566
Manuel Klimek47ea7f62013-01-15 13:38:33 +00004567 // Elaborate types where incorrectly parsing the structural element would
4568 // break the indent.
4569 verifyFormat("if (true)\n"
4570 " class X x;\n"
4571 "else\n"
4572 " f();\n");
Daniel Jasper6fe554e2013-03-20 15:12:38 +00004573
4574 // This is simply incomplete. Formatting is not important, but must not crash.
Daniel Jasper6315fec2013-08-13 10:58:30 +00004575 verifyFormat("class A:");
Manuel Klimek606e07e2013-01-11 18:13:04 +00004576}
4577
Manuel Klimek407a31a2013-01-15 15:50:27 +00004578TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
Manuel Klimekae76f7f2013-10-11 21:25:45 +00004579 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n",
4580 format("#error Leave all white!!!!! space* alone!\n"));
4581 EXPECT_EQ(
4582 "#warning Leave all white!!!!! space* alone!\n",
4583 format("#warning Leave all white!!!!! space* alone!\n"));
Manuel Klimek407a31a2013-01-15 15:50:27 +00004584 EXPECT_EQ("#error 1", format(" # error 1"));
4585 EXPECT_EQ("#warning 1", format(" # warning 1"));
4586}
4587
Daniel Jasperaae7bad2013-04-23 13:54:04 +00004588TEST_F(FormatTest, FormatHashIfExpressions) {
4589 // FIXME: Come up with a better indentation for #elif.
4590 verifyFormat(
4591 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n"
4592 " defined(BBBBBBBB)\n"
4593 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n"
4594 " defined(BBBBBBBB)\n"
4595 "#endif",
4596 getLLVMStyleWithColumns(65));
4597}
4598
Manuel Klimek525fe162013-01-18 14:04:34 +00004599TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
4600 FormatStyle AllowsMergedIf = getGoogleStyle();
4601 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true;
4602 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
4603 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
Manuel Klimek4c128122013-01-18 14:46:43 +00004604 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf);
4605 EXPECT_EQ("if (true) return 42;",
4606 format("if (true)\nreturn 42;", AllowsMergedIf));
4607 FormatStyle ShortMergedIf = AllowsMergedIf;
4608 ShortMergedIf.ColumnLimit = 25;
Daniel Jasper2972d042013-04-25 08:56:26 +00004609 verifyFormat("#define A \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004610 " if (true) return 42;",
4611 ShortMergedIf);
Daniel Jasper2972d042013-04-25 08:56:26 +00004612 verifyFormat("#define A \\\n"
4613 " f(); \\\n"
Manuel Klimek4c128122013-01-18 14:46:43 +00004614 " if (true)\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004615 "#define B",
4616 ShortMergedIf);
Daniel Jasper2972d042013-04-25 08:56:26 +00004617 verifyFormat("#define A \\\n"
4618 " f(); \\\n"
Manuel Klimek4c128122013-01-18 14:46:43 +00004619 " if (true)\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004620 "g();",
4621 ShortMergedIf);
Manuel Klimek0fbe0082013-01-21 14:16:56 +00004622 verifyFormat("{\n"
4623 "#ifdef A\n"
4624 " // Comment\n"
4625 " if (true) continue;\n"
4626 "#endif\n"
4627 " // Comment\n"
Manuel Klimekae76f7f2013-10-11 21:25:45 +00004628 " if (true) continue;\n"
4629 "}",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004630 ShortMergedIf);
Manuel Klimek525fe162013-01-18 14:04:34 +00004631}
4632
Manuel Klimek86721d22013-01-22 16:31:55 +00004633TEST_F(FormatTest, BlockCommentsInControlLoops) {
4634 verifyFormat("if (0) /* a comment in a strange place */ {\n"
4635 " f();\n"
4636 "}");
4637 verifyFormat("if (0) /* a comment in a strange place */ {\n"
4638 " f();\n"
4639 "} /* another comment */ else /* comment #3 */ {\n"
4640 " g();\n"
4641 "}");
4642 verifyFormat("while (0) /* a comment in a strange place */ {\n"
4643 " f();\n"
4644 "}");
4645 verifyFormat("for (;;) /* a comment in a strange place */ {\n"
4646 " f();\n"
4647 "}");
4648 verifyFormat("do /* a comment in a strange place */ {\n"
4649 " f();\n"
4650 "} /* another comment */ while (0);");
4651}
4652
4653TEST_F(FormatTest, BlockComments) {
4654 EXPECT_EQ("/* */ /* */ /* */\n/* */ /* */ /* */",
4655 format("/* *//* */ /* */\n/* *//* */ /* */"));
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004656 EXPECT_EQ("/* */ a /* */ b;", format(" /* */ a/* */ b;"));
Daniel Jasperc9346c92013-08-28 09:07:32 +00004657 EXPECT_EQ("#define A /*123*/ \\\n"
Manuel Klimek86721d22013-01-22 16:31:55 +00004658 " b\n"
4659 "/* */\n"
4660 "someCall(\n"
4661 " parameter);",
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00004662 format("#define A /*123*/ b\n"
Manuel Klimek86721d22013-01-22 16:31:55 +00004663 "/* */\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004664 "someCall(parameter);",
4665 getLLVMStyleWithColumns(15)));
Manuel Klimek86721d22013-01-22 16:31:55 +00004666
4667 EXPECT_EQ("#define A\n"
4668 "/* */ someCall(\n"
4669 " parameter);",
4670 format("#define A\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004671 "/* */someCall(parameter);",
4672 getLLVMStyleWithColumns(15)));
Daniel Jaspere2c482f2013-05-30 06:40:07 +00004673 EXPECT_EQ("/*\n**\n*/", format("/*\n**\n*/"));
Daniel Jasper92092702013-05-30 15:20:29 +00004674 EXPECT_EQ("/*\n"
4675 "*\n"
4676 " * aaaaaa\n"
Alexander Kornienko1659ded2013-07-08 14:12:07 +00004677 "*aaaaaa\n"
Daniel Jasper92092702013-05-30 15:20:29 +00004678 "*/",
4679 format("/*\n"
4680 "*\n"
4681 " * aaaaaa aaaaaa\n"
4682 "*/",
4683 getLLVMStyleWithColumns(10)));
Daniel Jaspercb4b40b2013-05-30 17:27:48 +00004684 EXPECT_EQ("/*\n"
4685 "**\n"
4686 "* aaaaaa\n"
Alexander Kornienko1659ded2013-07-08 14:12:07 +00004687 "*aaaaaa\n"
Daniel Jaspercb4b40b2013-05-30 17:27:48 +00004688 "*/",
4689 format("/*\n"
4690 "**\n"
4691 "* aaaaaa aaaaaa\n"
4692 "*/",
4693 getLLVMStyleWithColumns(10)));
Daniel Jasper2752ff32013-02-04 07:32:14 +00004694
Daniel Jasperfaab0d32013-02-27 09:47:53 +00004695 FormatStyle NoBinPacking = getLLVMStyle();
4696 NoBinPacking.BinPackParameters = false;
Daniel Jasper2752ff32013-02-04 07:32:14 +00004697 EXPECT_EQ("someFunction(1, /* comment 1 */\n"
4698 " 2, /* comment 2 */\n"
4699 " 3, /* comment 3 */\n"
Daniel Jaspercda16502013-02-04 08:34:57 +00004700 " aaaa,\n"
4701 " bbbb);",
Daniel Jasper2752ff32013-02-04 07:32:14 +00004702 format("someFunction (1, /* comment 1 */\n"
4703 " 2, /* comment 2 */ \n"
4704 " 3, /* comment 3 */\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004705 "aaaa, bbbb );",
Daniel Jasperfaab0d32013-02-27 09:47:53 +00004706 NoBinPacking));
Daniel Jasper36ba0ff2013-02-06 15:23:09 +00004707 verifyFormat(
4708 "bool aaaaaaaaaaaaa = /* comment: */ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4709 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
4710 EXPECT_EQ(
4711 "bool aaaaaaaaaaaaa = /* trailing comment */\n"
4712 " aaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4713 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;",
4714 format(
4715 "bool aaaaaaaaaaaaa = /* trailing comment */\n"
4716 " aaaaaaaaaaaaaaaaaaaaaaaaaaa||aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4717 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;"));
Daniel Jasper15417ef2013-02-06 20:07:35 +00004718 EXPECT_EQ(
4719 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n"
4720 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n"
4721 "int cccccccccccccccccccccccccccccc; /* comment */\n",
4722 format("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n"
4723 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n"
4724 "int cccccccccccccccccccccccccccccc; /* comment */\n"));
Daniel Jasper3a1847e2013-07-01 09:34:09 +00004725
4726 verifyFormat("void f(int * /* unused */) {}");
Alexander Kornienko1659ded2013-07-08 14:12:07 +00004727
4728 EXPECT_EQ("/*\n"
4729 " **\n"
4730 " */",
4731 format("/*\n"
4732 " **\n"
4733 " */"));
4734 EXPECT_EQ("/*\n"
4735 " *q\n"
4736 " */",
4737 format("/*\n"
4738 " *q\n"
4739 " */"));
4740 EXPECT_EQ("/*\n"
4741 " * q\n"
4742 " */",
4743 format("/*\n"
4744 " * q\n"
4745 " */"));
4746 EXPECT_EQ("/*\n"
4747 " **/",
4748 format("/*\n"
4749 " **/"));
4750 EXPECT_EQ("/*\n"
4751 " ***/",
4752 format("/*\n"
4753 " ***/"));
Manuel Klimek86721d22013-01-22 16:31:55 +00004754}
4755
Manuel Klimekb3507cd2013-02-06 16:40:56 +00004756TEST_F(FormatTest, BlockCommentsInMacros) {
4757 EXPECT_EQ("#define A \\\n"
4758 " { \\\n"
4759 " /* one line */ \\\n"
4760 " someCall();",
4761 format("#define A { \\\n"
4762 " /* one line */ \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004763 " someCall();",
4764 getLLVMStyleWithColumns(20)));
Manuel Klimekb3507cd2013-02-06 16:40:56 +00004765 EXPECT_EQ("#define A \\\n"
4766 " { \\\n"
4767 " /* previous */ \\\n"
4768 " /* one line */ \\\n"
4769 " someCall();",
4770 format("#define A { \\\n"
4771 " /* previous */ \\\n"
4772 " /* one line */ \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004773 " someCall();",
4774 getLLVMStyleWithColumns(20)));
Manuel Klimekb3507cd2013-02-06 16:40:56 +00004775}
4776
Manuel Klimekbe9ed772013-05-29 22:06:18 +00004777TEST_F(FormatTest, BlockCommentsAtEndOfLine) {
4778 EXPECT_EQ("a = {\n"
4779 " 1111 /* */\n"
4780 "};",
Alexander Kornienkoe3f11972013-06-12 19:04:12 +00004781 format("a = {1111 /* */\n"
Manuel Klimekbe9ed772013-05-29 22:06:18 +00004782 "};",
4783 getLLVMStyleWithColumns(15)));
4784 EXPECT_EQ("a = {\n"
4785 " 1111 /* */\n"
4786 "};",
Alexander Kornienkoe3f11972013-06-12 19:04:12 +00004787 format("a = {1111 /* */\n"
Manuel Klimekbe9ed772013-05-29 22:06:18 +00004788 "};",
4789 getLLVMStyleWithColumns(15)));
4790
4791 // FIXME: The formatting is still wrong here.
4792 EXPECT_EQ("a = {\n"
4793 " 1111 /* a\n"
4794 " */\n"
4795 "};",
Alexander Kornienkoe3f11972013-06-12 19:04:12 +00004796 format("a = {1111 /* a */\n"
Manuel Klimekbe9ed772013-05-29 22:06:18 +00004797 "};",
4798 getLLVMStyleWithColumns(15)));
4799}
4800
Manuel Klimekb3507cd2013-02-06 16:40:56 +00004801TEST_F(FormatTest, IndentLineCommentsInStartOfBlockAtEndOfFile) {
4802 // FIXME: This is not what we want...
4803 verifyFormat("{\n"
4804 "// a"
4805 "// b");
4806}
4807
Manuel Klimek092a2c72013-01-23 10:09:28 +00004808TEST_F(FormatTest, FormatStarDependingOnContext) {
Manuel Klimek70b03f42013-01-23 09:32:48 +00004809 verifyFormat("void f(int *a);");
4810 verifyFormat("void f() { f(fint * b); }");
Manuel Klimek836b58f2013-01-23 11:03:04 +00004811 verifyFormat("class A {\n void f(int *a);\n};");
4812 verifyFormat("class A {\n int *a;\n};");
4813 verifyFormat("namespace a {\n"
4814 "namespace b {\n"
4815 "class A {\n"
4816 " void f() {}\n"
4817 " int *a;\n"
4818 "};\n"
4819 "}\n"
4820 "}");
Manuel Klimek70b03f42013-01-23 09:32:48 +00004821}
4822
Manuel Klimek092a2c72013-01-23 10:09:28 +00004823TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
4824 verifyFormat("while");
4825 verifyFormat("operator");
4826}
4827
Nico Webercf4a79c2013-01-08 17:56:31 +00004828//===----------------------------------------------------------------------===//
4829// Objective-C tests.
4830//===----------------------------------------------------------------------===//
4831
Fariborz Jahanian154120c2012-12-20 19:54:13 +00004832TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
4833 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
4834 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
4835 format("-(NSUInteger)indexOfObject:(id)anObject;"));
Daniel Jaspercd162382013-01-07 13:26:07 +00004836 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
Fariborz Jahanian154120c2012-12-20 19:54:13 +00004837 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
4838 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
4839 format("-(NSInteger)Method3:(id)anObject;"));
4840 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
4841 format("-(NSInteger)Method4:(id)anObject;"));
4842 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
4843 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
4844 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
4845 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
Daniel Jaspercd162382013-01-07 13:26:07 +00004846 EXPECT_EQ(
4847 "- (void)sendAction:(SEL)aSelector to:(id)anObject forAllCells:(BOOL)flag;",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004848 format(
4849 "- (void)sendAction:(SEL)aSelector to:(id)anObject forAllCells:(BOOL)flag;"));
Fariborz Jahanian9b3f02c2012-12-21 22:51:18 +00004850
4851 // Very long objectiveC method declaration.
Daniel Jasper63d7ced2013-02-05 10:07:47 +00004852 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
4853 " inRange:(NSRange)range\n"
4854 " outRange:(NSRange)out_range\n"
4855 " outRange1:(NSRange)out_range1\n"
4856 " outRange2:(NSRange)out_range2\n"
4857 " outRange3:(NSRange)out_range3\n"
4858 " outRange4:(NSRange)out_range4\n"
4859 " outRange5:(NSRange)out_range5\n"
4860 " outRange6:(NSRange)out_range6\n"
4861 " outRange7:(NSRange)out_range7\n"
4862 " outRange8:(NSRange)out_range8\n"
4863 " outRange9:(NSRange)out_range9;");
Nico Webere0fd4292013-01-10 20:18:33 +00004864
4865 verifyFormat("- (int)sum:(vector<int>)numbers;");
Nico Weberaab60052013-01-17 06:14:50 +00004866 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
Nico Webere0fd4292013-01-10 20:18:33 +00004867 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
4868 // protocol lists (but not for template classes):
4869 //verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
Nico Webercd52bda2013-01-10 23:11:41 +00004870
Daniel Jasper431f5912013-05-28 08:33:00 +00004871 verifyFormat("- (int (*)())foo:(int (*)())f;");
4872 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
Nico Webercd52bda2013-01-10 23:11:41 +00004873
4874 // If there's no return type (very rare in practice!), LLVM and Google style
4875 // agree.
Daniel Jasper627707b2013-03-22 16:55:40 +00004876 verifyFormat("- foo;");
Nico Webercd52bda2013-01-10 23:11:41 +00004877 verifyFormat("- foo:(int)f;");
4878 verifyGoogleFormat("- foo:(int)foo;");
Fariborz Jahanian154120c2012-12-20 19:54:13 +00004879}
4880
Daniel Jasper886568d2013-01-09 08:36:49 +00004881TEST_F(FormatTest, FormatObjCBlocks) {
Daniel Jasper46ef8522013-01-10 13:08:12 +00004882 verifyFormat("int (^Block)(int, int);");
4883 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)");
Daniel Jasper886568d2013-01-09 08:36:49 +00004884}
4885
Nico Weber27d13672013-01-09 20:25:35 +00004886TEST_F(FormatTest, FormatObjCInterface) {
Nico Weber5f500df2013-01-10 20:12:55 +00004887 verifyFormat("@interface Foo : NSObject <NSSomeDelegate> {\n"
Nico Weber27d13672013-01-09 20:25:35 +00004888 "@public\n"
4889 " int field1;\n"
4890 "@protected\n"
4891 " int field2;\n"
4892 "@private\n"
4893 " int field3;\n"
4894 "@package\n"
4895 " int field4;\n"
4896 "}\n"
4897 "+ (id)init;\n"
4898 "@end");
4899
Nico Weber27d13672013-01-09 20:25:35 +00004900 verifyGoogleFormat("@interface Foo : NSObject<NSSomeDelegate> {\n"
4901 " @public\n"
4902 " int field1;\n"
4903 " @protected\n"
4904 " int field2;\n"
4905 " @private\n"
4906 " int field3;\n"
4907 " @package\n"
4908 " int field4;\n"
4909 "}\n"
Nico Weberaab60052013-01-17 06:14:50 +00004910 "+ (id)init;\n"
Nico Weber27d13672013-01-09 20:25:35 +00004911 "@end");
4912
Nico Weberf5ecfa52013-01-22 16:53:59 +00004913 verifyFormat("@interface /* wait for it */ Foo\n"
Nico Weber27d13672013-01-09 20:25:35 +00004914 "+ (id)init;\n"
4915 "// Look, a comment!\n"
4916 "- (int)answerWith:(int)i;\n"
4917 "@end");
4918
4919 verifyFormat("@interface Foo\n"
Nico Weber049c4472013-01-09 21:42:32 +00004920 "@end\n"
4921 "@interface Bar\n"
Nico Weber27d13672013-01-09 20:25:35 +00004922 "@end");
4923
4924 verifyFormat("@interface Foo : Bar\n"
4925 "+ (id)init;\n"
4926 "@end");
4927
Nico Weberf5ecfa52013-01-22 16:53:59 +00004928 verifyFormat("@interface Foo : /**/ Bar /**/ <Baz, /**/ Quux>\n"
Nico Weber27d13672013-01-09 20:25:35 +00004929 "+ (id)init;\n"
4930 "@end");
4931
Nico Weber5f500df2013-01-10 20:12:55 +00004932 verifyGoogleFormat("@interface Foo : Bar<Baz, Quux>\n"
Nico Weberaab60052013-01-17 06:14:50 +00004933 "+ (id)init;\n"
Nico Weber5f500df2013-01-10 20:12:55 +00004934 "@end");
4935
Nico Webered91bba2013-01-10 19:19:14 +00004936 verifyFormat("@interface Foo (HackStuff)\n"
Nico Weber27d13672013-01-09 20:25:35 +00004937 "+ (id)init;\n"
4938 "@end");
4939
Nico Webered91bba2013-01-10 19:19:14 +00004940 verifyFormat("@interface Foo ()\n"
Nico Weber27d13672013-01-09 20:25:35 +00004941 "+ (id)init;\n"
4942 "@end");
4943
Nico Weber5f500df2013-01-10 20:12:55 +00004944 verifyFormat("@interface Foo (HackStuff) <MyProtocol>\n"
Nico Weber27d13672013-01-09 20:25:35 +00004945 "+ (id)init;\n"
4946 "@end");
4947
Nico Weber5f500df2013-01-10 20:12:55 +00004948 verifyGoogleFormat("@interface Foo (HackStuff)<MyProtocol>\n"
Nico Weberaab60052013-01-17 06:14:50 +00004949 "+ (id)init;\n"
Nico Weber5f500df2013-01-10 20:12:55 +00004950 "@end");
4951
Manuel Klimekd5688cf2013-01-11 19:17:44 +00004952 verifyFormat("@interface Foo {\n"
4953 " int _i;\n"
4954 "}\n"
Nico Weber27d13672013-01-09 20:25:35 +00004955 "+ (id)init;\n"
4956 "@end");
4957
Manuel Klimekd5688cf2013-01-11 19:17:44 +00004958 verifyFormat("@interface Foo : Bar {\n"
4959 " int _i;\n"
4960 "}\n"
Nico Weber27d13672013-01-09 20:25:35 +00004961 "+ (id)init;\n"
4962 "@end");
4963
Manuel Klimekd5688cf2013-01-11 19:17:44 +00004964 verifyFormat("@interface Foo : Bar <Baz, Quux> {\n"
4965 " int _i;\n"
4966 "}\n"
Nico Weber27d13672013-01-09 20:25:35 +00004967 "+ (id)init;\n"
4968 "@end");
4969
Manuel Klimekd5688cf2013-01-11 19:17:44 +00004970 verifyFormat("@interface Foo (HackStuff) {\n"
4971 " int _i;\n"
4972 "}\n"
Nico Weber27d13672013-01-09 20:25:35 +00004973 "+ (id)init;\n"
4974 "@end");
4975
Manuel Klimekd5688cf2013-01-11 19:17:44 +00004976 verifyFormat("@interface Foo () {\n"
4977 " int _i;\n"
4978 "}\n"
Nico Weber27d13672013-01-09 20:25:35 +00004979 "+ (id)init;\n"
4980 "@end");
4981
Manuel Klimekd5688cf2013-01-11 19:17:44 +00004982 verifyFormat("@interface Foo (HackStuff) <MyProtocol> {\n"
4983 " int _i;\n"
4984 "}\n"
Nico Weber27d13672013-01-09 20:25:35 +00004985 "+ (id)init;\n"
4986 "@end");
4987}
4988
Nico Weber50767d82013-01-09 23:25:37 +00004989TEST_F(FormatTest, FormatObjCImplementation) {
4990 verifyFormat("@implementation Foo : NSObject {\n"
4991 "@public\n"
4992 " int field1;\n"
4993 "@protected\n"
4994 " int field2;\n"
4995 "@private\n"
4996 " int field3;\n"
4997 "@package\n"
4998 " int field4;\n"
4999 "}\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00005000 "+ (id)init {\n}\n"
Nico Weber50767d82013-01-09 23:25:37 +00005001 "@end");
5002
5003 verifyGoogleFormat("@implementation Foo : NSObject {\n"
5004 " @public\n"
5005 " int field1;\n"
5006 " @protected\n"
5007 " int field2;\n"
5008 " @private\n"
5009 " int field3;\n"
5010 " @package\n"
5011 " int field4;\n"
5012 "}\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00005013 "+ (id)init {\n}\n"
Nico Weber50767d82013-01-09 23:25:37 +00005014 "@end");
5015
5016 verifyFormat("@implementation Foo\n"
5017 "+ (id)init {\n"
Daniel Jasper6f5bb2c2013-01-14 16:24:39 +00005018 " if (true)\n"
5019 " return nil;\n"
Nico Weber50767d82013-01-09 23:25:37 +00005020 "}\n"
5021 "// Look, a comment!\n"
Manuel Klimekd5688cf2013-01-11 19:17:44 +00005022 "- (int)answerWith:(int)i {\n"
5023 " return i;\n"
5024 "}\n"
Nico Weber67015ed2013-01-11 21:14:08 +00005025 "+ (int)answerWith:(int)i {\n"
5026 " return i;\n"
5027 "}\n"
Nico Weber50767d82013-01-09 23:25:37 +00005028 "@end");
5029
5030 verifyFormat("@implementation Foo\n"
5031 "@end\n"
5032 "@implementation Bar\n"
5033 "@end");
5034
5035 verifyFormat("@implementation Foo : Bar\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00005036 "+ (id)init {\n}\n"
5037 "- (void)foo {\n}\n"
Nico Weber50767d82013-01-09 23:25:37 +00005038 "@end");
5039
Manuel Klimekd5688cf2013-01-11 19:17:44 +00005040 verifyFormat("@implementation Foo {\n"
5041 " int _i;\n"
5042 "}\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00005043 "+ (id)init {\n}\n"
Nico Weber50767d82013-01-09 23:25:37 +00005044 "@end");
5045
Manuel Klimekd5688cf2013-01-11 19:17:44 +00005046 verifyFormat("@implementation Foo : Bar {\n"
5047 " int _i;\n"
5048 "}\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00005049 "+ (id)init {\n}\n"
Nico Weber50767d82013-01-09 23:25:37 +00005050 "@end");
5051
Nico Webered91bba2013-01-10 19:19:14 +00005052 verifyFormat("@implementation Foo (HackStuff)\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00005053 "+ (id)init {\n}\n"
Nico Weber50767d82013-01-09 23:25:37 +00005054 "@end");
Daniel Jasper7186ccc2013-08-28 08:04:23 +00005055 verifyFormat("@implementation ObjcClass\n"
5056 "- (void)method;\n"
5057 "{}\n"
5058 "@end");
Nico Weber50767d82013-01-09 23:25:37 +00005059}
5060
Nico Weber1abe6ea2013-01-09 21:15:03 +00005061TEST_F(FormatTest, FormatObjCProtocol) {
5062 verifyFormat("@protocol Foo\n"
5063 "@property(weak) id delegate;\n"
5064 "- (NSUInteger)numberOfThings;\n"
5065 "@end");
5066
Nico Weber5f500df2013-01-10 20:12:55 +00005067 verifyFormat("@protocol MyProtocol <NSObject>\n"
Nico Weber1abe6ea2013-01-09 21:15:03 +00005068 "- (NSUInteger)numberOfThings;\n"
5069 "@end");
5070
Nico Weber5f500df2013-01-10 20:12:55 +00005071 verifyGoogleFormat("@protocol MyProtocol<NSObject>\n"
Nico Weberaab60052013-01-17 06:14:50 +00005072 "- (NSUInteger)numberOfThings;\n"
Nico Weber5f500df2013-01-10 20:12:55 +00005073 "@end");
5074
Nico Weber1abe6ea2013-01-09 21:15:03 +00005075 verifyFormat("@protocol Foo;\n"
5076 "@protocol Bar;\n");
Nico Weber049c4472013-01-09 21:42:32 +00005077
5078 verifyFormat("@protocol Foo\n"
5079 "@end\n"
5080 "@protocol Bar\n"
5081 "@end");
Nico Weberb530fa32013-01-10 00:25:19 +00005082
5083 verifyFormat("@protocol myProtocol\n"
5084 "- (void)mandatoryWithInt:(int)i;\n"
5085 "@optional\n"
5086 "- (void)optional;\n"
5087 "@required\n"
5088 "- (void)required;\n"
Nico Weber880e5382013-01-10 00:42:07 +00005089 "@optional\n"
5090 "@property(assign) int madProp;\n"
Nico Weberb530fa32013-01-10 00:25:19 +00005091 "@end\n");
Daniel Jasperaa9e7b12013-08-01 13:46:58 +00005092
5093 verifyFormat("@property(nonatomic, assign, readonly)\n"
5094 " int *looooooooooooooooooooooooooooongNumber;\n"
5095 "@property(nonatomic, assign, readonly)\n"
5096 " NSString *looooooooooooooooooooooooooooongName;");
Nico Weber1abe6ea2013-01-09 21:15:03 +00005097}
5098
Daniel Jasper63d7ced2013-02-05 10:07:47 +00005099TEST_F(FormatTest, FormatObjCMethodDeclarations) {
5100 verifyFormat("- (void)doSomethingWith:(GTMFoo *)theFoo\n"
5101 " rect:(NSRect)theRect\n"
5102 " interval:(float)theInterval {\n"
5103 "}");
5104 verifyFormat("- (void)shortf:(GTMFoo *)theFoo\n"
5105 " longKeyword:(NSRect)theRect\n"
5106 " evenLongerKeyword:(float)theInterval\n"
5107 " error:(NSError **)theError {\n"
5108 "}");
5109}
5110
Nico Weberbcfdd262013-01-12 06:18:40 +00005111TEST_F(FormatTest, FormatObjCMethodExpr) {
5112 verifyFormat("[foo bar:baz];");
5113 verifyFormat("return [foo bar:baz];");
5114 verifyFormat("f([foo bar:baz]);");
5115 verifyFormat("f(2, [foo bar:baz]);");
5116 verifyFormat("f(2, a ? b : c);");
5117 verifyFormat("[[self initWithInt:4] bar:[baz quux:arrrr]];");
5118
Nico Weberee0feec2013-02-05 16:21:00 +00005119 // Unary operators.
5120 verifyFormat("int a = +[foo bar:baz];");
5121 verifyFormat("int a = -[foo bar:baz];");
5122 verifyFormat("int a = ![foo bar:baz];");
5123 verifyFormat("int a = ~[foo bar:baz];");
5124 verifyFormat("int a = ++[foo bar:baz];");
5125 verifyFormat("int a = --[foo bar:baz];");
5126 verifyFormat("int a = sizeof [foo bar:baz];");
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00005127 verifyFormat("int a = alignof [foo bar:baz];", getGoogleStyle());
Nico Webere8a97982013-02-06 06:20:11 +00005128 verifyFormat("int a = &[foo bar:baz];");
5129 verifyFormat("int a = *[foo bar:baz];");
Nico Weberee0feec2013-02-05 16:21:00 +00005130 // FIXME: Make casts work, without breaking f()[4].
Nico Weber4c2cc602013-02-13 03:48:27 +00005131 //verifyFormat("int a = (int)[foo bar:baz];");
Nico Webere0dc7c72013-02-13 04:40:03 +00005132 //verifyFormat("return (int)[foo bar:baz];");
5133 //verifyFormat("(void)[foo bar:baz];");
Nico Weber4c2cc602013-02-13 03:48:27 +00005134 verifyFormat("return (MyType *)[self.tableView cellForRowAtIndexPath:cell];");
Nico Weberee0feec2013-02-05 16:21:00 +00005135
5136 // Binary operators.
Nico Weberbcfdd262013-01-12 06:18:40 +00005137 verifyFormat("[foo bar:baz], [foo bar:baz];");
5138 verifyFormat("[foo bar:baz] = [foo bar:baz];");
5139 verifyFormat("[foo bar:baz] *= [foo bar:baz];");
5140 verifyFormat("[foo bar:baz] /= [foo bar:baz];");
5141 verifyFormat("[foo bar:baz] %= [foo bar:baz];");
5142 verifyFormat("[foo bar:baz] += [foo bar:baz];");
5143 verifyFormat("[foo bar:baz] -= [foo bar:baz];");
5144 verifyFormat("[foo bar:baz] <<= [foo bar:baz];");
5145 verifyFormat("[foo bar:baz] >>= [foo bar:baz];");
5146 verifyFormat("[foo bar:baz] &= [foo bar:baz];");
5147 verifyFormat("[foo bar:baz] ^= [foo bar:baz];");
5148 verifyFormat("[foo bar:baz] |= [foo bar:baz];");
5149 verifyFormat("[foo bar:baz] ? [foo bar:baz] : [foo bar:baz];");
5150 verifyFormat("[foo bar:baz] || [foo bar:baz];");
5151 verifyFormat("[foo bar:baz] && [foo bar:baz];");
5152 verifyFormat("[foo bar:baz] | [foo bar:baz];");
5153 verifyFormat("[foo bar:baz] ^ [foo bar:baz];");
5154 verifyFormat("[foo bar:baz] & [foo bar:baz];");
5155 verifyFormat("[foo bar:baz] == [foo bar:baz];");
5156 verifyFormat("[foo bar:baz] != [foo bar:baz];");
5157 verifyFormat("[foo bar:baz] >= [foo bar:baz];");
5158 verifyFormat("[foo bar:baz] <= [foo bar:baz];");
5159 verifyFormat("[foo bar:baz] > [foo bar:baz];");
5160 verifyFormat("[foo bar:baz] < [foo bar:baz];");
5161 verifyFormat("[foo bar:baz] >> [foo bar:baz];");
5162 verifyFormat("[foo bar:baz] << [foo bar:baz];");
5163 verifyFormat("[foo bar:baz] - [foo bar:baz];");
5164 verifyFormat("[foo bar:baz] + [foo bar:baz];");
5165 verifyFormat("[foo bar:baz] * [foo bar:baz];");
5166 verifyFormat("[foo bar:baz] / [foo bar:baz];");
5167 verifyFormat("[foo bar:baz] % [foo bar:baz];");
5168 // Whew!
5169
Nico Weberc2e6d2a2013-02-11 15:32:15 +00005170 verifyFormat("return in[42];");
5171 verifyFormat("for (id foo in [self getStuffFor:bla]) {\n"
5172 "}");
5173
Nico Weberbcfdd262013-01-12 06:18:40 +00005174 verifyFormat("[self stuffWithInt:(4 + 2) float:4.5];");
5175 verifyFormat("[self stuffWithInt:a ? b : c float:4.5];");
5176 verifyFormat("[self stuffWithInt:a ? [self foo:bar] : c];");
5177 verifyFormat("[self stuffWithInt:a ? (e ? f : g) : c];");
5178 verifyFormat("[cond ? obj1 : obj2 methodWithParam:param]");
Nico Weber6292dd42013-01-12 23:41:33 +00005179 verifyFormat("[button setAction:@selector(zoomOut:)];");
Nico Webercd458332013-01-12 23:48:49 +00005180 verifyFormat("[color getRed:&r green:&g blue:&b alpha:&a];");
Daniel Jasper63d7ced2013-02-05 10:07:47 +00005181
Nico Weberbcfdd262013-01-12 06:18:40 +00005182 verifyFormat("arr[[self indexForFoo:a]];");
5183 verifyFormat("throw [self errorFor:a];");
5184 verifyFormat("@throw [self errorFor:a];");
5185
Nico Weber465e8612013-06-25 00:55:57 +00005186 verifyFormat("[(id)foo bar:(id)baz quux:(id)snorf];");
5187 verifyFormat("[(id)foo bar:(id) ? baz : quux];");
5188 verifyFormat("4 > 4 ? (id)a : (id)baz;");
5189
Nico Webere8ccc812013-01-12 22:48:47 +00005190 // This tests that the formatter doesn't break after "backing" but before ":",
5191 // which would be at 80 columns.
Nico Weberbcfdd262013-01-12 06:18:40 +00005192 verifyFormat(
5193 "void f() {\n"
Daniel Jasper63d7ced2013-02-05 10:07:47 +00005194 " if ((self = [super initWithContentRect:contentRect\n"
Daniel Jasper1eaa9972013-08-01 23:13:03 +00005195 " styleMask:styleMask ?: otherMask\n"
Daniel Jasper63d7ced2013-02-05 10:07:47 +00005196 " backing:NSBackingStoreBuffered\n"
5197 " defer:YES]))");
5198
Daniel Jasper4e778092013-02-06 10:05:46 +00005199 verifyFormat(
5200 "[foo checkThatBreakingAfterColonWorksOk:\n"
Daniel Jasper1eaa9972013-08-01 23:13:03 +00005201 " [bar ifItDoes:reduceOverallLineLengthLikeInThisCase]];");
Daniel Jasper63d7ced2013-02-05 10:07:47 +00005202
5203 verifyFormat("[myObj short:arg1 // Force line break\n"
Daniel Jasper1eaa9972013-08-01 23:13:03 +00005204 " longKeyword:arg2 != nil ? arg2 : @\"longKeyword\"\n"
5205 " evenLongerKeyword:arg3 ?: @\"evenLongerKeyword\"\n"
Daniel Jasper63d7ced2013-02-05 10:07:47 +00005206 " error:arg4];");
5207 verifyFormat(
5208 "void f() {\n"
5209 " popup_window_.reset([[RenderWidgetPopupWindow alloc]\n"
5210 " initWithContentRect:NSMakeRect(origin_global.x, origin_global.y,\n"
5211 " pos.width(), pos.height())\n"
5212 " styleMask:NSBorderlessWindowMask\n"
5213 " backing:NSBackingStoreBuffered\n"
5214 " defer:NO]);\n"
5215 "}");
Daniel Jasper4e778092013-02-06 10:05:46 +00005216 verifyFormat("[contentsContainer replaceSubview:[subviews objectAtIndex:0]\n"
5217 " with:contentsNativeView];");
5218
5219 verifyFormat(
5220 "[pboard addTypes:[NSArray arrayWithObject:kBookmarkButtonDragType]\n"
5221 " owner:nillllll];");
5222
Daniel Jasper4e778092013-02-06 10:05:46 +00005223 verifyFormat(
Daniel Jasperce3d1a62013-02-08 08:22:00 +00005224 "[pboard setData:[NSData dataWithBytes:&button length:sizeof(button)]\n"
Daniel Jasper4e778092013-02-06 10:05:46 +00005225 " forType:kBookmarkButtonDragType];");
5226
5227 verifyFormat("[defaultCenter addObserver:self\n"
5228 " selector:@selector(willEnterFullscreen)\n"
5229 " name:kWillEnterFullscreenNotification\n"
5230 " object:nil];");
Daniel Jasper9e9e6e02013-02-06 16:00:26 +00005231 verifyFormat("[image_rep drawInRect:drawRect\n"
5232 " fromRect:NSZeroRect\n"
5233 " operation:NSCompositeCopy\n"
5234 " fraction:1.0\n"
5235 " respectFlipped:NO\n"
5236 " hints:nil];");
Nico Weber4ed7f3e2013-02-06 16:54:35 +00005237
5238 verifyFormat(
5239 "scoped_nsobject<NSTextField> message(\n"
5240 " // The frame will be fixed up when |-setMessageText:| is called.\n"
5241 " [[NSTextField alloc] initWithFrame:NSMakeRect(0, 0, 0, 0)]);");
Daniel Jasper1eaa9972013-08-01 23:13:03 +00005242 verifyFormat("[self aaaaaa:bbbbbbbbbbbbb\n"
5243 " aaaaaaaaaa:bbbbbbbbbbbbbbbbb\n"
5244 " aaaaa:bbbbbbbbbbb + bbbbbbbbbbbb\n"
5245 " aaaa:bbb];");
Nico Weberbcfdd262013-01-12 06:18:40 +00005246}
5247
Nico Weber581f5572013-01-07 15:56:25 +00005248TEST_F(FormatTest, ObjCAt) {
Nico Weber4a293a22013-01-07 16:07:07 +00005249 verifyFormat("@autoreleasepool");
Nico Weberd0af4b42013-01-07 16:14:28 +00005250 verifyFormat("@catch");
5251 verifyFormat("@class");
Nico Weber4a293a22013-01-07 16:07:07 +00005252 verifyFormat("@compatibility_alias");
5253 verifyFormat("@defs");
Nico Weberefcfe732013-01-07 15:17:23 +00005254 verifyFormat("@dynamic");
Nico Weber4a293a22013-01-07 16:07:07 +00005255 verifyFormat("@encode");
5256 verifyFormat("@end");
5257 verifyFormat("@finally");
5258 verifyFormat("@implementation");
5259 verifyFormat("@import");
5260 verifyFormat("@interface");
5261 verifyFormat("@optional");
5262 verifyFormat("@package");
Nico Weberd0af4b42013-01-07 16:14:28 +00005263 verifyFormat("@private");
Nico Weber4a293a22013-01-07 16:07:07 +00005264 verifyFormat("@property");
Nico Weberd0af4b42013-01-07 16:14:28 +00005265 verifyFormat("@protected");
Nico Weber4a293a22013-01-07 16:07:07 +00005266 verifyFormat("@protocol");
Nico Weberd0af4b42013-01-07 16:14:28 +00005267 verifyFormat("@public");
Nico Weber4a293a22013-01-07 16:07:07 +00005268 verifyFormat("@required");
5269 verifyFormat("@selector");
5270 verifyFormat("@synchronized");
5271 verifyFormat("@synthesize");
Nico Weberd0af4b42013-01-07 16:14:28 +00005272 verifyFormat("@throw");
5273 verifyFormat("@try");
Nico Weber4a293a22013-01-07 16:07:07 +00005274
Nico Weber581f5572013-01-07 15:56:25 +00005275 EXPECT_EQ("@interface", format("@ interface"));
5276
5277 // The precise formatting of this doesn't matter, nobody writes code like
5278 // this.
5279 verifyFormat("@ /*foo*/ interface");
Nico Weberefcfe732013-01-07 15:17:23 +00005280}
5281
Nico Weberc31689a2013-01-08 19:15:23 +00005282TEST_F(FormatTest, ObjCSnippets) {
Manuel Klimekd5688cf2013-01-11 19:17:44 +00005283 verifyFormat("@autoreleasepool {\n"
5284 " foo();\n"
5285 "}");
Nico Webercf4a79c2013-01-08 17:56:31 +00005286 verifyFormat("@class Foo, Bar;");
Nico Weberc31689a2013-01-08 19:15:23 +00005287 verifyFormat("@compatibility_alias AliasName ExistingClass;");
Nico Webercf4a79c2013-01-08 17:56:31 +00005288 verifyFormat("@dynamic textColor;");
Nico Weber5dfe9b42013-01-18 05:11:47 +00005289 verifyFormat("char *buf1 = @encode(int *);");
5290 verifyFormat("char *buf1 = @encode(typeof(4 * 5));");
Nico Weber95e8e462013-02-12 16:17:07 +00005291 verifyFormat("char *buf1 = @encode(int **);");
Nico Weber3a2673e2013-01-08 20:16:23 +00005292 verifyFormat("Protocol *proto = @protocol(p1);");
Nico Weber6a21a552013-01-18 02:43:57 +00005293 verifyFormat("SEL s = @selector(foo:);");
Manuel Klimekd5688cf2013-01-11 19:17:44 +00005294 verifyFormat("@synchronized(self) {\n"
5295 " f();\n"
5296 "}");
Nico Webercf4a79c2013-01-08 17:56:31 +00005297
Nico Weber70848232013-01-10 21:30:42 +00005298 verifyFormat("@synthesize dropArrowPosition = dropArrowPosition_;");
5299 verifyGoogleFormat("@synthesize dropArrowPosition = dropArrowPosition_;");
5300
Nico Webercf4a79c2013-01-08 17:56:31 +00005301 verifyFormat("@property(assign, nonatomic) CGFloat hoverAlpha;");
Nico Weber70848232013-01-10 21:30:42 +00005302 verifyFormat("@property(assign, getter=isEditable) BOOL editable;");
5303 verifyGoogleFormat("@property(assign, getter=isEditable) BOOL editable;");
Nico Weber10fc2c62013-06-25 00:25:40 +00005304
5305 verifyFormat("@import foo.bar;\n"
5306 "@import baz;");
Nico Webercf4a79c2013-01-08 17:56:31 +00005307}
5308
Nico Weber712f5b32013-02-07 00:19:29 +00005309TEST_F(FormatTest, ObjCLiterals) {
5310 verifyFormat("@\"String\"");
5311 verifyFormat("@1");
5312 verifyFormat("@+4.8");
5313 verifyFormat("@-4");
5314 verifyFormat("@1LL");
5315 verifyFormat("@.5");
5316 verifyFormat("@'c'");
5317 verifyFormat("@true");
5318
5319 verifyFormat("NSNumber *smallestInt = @(-INT_MAX - 1);");
5320 verifyFormat("NSNumber *piOverTwo = @(M_PI / 2);");
5321 verifyFormat("NSNumber *favoriteColor = @(Green);");
5322 verifyFormat("NSString *path = @(getenv(\"PATH\"));");
5323
Nico Weber712f5b32013-02-07 00:19:29 +00005324 verifyFormat("@[");
Nico Weber051860e2013-02-10 02:08:05 +00005325 verifyFormat("@[]");
5326 verifyFormat(
5327 "NSArray *array = @[ @\" Hey \", NSApp, [NSNumber numberWithInt:42] ];");
5328 verifyFormat("return @[ @3, @[], @[ @4, @5 ] ];");
5329
Nico Weber712f5b32013-02-07 00:19:29 +00005330 verifyFormat("@{");
Nico Weberd74fcdb2013-02-10 20:35:35 +00005331 verifyFormat("@{}");
5332 verifyFormat("@{ @\"one\" : @1 }");
5333 verifyFormat("return @{ @\"one\" : @1 };");
5334 verifyFormat("@{ @\"one\" : @1, }");
Manuel Klimek67d080d2013-04-12 14:13:36 +00005335
Daniel Jasper88959b72013-05-28 18:50:02 +00005336 verifyFormat("@{ @\"one\" : @{ @2 : @1 } }");
5337 verifyFormat("@{ @\"one\" : @{ @2 : @1 }, }");
Manuel Klimek67d080d2013-04-12 14:13:36 +00005338
Nico Weberd74fcdb2013-02-10 20:35:35 +00005339 verifyFormat("@{ 1 > 2 ? @\"one\" : @\"two\" : 1 > 2 ? @1 : @2 }");
5340 verifyFormat("[self setDict:@{}");
5341 verifyFormat("[self setDict:@{ @1 : @2 }");
5342 verifyFormat("NSLog(@\"%@\", @{ @1 : @2, @2 : @3 }[@1]);");
5343 verifyFormat(
5344 "NSDictionary *masses = @{ @\"H\" : @1.0078, @\"He\" : @4.0026 };");
Nico Webere6262002013-02-10 20:39:05 +00005345 verifyFormat(
5346 "NSDictionary *settings = @{ AVEncoderKey : @(AVAudioQualityMax) };");
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005347
Nico Weberd74fcdb2013-02-10 20:35:35 +00005348 // FIXME: Nested and multi-line array and dictionary literals need more work.
Nico Weber0ac717b2013-02-10 20:48:24 +00005349 verifyFormat(
5350 "NSDictionary *d = @{ @\"nam\" : NSUserNam(), @\"dte\" : [NSDate date],\n"
5351 " @\"processInfo\" : [NSProcessInfo processInfo] };");
Nico Weberf2ff8122013-05-26 05:39:26 +00005352 verifyFormat(
5353 "@{ NSFontAttributeNameeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee :\n"
5354 " regularFont, };");
5355
Nico Weber712f5b32013-02-07 00:19:29 +00005356}
5357
Manuel Klimek547d5db2013-02-08 17:38:27 +00005358TEST_F(FormatTest, ReformatRegionAdjustsIndent) {
5359 EXPECT_EQ("{\n"
5360 "{\n"
5361 "a;\n"
5362 "b;\n"
5363 "}\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005364 "}",
5365 format("{\n"
5366 "{\n"
5367 "a;\n"
5368 " b;\n"
5369 "}\n"
5370 "}",
5371 13, 2, getLLVMStyle()));
Manuel Klimek547d5db2013-02-08 17:38:27 +00005372 EXPECT_EQ("{\n"
5373 "{\n"
5374 " a;\n"
5375 "b;\n"
5376 "}\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005377 "}",
5378 format("{\n"
5379 "{\n"
5380 " a;\n"
5381 "b;\n"
5382 "}\n"
5383 "}",
5384 9, 2, getLLVMStyle()));
Manuel Klimek547d5db2013-02-08 17:38:27 +00005385 EXPECT_EQ("{\n"
5386 "{\n"
5387 "public:\n"
5388 " b;\n"
5389 "}\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005390 "}",
5391 format("{\n"
5392 "{\n"
5393 "public:\n"
5394 " b;\n"
5395 "}\n"
5396 "}",
5397 17, 2, getLLVMStyle()));
Manuel Klimek547d5db2013-02-08 17:38:27 +00005398 EXPECT_EQ("{\n"
5399 "{\n"
5400 "a;\n"
5401 "}\n"
5402 "{\n"
Daniel Jasper1fb8d882013-05-14 09:30:02 +00005403 " b; //\n"
Manuel Klimek547d5db2013-02-08 17:38:27 +00005404 "}\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005405 "}",
5406 format("{\n"
5407 "{\n"
5408 "a;\n"
5409 "}\n"
5410 "{\n"
Daniel Jasper1fb8d882013-05-14 09:30:02 +00005411 " b; //\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005412 "}\n"
5413 "}",
5414 22, 2, getLLVMStyle()));
Manuel Klimek52635ff2013-02-08 19:53:32 +00005415 EXPECT_EQ(" {\n"
Daniel Jasper1fb8d882013-05-14 09:30:02 +00005416 " a; //\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005417 " }",
5418 format(" {\n"
Daniel Jasper1fb8d882013-05-14 09:30:02 +00005419 "a; //\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005420 " }",
5421 4, 2, getLLVMStyle()));
Daniel Jasper9ece2bb2013-02-12 16:51:23 +00005422 EXPECT_EQ("void f() {}\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005423 "void g() {}",
5424 format("void f() {}\n"
5425 "void g() {}",
5426 13, 0, getLLVMStyle()));
Daniel Jasper83a90e52013-03-20 14:31:47 +00005427 EXPECT_EQ("int a; // comment\n"
5428 " // line 2\n"
5429 "int b;",
5430 format("int a; // comment\n"
5431 " // line 2\n"
5432 " int b;",
5433 35, 0, getLLVMStyle()));
Daniel Jasper15ec3a82013-07-11 21:27:40 +00005434 EXPECT_EQ(" int a;\n"
5435 " void\n"
5436 " ffffff() {\n"
5437 " }",
5438 format(" int a;\n"
5439 "void ffffff() {}",
5440 11, 0, getLLVMStyleWithColumns(11)));
Manuel Klimek52635ff2013-02-08 19:53:32 +00005441}
Manuel Klimek547d5db2013-02-08 17:38:27 +00005442
Manuel Klimek8092a942013-02-20 10:15:13 +00005443TEST_F(FormatTest, BreakStringLiterals) {
5444 EXPECT_EQ("\"some text \"\n"
5445 "\"other\";",
5446 format("\"some text other\";", getLLVMStyleWithColumns(12)));
Alexander Kornienko919398b2013-04-17 17:34:05 +00005447 EXPECT_EQ("\"some text \"\n"
5448 "\"other\";",
5449 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
Manuel Klimek8092a942013-02-20 10:15:13 +00005450 EXPECT_EQ(
5451 "#define A \\\n"
5452 " \"some \" \\\n"
5453 " \"text \" \\\n"
5454 " \"other\";",
5455 format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
5456 EXPECT_EQ(
5457 "#define A \\\n"
5458 " \"so \" \\\n"
5459 " \"text \" \\\n"
5460 " \"other\";",
5461 format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
5462
5463 EXPECT_EQ("\"some text\"",
5464 format("\"some text\"", getLLVMStyleWithColumns(1)));
5465 EXPECT_EQ("\"some text\"",
5466 format("\"some text\"", getLLVMStyleWithColumns(11)));
5467 EXPECT_EQ("\"some \"\n"
5468 "\"text\"",
5469 format("\"some text\"", getLLVMStyleWithColumns(10)));
5470 EXPECT_EQ("\"some \"\n"
5471 "\"text\"",
5472 format("\"some text\"", getLLVMStyleWithColumns(7)));
Manuel Klimekaf31fd72013-03-01 13:14:08 +00005473 EXPECT_EQ("\"some\"\n"
Alexander Kornienko70ce7882013-04-15 14:28:00 +00005474 "\" tex\"\n"
5475 "\"t\"",
Manuel Klimek8092a942013-02-20 10:15:13 +00005476 format("\"some text\"", getLLVMStyleWithColumns(6)));
Manuel Klimek00905912013-03-04 20:03:38 +00005477 EXPECT_EQ("\"some\"\n"
5478 "\" tex\"\n"
5479 "\" and\"",
5480 format("\"some tex and\"", getLLVMStyleWithColumns(6)));
5481 EXPECT_EQ("\"some\"\n"
5482 "\"/tex\"\n"
5483 "\"/and\"",
5484 format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
Manuel Klimek8092a942013-02-20 10:15:13 +00005485
5486 EXPECT_EQ("variable =\n"
5487 " \"long string \"\n"
5488 " \"literal\";",
5489 format("variable = \"long string literal\";",
5490 getLLVMStyleWithColumns(20)));
5491
5492 EXPECT_EQ("variable = f(\n"
5493 " \"long string \"\n"
Daniel Jasperfaab0d32013-02-27 09:47:53 +00005494 " \"literal\",\n"
5495 " short,\n"
Manuel Klimek8092a942013-02-20 10:15:13 +00005496 " loooooooooooooooooooong);",
5497 format("variable = f(\"long string literal\", short, "
5498 "loooooooooooooooooooong);",
5499 getLLVMStyleWithColumns(20)));
Alexander Kornienko22d0e292013-06-17 12:59:44 +00005500
5501 EXPECT_EQ("f(g(\"long string \"\n"
5502 " \"literal\"),\n"
5503 " b);",
5504 format("f(g(\"long string literal\"), b);",
5505 getLLVMStyleWithColumns(20)));
5506 EXPECT_EQ("f(g(\"long string \"\n"
5507 " \"literal\",\n"
5508 " a),\n"
5509 " b);",
5510 format("f(g(\"long string literal\", a), b);",
5511 getLLVMStyleWithColumns(20)));
Manuel Klimek8092a942013-02-20 10:15:13 +00005512 EXPECT_EQ(
5513 "f(\"one two\".split(\n"
Daniel Jasper13d2aa52013-08-30 08:29:25 +00005514 " variable));",
Manuel Klimek8092a942013-02-20 10:15:13 +00005515 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
5516 EXPECT_EQ("f(\"one two three four five six \"\n"
5517 " \"seven\".split(\n"
5518 " really_looooong_variable));",
5519 format("f(\"one two three four five six seven\"."
5520 "split(really_looooong_variable));",
5521 getLLVMStyleWithColumns(33)));
5522
5523 EXPECT_EQ("f(\"some \"\n"
5524 " \"text\",\n"
5525 " other);",
5526 format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
Daniel Jasper0fb382b2013-02-26 12:52:34 +00005527
5528 // Only break as a last resort.
5529 verifyFormat(
5530 "aaaaaaaaaaaaaaaaaaaa(\n"
5531 " aaaaaaaaaaaaaaaaaaaa,\n"
5532 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
Manuel Klimekaf31fd72013-03-01 13:14:08 +00005533
5534 EXPECT_EQ(
5535 "\"splitmea\"\n"
Manuel Klimekbc30c712013-03-01 13:29:19 +00005536 "\"trandomp\"\n"
5537 "\"oint\"",
Manuel Klimekaf31fd72013-03-01 13:14:08 +00005538 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
Manuel Klimekbc30c712013-03-01 13:29:19 +00005539
5540 EXPECT_EQ(
5541 "\"split/\"\n"
5542 "\"pathat/\"\n"
5543 "\"slashes\"",
5544 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
Daniel Jasper2972d042013-04-25 08:56:26 +00005545
Alexander Kornienkof2b2c7d2013-06-19 14:22:47 +00005546 EXPECT_EQ(
5547 "\"split/\"\n"
5548 "\"pathat/\"\n"
5549 "\"slashes\"",
5550 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
5551 EXPECT_EQ("\"split at \"\n"
5552 "\"spaces/at/\"\n"
5553 "\"slashes.at.any$\"\n"
5554 "\"non-alphanumeric%\"\n"
5555 "\"1111111111characte\"\n"
5556 "\"rs\"",
5557 format("\"split at "
5558 "spaces/at/"
5559 "slashes.at."
5560 "any$non-"
5561 "alphanumeric%"
5562 "1111111111characte"
5563 "rs\"",
5564 getLLVMStyleWithColumns(20)));
5565
Daniel Jasper0fde9502013-07-12 11:37:05 +00005566 // Verify that splitting the strings understands
5567 // Style::AlwaysBreakBeforeMultilineStrings.
5568 EXPECT_EQ("aaaaaaaaaaaa(aaaaaaaaaaaaa,\n"
5569 " \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
5570 " \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
5571 format("aaaaaaaaaaaa(aaaaaaaaaaaaa, \"aaaaaaaaaaaaaaaaaaaaaa "
5572 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa "
5573 "aaaaaaaaaaaaaaaaaaaaaa\");",
5574 getGoogleStyle()));
Daniel Jasper75e58bb2013-08-02 11:01:15 +00005575 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
5576 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
5577 format("llvm::outs() << "
5578 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
5579 "aaaaaaaaaaaaaaaaaaa\";"));
Daniel Jasper4df1ff92013-08-23 11:57:34 +00005580 EXPECT_EQ("ffff(\n"
5581 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
5582 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
5583 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
5584 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
5585 getGoogleStyle()));
Daniel Jasper0fde9502013-07-12 11:37:05 +00005586
Daniel Jasper2972d042013-04-25 08:56:26 +00005587 FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
5588 AlignLeft.AlignEscapedNewlinesLeft = true;
5589 EXPECT_EQ(
5590 "#define A \\\n"
5591 " \"some \" \\\n"
5592 " \"text \" \\\n"
5593 " \"other\";",
5594 format("#define A \"some text other\";", AlignLeft));
Manuel Klimek8092a942013-02-20 10:15:13 +00005595}
5596
Alexander Kornienko2c2f7292013-09-16 20:20:49 +00005597TEST_F(FormatTest, BreaksWideStringLiterals) {
5598 EXPECT_EQ(
5599 "u8\"utf8 string \"\n"
5600 "u8\"literal\";",
5601 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
5602 EXPECT_EQ(
5603 "u\"utf16 string \"\n"
5604 "u\"literal\";",
5605 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
5606 EXPECT_EQ(
5607 "U\"utf32 string \"\n"
5608 "U\"literal\";",
5609 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
5610 EXPECT_EQ("L\"wide string \"\n"
5611 "L\"literal\";",
5612 format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
5613}
5614
5615TEST_F(FormatTest, BreaksRawStringLiterals) {
5616 EXPECT_EQ("R\"x(raw )x\"\n"
5617 "R\"x(literal)x\";",
5618 format("R\"x(raw literal)x\";", getGoogleStyleWithColumns(15)));
5619 EXPECT_EQ("uR\"x(raw )x\"\n"
5620 "uR\"x(literal)x\";",
5621 format("uR\"x(raw literal)x\";", getGoogleStyleWithColumns(16)));
5622 EXPECT_EQ("u8R\"x(raw )x\"\n"
5623 "u8R\"x(literal)x\";",
5624 format("u8R\"x(raw literal)x\";", getGoogleStyleWithColumns(17)));
5625 EXPECT_EQ("LR\"x(raw )x\"\n"
5626 "LR\"x(literal)x\";",
5627 format("LR\"x(raw literal)x\";", getGoogleStyleWithColumns(16)));
5628 EXPECT_EQ("UR\"x(raw )x\"\n"
5629 "UR\"x(literal)x\";",
5630 format("UR\"x(raw literal)x\";", getGoogleStyleWithColumns(16)));
5631}
5632
5633TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
5634 FormatStyle Style = getLLVMStyleWithColumns(20);
5635 EXPECT_EQ(
5636 "_T(\"aaaaaaaaaaaaaa\")\n"
5637 "_T(\"aaaaaaaaaaaaaa\")\n"
5638 "_T(\"aaaaaaaaaaaa\")",
5639 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
5640 EXPECT_EQ("f(x, _T(\"aaaaaaaaa\")\n"
5641 " _T(\"aaaaaa\"),\n"
5642 " z);",
5643 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
5644
5645 // FIXME: Handle embedded spaces in one iteration.
5646 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
5647 // "_T(\"aaaaaaaaaaaaa\")\n"
5648 // "_T(\"aaaaaaaaaaaaa\")\n"
5649 // "_T(\"a\")",
5650 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
5651 // getLLVMStyleWithColumns(20)));
5652 EXPECT_EQ(
5653 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
5654 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
5655}
5656
Alexander Kornienko10c26b22013-07-16 21:06:13 +00005657TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
Alexander Kornienkodcc0c5b2013-08-29 17:32:57 +00005658 EXPECT_EQ(
5659 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
5660 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
5661 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
5662 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
5663 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
5664 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
5665}
5666
5667TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
5668 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
5669 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle()));
5670 EXPECT_EQ("fffffffffff(g(R\"x(\n"
5671 "multiline raw string literal xxxxxxxxxxxxxx\n"
5672 ")x\",\n"
5673 " a),\n"
5674 " b);",
5675 format("fffffffffff(g(R\"x(\n"
5676 "multiline raw string literal xxxxxxxxxxxxxx\n"
5677 ")x\", a), b);",
5678 getGoogleStyleWithColumns(20)));
5679 EXPECT_EQ("fffffffffff(\n"
5680 " g(R\"x(qqq\n"
5681 "multiline raw string literal xxxxxxxxxxxxxx\n"
5682 ")x\",\n"
5683 " a),\n"
5684 " b);",
5685 format("fffffffffff(g(R\"x(qqq\n"
5686 "multiline raw string literal xxxxxxxxxxxxxx\n"
5687 ")x\", a), b);",
5688 getGoogleStyleWithColumns(20)));
5689
5690 EXPECT_EQ("fffffffffff(R\"x(\n"
5691 "multiline raw string literal xxxxxxxxxxxxxx\n"
5692 ")x\");",
5693 format("fffffffffff(R\"x(\n"
5694 "multiline raw string literal xxxxxxxxxxxxxx\n"
5695 ")x\");",
5696 getGoogleStyleWithColumns(20)));
5697 EXPECT_EQ("fffffffffff(R\"x(\n"
5698 "multiline raw string literal xxxxxxxxxxxxxx\n"
5699 ")x\" +\n"
5700 " bbbbbb);",
5701 format("fffffffffff(R\"x(\n"
5702 "multiline raw string literal xxxxxxxxxxxxxx\n"
5703 ")x\" + bbbbbb);",
5704 getGoogleStyleWithColumns(20)));
Alexander Kornienko10c26b22013-07-16 21:06:13 +00005705}
5706
Alexander Kornienko16a0ec62013-06-14 11:46:10 +00005707TEST_F(FormatTest, SkipsUnknownStringLiterals) {
Daniel Jasper561211d2013-07-16 20:28:33 +00005708 verifyFormat("string a = \"unterminated;");
5709 EXPECT_EQ("function(\"unterminated,\n"
5710 " OtherParameter);",
5711 format("function( \"unterminated,\n"
5712 " OtherParameter);"));
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00005713}
5714
5715TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
5716 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
5717 format("#define x(_a) printf(\"foo\"_a);", getLLVMStyle()));
Alexander Kornienko16a0ec62013-06-14 11:46:10 +00005718}
5719
Manuel Klimek2a9805d2013-05-14 09:04:24 +00005720TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
5721 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
5722 " \"ddeeefff\");",
5723 format("someFunction(\"aaabbbcccdddeeefff\");",
5724 getLLVMStyleWithColumns(25)));
5725 EXPECT_EQ("someFunction1234567890(\n"
5726 " \"aaabbbcccdddeeefff\");",
5727 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
5728 getLLVMStyleWithColumns(26)));
5729 EXPECT_EQ("someFunction1234567890(\n"
5730 " \"aaabbbcccdddeeeff\"\n"
5731 " \"f\");",
5732 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
5733 getLLVMStyleWithColumns(25)));
5734 EXPECT_EQ("someFunction1234567890(\n"
5735 " \"aaabbbcccdddeeeff\"\n"
5736 " \"f\");",
5737 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
5738 getLLVMStyleWithColumns(24)));
Daniel Jasperf5461782013-08-28 10:03:58 +00005739 EXPECT_EQ("someFunction(\"aaabbbcc \"\n"
5740 " \"ddde \"\n"
5741 " \"efff\");",
5742 format("someFunction(\"aaabbbcc ddde efff\");",
Manuel Klimek2a9805d2013-05-14 09:04:24 +00005743 getLLVMStyleWithColumns(25)));
5744 EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
5745 " \"ddeeefff\");",
5746 format("someFunction(\"aaabbbccc ddeeefff\");",
5747 getLLVMStyleWithColumns(25)));
5748 EXPECT_EQ("someFunction1234567890(\n"
5749 " \"aaabb \"\n"
5750 " \"cccdddeeefff\");",
5751 format("someFunction1234567890(\"aaabb cccdddeeefff\");",
5752 getLLVMStyleWithColumns(25)));
5753 EXPECT_EQ("#define A \\\n"
5754 " string s = \\\n"
5755 " \"123456789\" \\\n"
5756 " \"0\"; \\\n"
5757 " int i;",
5758 format("#define A string s = \"1234567890\"; int i;",
5759 getLLVMStyleWithColumns(20)));
Daniel Jasperf5461782013-08-28 10:03:58 +00005760 // FIXME: Put additional penalties on breaking at non-whitespace locations.
5761 EXPECT_EQ("someFunction(\"aaabbbcc \"\n"
5762 " \"dddeeeff\"\n"
5763 " \"f\");",
5764 format("someFunction(\"aaabbbcc dddeeefff\");",
5765 getLLVMStyleWithColumns(25)));
Manuel Klimek2a9805d2013-05-14 09:04:24 +00005766}
5767
Manuel Klimekaa62d0c2013-03-08 18:59:48 +00005768TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
5769 EXPECT_EQ("\"\\a\"",
5770 format("\"\\a\"", getLLVMStyleWithColumns(3)));
5771 EXPECT_EQ("\"\\\"",
5772 format("\"\\\"", getLLVMStyleWithColumns(2)));
5773 EXPECT_EQ("\"test\"\n"
5774 "\"\\n\"",
5775 format("\"test\\n\"", getLLVMStyleWithColumns(7)));
5776 EXPECT_EQ("\"tes\\\\\"\n"
5777 "\"n\"",
5778 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
5779 EXPECT_EQ("\"\\\\\\\\\"\n"
5780 "\"\\n\"",
5781 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
5782 EXPECT_EQ("\"\\uff01\"",
5783 format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
5784 EXPECT_EQ("\"\\uff01\"\n"
5785 "\"test\"",
5786 format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
5787 EXPECT_EQ("\"\\Uff01ff02\"",
5788 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
5789 EXPECT_EQ("\"\\x000000000001\"\n"
5790 "\"next\"",
5791 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
5792 EXPECT_EQ("\"\\x000000000001next\"",
5793 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
5794 EXPECT_EQ("\"\\x000000000001\"",
5795 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
5796 EXPECT_EQ("\"test\"\n"
5797 "\"\\000000\"\n"
5798 "\"000001\"",
5799 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
5800 EXPECT_EQ("\"test\\000\"\n"
Alexander Kornienko70ce7882013-04-15 14:28:00 +00005801 "\"00000000\"\n"
5802 "\"1\"",
Manuel Klimekaa62d0c2013-03-08 18:59:48 +00005803 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
Alexander Kornienko2c2f7292013-09-16 20:20:49 +00005804 // FIXME: We probably don't need to care about escape sequences in raw
5805 // literals.
5806 EXPECT_EQ("R\"(\\x)\"\n"
5807 "R\"(\\x00)\"\n",
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00005808 format("R\"(\\x\\x00)\"\n", getGoogleStyleWithColumns(7)));
Manuel Klimekaa62d0c2013-03-08 18:59:48 +00005809}
5810
Manuel Klimek423dd932013-04-10 09:52:05 +00005811TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
5812 verifyFormat("void f() {\n"
5813 " return g() {}\n"
5814 " void h() {}");
5815 verifyFormat("if (foo)\n"
5816 " return { forgot_closing_brace();\n"
5817 "test();");
Daniel Jasper88959b72013-05-28 18:50:02 +00005818 verifyFormat("int a[] = { void forgot_closing_brace() { f();\n"
5819 "g();\n"
Manuel Klimek423dd932013-04-10 09:52:05 +00005820 "}");
5821}
5822
Manuel Klimek07a64ec2013-05-13 08:42:42 +00005823TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
5824 verifyFormat("class X {\n"
5825 " void f() {\n"
5826 " }\n"
5827 "};",
5828 getLLVMStyleWithColumns(12));
5829}
5830
5831TEST_F(FormatTest, ConfigurableIndentWidth) {
5832 FormatStyle EightIndent = getLLVMStyleWithColumns(18);
5833 EightIndent.IndentWidth = 8;
5834 verifyFormat("void f() {\n"
5835 " someFunction();\n"
5836 " if (true) {\n"
5837 " f();\n"
5838 " }\n"
5839 "}",
5840 EightIndent);
5841 verifyFormat("class X {\n"
5842 " void f() {\n"
5843 " }\n"
5844 "};",
5845 EightIndent);
5846 verifyFormat("int x[] = {\n"
5847 " call(),\n"
5848 " call(),\n"
5849 "};",
5850 EightIndent);
5851}
5852
Alexander Kornienkoc1c76252013-06-22 01:35:36 +00005853TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
Manuel Klimeka9a7f102013-06-21 17:25:42 +00005854 verifyFormat("void\n"
5855 "f();",
5856 getLLVMStyleWithColumns(8));
5857}
5858
Manuel Klimek7c9a93e2013-05-13 09:22:11 +00005859TEST_F(FormatTest, ConfigurableUseOfTab) {
5860 FormatStyle Tab = getLLVMStyleWithColumns(42);
5861 Tab.IndentWidth = 8;
Alexander Kornienko3d9ffcf2013-09-27 16:14:22 +00005862 Tab.UseTab = FormatStyle::UT_Always;
Manuel Klimek7c9a93e2013-05-13 09:22:11 +00005863 Tab.AlignEscapedNewlinesLeft = true;
Alexander Kornienkoacf8e902013-09-27 09:45:40 +00005864
5865 EXPECT_EQ("if (aaaaaaaa && // q\n"
5866 " bb)\t\t// w\n"
5867 "\t;",
5868 format("if (aaaaaaaa &&// q\n"
5869 "bb)// w\n"
5870 ";",
5871 Tab));
5872 EXPECT_EQ("if (aaa && bbb) // w\n"
5873 "\t;",
5874 format("if(aaa&&bbb)// w\n"
5875 ";",
5876 Tab));
5877
Manuel Klimek7c9a93e2013-05-13 09:22:11 +00005878 verifyFormat("class X {\n"
5879 "\tvoid f() {\n"
5880 "\t\tsomeFunction(parameter1,\n"
5881 "\t\t\t parameter2);\n"
5882 "\t}\n"
5883 "};",
5884 Tab);
5885 verifyFormat("#define A \\\n"
5886 "\tvoid f() { \\\n"
5887 "\t\tsomeFunction( \\\n"
5888 "\t\t parameter1, \\\n"
5889 "\t\t parameter2); \\\n"
5890 "\t}",
5891 Tab);
Manuel Klimekc41e8192013-08-29 15:21:40 +00005892 EXPECT_EQ("void f() {\n"
5893 "\tf();\n"
5894 "\tg();\n"
5895 "}",
5896 format("void f() {\n"
5897 "\tf();\n"
5898 "\tg();\n"
5899 "}",
5900 0, 0, Tab));
5901 EXPECT_EQ("void f() {\n"
5902 "\tf();\n"
5903 "\tg();\n"
5904 "}",
5905 format("void f() {\n"
5906 "\tf();\n"
5907 "\tg();\n"
5908 "}",
5909 16, 0, Tab));
5910 EXPECT_EQ("void f() {\n"
5911 " \tf();\n"
5912 "\tg();\n"
5913 "}",
5914 format("void f() {\n"
5915 " \tf();\n"
5916 " \tg();\n"
5917 "}",
5918 21, 0, Tab));
Manuel Klimekd63312b2013-05-28 10:01:59 +00005919
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00005920 Tab.TabWidth = 4;
5921 Tab.IndentWidth = 8;
5922 verifyFormat("class TabWidth4Indent8 {\n"
5923 "\t\tvoid f() {\n"
5924 "\t\t\t\tsomeFunction(parameter1,\n"
5925 "\t\t\t\t\t\t\t parameter2);\n"
5926 "\t\t}\n"
5927 "};",
5928 Tab);
5929
5930 Tab.TabWidth = 4;
5931 Tab.IndentWidth = 4;
5932 verifyFormat("class TabWidth4Indent4 {\n"
5933 "\tvoid f() {\n"
5934 "\t\tsomeFunction(parameter1,\n"
5935 "\t\t\t\t\t parameter2);\n"
5936 "\t}\n"
5937 "};",
5938 Tab);
5939
5940 Tab.TabWidth = 8;
5941 Tab.IndentWidth = 4;
5942 verifyFormat("class TabWidth8Indent4 {\n"
5943 " void f() {\n"
5944 "\tsomeFunction(parameter1,\n"
5945 "\t\t parameter2);\n"
5946 " }\n"
5947 "};",
5948 Tab);
5949
Alexander Kornienko83a7dcd2013-09-10 09:38:25 +00005950 Tab.TabWidth = 8;
5951 Tab.IndentWidth = 8;
5952 EXPECT_EQ("/*\n"
5953 "\t a\t\tcomment\n"
5954 "\t in multiple lines\n"
5955 " */",
5956 format(" /*\t \t \n"
5957 " \t \t a\t\tcomment\t \t\n"
5958 " \t \t in multiple lines\t\n"
5959 " \t */",
5960 Tab));
Alexander Kornienkoacf8e902013-09-27 09:45:40 +00005961
Alexander Kornienko3d9ffcf2013-09-27 16:14:22 +00005962 Tab.UseTab = FormatStyle::UT_ForIndentation;
5963 EXPECT_EQ("if (aaaaaaaa && // q\n"
5964 " bb) // w\n"
5965 "\t;",
5966 format("if (aaaaaaaa &&// q\n"
5967 "bb)// w\n"
5968 ";",
5969 Tab));
5970 verifyFormat("class X {\n"
5971 "\tvoid f() {\n"
5972 "\t\tsomeFunction(parameter1,\n"
5973 "\t\t parameter2);\n"
5974 "\t}\n"
5975 "};",
5976 Tab);
5977 verifyFormat("{\n"
5978 "\tQ({\n"
5979 "\t\t int a;\n"
5980 "\t\t someFunction(aaaaaaaaaa,\n"
5981 "\t\t bbbbbbbbb);\n"
5982 "\t },\n"
5983 "\t p);\n"
5984 "}",
5985 Tab);
5986 EXPECT_EQ("{\n"
5987 "\t/* aaaa\n"
5988 "\t bbbb */\n"
5989 "}",
5990 format("{\n"
5991 "/* aaaa\n"
5992 " bbbb */\n"
5993 "}",
5994 Tab));
5995 EXPECT_EQ("{\n"
5996 "\t/*\n"
5997 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5998 "\t bbbbbbbbbbbbb\n"
5999 "\t*/\n"
6000 "}",
6001 format("{\n"
6002 "/*\n"
6003 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
6004 "*/\n"
6005 "}",
6006 Tab));
6007 EXPECT_EQ("{\n"
6008 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6009 "\t// bbbbbbbbbbbbb\n"
6010 "}",
6011 format("{\n"
6012 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
6013 "}",
6014 Tab));
6015 EXPECT_EQ("{\n"
6016 "\t/*\n"
6017 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6018 "\t bbbbbbbbbbbbb\n"
6019 "\t*/\n"
6020 "}",
6021 format("{\n"
6022 "\t/*\n"
6023 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
6024 "\t*/\n"
6025 "}",
6026 Tab));
6027 EXPECT_EQ("{\n"
6028 "\t/*\n"
6029 "\n"
6030 "\t*/\n"
6031 "}",
6032 format("{\n"
6033 "\t/*\n"
6034 "\n"
6035 "\t*/\n"
Alexander Kornienko6967e782013-09-27 16:40:11 +00006036 "}",
6037 Tab));
6038 EXPECT_EQ("{\n"
6039 "\t/*\n"
6040 " asdf\n"
6041 "\t*/\n"
6042 "}",
6043 format("{\n"
6044 "\t/*\n"
6045 " asdf\n"
6046 "\t*/\n"
6047 "}",
6048 Tab));
Alexander Kornienko3d9ffcf2013-09-27 16:14:22 +00006049
6050 Tab.UseTab = FormatStyle::UT_Never;
Alexander Kornienko83a7dcd2013-09-10 09:38:25 +00006051 EXPECT_EQ("/*\n"
6052 " a\t\tcomment\n"
6053 " in multiple lines\n"
6054 " */",
6055 format(" /*\t \t \n"
6056 " \t \t a\t\tcomment\t \t\n"
6057 " \t \t in multiple lines\t\n"
6058 " \t */",
6059 Tab));
6060 EXPECT_EQ("/* some\n"
6061 " comment */",
6062 format(" \t \t /* some\n"
6063 " \t \t comment */",
6064 Tab));
6065 EXPECT_EQ("int a; /* some\n"
6066 " comment */",
6067 format(" \t \t int a; /* some\n"
6068 " \t \t comment */",
6069 Tab));
Manuel Klimekd63312b2013-05-28 10:01:59 +00006070
Alexander Kornienko83a7dcd2013-09-10 09:38:25 +00006071 EXPECT_EQ("int a; /* some\n"
6072 "comment */",
6073 format(" \t \t int\ta; /* some\n"
6074 " \t \t comment */",
6075 Tab));
6076 EXPECT_EQ("f(\"\t\t\"); /* some\n"
6077 " comment */",
6078 format(" \t \t f(\"\t\t\"); /* some\n"
6079 " \t \t comment */",
6080 Tab));
Manuel Klimekd63312b2013-05-28 10:01:59 +00006081 EXPECT_EQ("{\n"
6082 " /*\n"
6083 " * Comment\n"
6084 " */\n"
6085 " int i;\n"
6086 "}",
6087 format("{\n"
6088 "\t/*\n"
6089 "\t * Comment\n"
6090 "\t */\n"
6091 "\t int i;\n"
6092 "}"));
Manuel Klimek7c9a93e2013-05-13 09:22:11 +00006093}
6094
Alexander Kornienko6f6154c2013-09-10 12:29:48 +00006095TEST_F(FormatTest, CalculatesOriginalColumn) {
6096 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
6097 "q\"; /* some\n"
6098 " comment */",
6099 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
6100 "q\"; /* some\n"
6101 " comment */",
6102 getLLVMStyle()));
6103 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
6104 "/* some\n"
6105 " comment */",
6106 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
6107 " /* some\n"
6108 " comment */",
6109 getLLVMStyle()));
6110 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
6111 "qqq\n"
6112 "/* some\n"
6113 " comment */",
6114 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
6115 "qqq\n"
6116 " /* some\n"
6117 " comment */",
6118 getLLVMStyle()));
6119 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
6120 "wwww; /* some\n"
6121 " comment */",
6122 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
6123 "wwww; /* some\n"
6124 " comment */",
6125 getLLVMStyle()));
6126}
6127
Daniel Jasper7df56bf2013-08-20 12:36:34 +00006128TEST_F(FormatTest, ConfigurableSpaceAfterControlStatementKeyword) {
6129 FormatStyle NoSpace = getLLVMStyle();
6130 NoSpace.SpaceAfterControlStatementKeyword = false;
6131
6132 verifyFormat("while(true)\n"
6133 " continue;", NoSpace);
6134 verifyFormat("for(;;)\n"
6135 " continue;", NoSpace);
6136 verifyFormat("if(true)\n"
6137 " f();\n"
6138 "else if(true)\n"
6139 " f();", NoSpace);
6140 verifyFormat("do {\n"
6141 " do_something();\n"
6142 "} while(something());", NoSpace);
6143 verifyFormat("switch(x) {\n"
6144 "default:\n"
6145 " break;\n"
6146 "}", NoSpace);
6147}
6148
6149TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
6150 FormatStyle Spaces = getLLVMStyle();
6151
6152 Spaces.SpacesInParentheses = true;
6153 verifyFormat("call( x, y, z );", Spaces);
6154 verifyFormat("while ( (bool)1 )\n"
6155 " continue;", Spaces);
6156 verifyFormat("for ( ;; )\n"
6157 " continue;", Spaces);
6158 verifyFormat("if ( true )\n"
6159 " f();\n"
6160 "else if ( true )\n"
6161 " f();", Spaces);
6162 verifyFormat("do {\n"
6163 " do_something( (int)i );\n"
6164 "} while ( something() );", Spaces);
6165 verifyFormat("switch ( x ) {\n"
6166 "default:\n"
6167 " break;\n"
6168 "}", Spaces);
6169
6170 Spaces.SpacesInParentheses = false;
6171 Spaces.SpacesInCStyleCastParentheses = true;
6172 verifyFormat("Type *A = ( Type * )P;", Spaces);
6173 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
6174 verifyFormat("x = ( int32 )y;", Spaces);
6175 verifyFormat("int a = ( int )(2.0f);", Spaces);
6176 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
6177 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
6178 verifyFormat("#define x (( int )-1)", Spaces);
6179
6180 Spaces.SpacesInParentheses = false;
6181 Spaces.SpaceInEmptyParentheses = true;
6182 verifyFormat("call(x, y, z);", Spaces);
6183 verifyFormat("call( )", Spaces);
6184
6185 // Run the first set of tests again with
6186 // Spaces.SpacesInParentheses = false,
6187 // Spaces.SpaceInEmptyParentheses = true and
6188 // Spaces.SpacesInCStyleCastParentheses = true
6189 Spaces.SpacesInParentheses = false,
6190 Spaces.SpaceInEmptyParentheses = true;
6191 Spaces.SpacesInCStyleCastParentheses = true;
6192 verifyFormat("call(x, y, z);", Spaces);
6193 verifyFormat("while (( bool )1)\n"
6194 " continue;", Spaces);
6195 verifyFormat("for (;;)\n"
6196 " continue;", Spaces);
6197 verifyFormat("if (true)\n"
6198 " f( );\n"
6199 "else if (true)\n"
6200 " f( );", Spaces);
6201 verifyFormat("do {\n"
6202 " do_something(( int )i);\n"
6203 "} while (something( ));", Spaces);
6204 verifyFormat("switch (x) {\n"
6205 "default:\n"
6206 " break;\n"
6207 "}", Spaces);
6208}
6209
Daniel Jasper9b4de852013-09-25 15:15:02 +00006210TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
6211 verifyFormat("int a = 5;");
6212 verifyFormat("a += 42;");
6213 verifyFormat("a or_eq 8;");
6214
6215 FormatStyle Spaces = getLLVMStyle();
6216 Spaces.SpaceBeforeAssignmentOperators = false;
6217 verifyFormat("int a= 5;", Spaces);
6218 verifyFormat("a+= 42;", Spaces);
6219 verifyFormat("a or_eq 8;", Spaces);
6220}
6221
Manuel Klimek44135b82013-05-13 12:51:40 +00006222TEST_F(FormatTest, LinuxBraceBreaking) {
6223 FormatStyle BreakBeforeBrace = getLLVMStyle();
6224 BreakBeforeBrace.BreakBeforeBraces = FormatStyle::BS_Linux;
6225 verifyFormat("namespace a\n"
6226 "{\n"
6227 "class A\n"
6228 "{\n"
6229 " void f()\n"
6230 " {\n"
6231 " if (true) {\n"
6232 " a();\n"
6233 " b();\n"
6234 " }\n"
6235 " }\n"
Daniel Jasper9f321612013-05-15 08:30:06 +00006236 " void g()\n"
6237 " {\n"
6238 " return;\n"
6239 " }\n"
Manuel Klimek44135b82013-05-13 12:51:40 +00006240 "}\n"
6241 "}",
6242 BreakBeforeBrace);
6243}
6244
6245TEST_F(FormatTest, StroustrupBraceBreaking) {
6246 FormatStyle BreakBeforeBrace = getLLVMStyle();
6247 BreakBeforeBrace.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
6248 verifyFormat("namespace a {\n"
6249 "class A {\n"
6250 " void f()\n"
6251 " {\n"
6252 " if (true) {\n"
6253 " a();\n"
6254 " b();\n"
6255 " }\n"
6256 " }\n"
Daniel Jasper9f321612013-05-15 08:30:06 +00006257 " void g()\n"
6258 " {\n"
6259 " return;\n"
6260 " }\n"
Manuel Klimek44135b82013-05-13 12:51:40 +00006261 "}\n"
6262 "}",
6263 BreakBeforeBrace);
6264}
6265
Manuel Klimeke4907052013-08-02 21:31:59 +00006266TEST_F(FormatTest, AllmanBraceBreaking) {
6267 FormatStyle BreakBeforeBrace = getLLVMStyle();
6268 BreakBeforeBrace.BreakBeforeBraces = FormatStyle::BS_Allman;
6269 verifyFormat("namespace a\n"
6270 "{\n"
6271 "class A\n"
6272 "{\n"
6273 " void f()\n"
6274 " {\n"
6275 " if (true)\n"
6276 " {\n"
6277 " a();\n"
6278 " b();\n"
6279 " }\n"
6280 " }\n"
6281 " void g()\n"
6282 " {\n"
6283 " return;\n"
6284 " }\n"
6285 "}\n"
6286 "}",
6287 BreakBeforeBrace);
6288
6289 verifyFormat("void f()\n"
6290 "{\n"
6291 " if (true)\n"
6292 " {\n"
6293 " a();\n"
6294 " }\n"
6295 " else if (false)\n"
6296 " {\n"
6297 " b();\n"
6298 " }\n"
6299 " else\n"
6300 " {\n"
6301 " c();\n"
6302 " }\n"
6303 "}\n",
6304 BreakBeforeBrace);
6305
6306 verifyFormat("void f()\n"
6307 "{\n"
6308 " for (int i = 0; i < 10; ++i)\n"
6309 " {\n"
6310 " a();\n"
6311 " }\n"
6312 " while (false)\n"
6313 " {\n"
6314 " b();\n"
6315 " }\n"
6316 " do\n"
6317 " {\n"
6318 " c();\n"
6319 " } while (false)\n"
6320 "}\n",
6321 BreakBeforeBrace);
6322
6323 verifyFormat("void f(int a)\n"
6324 "{\n"
6325 " switch (a)\n"
6326 " {\n"
6327 " case 0:\n"
6328 " break;\n"
6329 " case 1:\n"
6330 " {\n"
6331 " break;\n"
6332 " }\n"
6333 " case 2:\n"
6334 " {\n"
6335 " }\n"
6336 " break;\n"
6337 " default:\n"
6338 " break;\n"
6339 " }\n"
6340 "}\n",
6341 BreakBeforeBrace);
Manuel Klimekd3a247c2013-08-07 19:20:45 +00006342
6343 verifyFormat("enum X\n"
6344 "{\n"
6345 " Y = 0,\n"
6346 "}\n",
6347 BreakBeforeBrace);
6348
6349 FormatStyle BreakBeforeBraceShortIfs = BreakBeforeBrace;
6350 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = true;
6351 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
6352 verifyFormat("void f(bool b)\n"
6353 "{\n"
6354 " if (b)\n"
6355 " {\n"
6356 " return;\n"
6357 " }\n"
6358 "}\n",
6359 BreakBeforeBraceShortIfs);
6360 verifyFormat("void f(bool b)\n"
6361 "{\n"
6362 " if (b) return;\n"
6363 "}\n",
6364 BreakBeforeBraceShortIfs);
6365 verifyFormat("void f(bool b)\n"
6366 "{\n"
6367 " while (b)\n"
6368 " {\n"
6369 " return;\n"
6370 " }\n"
6371 "}\n",
6372 BreakBeforeBraceShortIfs);
Manuel Klimeke4907052013-08-02 21:31:59 +00006373}
6374
Manuel Klimek2530fd52013-08-12 03:51:17 +00006375TEST_F(FormatTest, CatchExceptionReferenceBinding) {
6376 verifyFormat("void f() {\n"
6377 " try {\n"
6378 " }\n"
6379 " catch (const Exception &e) {\n"
6380 " }\n"
6381 "}\n",
6382 getLLVMStyle());
6383}
6384
Daniel Jasper1dc6f742013-08-07 16:29:23 +00006385TEST_F(FormatTest, UnderstandsPragmas) {
6386 verifyFormat("#pragma omp reduction(| : var)");
6387 verifyFormat("#pragma omp reduction(+ : var)");
6388}
6389
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006390bool allStylesEqual(ArrayRef<FormatStyle> Styles) {
6391 for (size_t i = 1; i < Styles.size(); ++i)
6392 if (!(Styles[0] == Styles[i]))
6393 return false;
6394 return true;
6395}
6396
6397TEST_F(FormatTest, GetsPredefinedStyleByName) {
Alexander Kornienko885f87b2013-05-19 00:53:30 +00006398 FormatStyle Styles[3];
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006399
Alexander Kornienko885f87b2013-05-19 00:53:30 +00006400 Styles[0] = getLLVMStyle();
6401 EXPECT_TRUE(getPredefinedStyle("LLVM", &Styles[1]));
6402 EXPECT_TRUE(getPredefinedStyle("lLvM", &Styles[2]));
6403 EXPECT_TRUE(allStylesEqual(Styles));
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006404
Alexander Kornienko885f87b2013-05-19 00:53:30 +00006405 Styles[0] = getGoogleStyle();
6406 EXPECT_TRUE(getPredefinedStyle("Google", &Styles[1]));
6407 EXPECT_TRUE(getPredefinedStyle("gOOgle", &Styles[2]));
6408 EXPECT_TRUE(allStylesEqual(Styles));
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006409
Alexander Kornienko885f87b2013-05-19 00:53:30 +00006410 Styles[0] = getChromiumStyle();
6411 EXPECT_TRUE(getPredefinedStyle("Chromium", &Styles[1]));
6412 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", &Styles[2]));
6413 EXPECT_TRUE(allStylesEqual(Styles));
6414
6415 Styles[0] = getMozillaStyle();
6416 EXPECT_TRUE(getPredefinedStyle("Mozilla", &Styles[1]));
6417 EXPECT_TRUE(getPredefinedStyle("moZILla", &Styles[2]));
6418 EXPECT_TRUE(allStylesEqual(Styles));
6419
Daniel Jaspere05dc6d2013-07-24 13:10:59 +00006420 Styles[0] = getWebKitStyle();
6421 EXPECT_TRUE(getPredefinedStyle("WebKit", &Styles[1]));
6422 EXPECT_TRUE(getPredefinedStyle("wEbKit", &Styles[2]));
6423 EXPECT_TRUE(allStylesEqual(Styles));
6424
Alexander Kornienko885f87b2013-05-19 00:53:30 +00006425 EXPECT_FALSE(getPredefinedStyle("qwerty", &Styles[0]));
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006426}
6427
6428TEST_F(FormatTest, ParsesConfiguration) {
6429 FormatStyle Style = {};
6430#define CHECK_PARSE(TEXT, FIELD, VALUE) \
6431 EXPECT_NE(VALUE, Style.FIELD); \
6432 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \
6433 EXPECT_EQ(VALUE, Style.FIELD)
6434
6435#define CHECK_PARSE_BOOL(FIELD) \
6436 Style.FIELD = false; \
6437 EXPECT_EQ(0, parseConfiguration(#FIELD ": true", &Style).value()); \
Alexander Kornienko885f87b2013-05-19 00:53:30 +00006438 EXPECT_TRUE(Style.FIELD); \
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006439 EXPECT_EQ(0, parseConfiguration(#FIELD ": false", &Style).value()); \
Patrik Hagglund33717112013-05-14 07:53:53 +00006440 EXPECT_FALSE(Style.FIELD);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006441
6442 CHECK_PARSE_BOOL(AlignEscapedNewlinesLeft);
Daniel Jasper893ea8d2013-07-31 23:55:15 +00006443 CHECK_PARSE_BOOL(AlignTrailingComments);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006444 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
6445 CHECK_PARSE_BOOL(AllowShortIfStatementsOnASingleLine);
Daniel Jasper2a2579a2013-05-16 12:16:23 +00006446 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
Daniel Jasperbbc87762013-05-29 12:07:31 +00006447 CHECK_PARSE_BOOL(AlwaysBreakTemplateDeclarations);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006448 CHECK_PARSE_BOOL(BinPackParameters);
Daniel Jaspere8b10d32013-07-26 16:56:36 +00006449 CHECK_PARSE_BOOL(BreakBeforeBinaryOperators);
6450 CHECK_PARSE_BOOL(BreakConstructorInitializersBeforeComma);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006451 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
6452 CHECK_PARSE_BOOL(DerivePointerBinding);
6453 CHECK_PARSE_BOOL(IndentCaseLabels);
6454 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
6455 CHECK_PARSE_BOOL(PointerBindsToType);
Daniel Jasperb5dc3f42013-07-16 18:22:10 +00006456 CHECK_PARSE_BOOL(Cpp11BracedListStyle);
Manuel Klimeka9a7f102013-06-21 17:25:42 +00006457 CHECK_PARSE_BOOL(IndentFunctionDeclarationAfterType);
Daniel Jasper7df56bf2013-08-20 12:36:34 +00006458 CHECK_PARSE_BOOL(SpacesInParentheses);
6459 CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
6460 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
6461 CHECK_PARSE_BOOL(SpaceAfterControlStatementKeyword);
Daniel Jasper9b4de852013-09-25 15:15:02 +00006462 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006463
6464 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
Daniel Jasper6315fec2013-08-13 10:58:30 +00006465 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
6466 ConstructorInitializerIndentWidth, 1234u);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006467 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
6468 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
6469 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
6470 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
6471 PenaltyReturnTypeOnItsOwnLine, 1234u);
6472 CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
6473 SpacesBeforeTrailingComments, 1234u);
Manuel Klimek07a64ec2013-05-13 08:42:42 +00006474 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006475
6476 Style.Standard = FormatStyle::LS_Auto;
Alexander Kornienko9321e872013-09-04 14:09:13 +00006477 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
6478 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Cpp11);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006479 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
6480 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
6481 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
6482
Alexander Kornienko3d9ffcf2013-09-27 16:14:22 +00006483 Style.UseTab = FormatStyle::UT_ForIndentation;
6484 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
6485 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
6486 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
6487 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
6488 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
6489
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006490 Style.ColumnLimit = 123;
6491 FormatStyle BaseStyle = getLLVMStyle();
6492 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
6493 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
6494
Manuel Klimek44135b82013-05-13 12:51:40 +00006495 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
6496 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
6497 FormatStyle::BS_Attach);
6498 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
6499 FormatStyle::BS_Linux);
6500 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
6501 FormatStyle::BS_Stroustrup);
6502
Daniel Jaspereff18b92013-07-31 23:16:02 +00006503 Style.NamespaceIndentation = FormatStyle::NI_All;
6504 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
6505 FormatStyle::NI_None);
6506 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
6507 FormatStyle::NI_Inner);
6508 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
6509 FormatStyle::NI_All);
6510
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006511#undef CHECK_PARSE
6512#undef CHECK_PARSE_BOOL
6513}
6514
6515TEST_F(FormatTest, ConfigurationRoundTripTest) {
6516 FormatStyle Style = getLLVMStyle();
6517 std::string YAML = configurationAsText(Style);
6518 FormatStyle ParsedStyle = {};
6519 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
6520 EXPECT_EQ(Style, ParsedStyle);
6521}
6522
Alexander Kornienko00895102013-06-05 14:09:10 +00006523TEST_F(FormatTest, WorksFor8bitEncodings) {
6524 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
6525 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
6526 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
6527 "\"\xef\xee\xf0\xf3...\"",
6528 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
6529 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
6530 "\xef\xee\xf0\xf3...\"",
6531 getLLVMStyleWithColumns(12)));
6532}
6533
NAKAMURA Takumi07eda942013-06-06 01:14:58 +00006534// FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
6535#if !defined(_MSC_VER)
6536
Alexander Kornienko00895102013-06-05 14:09:10 +00006537TEST_F(FormatTest, CountsUTF8CharactersProperly) {
6538 verifyFormat("\"Однажды в студёную зимнюю пору...\"",
6539 getLLVMStyleWithColumns(35));
6540 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00006541 getLLVMStyleWithColumns(31));
Alexander Kornienko00895102013-06-05 14:09:10 +00006542 verifyFormat("// Однажды в студёную зимнюю пору...",
6543 getLLVMStyleWithColumns(36));
6544 verifyFormat("// 一 二 三 四 五 六 七 八 九 十",
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00006545 getLLVMStyleWithColumns(32));
Alexander Kornienko00895102013-06-05 14:09:10 +00006546 verifyFormat("/* Однажды в студёную зимнюю пору... */",
6547 getLLVMStyleWithColumns(39));
6548 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00006549 getLLVMStyleWithColumns(35));
Alexander Kornienko00895102013-06-05 14:09:10 +00006550}
6551
6552TEST_F(FormatTest, SplitsUTF8Strings) {
6553 EXPECT_EQ(
6554 "\"Однажды, в \"\n"
6555 "\"студёную \"\n"
6556 "\"зимнюю \"\n"
6557 "\"пору,\"",
6558 format("\"Однажды, в студёную зимнюю пору,\"",
6559 getLLVMStyleWithColumns(13)));
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00006560 EXPECT_EQ("\"一 二 三 \"\n"
6561 "\"四 五六 \"\n"
6562 "\"七 八 九 \"\n"
6563 "\"十\"",
6564 format("\"一 二 三 四 五六 七 八 九 十\"",
6565 getLLVMStyleWithColumns(11)));
6566 EXPECT_EQ("\"一\t二 \"\n"
6567 "\"\t三 \"\n"
6568 "\"四 五\t六 \"\n"
6569 "\"\t七 \"\n"
6570 "\"八九十\tqq\"",
6571 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
6572 getLLVMStyleWithColumns(11)));
6573}
6574
6575
6576TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
6577 EXPECT_EQ("const char *sssss =\n"
6578 " \"一二三四五六七八\\\n"
6579 " 九 十\";",
6580 format("const char *sssss = \"一二三四五六七八\\\n"
6581 " 九 十\";",
6582 getLLVMStyleWithColumns(30)));
Alexander Kornienko00895102013-06-05 14:09:10 +00006583}
6584
6585TEST_F(FormatTest, SplitsUTF8LineComments) {
6586 EXPECT_EQ("// Я из лесу\n"
6587 "// вышел; был\n"
6588 "// сильный\n"
6589 "// мороз.",
6590 format("// Я из лесу вышел; был сильный мороз.",
6591 getLLVMStyleWithColumns(13)));
6592 EXPECT_EQ("// 一二三\n"
6593 "// 四五六七\n"
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00006594 "// 八 九\n"
6595 "// 十",
6596 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9)));
Alexander Kornienko00895102013-06-05 14:09:10 +00006597}
6598
6599TEST_F(FormatTest, SplitsUTF8BlockComments) {
6600 EXPECT_EQ("/* Гляжу,\n"
6601 " * поднимается\n"
6602 " * медленно в\n"
6603 " * гору\n"
6604 " * Лошадка,\n"
6605 " * везущая\n"
6606 " * хворосту\n"
6607 " * воз. */",
6608 format("/* Гляжу, поднимается медленно в гору\n"
6609 " * Лошадка, везущая хворосту воз. */",
6610 getLLVMStyleWithColumns(13)));
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00006611 EXPECT_EQ(
6612 "/* 一二三\n"
6613 " * 四五六七\n"
6614 " * 八 九\n"
6615 " * 十 */",
6616 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9)));
Alexander Kornienkodda770b2013-06-05 15:08:20 +00006617 EXPECT_EQ("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯\n"
6618 " * 𝕓𝕪𝕥𝕖\n"
6619 " * 𝖀𝕿𝕱-𝟠 */",
6620 format("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯 𝕓𝕪𝕥𝕖 𝖀𝕿𝕱-𝟠 */", getLLVMStyleWithColumns(12)));
Alexander Kornienko00895102013-06-05 14:09:10 +00006621}
6622
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00006623#endif // _MSC_VER
6624
Daniel Jasper6315fec2013-08-13 10:58:30 +00006625TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
6626 FormatStyle Style = getLLVMStyle();
6627
6628 Style.ConstructorInitializerIndentWidth = 4;
6629 verifyFormat(
6630 "SomeClass::Constructor()\n"
6631 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
6632 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
6633 Style);
6634
6635 Style.ConstructorInitializerIndentWidth = 2;
6636 verifyFormat(
6637 "SomeClass::Constructor()\n"
6638 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
6639 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
6640 Style);
6641
6642 Style.ConstructorInitializerIndentWidth = 0;
6643 verifyFormat(
6644 "SomeClass::Constructor()\n"
6645 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
6646 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
6647 Style);
6648
6649 Style.BreakConstructorInitializersBeforeComma = true;
6650 Style.ConstructorInitializerIndentWidth = 4;
6651 verifyFormat("SomeClass::Constructor()\n"
6652 " : a(a)\n"
6653 " , b(b)\n"
6654 " , c(c) {}",
6655 Style);
6656
6657 Style.ConstructorInitializerIndentWidth = 2;
6658 verifyFormat("SomeClass::Constructor()\n"
6659 " : a(a)\n"
6660 " , b(b)\n"
6661 " , c(c) {}",
6662 Style);
6663
6664 Style.ConstructorInitializerIndentWidth = 0;
6665 verifyFormat("SomeClass::Constructor()\n"
6666 ": a(a)\n"
6667 ", b(b)\n"
6668 ", c(c) {}",
6669 Style);
Daniel Jasper19ccb122013-10-08 05:11:18 +00006670
6671 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
6672 Style.ConstructorInitializerIndentWidth = 4;
6673 verifyFormat(
6674 "SomeClass::Constructor()\n"
6675 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
6676 Style);
6677 Style.ConstructorInitializerIndentWidth = 4;
6678 Style.ColumnLimit = 60;
6679 verifyFormat("SomeClass::Constructor()\n"
6680 " : aaaaaaaa(aaaaaaaa)\n"
6681 " , aaaaaaaa(aaaaaaaa)\n"
6682 " , aaaaaaaa(aaaaaaaa) {}",
6683 Style);
Daniel Jasper6315fec2013-08-13 10:58:30 +00006684}
6685
Daniel Jaspere05dc6d2013-07-24 13:10:59 +00006686TEST_F(FormatTest, FormatsWithWebKitStyle) {
6687 FormatStyle Style = getWebKitStyle();
6688
6689 // Don't indent in outer namespaces.
6690 verifyFormat("namespace outer {\n"
6691 "int i;\n"
6692 "namespace inner {\n"
Daniel Jaspereff18b92013-07-31 23:16:02 +00006693 " int i;\n"
Daniel Jaspere05dc6d2013-07-24 13:10:59 +00006694 "} // namespace inner\n"
6695 "} // namespace outer\n"
6696 "namespace other_outer {\n"
6697 "int i;\n"
6698 "}",
6699 Style);
6700
6701 // Don't indent case labels.
6702 verifyFormat("switch (variable) {\n"
6703 "case 1:\n"
6704 "case 2:\n"
6705 " doSomething();\n"
6706 " break;\n"
6707 "default:\n"
6708 " ++variable;\n"
6709 "}",
6710 Style);
6711
6712 // Wrap before binary operators.
6713 EXPECT_EQ(
6714 "void f()\n"
6715 "{\n"
6716 " if (aaaaaaaaaaaaaaaa\n"
6717 " && bbbbbbbbbbbbbbbbbbbbbbbb\n"
6718 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
6719 " return;\n"
6720 "}",
6721 format(
6722 "void f() {\n"
6723 "if (aaaaaaaaaaaaaaaa\n"
6724 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
6725 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
6726 "return;\n"
6727 "}",
6728 Style));
6729
6730 // Constructor initializers are formatted one per line with the "," on the
6731 // new line.
Daniel Jaspere8b10d32013-07-26 16:56:36 +00006732 verifyFormat("Constructor()\n"
6733 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6734 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
6735 " aaaaaaaaaaaaaa)\n"
6736 " , aaaaaaaaaaaaaaaaaaaaaaa()\n{\n}",
6737 Style);
Daniel Jaspere05dc6d2013-07-24 13:10:59 +00006738
Daniel Jaspereff18b92013-07-31 23:16:02 +00006739 // Access specifiers should be aligned left.
6740 verifyFormat("class C {\n"
6741 "public:\n"
6742 " int i;\n"
6743 "};",
6744 Style);
6745
Daniel Jaspere05dc6d2013-07-24 13:10:59 +00006746 // Do not align comments.
Daniel Jasper893ea8d2013-07-31 23:55:15 +00006747 verifyFormat("int a; // Do not\n"
6748 "double b; // align comments.",
6749 Style);
Daniel Jaspere05dc6d2013-07-24 13:10:59 +00006750
6751 // Accept input's line breaks.
6752 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
6753 " || bbbbbbbbbbbbbbb) {\n"
6754 " i++;\n"
6755 "}",
6756 format("if (aaaaaaaaaaaaaaa\n"
6757 "|| bbbbbbbbbbbbbbb) { i++; }",
6758 Style));
6759 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
6760 " i++;\n"
6761 "}",
6762 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
6763}
6764
Daniel Jasperec172262013-08-30 10:36:58 +00006765TEST_F(FormatTest, FormatsProtocolBufferDefinitions) {
6766 // It seems that clang-format can format protocol buffer definitions
6767 // (see https://code.google.com/p/protobuf/).
6768 verifyFormat("message SomeMessage {\n"
6769 " required int32 field1 = 1;\n"
6770 " optional string field2 = 2 [default = \"2\"]\n"
6771 "}");
6772}
6773
Manuel Klimekb61a8af2013-09-03 15:10:01 +00006774TEST_F(FormatTest, FormatsLambdas) {
Daniel Jasper567dcf92013-09-05 09:29:45 +00006775 verifyFormat("int c = [b]() mutable {\n"
6776 " return [&b] { return b++; }();\n"
6777 "}();\n");
6778 verifyFormat("int c = [&] {\n"
6779 " [=] { return b++; }();\n"
6780 "}();\n");
6781 verifyFormat("int c = [&, &a, a] {\n"
6782 " [=, c, &d] { return b++; }();\n"
6783 "}();\n");
6784 verifyFormat("int c = [&a, &a, a] {\n"
6785 " [=, a, b, &c] { return b++; }();\n"
6786 "}();\n");
6787 verifyFormat("auto c = { [&a, &a, a] {\n"
6788 " [=, a, b, &c] { return b++; }();\n"
6789 "} }\n");
Daniel Jasper14e25c02013-09-08 14:07:57 +00006790 verifyFormat("auto c = { [&a, &a, a] { [=, a, b, &c] {}(); } }\n");
Daniel Jasper567dcf92013-09-05 09:29:45 +00006791 verifyFormat("void f() {\n"
6792 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
6793 "}\n");
Daniel Jasper567dcf92013-09-05 09:29:45 +00006794 verifyFormat("void f() {\n"
6795 " other(x.begin(), //\n"
6796 " x.end(), //\n"
Daniel Jasperac2c9742013-09-05 10:04:31 +00006797 " [&](int, int) { return 1; });\n"
Daniel Jasper567dcf92013-09-05 09:29:45 +00006798 "}\n");
Daniel Jasper2d657052013-09-05 11:49:39 +00006799
6800 // Not lambdas.
6801 verifyFormat("constexpr char hello[]{ \"hello\" };");
Daniel Jasper520cca82013-09-06 21:25:51 +00006802 verifyFormat("double &operator[](int i) { return 0; }\n"
6803 "int i;");
Manuel Klimekb61a8af2013-09-03 15:10:01 +00006804}
6805
Manuel Klimek753a5112013-09-04 13:25:30 +00006806TEST_F(FormatTest, FormatsBlocks) {
6807 // FIXME: Make whitespace formatting consistent. Ask a ObjC dev how
6808 // it would ideally look.
Daniel Jasper567dcf92013-09-05 09:29:45 +00006809 verifyFormat("[operation setCompletionBlock:^{ [self onOperationDone]; }];");
6810 verifyFormat("int i = {[operation setCompletionBlock : ^{ [self "
6811 "onOperationDone]; }] };");
Manuel Klimek753a5112013-09-04 13:25:30 +00006812}
6813
Alexander Kornienko73d845c2013-09-11 12:25:57 +00006814TEST_F(FormatTest, SupportsCRLF) {
6815 EXPECT_EQ("int a;\r\n"
6816 "int b;\r\n"
6817 "int c;\r\n",
6818 format("int a;\r\n"
6819 " int b;\r\n"
6820 " int c;\r\n",
6821 getLLVMStyle()));
6822 EXPECT_EQ("int a;\r\n"
6823 "int b;\r\n"
6824 "int c;\r\n",
6825 format("int a;\r\n"
6826 " int b;\n"
6827 " int c;\r\n",
6828 getLLVMStyle()));
6829 EXPECT_EQ("int a;\n"
6830 "int b;\n"
6831 "int c;\n",
6832 format("int a;\r\n"
6833 " int b;\n"
6834 " int c;\n",
6835 getLLVMStyle()));
6836 EXPECT_EQ("\"aaaaaaa \"\r\n"
6837 "\"bbbbbbb\";\r\n",
6838 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
6839 EXPECT_EQ("#define A \\\r\n"
6840 " b; \\\r\n"
6841 " c; \\\r\n"
6842 " d;\r\n",
6843 format("#define A \\\r\n"
6844 " b; \\\r\n"
6845 " c; d; \r\n",
6846 getGoogleStyle()));
6847}
6848
Daniel Jaspercd162382013-01-07 13:26:07 +00006849} // end namespace tooling
6850} // end namespace clang