blob: d49d49ffe3b1b4b11fec13dc514b45a94ec1fef0 [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) {
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +00001876 verifyFormat(
Daniel Jasper1407bee2013-04-11 14:29:13 +00001877 "virtual void write(ELFWriter *writerrr,\n"
1878 " OwningPtr<FileOutputBuffer> &buffer) = 0;");
Daniel Jasper71607512013-01-07 10:48:50 +00001879}
1880
Manuel Klimekbd04f2a2013-01-31 15:58:48 +00001881TEST_F(FormatTest, LayoutUnknownPPDirective) {
1882 EXPECT_EQ("#123 \"A string literal\"",
1883 format(" # 123 \"A string literal\""));
1884 EXPECT_EQ("#;", format("#;"));
Manuel Klimekdd5b1012013-01-07 10:03:37 +00001885 verifyFormat("#\n;\n;\n;");
Manuel Klimeka080a182013-01-02 16:30:12 +00001886}
1887
1888TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) {
1889 EXPECT_EQ("#line 42 \"test\"\n",
1890 format("# \\\n line \\\n 42 \\\n \"test\"\n"));
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001891 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n",
1892 getLLVMStyleWithColumns(12)));
Manuel Klimeka080a182013-01-02 16:30:12 +00001893}
1894
1895TEST_F(FormatTest, EndOfFileEndsPPDirective) {
1896 EXPECT_EQ("#line 42 \"test\"",
1897 format("# \\\n line \\\n 42 \\\n \"test\""));
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001898 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B"));
Manuel Klimeka080a182013-01-02 16:30:12 +00001899}
1900
Daniel Jasper1d82b1a2013-10-11 19:45:02 +00001901TEST_F(FormatTest, DoesntRemoveUnknownTokens) {
1902 verifyFormat("#define A \\x20");
1903 verifyFormat("#define A \\ x20");
1904 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20"));
1905 verifyFormat("#define A ''");
1906 verifyFormat("#define A ''qqq");
1907 verifyFormat("#define A `qqq");
1908 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");
1909}
1910
Manuel Klimek060143e2013-01-02 18:33:23 +00001911TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {
Daniel Jaspera4d46212013-02-28 11:05:57 +00001912 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
1913 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12));
Manuel Klimek060143e2013-01-02 18:33:23 +00001914 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12));
Daniel Jaspera4d46212013-02-28 11:05:57 +00001915 // FIXME: We never break before the macro name.
Daniel Jasperc9346c92013-08-28 09:07:32 +00001916 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12));
Daniel Jaspere0b15ea2013-01-14 15:40:57 +00001917
1918 verifyFormat("#define A A\n#define A A");
1919 verifyFormat("#define A(X) A\n#define A A");
1920
Daniel Jaspera4d46212013-02-28 11:05:57 +00001921 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
1922 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22));
Manuel Klimek060143e2013-01-02 18:33:23 +00001923}
1924
1925TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {
Alexander Kornienko9fdc00a2013-03-28 18:40:55 +00001926 EXPECT_EQ("// somecomment\n"
Manuel Klimekd4397b92013-01-04 23:34:14 +00001927 "#include \"a.h\"\n"
Daniel Jaspera4d46212013-02-28 11:05:57 +00001928 "#define A( \\\n"
1929 " A, B)\n"
Manuel Klimekd4397b92013-01-04 23:34:14 +00001930 "#include \"b.h\"\n"
Alexander Kornienko5262dd92013-03-27 11:52:18 +00001931 "// somecomment\n",
Alexander Kornienko9fdc00a2013-03-28 18:40:55 +00001932 format(" // somecomment\n"
Manuel Klimekd4397b92013-01-04 23:34:14 +00001933 " #include \"a.h\"\n"
1934 "#define A(A,\\\n"
1935 " B)\n"
1936 " #include \"b.h\"\n"
Alexander Kornienko5262dd92013-03-27 11:52:18 +00001937 " // somecomment\n",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001938 getLLVMStyleWithColumns(13)));
Manuel Klimek060143e2013-01-02 18:33:23 +00001939}
1940
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001941TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
Manuel Klimekd4397b92013-01-04 23:34:14 +00001942
1943TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
1944 EXPECT_EQ("#define A \\\n"
1945 " c; \\\n"
1946 " e;\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001947 "f;",
1948 format("#define A c; e;\n"
1949 "f;",
1950 getLLVMStyleWithColumns(14)));
Manuel Klimekd4397b92013-01-04 23:34:14 +00001951}
1952
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001953TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
Manuel Klimekd4397b92013-01-04 23:34:14 +00001954
Daniel Jasper89b3a7f2013-05-10 13:00:49 +00001955TEST_F(FormatTest, AlwaysFormatsEntireMacroDefinitions) {
1956 EXPECT_EQ("int i;\n"
1957 "#define A \\\n"
1958 " int i; \\\n"
1959 " int j\n"
1960 "int k;",
1961 format("int i;\n"
1962 "#define A \\\n"
1963 " int i ; \\\n"
1964 " int j\n"
1965 "int k;",
1966 8, 0, getGoogleStyle())); // 8: position of "#define".
1967 EXPECT_EQ("int i;\n"
1968 "#define A \\\n"
1969 " int i; \\\n"
1970 " int j\n"
1971 "int k;",
1972 format("int i;\n"
1973 "#define A \\\n"
1974 " int i ; \\\n"
1975 " int j\n"
1976 "int k;",
1977 45, 0, getGoogleStyle())); // 45: position of "j".
Manuel Klimekd4397b92013-01-04 23:34:14 +00001978}
1979
1980TEST_F(FormatTest, MacroDefinitionInsideStatement) {
Manuel Klimek526ed112013-01-09 15:25:02 +00001981 EXPECT_EQ("int x,\n"
1982 "#define A\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001983 " y;",
1984 format("int x,\n#define A\ny;"));
Manuel Klimekd4397b92013-01-04 23:34:14 +00001985}
1986
Manuel Klimek6f8424b2013-01-05 21:34:55 +00001987TEST_F(FormatTest, HashInMacroDefinition) {
Alexander Kornienkodaa07e92013-09-10 13:41:43 +00001988 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle()));
Manuel Klimek6f8424b2013-01-05 21:34:55 +00001989 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11));
Daniel Jasperc9346c92013-08-28 09:07:32 +00001990 verifyFormat("#define A \\\n"
1991 " { \\\n"
1992 " f(#c); \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001993 " }",
1994 getLLVMStyleWithColumns(11));
Daniel Jasper765561f2013-01-08 16:17:54 +00001995
1996 verifyFormat("#define A(X) \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00001997 " void function##X()",
1998 getLLVMStyleWithColumns(22));
Daniel Jasper765561f2013-01-08 16:17:54 +00001999
2000 verifyFormat("#define A(a, b, c) \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002001 " void a##b##c()",
2002 getLLVMStyleWithColumns(22));
Daniel Jasper765561f2013-01-08 16:17:54 +00002003
Daniel Jaspere0b15ea2013-01-14 15:40:57 +00002004 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
Manuel Klimek6f8424b2013-01-05 21:34:55 +00002005}
2006
Manuel Klimek7ccbc212013-01-23 14:37:36 +00002007TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) {
2008 verifyFormat("#define A (1)");
2009}
2010
Manuel Klimeka28fc062013-02-11 12:33:24 +00002011TEST_F(FormatTest, EmptyLinesInMacroDefinitions) {
2012 EXPECT_EQ("#define A b;", format("#define A \\\n"
2013 " \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002014 " b;",
2015 getLLVMStyleWithColumns(25)));
Manuel Klimeka28fc062013-02-11 12:33:24 +00002016 EXPECT_EQ("#define A \\\n"
2017 " \\\n"
2018 " a; \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002019 " b;",
2020 format("#define A \\\n"
2021 " \\\n"
2022 " a; \\\n"
2023 " b;",
2024 getLLVMStyleWithColumns(11)));
Manuel Klimeka28fc062013-02-11 12:33:24 +00002025 EXPECT_EQ("#define A \\\n"
2026 " a; \\\n"
2027 " \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002028 " b;",
2029 format("#define A \\\n"
2030 " a; \\\n"
2031 " \\\n"
2032 " b;",
2033 getLLVMStyleWithColumns(11)));
Manuel Klimeka28fc062013-02-11 12:33:24 +00002034}
2035
Daniel Jasper34511fb2013-02-19 17:14:38 +00002036TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
Daniel Jaspercf6d76a2013-03-18 12:50:26 +00002037 verifyFormat("#define A :");
Daniel Jasper34511fb2013-02-19 17:14:38 +00002038 verifyFormat("#define SOMECASES \\\n"
Daniel Jasperbcca7e42013-03-20 10:23:53 +00002039 " case 1: \\\n"
Daniel Jasper34511fb2013-02-19 17:14:38 +00002040 " case 2\n",
2041 getLLVMStyleWithColumns(20));
Daniel Jasper34511fb2013-02-19 17:14:38 +00002042 verifyFormat("#define A template <typename T>");
Daniel Jasper03628b82013-02-19 20:05:41 +00002043 verifyFormat("#define STR(x) #x\n"
2044 "f(STR(this_is_a_string_literal{));");
Daniel Jasper7143a212013-08-28 09:17:37 +00002045 verifyFormat("#pragma omp threadprivate( \\\n"
2046 " y)), // expected-warning",
2047 getLLVMStyleWithColumns(28));
Daniel Jasper34511fb2013-02-19 17:14:38 +00002048}
2049
Daniel Jasper7e70f4c2013-05-29 13:16:10 +00002050TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) {
2051 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
2052 EXPECT_EQ("class A : public QObject {\n"
2053 " Q_OBJECT\n"
2054 "\n"
2055 " A() {}\n"
2056 "};",
2057 format("class A : public QObject {\n"
2058 " Q_OBJECT\n"
2059 "\n"
2060 " A() {\n}\n"
2061 "} ;"));
Daniel Jasperc76d59d2013-05-29 14:09:17 +00002062 EXPECT_EQ("SOME_MACRO\n"
2063 "namespace {\n"
2064 "void f();\n"
2065 "}",
2066 format("SOME_MACRO\n"
2067 " namespace {\n"
2068 "void f( );\n"
2069 "}"));
Daniel Jasper7e70f4c2013-05-29 13:16:10 +00002070 // Only if the identifier contains at least 5 characters.
2071 EXPECT_EQ("HTTP f();",
2072 format("HTTP\nf();"));
2073 EXPECT_EQ("MACRO\nf();",
2074 format("MACRO\nf();"));
2075 // Only if everything is upper case.
2076 EXPECT_EQ("class A : public QObject {\n"
2077 " Q_Object A() {}\n"
2078 "};",
2079 format("class A : public QObject {\n"
2080 " Q_Object\n"
2081 "\n"
2082 " A() {\n}\n"
2083 "} ;"));
2084}
2085
Alexander Kornienko3d713a72013-04-08 22:16:06 +00002086TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) {
2087 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
2088 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
2089 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
Daniel Jasper8893b8a2013-05-31 14:56:20 +00002090 "class X {};\n"
Alexander Kornienko3d713a72013-04-08 22:16:06 +00002091 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
2092 "int *createScopDetectionPass() { return 0; }",
2093 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
2094 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
2095 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
2096 " class X {};\n"
2097 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
2098 " int *createScopDetectionPass() { return 0; }"));
Alexander Kornienko99b0e142013-04-09 16:15:19 +00002099 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as
2100 // braces, so that inner block is indented one level more.
2101 EXPECT_EQ("int q() {\n"
2102 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
2103 " IPC_MESSAGE_HANDLER(xxx, qqq)\n"
2104 " IPC_END_MESSAGE_MAP()\n"
2105 "}",
2106 format("int q() {\n"
2107 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
2108 " IPC_MESSAGE_HANDLER(xxx, qqq)\n"
2109 " IPC_END_MESSAGE_MAP()\n"
2110 "}"));
Daniel Jasper42ff2632013-09-17 09:26:07 +00002111
2112 // These must not be recognized as macros.
Alexander Kornienko99b0e142013-04-09 16:15:19 +00002113 EXPECT_EQ("int q() {\n"
2114 " f(x);\n"
2115 " f(x) {}\n"
2116 " f(x)->g();\n"
2117 " f(x)->*g();\n"
2118 " f(x).g();\n"
2119 " f(x) = x;\n"
2120 " f(x) += x;\n"
2121 " f(x) -= x;\n"
2122 " f(x) *= x;\n"
2123 " f(x) /= x;\n"
2124 " f(x) %= x;\n"
2125 " f(x) &= x;\n"
2126 " f(x) |= x;\n"
2127 " f(x) ^= x;\n"
2128 " f(x) >>= x;\n"
2129 " f(x) <<= x;\n"
2130 " f(x)[y].z();\n"
2131 " LOG(INFO) << x;\n"
2132 " ifstream(x) >> x;\n"
2133 "}\n",
2134 format("int q() {\n"
2135 " f(x)\n;\n"
2136 " f(x)\n {}\n"
2137 " f(x)\n->g();\n"
2138 " f(x)\n->*g();\n"
2139 " f(x)\n.g();\n"
2140 " f(x)\n = x;\n"
2141 " f(x)\n += x;\n"
2142 " f(x)\n -= x;\n"
2143 " f(x)\n *= x;\n"
2144 " f(x)\n /= x;\n"
2145 " f(x)\n %= x;\n"
2146 " f(x)\n &= x;\n"
2147 " f(x)\n |= x;\n"
2148 " f(x)\n ^= x;\n"
2149 " f(x)\n >>= x;\n"
2150 " f(x)\n <<= x;\n"
2151 " f(x)\n[y].z();\n"
2152 " LOG(INFO)\n << x;\n"
2153 " ifstream(x)\n >> x;\n"
2154 "}\n"));
2155 EXPECT_EQ("int q() {\n"
2156 " f(x)\n"
2157 " if (1) {\n"
2158 " }\n"
2159 " f(x)\n"
2160 " while (1) {\n"
2161 " }\n"
2162 " f(x)\n"
2163 " g(x);\n"
2164 " f(x)\n"
2165 " try {\n"
2166 " q();\n"
2167 " }\n"
2168 " catch (...) {\n"
2169 " }\n"
2170 "}\n",
2171 format("int q() {\n"
2172 "f(x)\n"
2173 "if (1) {}\n"
2174 "f(x)\n"
2175 "while (1) {}\n"
2176 "f(x)\n"
2177 "g(x);\n"
2178 "f(x)\n"
2179 "try { q(); } catch (...) {}\n"
2180 "}\n"));
2181 EXPECT_EQ("class A {\n"
2182 " A() : t(0) {}\n"
2183 " A(X x)\n" // FIXME: function-level try blocks are broken.
2184 " try : t(0) {\n"
2185 " }\n"
2186 " catch (...) {\n"
2187 " }\n"
2188 "};",
2189 format("class A {\n"
2190 " A()\n : t(0) {}\n"
2191 " A(X x)\n"
2192 " try : t(0) {} catch (...) {}\n"
2193 "};"));
Alexander Kornienko3d713a72013-04-08 22:16:06 +00002194}
2195
Manuel Klimeke573c3f2013-05-22 12:51:29 +00002196TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) {
2197 verifyFormat("#define A \\\n"
2198 " f({ \\\n"
2199 " g(); \\\n"
2200 " });", getLLVMStyleWithColumns(11));
2201}
2202
Manuel Klimekc37b4d62013-01-05 22:14:16 +00002203TEST_F(FormatTest, IndentPreprocessorDirectivesAtZero) {
2204 EXPECT_EQ("{\n {\n#define A\n }\n}", format("{{\n#define A\n}}"));
2205}
2206
Manuel Klimekf6fd00b2013-01-05 22:56:06 +00002207TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) {
Manuel Klimek517e8942013-01-11 17:54:10 +00002208 verifyFormat("{\n { a #c; }\n}");
Manuel Klimekf6fd00b2013-01-05 22:56:06 +00002209}
2210
Manuel Klimeka5342db2013-01-06 20:07:31 +00002211TEST_F(FormatTest, FormatUnbalancedStructuralElements) {
2212 EXPECT_EQ("#define A \\\n { \\\n {\nint i;",
2213 format("#define A { {\nint i;", getLLVMStyleWithColumns(11)));
2214 EXPECT_EQ("#define A \\\n } \\\n }\nint i;",
2215 format("#define A } }\nint i;", getLLVMStyleWithColumns(11)));
2216}
Manuel Klimekd4397b92013-01-04 23:34:14 +00002217
Alexander Kornienko54e6c9d2013-06-07 17:45:07 +00002218TEST_F(FormatTest, EscapedNewlineAtStartOfToken) {
Daniel Jaspercd162382013-01-07 13:26:07 +00002219 EXPECT_EQ(
2220 "#define A \\\n int i; \\\n int j;",
2221 format("#define A \\\nint i;\\\n int j;", getLLVMStyleWithColumns(11)));
Alexander Kornienko54e6c9d2013-06-07 17:45:07 +00002222 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
Manuel Klimek95419382013-01-07 07:56:50 +00002223}
2224
Alexander Kornienko16a0ec62013-06-14 11:46:10 +00002225TEST_F(FormatTest, NoEscapedNewlineHandlingInBlockComments) {
2226 EXPECT_EQ("/* \\ \\ \\\n*/", format("\\\n/* \\ \\ \\\n*/"));
2227}
2228
Manuel Klimekd544c572013-01-07 09:24:17 +00002229TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) {
2230 verifyFormat("#define A \\\n"
2231 " int v( \\\n"
2232 " a); \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002233 " int i;",
2234 getLLVMStyleWithColumns(11));
Manuel Klimekd544c572013-01-07 09:24:17 +00002235}
2236
Manuel Klimeka080a182013-01-02 16:30:12 +00002237TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) {
Manuel Klimekd4397b92013-01-04 23:34:14 +00002238 EXPECT_EQ(
2239 "#define ALooooooooooooooooooooooooooooooooooooooongMacro("
2240 " \\\n"
2241 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
2242 "\n"
2243 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
2244 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n",
2245 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro("
2246 "\\\n"
2247 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
2248 " \n"
2249 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
2250 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n"));
Manuel Klimeka080a182013-01-02 16:30:12 +00002251}
2252
Manuel Klimek526ed112013-01-09 15:25:02 +00002253TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {
2254 EXPECT_EQ("int\n"
2255 "#define A\n"
Daniel Jasper53e72cd2013-05-06 08:27:33 +00002256 " a;",
Manuel Klimeka9a7f102013-06-21 17:25:42 +00002257 format("int\n#define A\na;", getGoogleStyle()));
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002258 verifyFormat("functionCallTo(\n"
2259 " someOtherFunction(\n"
2260 " withSomeParameters, whichInSequence,\n"
2261 " areLongerThanALine(andAnotherCall,\n"
2262 "#define A B\n"
2263 " withMoreParamters,\n"
2264 " whichStronglyInfluenceTheLayout),\n"
Daniel Jasper7d812812013-02-21 15:00:29 +00002265 " andMoreParameters),\n"
2266 " trailing);",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002267 getLLVMStyleWithColumns(69));
Daniel Jasperebaa1712013-09-17 09:52:48 +00002268 verifyFormat("Foo::Foo()\n"
2269 "#ifdef BAR\n"
2270 " : baz(0)\n"
2271 "#endif\n"
2272 "{\n"
2273 "}");
Manuel Klimekae76f7f2013-10-11 21:25:45 +00002274 verifyFormat("void f() {\n"
2275 " if (true)\n"
2276 "#ifdef A\n"
2277 " f(42);\n"
2278 " x();\n"
2279 "#else\n"
2280 " g();\n"
2281 " x();\n"
2282 "#endif\n"
2283 "}");
2284 verifyFormat("void f(param1, param2,\n"
2285 " param3,\n"
2286 "#ifdef A\n"
2287 " param4(param5,\n"
2288 "#ifdef A1\n"
2289 " param6,\n"
2290 "#ifdef A2\n"
2291 " param7),\n"
2292 "#else\n"
2293 " param8),\n"
2294 " param9,\n"
2295 "#endif\n"
2296 " param10,\n"
2297 "#endif\n"
2298 " param11)\n"
2299 "#else\n"
2300 " param12)\n"
2301 "#endif\n"
2302 "{\n"
2303 " x();\n"
2304 "}",
2305 getLLVMStyleWithColumns(28));
Manuel Klimek526ed112013-01-09 15:25:02 +00002306}
2307
Manuel Klimekbb42bf12013-01-10 11:52:21 +00002308TEST_F(FormatTest, LayoutBlockInsideParens) {
Daniel Jasper567dcf92013-09-05 09:29:45 +00002309 EXPECT_EQ("functionCall({ int i; });", format(" functionCall ( {int i;} );"));
Manuel Klimekbb42bf12013-01-10 11:52:21 +00002310 EXPECT_EQ("functionCall({\n"
2311 " int i;\n"
Daniel Jasper567dcf92013-09-05 09:29:45 +00002312 " int j;\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002313 "});",
Daniel Jasper567dcf92013-09-05 09:29:45 +00002314 format(" functionCall ( {int i;int j;} );"));
Daniel Jasperf7ec1cc2013-05-31 14:56:29 +00002315 EXPECT_EQ("functionCall({\n"
Daniel Jasper567dcf92013-09-05 09:29:45 +00002316 " int i;\n"
2317 " int j;\n"
2318 " },\n"
Daniel Jasperf7ec1cc2013-05-31 14:56:29 +00002319 " aaaa, bbbb, cccc);",
Daniel Jasper567dcf92013-09-05 09:29:45 +00002320 format(" functionCall ( {int i;int j;}, aaaa, bbbb, cccc);"));
2321 EXPECT_EQ("functionCall(aaaa, bbbb, { int i; });",
2322 format(" functionCall (aaaa, bbbb, {int i;});"));
2323 EXPECT_EQ("functionCall(aaaa, bbbb, {\n"
2324 " int i;\n"
2325 " int j;\n"
2326 "});",
2327 format(" functionCall (aaaa, bbbb, {int i;int j;});"));
2328 EXPECT_EQ("functionCall(aaaa, bbbb, { int i; });",
2329 format(" functionCall (aaaa, bbbb, {int i;});"));
Daniel Jasperf7ec1cc2013-05-31 14:56:29 +00002330 verifyFormat(
2331 "Aaa({\n"
Daniel Jasper567dcf92013-09-05 09:29:45 +00002332 " int i; // break\n"
2333 " },\n"
Daniel Jasperf7ec1cc2013-05-31 14:56:29 +00002334 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
2335 " ccccccccccccccccc));");
Daniel Jasper567dcf92013-09-05 09:29:45 +00002336 verifyFormat("DEBUG({\n"
2337 " if (a)\n"
2338 " f();\n"
2339 "});");
Manuel Klimekbb42bf12013-01-10 11:52:21 +00002340}
2341
2342TEST_F(FormatTest, LayoutBlockInsideStatement) {
Manuel Klimek517e8942013-01-11 17:54:10 +00002343 EXPECT_EQ("SOME_MACRO { int i; }\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002344 "int i;",
2345 format(" SOME_MACRO {int i;} int i;"));
Manuel Klimekbb42bf12013-01-10 11:52:21 +00002346}
2347
2348TEST_F(FormatTest, LayoutNestedBlocks) {
2349 verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
2350 " struct s {\n"
2351 " int i;\n"
2352 " };\n"
2353 " s kBitsToOs[] = { { 10 } };\n"
2354 " for (int i = 0; i < 10; ++i)\n"
2355 " return;\n"
2356 "}");
Daniel Jasperb77d7412013-09-06 07:54:20 +00002357 verifyFormat("call(parameter, {\n"
2358 " something();\n"
2359 " // Comment using all columns.\n"
2360 " somethingelse();\n"
2361 "});",
2362 getLLVMStyleWithColumns(40));
2363 EXPECT_EQ("call(parameter, {\n"
2364 " something();\n"
2365 " // Comment too\n"
2366 " // looooooooooong.\n"
2367 " somethingElse();\n"
2368 "});",
2369 format("call(parameter, {\n"
2370 " something();\n"
2371 " // Comment too looooooooooong.\n"
2372 " somethingElse();\n"
2373 "});",
2374 getLLVMStyleWithColumns(29)));
Daniel Jasper14e25c02013-09-08 14:07:57 +00002375 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });"));
2376 EXPECT_EQ("DEBUG({\n"
2377 " int i;\n"
2378 "\n"
2379 " // comment\n"
2380 " int j;\n"
2381 "});",
2382 format("DEBUG({\n"
2383 " int i;\n"
2384 "\n"
2385 " // comment\n"
2386 " int j;\n"
2387 "});"));
Manuel Klimekbb42bf12013-01-10 11:52:21 +00002388}
2389
Manuel Klimek36fab8d2013-01-10 13:24:24 +00002390TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) {
2391 EXPECT_EQ("{}", format("{}"));
Daniel Jasper8893b8a2013-05-31 14:56:20 +00002392 verifyFormat("enum E {};");
Manuel Klimek2f1ac412013-01-21 16:42:44 +00002393 verifyFormat("enum E {}");
Manuel Klimek36fab8d2013-01-10 13:24:24 +00002394}
2395
Alexander Kornienko15757312012-12-06 18:03:27 +00002396//===----------------------------------------------------------------------===//
2397// Line break tests.
2398//===----------------------------------------------------------------------===//
2399
Daniel Jasper13d2aa52013-08-30 08:29:25 +00002400TEST_F(FormatTest, PreventConfusingIndents) {
Alexander Kornienko15757312012-12-06 18:03:27 +00002401 verifyFormat(
Daniel Jasper986e17f2013-01-28 07:35:34 +00002402 "SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n"
2403 " parameter, parameter, parameter)),\n"
Daniel Jaspera4974cf2012-12-24 16:43:00 +00002404 " SecondLongCall(parameter));");
Daniel Jasper986e17f2013-01-28 07:35:34 +00002405 verifyFormat(
2406 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2407 " aaaaaaaaaaaaaaaaaaaaaaaa(\n"
2408 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
2409 " aaaaaaaaaaaaaaaaaaaaaaaa);");
2410 verifyFormat(
Daniel Jasper011c35d2013-07-12 11:19:37 +00002411 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2412 " [aaaaaaaaaaaaaaaaaaaaaaaa\n"
2413 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
2414 " [aaaaaaaaaaaaaaaaaaaaaaaa]];");
Daniel Jasper986e17f2013-01-28 07:35:34 +00002415 verifyFormat(
2416 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
2417 " aaaaaaaaaaaaaaaaaaaaaaaa<\n"
2418 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n"
2419 " aaaaaaaaaaaaaaaaaaaaaaaa>;");
Daniel Jasperae8699b2013-01-28 09:35:24 +00002420 verifyFormat("int a = bbbb && ccc && fffff(\n"
2421 "#define A Just forcing a new line\n"
2422 " ddd);");
Daniel Jasper986e17f2013-01-28 07:35:34 +00002423}
2424
Daniel Jasper11e13802013-05-08 14:12:04 +00002425TEST_F(FormatTest, LineBreakingInBinaryExpressions) {
2426 verifyFormat(
2427 "bool aaaaaaa =\n"
2428 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n"
2429 " bbbbbbbb();");
2430 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
2431 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n"
2432 " ccccccccc == ddddddddddd;");
2433
2434 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
2435 " aaaaaa) &&\n"
2436 " bbbbbb && cccccc;");
Daniel Jasper69c43712013-05-28 07:42:44 +00002437 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
2438 " aaaaaa) >>\n"
2439 " bbbbbb;");
Daniel Jasper11e13802013-05-08 14:12:04 +00002440 verifyFormat("Whitespaces.addUntouchableComment(\n"
2441 " SourceMgr.getSpellingColumnNumber(\n"
2442 " TheLine.Last->FormatTok.Tok.getLocation()) -\n"
2443 " 1);");
Daniel Jasperd741f022013-05-14 20:39:56 +00002444
Daniel Jasper5ef8aac2013-06-03 08:42:05 +00002445 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
2446 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n"
2447 " cccccc) {\n}");
2448
Daniel Jasper6df7a2d2013-07-03 10:34:47 +00002449 // If the LHS of a comparison is not a binary expression itself, the
2450 // additional linebreak confuses many people.
2451 verifyFormat(
2452 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2453 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n"
2454 "}");
2455 verifyFormat(
2456 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2457 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
2458 "}");
Daniel Jasperdb4813a2013-09-06 08:08:14 +00002459 verifyFormat(
2460 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n"
2461 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
2462 "}");
Daniel Jasper6df7a2d2013-07-03 10:34:47 +00002463 // Even explicit parentheses stress the precedence enough to make the
2464 // additional break unnecessary.
2465 verifyFormat(
2466 "if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2467 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
2468 "}");
2469 // This cases is borderline, but with the indentation it is still readable.
2470 verifyFormat(
2471 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2472 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2473 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
2474 "}",
2475 getLLVMStyleWithColumns(75));
2476
2477 // If the LHS is a binary expression, we should still use the additional break
2478 // as otherwise the formatting hides the operator precedence.
2479 verifyFormat(
2480 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2481 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2482 " 5) {\n"
2483 "}");
2484
Daniel Jasperd741f022013-05-14 20:39:56 +00002485 FormatStyle OnePerLine = getLLVMStyle();
2486 OnePerLine.BinPackParameters = false;
2487 verifyFormat(
2488 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
2489 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
2490 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}",
2491 OnePerLine);
Daniel Jasper11e13802013-05-08 14:12:04 +00002492}
2493
Daniel Jasperbf71ba22013-04-08 20:33:42 +00002494TEST_F(FormatTest, ExpressionIndentation) {
2495 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2496 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2497 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2498 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2499 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
2500 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n"
2501 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2502 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n"
2503 " ccccccccccccccccccccccccccccccccccccccccc;");
2504 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2505 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2506 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2507 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
2508 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2509 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2510 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2511 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
2512 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2513 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2514 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2515 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
Daniel Jasper9acb8b42013-06-06 09:11:58 +00002516 verifyFormat("if () {\n"
2517 "} else if (aaaaa && bbbbb > // break\n"
2518 " ccccc) {\n"
2519 "}");
Alexander Kornienkod71b15b2013-06-17 13:19:53 +00002520
2521 // Presence of a trailing comment used to change indentation of b.
2522 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
2523 " b;\n"
2524 "return aaaaaaaaaaaaaaaaaaa +\n"
2525 " b; //",
2526 getLLVMStyleWithColumns(30));
Daniel Jasperbf71ba22013-04-08 20:33:42 +00002527}
2528
Daniel Jaspere8b10d32013-07-26 16:56:36 +00002529TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) {
2530 // Not sure what the best system is here. Like this, the LHS can be found
2531 // immediately above an operator (everything with the same or a higher
2532 // indent). The RHS is aligned right of the operator and so compasses
2533 // everything until something with the same indent as the operator is found.
2534 // FIXME: Is this a good system?
2535 FormatStyle Style = getLLVMStyle();
2536 Style.BreakBeforeBinaryOperators = true;
2537 verifyFormat(
2538 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2539 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2540 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2541 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2542 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
2543 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
2544 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2545 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2546 " > ccccccccccccccccccccccccccccccccccccccccc;",
2547 Style);
2548 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2549 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2550 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2551 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
2552 Style);
2553 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2554 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2555 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2556 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
2557 Style);
2558 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2559 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2560 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2561 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
2562 Style);
2563 verifyFormat("if () {\n"
2564 "} else if (aaaaa && bbbbb // break\n"
2565 " > ccccc) {\n"
2566 "}",
2567 Style);
2568}
2569
Daniel Jasper1321eb52012-12-18 21:05:13 +00002570TEST_F(FormatTest, ConstructorInitializers) {
Manuel Klimek36fab8d2013-01-10 13:24:24 +00002571 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
Daniel Jasper7e9bf8c2013-01-11 11:37:55 +00002572 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
2573 getLLVMStyleWithColumns(45));
Daniel Jasperf11a7052013-02-21 21:33:55 +00002574 verifyFormat("Constructor()\n"
2575 " : Inttializer(FitsOnTheLine) {}",
Daniel Jasper7e9bf8c2013-01-11 11:37:55 +00002576 getLLVMStyleWithColumns(44));
Manuel Klimek2f1ac412013-01-21 16:42:44 +00002577 verifyFormat("Constructor()\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002578 " : Inttializer(FitsOnTheLine) {}",
Manuel Klimek2f1ac412013-01-21 16:42:44 +00002579 getLLVMStyleWithColumns(43));
Daniel Jasper1321eb52012-12-18 21:05:13 +00002580
2581 verifyFormat(
2582 "SomeClass::Constructor()\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002583 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
Daniel Jasper1321eb52012-12-18 21:05:13 +00002584
2585 verifyFormat(
2586 "SomeClass::Constructor()\n"
Daniel Jasper7e9bf8c2013-01-11 11:37:55 +00002587 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002588 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}");
Daniel Jasper7e9bf8c2013-01-11 11:37:55 +00002589 verifyFormat(
2590 "SomeClass::Constructor()\n"
Daniel Jasper1321eb52012-12-18 21:05:13 +00002591 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002592 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
Daniel Jasper1321eb52012-12-18 21:05:13 +00002593
2594 verifyFormat("Constructor()\n"
2595 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
2596 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2597 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002598 " aaaaaaaaaaaaaaaaaaaaaaa() {}");
Daniel Jasper1321eb52012-12-18 21:05:13 +00002599
Daniel Jasper02b771e2013-01-28 13:31:35 +00002600 verifyFormat("Constructor()\n"
2601 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002602 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasper02b771e2013-01-28 13:31:35 +00002603
Daniel Jasper9c3e71a2013-02-25 15:59:54 +00002604 verifyFormat("Constructor(int Parameter = 0)\n"
2605 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
2606 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}");
Daniel Jasper00e0f432013-09-06 21:46:41 +00002607 verifyFormat("Constructor()\n"
2608 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
2609 "}",
2610 getLLVMStyleWithColumns(60));
Daniel Jasper9c3e71a2013-02-25 15:59:54 +00002611
Daniel Jasper1321eb52012-12-18 21:05:13 +00002612 // Here a line could be saved by splitting the second initializer onto two
2613 // lines, but that is not desireable.
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002614 verifyFormat("Constructor()\n"
2615 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
2616 " aaaaaaaaaaa(aaaaaaaaaaa),\n"
2617 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasper1321eb52012-12-18 21:05:13 +00002618
Daniel Jasperb130a542013-02-15 16:49:44 +00002619 FormatStyle OnePerLine = getLLVMStyle();
2620 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
2621 verifyFormat("SomeClass::Constructor()\n"
2622 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
2623 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002624 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002625 OnePerLine);
Daniel Jasperb130a542013-02-15 16:49:44 +00002626 verifyFormat("SomeClass::Constructor()\n"
2627 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
2628 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002629 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002630 OnePerLine);
Daniel Jasperb130a542013-02-15 16:49:44 +00002631 verifyFormat("MyClass::MyClass(int var)\n"
2632 " : some_var_(var), // 4 space indent\n"
2633 " some_other_var_(var + 1) { // lined up\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002634 "}",
2635 OnePerLine);
Daniel Jasper3a39ac72013-02-28 09:39:12 +00002636 verifyFormat("Constructor()\n"
2637 " : aaaaa(aaaaaa),\n"
2638 " aaaaa(aaaaaa),\n"
2639 " aaaaa(aaaaaa),\n"
2640 " aaaaa(aaaaaa),\n"
2641 " aaaaa(aaaaaa) {}",
2642 OnePerLine);
Daniel Jasper001bf4e2013-04-22 07:59:53 +00002643 verifyFormat("Constructor()\n"
2644 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
2645 " aaaaaaaaaaaaaaaaaaaaaa) {}",
2646 OnePerLine);
Daniel Jasperfca24bc2013-04-25 13:31:51 +00002647}
2648
2649TEST_F(FormatTest, MemoizationTests) {
2650 // This breaks if the memoization lookup does not take \c Indent and
2651 // \c LastSpace into account.
2652 verifyFormat(
2653 "extern CFRunLoopTimerRef\n"
2654 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
2655 " CFTimeInterval interval, CFOptionFlags flags,\n"
2656 " CFIndex order, CFRunLoopTimerCallBack callout,\n"
Daniel Jasper53e72cd2013-05-06 08:27:33 +00002657 " CFRunLoopTimerContext *context) {}");
Daniel Jasperfca24bc2013-04-25 13:31:51 +00002658
2659 // Deep nesting somewhat works around our memoization.
2660 verifyFormat(
2661 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
2662 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
2663 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
2664 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
2665 " aaaaa())))))))))))))))))))))))))))))))))))))));",
2666 getLLVMStyleWithColumns(65));
Daniel Jasperc3df5ff2013-05-13 09:19:24 +00002667 verifyFormat(
2668 "aaaaa(\n"
2669 " aaaaa,\n"
2670 " aaaaa(\n"
2671 " aaaaa,\n"
2672 " aaaaa(\n"
2673 " aaaaa,\n"
2674 " aaaaa(\n"
2675 " aaaaa,\n"
2676 " aaaaa(\n"
2677 " aaaaa,\n"
2678 " aaaaa(\n"
2679 " aaaaa,\n"
2680 " aaaaa(\n"
2681 " aaaaa,\n"
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))))))))))));",
2693 getLLVMStyleWithColumns(65));
Daniel Jasper54b4e442013-05-22 05:27:42 +00002694 verifyFormat(
2695 "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"
2696 " a),\n"
2697 " a),\n"
2698 " a),\n"
2699 " a),\n"
2700 " a),\n"
2701 " a),\n"
2702 " a),\n"
2703 " a),\n"
2704 " a),\n"
2705 " a),\n"
2706 " a),\n"
2707 " a),\n"
2708 " a),\n"
2709 " a),\n"
2710 " a),\n"
2711 " a),\n"
2712 " a)",
2713 getLLVMStyleWithColumns(65));
Daniel Jasperb3123142013-01-12 07:36:22 +00002714
2715 // This test takes VERY long when memoization is broken.
Daniel Jasperfca24bc2013-04-25 13:31:51 +00002716 FormatStyle OnePerLine = getLLVMStyle();
2717 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002718 OnePerLine.BinPackParameters = false;
Daniel Jasper0df6acd2013-01-16 14:59:02 +00002719 std::string input = "Constructor()\n"
Daniel Jasper3499dda2013-01-25 15:43:32 +00002720 " : aaaa(a,\n";
Daniel Jasper0df6acd2013-01-16 14:59:02 +00002721 for (unsigned i = 0, e = 80; i != e; ++i) {
2722 input += " a,\n";
2723 }
Daniel Jasperf11a7052013-02-21 21:33:55 +00002724 input += " a) {}";
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002725 verifyFormat(input, OnePerLine);
Daniel Jasper1321eb52012-12-18 21:05:13 +00002726}
2727
Alexander Kornienko15757312012-12-06 18:03:27 +00002728TEST_F(FormatTest, BreaksAsHighAsPossible) {
2729 verifyFormat(
Alexander Kornienko3fd9ccd2013-03-12 16:28:18 +00002730 "void f() {\n"
2731 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
2732 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
2733 " f();\n"
2734 "}");
Daniel Jasper518ee342013-02-26 13:59:14 +00002735 verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
Daniel Jasperbf71ba22013-04-08 20:33:42 +00002736 " Intervals[i - 1].getRange().getLast()) {\n}");
Alexander Kornienko15757312012-12-06 18:03:27 +00002737}
2738
Daniel Jasper1407bee2013-04-11 14:29:13 +00002739TEST_F(FormatTest, BreaksFunctionDeclarations) {
2740 // Principially, we break function declarations in a certain order:
2741 // 1) break amongst arguments.
2742 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
2743 " Cccccccccccccc cccccccccccccc);");
Daniel Jasper92495a82013-08-19 10:16:18 +00002744 verifyFormat(
2745 "template <class TemplateIt>\n"
2746 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n"
2747 " TemplateIt *stop) {}");
Daniel Jasper1407bee2013-04-11 14:29:13 +00002748
2749 // 2) break after return type.
Daniel Jasper53e72cd2013-05-06 08:27:33 +00002750 verifyFormat(
Manuel Klimeka9a7f102013-06-21 17:25:42 +00002751 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2752 " bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);",
2753 getGoogleStyle());
Daniel Jasper1407bee2013-04-11 14:29:13 +00002754
2755 // 3) break after (.
2756 verifyFormat(
2757 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00002758 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);",
2759 getGoogleStyle());
Daniel Jasper1407bee2013-04-11 14:29:13 +00002760
2761 // 4) break before after nested name specifiers.
2762 verifyFormat(
2763 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper53e72cd2013-05-06 08:27:33 +00002764 " SomeClasssssssssssssssssssssssssssssssssssssss::\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00002765 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);",
2766 getGoogleStyle());
Daniel Jasper1407bee2013-04-11 14:29:13 +00002767
2768 // However, there are exceptions, if a sufficient amount of lines can be
2769 // saved.
2770 // FIXME: The precise cut-offs wrt. the number of saved lines might need some
2771 // more adjusting.
2772 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
2773 " Cccccccccccccc cccccccccc,\n"
2774 " Cccccccccccccc cccccccccc,\n"
2775 " Cccccccccccccc cccccccccc,\n"
2776 " Cccccccccccccc cccccccccc);");
2777 verifyFormat(
Manuel Klimeka9a7f102013-06-21 17:25:42 +00002778 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper53e72cd2013-05-06 08:27:33 +00002779 " bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
2780 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00002781 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);",
2782 getGoogleStyle());
Daniel Jasper1407bee2013-04-11 14:29:13 +00002783 verifyFormat(
2784 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
2785 " Cccccccccccccc cccccccccc,\n"
2786 " Cccccccccccccc cccccccccc,\n"
2787 " Cccccccccccccc cccccccccc,\n"
2788 " Cccccccccccccc cccccccccc,\n"
2789 " Cccccccccccccc cccccccccc,\n"
2790 " Cccccccccccccc cccccccccc);");
2791 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
2792 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
2793 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
2794 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
2795 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
Daniel Jasper01218ff2013-04-15 22:36:37 +00002796
2797 // Break after multi-line parameters.
2798 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2799 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2800 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2801 " bbbb bbbb);");
Daniel Jasper6561f6a2013-07-09 07:43:55 +00002802
2803 // Treat overloaded operators like other functions.
2804 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
2805 "operator>(const SomeLoooooooooooooooooooooooooogType &other);");
Daniel Jasperc476ea92013-08-28 07:27:35 +00002806 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
2807 "operator>>(const SomeLooooooooooooooooooooooooogType &other);");
Daniel Jasper6561f6a2013-07-09 07:43:55 +00002808 verifyGoogleFormat(
2809 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n"
2810 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
Daniel Jasper1407bee2013-04-11 14:29:13 +00002811}
2812
Daniel Jasper2ca37412013-07-09 14:36:48 +00002813TEST_F(FormatTest, TrailingReturnType) {
2814 verifyFormat("auto foo() -> int;\n");
2815 verifyFormat("struct S {\n"
2816 " auto bar() const -> int;\n"
2817 "};");
2818 verifyFormat("template <size_t Order, typename T>\n"
2819 "auto load_img(const std::string &filename)\n"
2820 " -> alias::tensor<Order, T, mem::tag::cpu> {}");
Daniel Jasper3262f4c2013-07-11 14:33:06 +00002821
2822 // Not trailing return types.
2823 verifyFormat("void f() { auto a = b->c(); }");
Daniel Jasper2ca37412013-07-09 14:36:48 +00002824}
2825
Daniel Jaspere033e872013-05-21 09:16:31 +00002826TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) {
Daniel Jasper20a0f8c2013-07-11 21:02:56 +00002827 // Avoid breaking before trailing 'const'.
Daniel Jasper5ad72bb2013-05-22 08:28:26 +00002828 verifyFormat("void someLongFunction(\n"
2829 " int someLongParameter) const {}",
2830 getLLVMStyleWithColumns(46));
2831 FormatStyle Style = getGoogleStyle();
2832 Style.ColumnLimit = 47;
2833 verifyFormat("void\n"
2834 "someLongFunction(int someLongParameter) const {\n}",
2835 getLLVMStyleWithColumns(47));
2836 verifyFormat("void someLongFunction(\n"
2837 " int someLongParameter) const {}",
2838 Style);
2839 verifyFormat("LoooooongReturnType\n"
2840 "someLoooooooongFunction() const {}",
2841 getLLVMStyleWithColumns(47));
2842 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
2843 " const {}",
2844 Style);
Daniel Jaspere033e872013-05-21 09:16:31 +00002845
Daniel Jasper20a0f8c2013-07-11 21:02:56 +00002846 // Avoid breaking before other trailing annotations, if they are not
2847 // function-like.
2848 verifyFormat("void SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2849 " aaaaaaaaaaaaaaaaaaaaaaaaaa) OVERRIDE;");
Daniel Jasper6b3ff8c2013-09-27 08:29:16 +00002850 verifyFormat("void SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2851 " aaaaaaaaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;");
2852 verifyFormat("void SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2853 " aaaaaaaaaaaaaaaaaaaaaaaaaa) override final;");
Daniel Jasper20a0f8c2013-07-11 21:02:56 +00002854
2855 // Breaking before function-like trailing annotations is fine to keep them
2856 // close to their arguments.
Daniel Jaspere033e872013-05-21 09:16:31 +00002857 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
2858 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
2859 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
2860 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
2861 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
2862 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}");
2863
2864 verifyFormat(
2865 "void aaaaaaaaaaaaaaaaaa()\n"
2866 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
2867 " aaaaaaaaaaaaaaaaaaaaaaaaa));");
2868 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2869 " __attribute__((unused));");
2870 verifyFormat(
Manuel Klimeka9a7f102013-06-21 17:25:42 +00002871 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2872 " GUARDED_BY(aaaaaaaaaaaa);",
2873 getGoogleStyle());
Daniel Jasperc18cff32013-07-11 12:34:23 +00002874 verifyFormat(
2875 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2876 " GUARDED_BY(aaaaaaaaaaaa);",
2877 getGoogleStyle());
Daniel Jaspere033e872013-05-21 09:16:31 +00002878}
2879
Daniel Jasperbac016b2012-12-03 18:12:45 +00002880TEST_F(FormatTest, BreaksDesireably) {
2881 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
2882 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00002883 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
Daniel Jaspere438bac2013-01-23 20:41:06 +00002884 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2885 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
2886 "}");
Daniel Jasperbac016b2012-12-03 18:12:45 +00002887
2888 verifyFormat(
2889 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00002890 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasperbac016b2012-12-03 18:12:45 +00002891
2892 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2893 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2894 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jaspera88bb452012-12-04 10:50:12 +00002895
2896 verifyFormat(
2897 "aaaaaaaa(aaaaaaaaaaaaa, aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2898 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
2899 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2900 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));");
Daniel Jasper33182dd2012-12-05 14:57:28 +00002901
2902 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
2903 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
2904
Daniel Jasper723f0302013-01-02 14:40:02 +00002905 verifyFormat(
Alexander Kornienko3fd9ccd2013-03-12 16:28:18 +00002906 "void f() {\n"
2907 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
2908 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
2909 "}");
Daniel Jasper3499dda2013-01-25 15:43:32 +00002910 verifyFormat(
2911 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2912 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
2913 verifyFormat(
2914 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2915 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jasper64f09282013-03-20 13:53:11 +00002916 verifyFormat(
2917 "aaaaaaaaaaaaaaaaa(\n"
2918 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2919 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper723f0302013-01-02 14:40:02 +00002920
Daniel Jasper13d2aa52013-08-30 08:29:25 +00002921 // Indent consistently indenpendent of call expression.
2922 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
2923 " dddddddddddddddddddddddddddddd));\n"
2924 "aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
2925 " dddddddddddddddddddddddddddddd));");
2926
Daniel Jasper33182dd2012-12-05 14:57:28 +00002927 // This test case breaks on an incorrect memoization, i.e. an optimization not
2928 // taking into account the StopAt value.
2929 verifyFormat(
2930 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
Daniel Jaspercf225b62012-12-24 13:43:52 +00002931 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
2932 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
2933 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jaspera4974cf2012-12-24 16:43:00 +00002934
Daniel Jaspercd162382013-01-07 13:26:07 +00002935 verifyFormat("{\n {\n {\n"
2936 " Annotation.SpaceRequiredBefore =\n"
2937 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
2938 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
2939 " }\n }\n}");
Alexander Kornienko22d0e292013-06-17 12:59:44 +00002940
2941 // Break on an outer level if there was a break on an inner level.
2942 EXPECT_EQ("f(g(h(a, // comment\n"
2943 " b, c),\n"
2944 " d, e),\n"
2945 " x, y);",
2946 format("f(g(h(a, // comment\n"
2947 " b, c), d, e), x, y);"));
Daniel Jasper88cc5622013-07-08 14:25:23 +00002948
2949 // Prefer breaking similar line breaks.
2950 verifyFormat(
2951 "const int kTrackingOptions = NSTrackingMouseMoved |\n"
2952 " NSTrackingMouseEnteredAndExited |\n"
2953 " NSTrackingActiveAlways;");
Daniel Jasperbac016b2012-12-03 18:12:45 +00002954}
2955
Daniel Jasper0df6acd2013-01-16 14:59:02 +00002956TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +00002957 FormatStyle NoBinPacking = getGoogleStyle();
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002958 NoBinPacking.BinPackParameters = false;
2959 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
2960 " aaaaaaaaaaaaaaaaaaaa,\n"
2961 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);",
2962 NoBinPacking);
2963 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
2964 " aaaaaaaaaaaaa,\n"
2965 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));",
2966 NoBinPacking);
2967 verifyFormat(
Daniel Jasper0df6acd2013-01-16 14:59:02 +00002968 "aaaaaaaa(aaaaaaaaaaaaa,\n"
2969 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2970 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
2971 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002972 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));",
2973 NoBinPacking);
2974 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
2975 " .aaaaaaaaaaaaaaaaaa();",
2976 NoBinPacking);
2977 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2978 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);",
2979 NoBinPacking);
Daniel Jasper66d19bd2013-02-18 11:59:17 +00002980
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002981 verifyFormat(
Daniel Jasper8f4bd7a2013-01-23 10:08:28 +00002982 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2983 " aaaaaaaaaaaa,\n"
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002984 " aaaaaaaaaaaa);",
2985 NoBinPacking);
2986 verifyFormat(
Daniel Jasper0df6acd2013-01-16 14:59:02 +00002987 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
2988 " ddddddddddddddddddddddddddddd),\n"
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002989 " test);",
2990 NoBinPacking);
Daniel Jasper0df6acd2013-01-16 14:59:02 +00002991
Daniel Jasperfaab0d32013-02-27 09:47:53 +00002992 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
2993 " aaaaaaaaaaaaaaaaaaaaaaa,\n"
2994 " aaaaaaaaaaaaaaaaaaaaaaa> aaaaaaaaaaaaaaaaaa;",
2995 NoBinPacking);
2996 verifyFormat("a(\"a\"\n"
2997 " \"a\",\n"
2998 " a);");
Daniel Jasper8f4bd7a2013-01-23 10:08:28 +00002999
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003000 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
Daniel Jasperf1579602013-01-29 16:03:49 +00003001 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
Daniel Jasper8f4bd7a2013-01-23 10:08:28 +00003002 " aaaaaaaaa,\n"
Daniel Jasperf1579602013-01-29 16:03:49 +00003003 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003004 NoBinPacking);
Daniel Jasperfc759082013-02-14 14:26:07 +00003005 verifyFormat(
3006 "void f() {\n"
3007 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
3008 " .aaaaaaa();\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003009 "}",
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003010 NoBinPacking);
Daniel Jasper24e19e42013-05-22 08:55:55 +00003011 verifyFormat(
3012 "template <class SomeType, class SomeOtherType>\n"
3013 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
3014 NoBinPacking);
Daniel Jasper0df6acd2013-01-16 14:59:02 +00003015}
3016
Daniel Jasperc7bd68f2013-07-10 14:02:49 +00003017TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
3018 FormatStyle Style = getLLVMStyleWithColumns(15);
3019 Style.ExperimentalAutoDetectBinPacking = true;
3020 EXPECT_EQ("aaa(aaaa,\n"
3021 " aaaa,\n"
3022 " aaaa);\n"
3023 "aaa(aaaa,\n"
3024 " aaaa,\n"
3025 " aaaa);",
3026 format("aaa(aaaa,\n" // one-per-line
3027 " aaaa,\n"
3028 " aaaa );\n"
3029 "aaa(aaaa, aaaa, aaaa);", // inconclusive
3030 Style));
3031 EXPECT_EQ("aaa(aaaa, aaaa,\n"
3032 " aaaa);\n"
3033 "aaa(aaaa, aaaa,\n"
3034 " aaaa);",
3035 format("aaa(aaaa, aaaa,\n" // bin-packed
3036 " aaaa );\n"
3037 "aaa(aaaa, aaaa, aaaa);", // inconclusive
3038 Style));
3039}
3040
Daniel Jasperc79afda2013-01-18 10:56:38 +00003041TEST_F(FormatTest, FormatsBuilderPattern) {
3042 verifyFormat(
3043 "return llvm::StringSwitch<Reference::Kind>(name)\n"
Daniel Jasper29082452013-08-30 07:27:13 +00003044 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
3045 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
3046 " .StartsWith(\".init\", ORDER_INIT)\n"
3047 " .StartsWith(\".fini\", ORDER_FINI)\n"
3048 " .StartsWith(\".hash\", ORDER_HASH)\n"
3049 " .Default(ORDER_TEXT);\n");
Daniel Jasper33f4b902013-05-15 09:35:08 +00003050
Daniel Jasper4a544e52013-02-15 20:33:06 +00003051 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
Daniel Jasperbf71ba22013-04-08 20:33:42 +00003052 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
Daniel Jasper515f65d2013-02-18 13:24:21 +00003053 verifyFormat(
Daniel Jasperefed6872013-08-07 05:34:02 +00003054 "aaaaaaa->aaaaaaa->aaaaaaaaaaaaaaaa(\n"
3055 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
Daniel Jasper515f65d2013-02-18 13:24:21 +00003056 " ->aaaaaaaa(aaaaaaaaaaaaaaa);");
Daniel Jasper82282dc2013-02-18 13:52:06 +00003057 verifyFormat(
3058 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
Daniel Jasper24849712013-03-01 16:48:32 +00003059 " aaaaaaaaaaaaaa);");
Daniel Jasper82282dc2013-02-18 13:52:06 +00003060 verifyFormat(
Daniel Jasperd489f8c2013-08-27 11:09:05 +00003061 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n"
3062 " aaaaaa->aaaaaaaaaaaa()\n"
3063 " ->aaaaaaaaaaaaaaaa(\n"
3064 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3065 " ->aaaaaaaaaaaaaaaaa();");
3066 verifyFormat(
3067 "someobj->Add((new util::filetools::Handler(dir))\n"
3068 " ->OnEvent1(NewPermanentCallback(\n"
3069 " this, &HandlerHolderClass::EventHandlerCBA))\n"
3070 " ->OnEvent2(NewPermanentCallback(\n"
3071 " this, &HandlerHolderClass::EventHandlerCBB))\n"
3072 " ->OnEvent3(NewPermanentCallback(\n"
3073 " this, &HandlerHolderClass::EventHandlerCBC))\n"
3074 " ->OnEvent5(NewPermanentCallback(\n"
3075 " this, &HandlerHolderClass::EventHandlerCBD))\n"
3076 " ->OnEvent6(NewPermanentCallback(\n"
3077 " this, &HandlerHolderClass::EventHandlerCBE)));");
Daniel Jasperd3fef0f2013-08-27 14:24:43 +00003078
3079 verifyFormat(
3080 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();");
3081 verifyFormat("aaaaaaaaaaaaaaa()\n"
3082 " .aaaaaaaaaaaaaaa()\n"
3083 " .aaaaaaaaaaaaaaa()\n"
3084 " .aaaaaaaaaaaaaaa()\n"
3085 " .aaaaaaaaaaaaaaa();");
3086 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
3087 " .aaaaaaaaaaaaaaa()\n"
3088 " .aaaaaaaaaaaaaaa()\n"
3089 " .aaaaaaaaaaaaaaa();");
3090 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
3091 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
3092 " .aaaaaaaaaaaaaaa();");
Daniel Jaspereb331832013-08-30 07:12:40 +00003093 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
3094 " ->aaaaaaaaaaaaaae(0)\n"
3095 " ->aaaaaaaaaaaaaaa();");
Daniel Jasper2f0a0202013-09-06 08:54:24 +00003096
3097 // Prefer not to break after empty parentheses.
3098 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
3099 " First->LastNewlineOffset);");
Daniel Jasperc79afda2013-01-18 10:56:38 +00003100}
3101
Daniel Jaspere2c7acf2012-12-24 00:13:23 +00003102TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) {
3103 verifyFormat(
3104 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003105 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
Daniel Jaspercd162382013-01-07 13:26:07 +00003106 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003107 " ccccccccccccccccccccccccc) {\n}");
Daniel Jaspercd162382013-01-07 13:26:07 +00003108 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003109 " ccccccccccccccccccccccccc) {\n}");
Daniel Jaspere2c7acf2012-12-24 00:13:23 +00003110 verifyFormat(
3111 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003112 " ccccccccccccccccccccccccc) {\n}");
Daniel Jasper29f123b2013-02-08 15:28:42 +00003113 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
3114 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
3115 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
3116 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
3117 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
3118 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
3119 " aaaaaaaaaaaaaaa != aa) {\n}");
Daniel Jaspere2c7acf2012-12-24 00:13:23 +00003120}
3121
Daniel Jasper7006e7e2013-01-23 12:27:43 +00003122TEST_F(FormatTest, BreaksAfterAssignments) {
Daniel Jasper9cda8002013-01-07 13:08:40 +00003123 verifyFormat(
Daniel Jasper7006e7e2013-01-23 12:27:43 +00003124 "unsigned Cost =\n"
3125 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
3126 " SI->getPointerAddressSpaceee());\n");
Daniel Jasper9cda8002013-01-07 13:08:40 +00003127 verifyFormat(
Daniel Jasper13cb7c22013-01-23 15:55:19 +00003128 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
3129 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
Daniel Jasperf39c8852013-01-23 16:58:21 +00003130
3131 verifyFormat(
Daniel Jasperd489f8c2013-08-27 11:09:05 +00003132 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
3133 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper512843a2013-05-27 12:45:09 +00003134 verifyFormat("unsigned OriginalStartColumn =\n"
3135 " SourceMgr.getSpellingColumnNumber(\n"
3136 " Current.FormatTok.getStartOfNonWhitespace()) -\n"
3137 " 1;");
Daniel Jasper9cda8002013-01-07 13:08:40 +00003138}
3139
Daniel Jaspercf225b62012-12-24 13:43:52 +00003140TEST_F(FormatTest, AlignsAfterAssignments) {
3141 verifyFormat(
3142 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper9cda8002013-01-07 13:08:40 +00003143 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jaspercf225b62012-12-24 13:43:52 +00003144 verifyFormat(
3145 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper9cda8002013-01-07 13:08:40 +00003146 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jaspercf225b62012-12-24 13:43:52 +00003147 verifyFormat(
3148 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper9cda8002013-01-07 13:08:40 +00003149 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jaspercf225b62012-12-24 13:43:52 +00003150 verifyFormat(
3151 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper9cda8002013-01-07 13:08:40 +00003152 " aaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper88cc5622013-07-08 14:25:23 +00003153 verifyFormat(
3154 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n"
3155 " aaaaaaaaaaaaaaaaaaaaaaaa +\n"
3156 " aaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jaspercf225b62012-12-24 13:43:52 +00003157}
3158
3159TEST_F(FormatTest, AlignsAfterReturn) {
3160 verifyFormat(
3161 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3162 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
3163 verifyFormat(
3164 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3165 " aaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper37911302013-04-02 14:33:13 +00003166 verifyFormat(
3167 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
Daniel Jasperbf71ba22013-04-08 20:33:42 +00003168 " aaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper37911302013-04-02 14:33:13 +00003169 verifyFormat(
3170 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
Daniel Jasperbf71ba22013-04-08 20:33:42 +00003171 " aaaaaaaaaaaaaaaaaaaaaa());");
3172 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3173 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
3174 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3175 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
3176 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasperf78bf4a2013-09-30 08:29:03 +00003177 verifyFormat("return\n"
3178 " // true if code is one of a or b.\n"
3179 " code == a || code == b;");
Daniel Jaspercf225b62012-12-24 13:43:52 +00003180}
3181
Daniel Jasper9c837d02013-01-09 07:06:56 +00003182TEST_F(FormatTest, BreaksConditionalExpressions) {
3183 verifyFormat(
Daniel Jasper88cc5622013-07-08 14:25:23 +00003184 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3185 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3186 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper1f2b0782013-01-16 16:23:19 +00003187 verifyFormat(
Daniel Jasperbfe6fd42013-01-28 12:45:14 +00003188 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3189 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
3190 verifyFormat(
3191 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
3192 " : aaaaaaaaaaaaa);");
3193 verifyFormat(
3194 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper64f09282013-03-20 13:53:11 +00003195 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasperbfe6fd42013-01-28 12:45:14 +00003196 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3197 " aaaaaaaaaaaaa);");
Daniel Jasperab3ce592013-08-01 22:05:00 +00003198 verifyFormat(
3199 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3200 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3201 " aaaaaaaaaaaaa);");
Daniel Jasperbfe6fd42013-01-28 12:45:14 +00003202 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3203 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3204 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3205 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3206 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
3207 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3208 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3209 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3210 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3211 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3212 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3213 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperab3ce592013-08-01 22:05:00 +00003214 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3215 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3216 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3217 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3218 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper7878a7b2013-02-15 11:07:25 +00003219 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3220 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3221 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper37911302013-04-02 14:33:13 +00003222 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
3223 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3224 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3225 " : aaaaaaaaaaaaaaaa;");
Daniel Jasper237d4c12013-02-23 21:01:55 +00003226 verifyFormat(
3227 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3228 " ? aaaaaaaaaaaaaaa\n"
3229 " : aaaaaaaaaaaaaaa;");
3230 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
Daniel Jasperbf71ba22013-04-08 20:33:42 +00003231 " aaaaaaaaa\n"
Daniel Jasper65622aa2013-04-08 10:45:44 +00003232 " ? b\n"
3233 " : c);");
Daniel Jasper087387a2013-02-08 16:49:27 +00003234 verifyFormat(
Daniel Jasper7878a7b2013-02-15 11:07:25 +00003235 "unsigned Indent =\n"
3236 " format(TheLine.First, IndentForLevel[TheLine.Level] >= 0\n"
3237 " ? IndentForLevel[TheLine.Level]\n"
Daniel Jasper7d812812013-02-21 15:00:29 +00003238 " : TheLine * 2,\n"
3239 " TheLine.InPPDirective, PreviousEndOfLineColumn);",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003240 getLLVMStyleWithColumns(70));
Daniel Jasperc01897c2013-05-31 14:56:12 +00003241 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
3242 " ? aaaaaaaaaaaaaaa\n"
3243 " : bbbbbbbbbbbbbbb //\n"
3244 " ? ccccccccccccccc\n"
3245 " : ddddddddddddddd;");
3246 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
3247 " ? aaaaaaaaaaaaaaa\n"
3248 " : (bbbbbbbbbbbbbbb //\n"
3249 " ? ccccccccccccccc\n"
3250 " : ddddddddddddddd);");
Daniel Jasper7878a7b2013-02-15 11:07:25 +00003251
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003252 FormatStyle NoBinPacking = getLLVMStyle();
3253 NoBinPacking.BinPackParameters = false;
3254 verifyFormat(
Daniel Jasper237d4c12013-02-23 21:01:55 +00003255 "void f() {\n"
3256 " g(aaa,\n"
3257 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
3258 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3259 " ? aaaaaaaaaaaaaaa\n"
3260 " : aaaaaaaaaaaaaaa);\n"
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003261 "}",
3262 NoBinPacking);
Daniel Jasperab3ce592013-08-01 22:05:00 +00003263 verifyFormat(
3264 "void f() {\n"
3265 " g(aaa,\n"
3266 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
3267 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3268 " ?: aaaaaaaaaaaaaaa);\n"
3269 "}",
3270 NoBinPacking);
Daniel Jasper9c837d02013-01-09 07:06:56 +00003271}
3272
Daniel Jasper2e603772013-01-29 11:21:01 +00003273TEST_F(FormatTest, DeclarationsOfMultipleVariables) {
3274 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
3275 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();");
3276 verifyFormat("bool a = true, b = false;");
3277
Daniel Jasper2e603772013-01-29 11:21:01 +00003278 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +00003279 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
Daniel Jasper2e603772013-01-29 11:21:01 +00003280 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
Daniel Jasper37911302013-04-02 14:33:13 +00003281 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);");
Daniel Jasper2e603772013-01-29 11:21:01 +00003282 verifyFormat(
Daniel Jasper7d812812013-02-21 15:00:29 +00003283 "bool aaaaaaaaaaaaaaaaaaaaa =\n"
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +00003284 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
Daniel Jasper7d812812013-02-21 15:00:29 +00003285 " d = e && f;");
Daniel Jasperadc0f092013-04-05 09:38:50 +00003286 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
3287 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;");
3288 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
3289 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;");
3290 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
3291 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;");
3292 // FIXME: If multiple variables are defined, the "*" needs to move to the new
3293 // line. Also fix indent for breaking after the type, this looks bad.
Manuel Klimeka9a7f102013-06-21 17:25:42 +00003294 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
Daniel Jasper53e72cd2013-05-06 08:27:33 +00003295 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00003296 " *b = bbbbbbbbbbbbbbbbbbb;",
3297 getGoogleStyle());
Daniel Jasper2e603772013-01-29 11:21:01 +00003298
Daniel Jasperadc0f092013-04-05 09:38:50 +00003299 // Not ideal, but pointer-with-type does not allow much here.
3300 verifyGoogleFormat(
3301 "aaaaaaaaa* a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
3302 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;");
Daniel Jasper2e603772013-01-29 11:21:01 +00003303}
3304
Nico Weber7d37b8b2013-01-12 01:28:06 +00003305TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
3306 verifyFormat("arr[foo ? bar : baz];");
3307 verifyFormat("f()[foo ? bar : baz];");
3308 verifyFormat("(a + b)[foo ? bar : baz];");
3309 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
3310}
3311
Daniel Jasperbac016b2012-12-03 18:12:45 +00003312TEST_F(FormatTest, AlignsStringLiterals) {
3313 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
3314 " \"short literal\");");
3315 verifyFormat(
3316 "looooooooooooooooooooooooongFunction(\n"
3317 " \"short literal\"\n"
3318 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003319 verifyFormat("someFunction(\"Always break between multi-line\"\n"
3320 " \" string literals\",\n"
3321 " and, other, parameters);");
Manuel Klimekb56b6d12013-02-20 15:25:48 +00003322 EXPECT_EQ("fun + \"1243\" /* comment */\n"
3323 " \"5678\";",
3324 format("fun + \"1243\" /* comment */\n"
3325 " \"5678\";",
3326 getLLVMStyleWithColumns(28)));
3327 EXPECT_EQ(
3328 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
3329 " \"aaaaaaaaaaaaaaaaaaaaa\"\n"
3330 " \"aaaaaaaaaaaaaaaa\";",
3331 format("aaaaaa ="
3332 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
3333 "aaaaaaaaaaaaaaaaaaaaa\" "
3334 "\"aaaaaaaaaaaaaaaa\";"));
Manuel Klimeke9a62262013-02-20 15:32:58 +00003335 verifyFormat("a = a + \"a\"\n"
3336 " \"a\"\n"
3337 " \"a\";");
Daniel Jasper9a2f8d02013-05-16 04:26:02 +00003338 verifyFormat("f(\"a\", \"b\"\n"
3339 " \"c\");");
Daniel Jasper3a204412013-02-23 07:46:38 +00003340
3341 verifyFormat(
3342 "#define LL_FORMAT \"ll\"\n"
3343 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
3344 " \"d, ddddddddd: %\" LL_FORMAT \"d\");");
Daniel Jasper27c7f542013-05-13 20:50:15 +00003345
3346 verifyFormat("#define A(X) \\\n"
3347 " \"aaaaa\" #X \"bbbbbb\" \\\n"
3348 " \"ccccc\"",
3349 getLLVMStyleWithColumns(23));
3350 verifyFormat("#define A \"def\"\n"
3351 "f(\"abc\" A \"ghi\"\n"
3352 " \"jkl\");");
Daniel Jasperbac016b2012-12-03 18:12:45 +00003353}
3354
Alexander Kornienko56312022013-07-04 12:02:44 +00003355TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) {
3356 FormatStyle NoBreak = getLLVMStyle();
3357 NoBreak.AlwaysBreakBeforeMultilineStrings = false;
3358 FormatStyle Break = getLLVMStyle();
3359 Break.AlwaysBreakBeforeMultilineStrings = true;
Daniel Jasper215c57f2013-07-17 15:38:19 +00003360 verifyFormat("aaaa = \"bbbb\"\n"
3361 " \"cccc\";",
3362 NoBreak);
3363 verifyFormat("aaaa =\n"
3364 " \"bbbb\"\n"
3365 " \"cccc\";",
3366 Break);
3367 verifyFormat("aaaa(\"bbbb\"\n"
3368 " \"cccc\");",
3369 NoBreak);
3370 verifyFormat("aaaa(\n"
3371 " \"bbbb\"\n"
3372 " \"cccc\");",
3373 Break);
3374 verifyFormat("aaaa(qqq, \"bbbb\"\n"
3375 " \"cccc\");",
3376 NoBreak);
3377 verifyFormat("aaaa(qqq,\n"
3378 " \"bbbb\"\n"
3379 " \"cccc\");",
3380 Break);
3381
3382 // Don't break if there is no column gain.
3383 verifyFormat("f(\"aaaa\"\n"
3384 " \"bbbb\");",
3385 Break);
3386
3387 // Treat literals with escaped newlines like multi-line string literals.
Alexander Kornienko10c26b22013-07-16 21:06:13 +00003388 EXPECT_EQ("x = \"a\\\n"
3389 "b\\\n"
3390 "c\";",
3391 format("x = \"a\\\n"
3392 "b\\\n"
3393 "c\";",
3394 NoBreak));
3395 EXPECT_EQ("x =\n"
3396 " \"a\\\n"
3397 "b\\\n"
3398 "c\";",
3399 format("x = \"a\\\n"
3400 "b\\\n"
3401 "c\";",
3402 Break));
Alexander Kornienko56312022013-07-04 12:02:44 +00003403}
3404
Alexander Kornienko15757312012-12-06 18:03:27 +00003405TEST_F(FormatTest, AlignsPipes) {
3406 verifyFormat(
3407 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3408 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3409 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
3410 verifyFormat(
3411 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
3412 " << aaaaaaaaaaaaaaaaaaaa;");
3413 verifyFormat(
3414 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3415 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
3416 verifyFormat(
3417 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
3418 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
3419 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";");
3420 verifyFormat(
3421 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3422 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3423 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasperfa543ac2013-02-04 07:34:48 +00003424
3425 verifyFormat("return out << \"somepacket = {\\n\"\n"
Manuel Klimekae76f7f2013-10-11 21:25:45 +00003426 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
3427 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
3428 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
3429 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
Daniel Jasperfa543ac2013-02-04 07:34:48 +00003430 " << \"}\";");
Daniel Jasper4e8a7b42013-02-06 21:04:05 +00003431
Daniel Jasper3e12e872013-07-15 14:12:30 +00003432 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
3433 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
3434 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;");
Daniel Jasper4e8a7b42013-02-06 21:04:05 +00003435 verifyFormat(
3436 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
3437 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
3438 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
3439 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
3440 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;");
Daniel Jasperbfa1edd2013-03-14 14:00:17 +00003441 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
3442 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
Daniel Jasper9637dda2013-07-15 14:33:14 +00003443 verifyFormat(
3444 "void f() {\n"
3445 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n"
3446 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
3447 "}");
Daniel Jasper37911302013-04-02 14:33:13 +00003448
Daniel Jasperfaec47b2013-07-11 20:41:21 +00003449 // Breaking before the first "<<" is generally not desirable.
3450 verifyFormat(
3451 "llvm::errs()\n"
3452 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3453 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3454 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3455 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
3456 getLLVMStyleWithColumns(70));
3457 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
3458 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3459 " << \"aaaaaaaaaaaaaaaaaaa: \"\n"
3460 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3461 " << \"aaaaaaaaaaaaaaaaaaa: \"\n"
3462 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
3463 getLLVMStyleWithColumns(70));
3464
Daniel Jasperb349a782013-08-12 12:58:05 +00003465 // But sometimes, breaking before the first "<<" is desirable.
Daniel Jaspera0740f52013-07-12 15:14:05 +00003466 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
3467 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3468 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasperb349a782013-08-12 12:58:05 +00003469 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
3470 " << BEF << IsTemplate << Description << E->getType();");
Daniel Jaspera0740f52013-07-12 15:14:05 +00003471
Daniel Jasper37911302013-04-02 14:33:13 +00003472 verifyFormat(
3473 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3474 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper20376982013-09-29 12:02:57 +00003475
3476 // Incomplete string literal.
3477 EXPECT_EQ("llvm::errs() << \"\n"
3478 " << a;",
3479 format("llvm::errs() << \"\n<<a;"));
Alexander Kornienko15757312012-12-06 18:03:27 +00003480}
3481
Daniel Jasperbac016b2012-12-03 18:12:45 +00003482TEST_F(FormatTest, UnderstandsEquals) {
3483 verifyFormat(
3484 "aaaaaaaaaaaaaaaaa =\n"
3485 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
3486 verifyFormat(
3487 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003488 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasperbac016b2012-12-03 18:12:45 +00003489 verifyFormat(
3490 "if (a) {\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +00003491 " f();\n"
Daniel Jasperbac016b2012-12-03 18:12:45 +00003492 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003493 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
3494 "}");
Daniel Jasperbac016b2012-12-03 18:12:45 +00003495
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003496 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
3497 " 100000000 + 10000000) {\n}");
Daniel Jasperbac016b2012-12-03 18:12:45 +00003498}
3499
Daniel Jasper9a0b4942012-12-17 14:34:14 +00003500TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
Daniel Jasper1321eb52012-12-18 21:05:13 +00003501 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
3502 " .looooooooooooooooooooooooooooooooooooooongFunction();");
Daniel Jasper9a0b4942012-12-17 14:34:14 +00003503
Daniel Jasper1321eb52012-12-18 21:05:13 +00003504 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
3505 " ->looooooooooooooooooooooooooooooooooooooongFunction();");
Daniel Jasper9a0b4942012-12-17 14:34:14 +00003506
3507 verifyFormat(
3508 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
3509 " Parameter2);");
3510
3511 verifyFormat(
3512 "ShortObject->shortFunction(\n"
3513 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
3514 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);");
3515
3516 verifyFormat("loooooooooooooongFunction(\n"
3517 " LoooooooooooooongObject->looooooooooooooooongFunction());");
3518
3519 verifyFormat(
3520 "function(LoooooooooooooooooooooooooooooooooooongObject\n"
3521 " ->loooooooooooooooooooooooooooooooooooooooongFunction());");
3522
Daniel Jasperfc759082013-02-14 14:26:07 +00003523 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
3524 " .WillRepeatedly(Return(SomeValue));");
3525 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)]\n"
3526 " .insert(ccccccccccccccccccccccc);");
Daniel Jasper259a0382013-05-27 11:50:16 +00003527 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3528 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa).aaaaa(aaaaa),\n"
3529 " aaaaaaaaaaaaaaaaaaaaa);");
Daniel Jaspere60084d2013-08-13 06:50:04 +00003530 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3531 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());");
Daniel Jasper3af59ce2013-03-15 14:57:30 +00003532 verifyFormat(
3533 "aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3534 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
Daniel Jasper88cc5622013-07-08 14:25:23 +00003535 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3536 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3537 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jasper37911302013-04-02 14:33:13 +00003538 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3539 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3540 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3541 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
3542 "}");
Daniel Jasperfc759082013-02-14 14:26:07 +00003543
Daniel Jasper46a46a22013-01-07 07:13:20 +00003544 // Here, it is not necessary to wrap at "." or "->".
Daniel Jasper1321eb52012-12-18 21:05:13 +00003545 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003546 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasper46a46a22013-01-07 07:13:20 +00003547 verifyFormat(
3548 "aaaaaaaaaaa->aaaaaaaaa(\n"
3549 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3550 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
Daniel Jasper9fc56f22013-02-14 15:01:34 +00003551
3552 verifyFormat(
3553 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3554 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
Daniel Jasper8d0d19a2013-03-13 15:37:48 +00003555 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
3556 " aaaaaaaaa()->aaaaaa()->aaaaa());");
3557 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
3558 " aaaaaaaaa()->aaaaaa()->aaaaa());");
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003559
Daniel Jasper3af59ce2013-03-15 14:57:30 +00003560 // FIXME: Should we break before .a()?
3561 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3562 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa).a();");
3563
Daniel Jasperfaab0d32013-02-27 09:47:53 +00003564 FormatStyle NoBinPacking = getLLVMStyle();
3565 NoBinPacking.BinPackParameters = false;
3566 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
3567 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
3568 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
3569 " aaaaaaaaaaaaaaaaaaa,\n"
3570 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
3571 NoBinPacking);
Daniel Jasperb1491792013-07-09 11:57:27 +00003572
3573 // If there is a subsequent call, change to hanging indentation.
3574 verifyFormat(
3575 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3576 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n"
3577 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
3578 verifyFormat(
3579 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3580 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));");
Daniel Jasper9a0b4942012-12-17 14:34:14 +00003581}
3582
Daniel Jasper9a64fb52013-01-02 15:08:56 +00003583TEST_F(FormatTest, WrapsTemplateDeclarations) {
3584 verifyFormat("template <typename T>\n"
3585 "virtual void loooooooooooongFunction(int Param1, int Param2);");
Daniel Jasper48c099f2013-09-27 07:49:08 +00003586 verifyFormat("template <typename T>\n"
3587 "// T should be one of {A, B}.\n"
3588 "virtual void loooooooooooongFunction(int Param1, int Param2);");
Daniel Jasper9a64fb52013-01-02 15:08:56 +00003589 verifyFormat(
Daniel Jasperc79afda2013-01-18 10:56:38 +00003590 "template <typename T>\n"
Daniel Jasper29f123b2013-02-08 15:28:42 +00003591 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;");
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003592 verifyFormat("template <typename T>\n"
3593 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
3594 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);");
Daniel Jasper9a64fb52013-01-02 15:08:56 +00003595 verifyFormat(
3596 "template <typename T>\n"
3597 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
3598 " int Paaaaaaaaaaaaaaaaaaaaram2);");
Daniel Jasper5eda31e2013-01-02 18:30:06 +00003599 verifyFormat(
3600 "template <typename T>\n"
3601 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
3602 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
3603 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperd64f7382013-01-09 09:50:48 +00003604 verifyFormat("template <typename T>\n"
3605 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +00003606 " int aaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper3fc0bb72013-01-09 10:40:23 +00003607 verifyFormat(
3608 "template <typename T1, typename T2 = char, typename T3 = char,\n"
3609 " typename T4 = char>\n"
3610 "void f();");
Daniel Jasper3499dda2013-01-25 15:43:32 +00003611 verifyFormat(
3612 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
3613 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper01786732013-02-04 07:21:18 +00003614
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003615 verifyFormat("a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
3616 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));");
Daniel Jasperbbc87762013-05-29 12:07:31 +00003617
Daniel Jasper8893b8a2013-05-31 14:56:20 +00003618 verifyFormat("template <typename T> class C {};");
Daniel Jasperbbc87762013-05-29 12:07:31 +00003619 verifyFormat("template <typename T> void f();");
3620 verifyFormat("template <typename T> void f() {}");
Daniel Jasper07ca5472013-07-05 09:14:35 +00003621 verifyFormat(
3622 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
3623 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3624 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
3625 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
3626 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3627 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
3628 " bbbbbbbbbbbbbbbbbbbbbbbb);",
3629 getLLVMStyleWithColumns(72));
Daniel Jasperd3d9e0f2013-09-14 08:13:22 +00003630
3631 FormatStyle AlwaysBreak = getLLVMStyle();
3632 AlwaysBreak.AlwaysBreakTemplateDeclarations = true;
3633 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
3634 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
3635 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
3636 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3637 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
3638 " ccccccccccccccccccccccccccccccccccccccccccccccc);");
3639 verifyFormat("template <template <typename> class Fooooooo,\n"
3640 " template <typename> class Baaaaaaar>\n"
3641 "struct C {};",
3642 AlwaysBreak);
Daniel Jasper6e7f1932013-10-09 15:06:17 +00003643 verifyFormat("template <typename T> // T can be A, B or C.\n"
3644 "struct C {};",
3645 AlwaysBreak);
Daniel Jasper9a64fb52013-01-02 15:08:56 +00003646}
3647
Daniel Jasper63f00362013-01-25 10:57:27 +00003648TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
3649 verifyFormat(
3650 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
3651 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
3652 verifyFormat(
3653 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
3654 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3655 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
3656
Daniel Jasperb2f063a2013-05-08 10:00:18 +00003657 // FIXME: Should we have the extra indent after the second break?
Daniel Jasper63f00362013-01-25 10:57:27 +00003658 verifyFormat(
3659 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
3660 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
Daniel Jasperb2f063a2013-05-08 10:00:18 +00003661 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper63f00362013-01-25 10:57:27 +00003662
Daniel Jasper63f00362013-01-25 10:57:27 +00003663 verifyFormat(
3664 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
Daniel Jasper5f2173e2013-01-28 07:43:15 +00003665 " cccccccccccccccccccccccccccccccccccccccccccccc());");
Daniel Jasper63f00362013-01-25 10:57:27 +00003666
3667 // Breaking at nested name specifiers is generally not desirable.
3668 verifyFormat(
3669 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3670 " aaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperbfe6fd42013-01-28 12:45:14 +00003671
3672 verifyFormat(
3673 "aaaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
3674 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3675 " aaaaaaaaaaaaaaaaaaaaa);",
3676 getLLVMStyleWithColumns(74));
Daniel Jasper37911302013-04-02 14:33:13 +00003677
3678 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
3679 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3680 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper63f00362013-01-25 10:57:27 +00003681}
3682
Daniel Jasperbac016b2012-12-03 18:12:45 +00003683TEST_F(FormatTest, UnderstandsTemplateParameters) {
3684 verifyFormat("A<int> a;");
3685 verifyFormat("A<A<A<int> > > a;");
3686 verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
3687 verifyFormat("bool x = a < 1 || 2 > a;");
3688 verifyFormat("bool x = 5 < f<int>();");
3689 verifyFormat("bool x = f<int>() > 5;");
3690 verifyFormat("bool x = 5 < a<int>::x;");
3691 verifyFormat("bool x = a < 4 ? a > 2 : false;");
3692 verifyFormat("bool x = f() ? a < 2 : a > 2;");
3693
3694 verifyGoogleFormat("A<A<int>> a;");
3695 verifyGoogleFormat("A<A<A<int>>> a;");
3696 verifyGoogleFormat("A<A<A<A<int>>>> a;");
Daniel Jasper8ff690a2013-02-06 14:22:40 +00003697 verifyGoogleFormat("A<A<int> > a;");
3698 verifyGoogleFormat("A<A<A<int> > > a;");
3699 verifyGoogleFormat("A<A<A<A<int> > > > a;");
3700 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
3701 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
Daniel Jasperbac016b2012-12-03 18:12:45 +00003702
3703 verifyFormat("test >> a >> b;");
3704 verifyFormat("test << a >> b;");
3705
3706 verifyFormat("f<int>();");
Manuel Klimek36fab8d2013-01-10 13:24:24 +00003707 verifyFormat("template <typename T> void f() {}");
Daniel Jasper0348be02013-06-01 18:56:00 +00003708
3709 // Not template parameters.
3710 verifyFormat("return a < b && c > d;");
3711 verifyFormat("void f() {\n"
3712 " while (a < b && c > d) {\n"
3713 " }\n"
3714 "}");
Daniel Jasper0236dd02013-07-30 22:37:19 +00003715 verifyFormat("template <typename... Types>\n"
3716 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}");
Daniel Jasper26356cc2013-09-17 08:15:46 +00003717
3718 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3719 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);",
3720 getLLVMStyleWithColumns(60));
Daniel Jasperbac016b2012-12-03 18:12:45 +00003721}
3722
Daniel Jasper807809c2013-02-28 09:21:10 +00003723TEST_F(FormatTest, UnderstandsBinaryOperators) {
3724 verifyFormat("COMPARE(a, ==, b);");
Alexander Kornienko54a38bd2013-03-20 16:41:56 +00003725}
3726
3727TEST_F(FormatTest, UnderstandsPointersToMembers) {
3728 verifyFormat("int A::*x;");
Daniel Jasper395228f2013-05-08 14:58:20 +00003729 verifyFormat("int (S::*func)(void *);");
Daniel Jasper431f5912013-05-28 08:33:00 +00003730 verifyFormat("void f() { int (S::*func)(void *); }");
Daniel Jasper4b7b1042013-05-08 15:06:58 +00003731 verifyFormat("typedef bool *(Class::*Member)() const;");
Daniel Jasper395228f2013-05-08 14:58:20 +00003732 verifyFormat("void f() {\n"
3733 " (a->*f)();\n"
3734 " a->*x;\n"
3735 " (a.*f)();\n"
3736 " ((*a).*f)();\n"
3737 " a.*x;\n"
3738 "}");
Daniel Jasper5e2169f2013-07-18 14:46:07 +00003739 verifyFormat("void f() {\n"
3740 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
3741 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n"
3742 "}");
Daniel Jasper4b7b1042013-05-08 15:06:58 +00003743 FormatStyle Style = getLLVMStyle();
3744 Style.PointerBindsToType = true;
3745 verifyFormat("typedef bool* (Class::*Member)() const;", Style);
Daniel Jasper807809c2013-02-28 09:21:10 +00003746}
3747
Daniel Jasper98e6b4a2012-12-21 09:41:31 +00003748TEST_F(FormatTest, UnderstandsUnaryOperators) {
Daniel Jasperbac016b2012-12-03 18:12:45 +00003749 verifyFormat("int a = -2;");
Daniel Jasper8822d3a2012-12-04 13:02:32 +00003750 verifyFormat("f(-1, -2, -3);");
3751 verifyFormat("a[-1] = 5;");
3752 verifyFormat("int a = 5 + -2;");
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003753 verifyFormat("if (i == -1) {\n}");
3754 verifyFormat("if (i != -1) {\n}");
3755 verifyFormat("if (i > -1) {\n}");
3756 verifyFormat("if (i < -1) {\n}");
Daniel Jasperd56a7372012-12-06 13:16:39 +00003757 verifyFormat("++(a->f());");
3758 verifyFormat("--(a->f());");
Daniel Jasper4abbb532013-01-14 12:18:19 +00003759 verifyFormat("(a->f())++;");
3760 verifyFormat("a[42]++;");
Manuel Klimek2f1ac412013-01-21 16:42:44 +00003761 verifyFormat("if (!(a->f())) {\n}");
Daniel Jasper98e6b4a2012-12-21 09:41:31 +00003762
3763 verifyFormat("a-- > b;");
3764 verifyFormat("b ? -a : c;");
3765 verifyFormat("n * sizeof char16;");
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00003766 verifyFormat("n * alignof char16;", getGoogleStyle());
Daniel Jasper98e6b4a2012-12-21 09:41:31 +00003767 verifyFormat("sizeof(char);");
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00003768 verifyFormat("alignof(char);", getGoogleStyle());
Daniel Jasper1f0754b2013-01-02 15:26:16 +00003769
3770 verifyFormat("return -1;");
3771 verifyFormat("switch (a) {\n"
3772 "case -1:\n"
3773 " break;\n"
3774 "}");
Daniel Jasperb5985422013-03-22 10:44:43 +00003775 verifyFormat("#define X -1");
3776 verifyFormat("#define X -kConstant");
Nico Webercc191d12013-01-12 05:41:23 +00003777
3778 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = { -5, +3 };");
3779 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = { +5, -3 };");
Daniel Jasperb369c2c2013-01-15 14:27:39 +00003780
3781 verifyFormat("int a = /* confusing comment */ -1;");
3782 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case.
3783 verifyFormat("int a = i /* confusing comment */++;");
Daniel Jasperbac016b2012-12-03 18:12:45 +00003784}
3785
Daniel Jasper34f3d052013-08-21 08:39:01 +00003786TEST_F(FormatTest, IndentsRelativeToUnaryOperators) {
3787 verifyFormat("if (!aaaaaaaaaa( // break\n"
3788 " aaaaa)) {\n"
3789 "}");
3790 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
3791 " aaaaa));");
Daniel Jasper3618e6f2013-08-23 15:14:03 +00003792
3793 // Only indent relative to unary operators if the expression is nested.
3794 verifyFormat("*aaa = aaaaaaa( // break\n"
3795 " bbbbbb);");
Daniel Jasper34f3d052013-08-21 08:39:01 +00003796}
3797
Daniel Jasper332c6772013-08-26 08:10:17 +00003798TEST_F(FormatTest, UnderstandsOverloadedOperators) {
Daniel Jasperf6aef6a2012-12-24 10:56:04 +00003799 verifyFormat("bool operator<();");
3800 verifyFormat("bool operator>();");
3801 verifyFormat("bool operator=();");
3802 verifyFormat("bool operator==();");
3803 verifyFormat("bool operator!=();");
3804 verifyFormat("int operator+();");
3805 verifyFormat("int operator++();");
3806 verifyFormat("bool operator();");
3807 verifyFormat("bool operator()();");
3808 verifyFormat("bool operator[]();");
3809 verifyFormat("operator bool();");
Daniel Jasper2b4c9242013-02-11 08:01:18 +00003810 verifyFormat("operator int();");
3811 verifyFormat("operator void *();");
Daniel Jasperf6aef6a2012-12-24 10:56:04 +00003812 verifyFormat("operator SomeType<int>();");
Daniel Jasper2b4c9242013-02-11 08:01:18 +00003813 verifyFormat("operator SomeType<int, int>();");
3814 verifyFormat("operator SomeType<SomeType<int> >();");
Daniel Jasperf6aef6a2012-12-24 10:56:04 +00003815 verifyFormat("void *operator new(std::size_t size);");
3816 verifyFormat("void *operator new[](std::size_t size);");
3817 verifyFormat("void operator delete(void *ptr);");
3818 verifyFormat("void operator delete[](void *ptr);");
Daniel Jasper6ea933c2013-05-10 07:59:58 +00003819 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
3820 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);");
Daniel Jasper2b4c9242013-02-11 08:01:18 +00003821
Daniel Jasperdc2efa12013-02-15 19:24:08 +00003822 verifyFormat(
3823 "ostream &operator<<(ostream &OutputStream,\n"
3824 " SomeReallyLongType WithSomeReallyLongValue);");
Daniel Jasper27b91cc2013-04-05 17:21:59 +00003825 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
3826 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
3827 " return left.group < right.group;\n"
3828 "}");
Daniel Jasper2eb23b72013-04-11 08:48:20 +00003829 verifyFormat("SomeType &operator=(const SomeType &S);");
Daniel Jasperdc2efa12013-02-15 19:24:08 +00003830
Daniel Jasper2b4c9242013-02-11 08:01:18 +00003831 verifyGoogleFormat("operator void*();");
3832 verifyGoogleFormat("operator SomeType<SomeType<int>>();");
Daniel Jasper174f60f2013-09-02 09:20:39 +00003833
3834 verifyFormat("using A::operator+;");
Daniel Jasperbac016b2012-12-03 18:12:45 +00003835}
3836
Daniel Jasper088dab52013-01-11 16:09:04 +00003837TEST_F(FormatTest, UnderstandsNewAndDelete) {
Daniel Jasper37eff832013-02-23 08:07:18 +00003838 verifyFormat("void f() {\n"
3839 " A *a = new A;\n"
3840 " A *a = new (placement) A;\n"
3841 " delete a;\n"
3842 " delete (A *)a;\n"
3843 "}");
Daniel Jasper088dab52013-01-11 16:09:04 +00003844}
3845
Daniel Jasper5d334402013-01-02 08:57:10 +00003846TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
Manuel Klimek36fab8d2013-01-10 13:24:24 +00003847 verifyFormat("int *f(int *a) {}");
Manuel Klimek36fab8d2013-01-10 13:24:24 +00003848 verifyFormat("int main(int argc, char **argv) {}");
Daniel Jasperd0f349b2013-02-18 12:44:35 +00003849 verifyFormat("Test::Test(int b) : a(b * b) {}");
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003850 verifyIndependentOfContext("f(a, *a);");
Daniel Jasper8a5d7cd2013-03-01 17:13:29 +00003851 verifyFormat("void g() { f(*a); }");
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003852 verifyIndependentOfContext("int a = b * 10;");
3853 verifyIndependentOfContext("int a = 10 * b;");
3854 verifyIndependentOfContext("int a = b * c;");
3855 verifyIndependentOfContext("int a += b * c;");
3856 verifyIndependentOfContext("int a -= b * c;");
3857 verifyIndependentOfContext("int a *= b * c;");
3858 verifyIndependentOfContext("int a /= b * c;");
3859 verifyIndependentOfContext("int a = *b;");
3860 verifyIndependentOfContext("int a = *b * c;");
3861 verifyIndependentOfContext("int a = b * *c;");
3862 verifyIndependentOfContext("return 10 * b;");
3863 verifyIndependentOfContext("return *b * *c;");
3864 verifyIndependentOfContext("return a & ~b;");
3865 verifyIndependentOfContext("f(b ? *c : *d);");
3866 verifyIndependentOfContext("int a = b ? *c : *d;");
3867 verifyIndependentOfContext("*b = a;");
3868 verifyIndependentOfContext("a * ~b;");
3869 verifyIndependentOfContext("a * !b;");
3870 verifyIndependentOfContext("a * +b;");
3871 verifyIndependentOfContext("a * -b;");
3872 verifyIndependentOfContext("a * ++b;");
3873 verifyIndependentOfContext("a * --b;");
3874 verifyIndependentOfContext("a[4] * b;");
Daniel Jasper9c65b062013-02-27 11:43:50 +00003875 verifyIndependentOfContext("a[a * a] = 1;");
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003876 verifyIndependentOfContext("f() * b;");
3877 verifyIndependentOfContext("a * [self dostuff];");
Daniel Jasper81d2d382013-04-01 17:13:26 +00003878 verifyIndependentOfContext("int x = a * (a + b);");
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003879 verifyIndependentOfContext("(a *)(a + b);");
3880 verifyIndependentOfContext("int *pa = (int *)&a;");
Nico Weber95e8e462013-02-12 16:17:07 +00003881 verifyIndependentOfContext("return sizeof(int **);");
3882 verifyIndependentOfContext("return sizeof(int ******);");
3883 verifyIndependentOfContext("return (int **&)a;");
Daniel Jasper3ff4a2f2013-05-28 15:27:10 +00003884 verifyIndependentOfContext("f((*PointerToArray)[10]);");
Daniel Jasper8a5d7cd2013-03-01 17:13:29 +00003885 verifyFormat("void f(Type (*parameter)[10]) {}");
Nico Weber95e8e462013-02-12 16:17:07 +00003886 verifyGoogleFormat("return sizeof(int**);");
3887 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);");
3888 verifyGoogleFormat("Type** A = static_cast<Type**>(P);");
Daniel Jasper567dcf92013-09-05 09:29:45 +00003889 verifyFormat("auto a = [](int **&, int ***) {};");
Daniel Jasperdb8afe42013-09-10 10:26:38 +00003890 verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
Daniel Jasperc74e2792012-12-07 09:52:15 +00003891
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003892 verifyIndependentOfContext("InvalidRegions[*R] = 0;");
Daniel Jasper9bb0d282013-01-04 20:46:38 +00003893
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003894 verifyIndependentOfContext("A<int *> a;");
3895 verifyIndependentOfContext("A<int **> a;");
3896 verifyIndependentOfContext("A<int *, int *> a;");
Daniel Jasper4e778092013-02-06 10:05:46 +00003897 verifyIndependentOfContext(
3898 "const char *const p = reinterpret_cast<const char *const>(q);");
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003899 verifyIndependentOfContext("A<int **, int **> a;");
Daniel Jasper6b5ba8b2013-02-06 10:57:42 +00003900 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);");
Daniel Jasperd3cf17b2013-03-14 10:50:25 +00003901 verifyFormat("for (char **a = b; *a; ++a) {\n}");
Daniel Jasper16a69ef2013-05-03 14:41:24 +00003902 verifyFormat("for (; a && b;) {\n}");
Daniel Jasper8b39c662012-12-10 18:59:13 +00003903
Daniel Jasper2db356d2013-01-08 20:03:18 +00003904 verifyFormat(
3905 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3906 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
3907
Manuel Klimek36fab8d2013-01-10 13:24:24 +00003908 verifyGoogleFormat("int main(int argc, char** argv) {}");
Daniel Jasper8b39c662012-12-10 18:59:13 +00003909 verifyGoogleFormat("A<int*> a;");
3910 verifyGoogleFormat("A<int**> a;");
3911 verifyGoogleFormat("A<int*, int*> a;");
3912 verifyGoogleFormat("A<int**, int**> a;");
Daniel Jasper5d334402013-01-02 08:57:10 +00003913 verifyGoogleFormat("f(b ? *c : *d);");
3914 verifyGoogleFormat("int a = b ? *c : *d;");
Daniel Jasper48bd7b72013-01-16 16:04:06 +00003915 verifyGoogleFormat("Type* t = **x;");
3916 verifyGoogleFormat("Type* t = *++*x;");
3917 verifyGoogleFormat("*++*x;");
3918 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);");
3919 verifyGoogleFormat("Type* t = x++ * y;");
Daniel Jasper4e778092013-02-06 10:05:46 +00003920 verifyGoogleFormat(
3921 "const char* const p = reinterpret_cast<const char* const>(q);");
Manuel Klimek1b6f4bd2013-01-14 10:58:01 +00003922
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003923 verifyIndependentOfContext("a = *(x + y);");
3924 verifyIndependentOfContext("a = &(x + y);");
3925 verifyIndependentOfContext("*(x + y).call();");
3926 verifyIndependentOfContext("&(x + y)->call();");
Daniel Jasper8a5d7cd2013-03-01 17:13:29 +00003927 verifyFormat("void f() { &(*I).first; }");
Daniel Jasperb369c2c2013-01-15 14:27:39 +00003928
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003929 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
Daniel Jasperb369c2c2013-01-15 14:27:39 +00003930 verifyFormat(
3931 "int *MyValues = {\n"
3932 " *A, // Operator detection might be confused by the '{'\n"
3933 " *BB // Operator detection might be confused by previous comment\n"
3934 "};");
Nico Weber5096a442013-01-17 17:17:19 +00003935
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003936 verifyIndependentOfContext("if (int *a = &b)");
3937 verifyIndependentOfContext("if (int &a = *b)");
3938 verifyIndependentOfContext("if (a & b[i])");
3939 verifyIndependentOfContext("if (a::b::c::d & b[i])");
3940 verifyIndependentOfContext("if (*b[i])");
3941 verifyIndependentOfContext("if (int *a = (&b))");
3942 verifyIndependentOfContext("while (int *a = &b)");
Daniel Jasper65da8e92013-09-21 17:31:51 +00003943 verifyIndependentOfContext("size = sizeof *a;");
Daniel Jasper20d35832013-01-23 12:58:14 +00003944 verifyFormat("void f() {\n"
3945 " for (const int &v : Values) {\n"
3946 " }\n"
3947 "}");
Daniel Jasperd0f349b2013-02-18 12:44:35 +00003948 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
3949 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
Daniel Jasper7e274002013-09-11 20:37:10 +00003950 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}");
Daniel Jasperffee1712013-01-22 11:46:26 +00003951
Daniel Jasper378d93d2013-05-13 07:14:40 +00003952 verifyFormat("#define MACRO \\\n"
3953 " int *i = a * b; \\\n"
3954 " void f(a *b);",
3955 getLLVMStyleWithColumns(19));
3956
Daniel Jasper6f21a982013-03-13 07:49:51 +00003957 verifyIndependentOfContext("A = new SomeType *[Length];");
Daniel Jasper4bfc65a2013-01-23 12:10:53 +00003958 verifyIndependentOfContext("A = new SomeType *[Length]();");
Daniel Jasperd6104f62013-07-05 13:30:40 +00003959 verifyIndependentOfContext("T **t = new T *;");
3960 verifyIndependentOfContext("T **t = new T *();");
Daniel Jasperffee1712013-01-22 11:46:26 +00003961 verifyGoogleFormat("A = new SomeType* [Length]();");
Daniel Jasper6f21a982013-03-13 07:49:51 +00003962 verifyGoogleFormat("A = new SomeType* [Length];");
Daniel Jasperd6104f62013-07-05 13:30:40 +00003963 verifyGoogleFormat("T** t = new T*;");
3964 verifyGoogleFormat("T** t = new T*();");
Daniel Jasper378d93d2013-05-13 07:14:40 +00003965
Daniel Jasperdbef71e2013-05-07 14:17:18 +00003966 FormatStyle PointerLeft = getLLVMStyle();
3967 PointerLeft.PointerBindsToType = true;
3968 verifyFormat("delete *x;", PointerLeft);
Daniel Jasper8a5d7cd2013-03-01 17:13:29 +00003969}
Daniel Jasper8ff690a2013-02-06 14:22:40 +00003970
Daniel Jaspere0fa4c52013-07-17 20:25:02 +00003971TEST_F(FormatTest, UnderstandsAttributes) {
3972 verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
3973}
3974
Daniel Jasperf0220182013-05-06 06:35:44 +00003975TEST_F(FormatTest, UnderstandsEllipsis) {
3976 verifyFormat("int printf(const char *fmt, ...);");
3977 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
Daniel Jasperc47d7f12013-07-01 09:47:25 +00003978 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}");
3979
3980 FormatStyle PointersLeft = getLLVMStyle();
3981 PointersLeft.PointerBindsToType = true;
3982 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft);
Daniel Jasperf0220182013-05-06 06:35:44 +00003983}
3984
Daniel Jasper8a5d7cd2013-03-01 17:13:29 +00003985TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
Daniel Jasper8ff690a2013-02-06 14:22:40 +00003986 EXPECT_EQ("int *a;\n"
3987 "int *a;\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003988 "int *a;",
3989 format("int *a;\n"
3990 "int* a;\n"
3991 "int *a;",
3992 getGoogleStyle()));
Daniel Jasper8ff690a2013-02-06 14:22:40 +00003993 EXPECT_EQ("int* a;\n"
3994 "int* a;\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00003995 "int* a;",
3996 format("int* a;\n"
3997 "int* a;\n"
3998 "int *a;",
3999 getGoogleStyle()));
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 Jasperbac016b2012-12-03 18:12:45 +00004007}
4008
Alexander Kornienko3fd9ccd2013-03-12 16:28:18 +00004009TEST_F(FormatTest, UnderstandsRvalueReferences) {
4010 verifyFormat("int f(int &&a) {}");
4011 verifyFormat("int f(int a, char &&b) {}");
4012 verifyFormat("void f() { int &&a = b; }");
4013 verifyGoogleFormat("int f(int a, char&& b) {}");
4014 verifyGoogleFormat("void f() { int&& a = b; }");
4015
Daniel Jasper131884a2013-05-27 16:36:33 +00004016 verifyIndependentOfContext("A<int &&> a;");
4017 verifyIndependentOfContext("A<int &&, int &&> a;");
4018 verifyGoogleFormat("A<int&&> a;");
4019 verifyGoogleFormat("A<int&&, int&&> a;");
Daniel Jasperb7000ca2013-08-01 17:58:23 +00004020
4021 // Not rvalue references:
4022 verifyFormat("template <bool B, bool C> class A {\n"
4023 " static_assert(B && C, \"Something is wrong\");\n"
4024 "};");
Daniel Jasperb644dd62013-08-13 09:09:09 +00004025 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))");
4026 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))");
Alexander Kornienko3fd9ccd2013-03-12 16:28:18 +00004027}
4028
Manuel Klimeka32a7fd2013-01-23 14:08:21 +00004029TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
4030 verifyFormat("void f() {\n"
4031 " x[aaaaaaaaa -\n"
Daniel Jasperbf71ba22013-04-08 20:33:42 +00004032 " b] = 23;\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004033 "}",
4034 getLLVMStyleWithColumns(15));
Manuel Klimeka32a7fd2013-01-23 14:08:21 +00004035}
4036
Daniel Jasper4981bd02013-01-13 08:01:36 +00004037TEST_F(FormatTest, FormatsCasts) {
4038 verifyFormat("Type *A = static_cast<Type *>(P);");
4039 verifyFormat("Type *A = (Type *)P;");
4040 verifyFormat("Type *A = (vector<Type *, int *>)P;");
4041 verifyFormat("int a = (int)(2.0f);");
Daniel Jasperb8b42952013-05-31 16:14:28 +00004042 verifyFormat("int a = (int)2.0f;");
4043 verifyFormat("x[(int32)y];");
4044 verifyFormat("x = (int32)y;");
4045 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
4046 verifyFormat("int a = (int)*b;");
4047 verifyFormat("int a = (int)2.0f;");
4048 verifyFormat("int a = (int)~0;");
4049 verifyFormat("int a = (int)++a;");
4050 verifyFormat("int a = (int)sizeof(int);");
4051 verifyFormat("int a = (int)+2;");
4052 verifyFormat("my_int a = (my_int)2.0f;");
4053 verifyFormat("my_int a = (my_int)sizeof(int);");
Daniel Jasperff1a2e52013-06-06 08:20:20 +00004054 verifyFormat("return (my_int)aaa;");
Daniel Jasper0c368782013-07-15 15:04:42 +00004055 verifyFormat("#define x ((int)-1)");
4056 verifyFormat("#define p(q) ((int *)&q)");
Daniel Jasper4981bd02013-01-13 08:01:36 +00004057
Daniel Jasperb8b42952013-05-31 16:14:28 +00004058 // FIXME: Without type knowledge, this can still fall apart miserably.
4059 verifyFormat("void f() { my_int a = (my_int) * b; }");
Alexander Kornienko2785b9a2013-06-07 16:02:52 +00004060 verifyFormat("void f() { return P ? (my_int) * P : (my_int)0; }");
Daniel Jasperb8b42952013-05-31 16:14:28 +00004061 verifyFormat("my_int a = (my_int) ~0;");
4062 verifyFormat("my_int a = (my_int)++ a;");
4063 verifyFormat("my_int a = (my_int) + 2;");
Daniel Jasper4981bd02013-01-13 08:01:36 +00004064
Daniel Jasper5e2169f2013-07-18 14:46:07 +00004065 // Don't break after a cast's
4066 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
4067 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
4068 " bbbbbbbbbbbbbbbbbbbbbb);");
4069
Daniel Jasper4981bd02013-01-13 08:01:36 +00004070 // These are not casts.
4071 verifyFormat("void f(int *) {}");
Nico Weber6fa7e742013-02-13 04:32:57 +00004072 verifyFormat("f(foo)->b;");
4073 verifyFormat("f(foo).b;");
4074 verifyFormat("f(foo)(b);");
4075 verifyFormat("f(foo)[b];");
Daniel Jasper567dcf92013-09-05 09:29:45 +00004076 verifyFormat("[](foo) { return 4; }(bar);");
Nico Weber6fa7e742013-02-13 04:32:57 +00004077 verifyFormat("(*funptr)(foo)[4];");
4078 verifyFormat("funptrs[4](foo)[4];");
Daniel Jasper4981bd02013-01-13 08:01:36 +00004079 verifyFormat("void f(int *);");
4080 verifyFormat("void f(int *) = 0;");
4081 verifyFormat("void f(SmallVector<int>) {}");
4082 verifyFormat("void f(SmallVector<int>);");
4083 verifyFormat("void f(SmallVector<int>) = 0;");
Nico Weber77280572013-02-09 18:02:07 +00004084 verifyFormat("void f(int i = (kValue) * kMask) {}");
4085 verifyFormat("void f(int i = (kA * kB) & kMask) {}");
Nico Weber6fa7e742013-02-13 04:32:57 +00004086 verifyFormat("int a = sizeof(int) * b;");
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00004087 verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
Daniel Jasperff1a2e52013-06-06 08:20:20 +00004088 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
4089 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
Daniel Jasper526df0f2013-07-08 14:58:01 +00004090 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
Daniel Jasperfaab0d32013-02-27 09:47:53 +00004091
Daniel Jasper37eff832013-02-23 08:07:18 +00004092 // These are not casts, but at some point were confused with casts.
4093 verifyFormat("virtual void foo(int *) override;");
4094 verifyFormat("virtual void foo(char &) const;");
4095 verifyFormat("virtual void foo(int *a, char *) const;");
Daniel Jasper6a365aa2013-03-13 17:13:53 +00004096 verifyFormat("int a = sizeof(int *) + b;");
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00004097 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
Daniel Jasper198c8bf2013-07-05 07:58:34 +00004098
4099 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
4100 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
Daniel Jasper011c35d2013-07-12 11:19:37 +00004101 // FIXME: The indentation here is not ideal.
Daniel Jasper07ca5472013-07-05 09:14:35 +00004102 verifyFormat(
Daniel Jasper011c35d2013-07-12 11:19:37 +00004103 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4104 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
4105 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];");
Daniel Jasper4981bd02013-01-13 08:01:36 +00004106}
4107
Daniel Jasper46ef8522013-01-10 13:08:12 +00004108TEST_F(FormatTest, FormatsFunctionTypes) {
Daniel Jasper46ef8522013-01-10 13:08:12 +00004109 verifyFormat("A<bool()> a;");
4110 verifyFormat("A<SomeType()> a;");
Daniel Jasper431f5912013-05-28 08:33:00 +00004111 verifyFormat("A<void (*)(int, std::string)> a;");
Daniel Jasper9322aae2013-03-20 09:53:18 +00004112 verifyFormat("A<void *(int)>;");
Daniel Jasper81d2d382013-04-01 17:13:26 +00004113 verifyFormat("void *(*a)(int *, SomeType *);");
Daniel Jasper8a5d7cd2013-03-01 17:13:29 +00004114 verifyFormat("int (*func)(void *);");
Daniel Jasper431f5912013-05-28 08:33:00 +00004115 verifyFormat("void f() { int (*func)(void *); }");
Daniel Jasper53352602013-08-12 12:16:34 +00004116 verifyFormat("template <class CallbackClass>\n"
4117 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);");
Daniel Jasper9322aae2013-03-20 09:53:18 +00004118
Daniel Jasper81d2d382013-04-01 17:13:26 +00004119 verifyGoogleFormat("A<void*(int*, SomeType*)>;");
4120 verifyGoogleFormat("void* (*a)(int);");
Daniel Jasper53352602013-08-12 12:16:34 +00004121 verifyGoogleFormat(
4122 "template <class CallbackClass>\n"
4123 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);");
Daniel Jasper7424d792013-05-14 08:34:47 +00004124
Daniel Jaspera8fda852013-05-15 07:51:51 +00004125 // Other constructs can look somewhat like function types:
Daniel Jasper7424d792013-05-14 08:34:47 +00004126 verifyFormat("A<sizeof(*x)> a;");
Daniel Jaspera8fda852013-05-15 07:51:51 +00004127 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
Daniel Jaspere7d3bff2013-07-16 11:37:21 +00004128 verifyFormat("some_var = function(*some_pointer_var)[0];");
4129 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
Daniel Jasper46ef8522013-01-10 13:08:12 +00004130}
4131
Daniel Jasper3c08a812013-02-24 18:54:32 +00004132TEST_F(FormatTest, BreaksLongDeclarations) {
Daniel Jasper53e72cd2013-05-06 08:27:33 +00004133 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00004134 " AnotherNameForTheLongType;",
4135 getGoogleStyle());
Daniel Jasper53e72cd2013-05-06 08:27:33 +00004136 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00004137 " LoooooooooooooooooooooooooooooooooooooooongVariable;",
4138 getGoogleStyle());
Daniel Jasper6ac431c2013-07-02 09:47:29 +00004139 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
4140 " LoooooooooooooooooooooooooooooooooooooooongVariable;",
4141 getGoogleStyle());
Daniel Jasper53e72cd2013-05-06 08:27:33 +00004142 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
Manuel Klimeka9a7f102013-06-21 17:25:42 +00004143 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();",
4144 getGoogleStyle());
Daniel Jasper53e72cd2013-05-06 08:27:33 +00004145 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
4146 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasper6ac431c2013-07-02 09:47:29 +00004147 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
4148 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
Daniel Jasper53e72cd2013-05-06 08:27:33 +00004149
4150 // FIXME: Without the comment, this breaks after "(".
Manuel Klimeka9a7f102013-06-21 17:25:42 +00004151 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n"
4152 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();",
4153 getGoogleStyle());
Daniel Jasper53e72cd2013-05-06 08:27:33 +00004154
Daniel Jasper83f25ba2013-01-28 15:16:31 +00004155 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00004156 " int LoooooooooooooooooooongParam2) {}");
Daniel Jasper4dc41de2013-01-02 08:44:14 +00004157 verifyFormat(
Daniel Jasper1407bee2013-04-11 14:29:13 +00004158 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
4159 " SourceLocation L, IdentifierIn *II,\n"
4160 " Type *T) {}");
Daniel Jasper3c08a812013-02-24 18:54:32 +00004161 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
4162 "ReallyReallyLongFunctionName(\n"
4163 " const std::string &SomeParameter,\n"
4164 " const SomeType<string, SomeOtherTemplateParameter> &\n"
4165 " ReallyReallyLongParameterName,\n"
4166 " const SomeType<string, SomeOtherTemplateParameter> &\n"
4167 " AnotherLongParameterName) {}");
Daniel Jasper33f4b902013-05-15 09:35:08 +00004168 verifyFormat("template <typename A>\n"
4169 "SomeLoooooooooooooooooooooongType<\n"
4170 " typename some_namespace::SomeOtherType<A>::Type>\n"
4171 "Function() {}");
Daniel Jasper3c08a812013-02-24 18:54:32 +00004172
Daniel Jasperd75ff642013-01-28 15:40:20 +00004173 verifyGoogleFormat(
Daniel Jasper92495a82013-08-19 10:16:18 +00004174 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
4175 " aaaaaaaaaaaaaaaaaaaaaaa;");
4176 verifyGoogleFormat(
Daniel Jasperfaab0d32013-02-27 09:47:53 +00004177 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
4178 " SourceLocation L) {}");
Daniel Jaspera03ab102013-02-13 20:33:44 +00004179 verifyGoogleFormat(
4180 "some_namespace::LongReturnType\n"
4181 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00004182 " int first_long_parameter, int second_parameter) {}");
Daniel Jaspera03ab102013-02-13 20:33:44 +00004183
4184 verifyGoogleFormat("template <typename T>\n"
4185 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
Daniel Jasperf11a7052013-02-21 21:33:55 +00004186 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
Daniel Jasperb6f02f32013-02-28 10:06:05 +00004187 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4188 " int aaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper4dc41de2013-01-02 08:44:14 +00004189}
4190
Daniel Jasper011c35d2013-07-12 11:19:37 +00004191TEST_F(FormatTest, FormatsArrays) {
4192 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
4193 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
4194 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4195 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
4196 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4197 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
4198 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4199 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
4200 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
4201 verifyFormat(
4202 "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
4203 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
4204 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
4205}
4206
Daniel Jasper3b5943f2012-12-06 09:56:08 +00004207TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
4208 verifyFormat("(a)->b();");
4209 verifyFormat("--a;");
4210}
4211
Daniel Jasper8822d3a2012-12-04 13:02:32 +00004212TEST_F(FormatTest, HandlesIncludeDirectives) {
Daniel Jasper2b9c10b2013-01-14 15:52:06 +00004213 verifyFormat("#include <string>\n"
4214 "#include <a/b/c.h>\n"
4215 "#include \"a/b/string\"\n"
4216 "#include \"string.h\"\n"
4217 "#include \"string.h\"\n"
Manuel Klimek407a31a2013-01-15 15:50:27 +00004218 "#include <a-a>\n"
Daniel Jasper3a204412013-02-23 07:46:38 +00004219 "#include < path with space >\n"
Daniel Jasper7ff96ed2013-05-06 10:24:51 +00004220 "#include \"abc.h\" // this is included for ABC\n"
Daniel Jasper5d5b4242013-05-16 12:59:13 +00004221 "#include \"some long include\" // with a comment\n"
Daniel Jasper3a204412013-02-23 07:46:38 +00004222 "#include \"some very long include paaaaaaaaaaaaaaaaaaaaaaath\"",
4223 getLLVMStyleWithColumns(35));
Nico Weberb23ae0c2012-12-21 18:21:56 +00004224
Daniel Jasper8134e1e2013-01-13 08:12:18 +00004225 verifyFormat("#import <string>");
4226 verifyFormat("#import <a/b/c.h>");
4227 verifyFormat("#import \"a/b/string\"");
4228 verifyFormat("#import \"string.h\"");
4229 verifyFormat("#import \"string.h\"");
Daniel Jaspera4dd9822013-08-28 08:24:04 +00004230 verifyFormat("#if __has_include(<strstream>)\n"
4231 "#include <strstream>\n"
4232 "#endif");
Daniel Jasper8822d3a2012-12-04 13:02:32 +00004233}
4234
Alexander Kornienko15757312012-12-06 18:03:27 +00004235//===----------------------------------------------------------------------===//
4236// Error recovery tests.
4237//===----------------------------------------------------------------------===//
4238
Daniel Jasperc5cfa492013-02-14 09:19:04 +00004239TEST_F(FormatTest, IncompleteParameterLists) {
Daniel Jasperfaab0d32013-02-27 09:47:53 +00004240 FormatStyle NoBinPacking = getLLVMStyle();
4241 NoBinPacking.BinPackParameters = false;
4242 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
4243 " double *min_x,\n"
4244 " double *max_x,\n"
4245 " double *min_y,\n"
4246 " double *max_y,\n"
4247 " double *min_z,\n"
4248 " double *max_z, ) {}",
4249 NoBinPacking);
Daniel Jasperc5cfa492013-02-14 09:19:04 +00004250}
4251
Daniel Jasper700e7102013-01-10 09:26:47 +00004252TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
Alexander Kornienko51c23fa2013-01-16 11:45:16 +00004253 verifyFormat("void f() { return; }\n42");
4254 verifyFormat("void f() {\n"
4255 " if (0)\n"
4256 " return;\n"
4257 "}\n"
4258 "42");
Alexander Kornienkod8818752013-01-16 11:43:46 +00004259 verifyFormat("void f() { return }\n42");
4260 verifyFormat("void f() {\n"
4261 " if (0)\n"
4262 " return\n"
4263 "}\n"
4264 "42");
4265}
4266
4267TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
4268 EXPECT_EQ("void f() { return }", format("void f ( ) { return }"));
4269 EXPECT_EQ("void f() {\n"
4270 " if (a)\n"
4271 " return\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004272 "}",
4273 format("void f ( ) { if ( a ) return }"));
Daniel Jasper5be59ba2013-05-15 14:09:55 +00004274 EXPECT_EQ("namespace N {\n"
4275 "void f()\n"
4276 "}",
4277 format("namespace N { void f() }"));
Alexander Kornienkod8818752013-01-16 11:43:46 +00004278 EXPECT_EQ("namespace N {\n"
4279 "void f() {}\n"
4280 "void g()\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004281 "}",
4282 format("namespace N { void f( ) { } void g( ) }"));
Daniel Jasper700e7102013-01-10 09:26:47 +00004283}
4284
Daniel Jasperceb99ab2013-01-09 10:16:05 +00004285TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
4286 verifyFormat("int aaaaaaaa =\n"
Alexander Kornienko5262dd92013-03-27 11:52:18 +00004287 " // Overlylongcomment\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004288 " b;",
4289 getLLVMStyleWithColumns(20));
Daniel Jasperceb99ab2013-01-09 10:16:05 +00004290 verifyFormat("function(\n"
4291 " ShortArgument,\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004292 " LoooooooooooongArgument);\n",
4293 getLLVMStyleWithColumns(20));
Daniel Jasperceb99ab2013-01-09 10:16:05 +00004294}
4295
Alexander Kornienko56e49c52012-12-10 16:34:48 +00004296TEST_F(FormatTest, IncorrectAccessSpecifier) {
4297 verifyFormat("public:");
4298 verifyFormat("class A {\n"
4299 "public\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +00004300 " void f() {}\n"
Alexander Kornienko56e49c52012-12-10 16:34:48 +00004301 "};");
4302 verifyFormat("public\n"
4303 "int qwerty;");
4304 verifyFormat("public\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +00004305 "B {}");
Alexander Kornienko56e49c52012-12-10 16:34:48 +00004306 verifyFormat("public\n"
Manuel Klimek36fab8d2013-01-10 13:24:24 +00004307 "{}");
Alexander Kornienko56e49c52012-12-10 16:34:48 +00004308 verifyFormat("public\n"
Manuel Klimek517e8942013-01-11 17:54:10 +00004309 "B { int x; }");
Alexander Kornienko56e49c52012-12-10 16:34:48 +00004310}
Daniel Jasperbac016b2012-12-03 18:12:45 +00004311
Daniel Jasper92f9faf2013-03-20 15:58:10 +00004312TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
4313 verifyFormat("{");
4314 verifyFormat("#})");
4315}
Alexander Kornienko393b0082012-12-04 15:40:36 +00004316
4317TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004318 verifyFormat("do {\n}");
4319 verifyFormat("do {\n}\n"
Alexander Kornienko393b0082012-12-04 15:40:36 +00004320 "f();");
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004321 verifyFormat("do {\n}\n"
Alexander Kornienko393b0082012-12-04 15:40:36 +00004322 "wheeee(fun);");
4323 verifyFormat("do {\n"
4324 " f();\n"
Manuel Klimekde768542013-01-07 18:10:23 +00004325 "}");
Alexander Kornienko393b0082012-12-04 15:40:36 +00004326}
4327
Manuel Klimek6eca03f2013-01-11 19:23:05 +00004328TEST_F(FormatTest, IncorrectCodeMissingParens) {
Manuel Klimekd4658432013-01-11 18:28:36 +00004329 verifyFormat("if {\n foo;\n foo();\n}");
Manuel Klimek6eca03f2013-01-11 19:23:05 +00004330 verifyFormat("switch {\n foo;\n foo();\n}");
4331 verifyFormat("for {\n foo;\n foo();\n}");
4332 verifyFormat("while {\n foo;\n foo();\n}");
4333 verifyFormat("do {\n foo;\n foo();\n} while;");
Manuel Klimekd4658432013-01-11 18:28:36 +00004334}
4335
Daniel Jasper1f42f112013-01-04 18:52:56 +00004336TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
4337 verifyFormat("namespace {\n"
Manuel Klimekae76f7f2013-10-11 21:25:45 +00004338 "class Foo { Foo (\n"
Daniel Jasperf7ec1cc2013-05-31 14:56:29 +00004339 "};\n"
4340 "} // comment");
Daniel Jasper1f42f112013-01-04 18:52:56 +00004341}
4342
Alexander Kornienkocff563c2012-12-04 17:27:50 +00004343TEST_F(FormatTest, IncorrectCodeErrorDetection) {
Manuel Klimek36fab8d2013-01-10 13:24:24 +00004344 EXPECT_EQ("{\n{}\n", format("{\n{\n}\n"));
4345 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n"));
4346 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n"));
4347 EXPECT_EQ("{\n {}\n }\n}\n", format("{\n {\n }\n }\n}\n"));
Alexander Kornienkocff563c2012-12-04 17:27:50 +00004348
Alexander Kornienkocff563c2012-12-04 17:27:50 +00004349 EXPECT_EQ("{\n"
4350 " {\n"
4351 " breakme(\n"
4352 " qwe);\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004353 "}\n",
4354 format("{\n"
4355 " {\n"
4356 " breakme(qwe);\n"
4357 "}\n",
4358 getLLVMStyleWithColumns(10)));
Alexander Kornienkocff563c2012-12-04 17:27:50 +00004359}
4360
Manuel Klimek2851c162013-01-10 14:36:46 +00004361TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004362 verifyFormat("int x = {\n"
4363 " avariable,\n"
4364 " b(alongervariable)\n"
4365 "};",
4366 getLLVMStyleWithColumns(25));
Manuel Klimek2851c162013-01-10 14:36:46 +00004367}
4368
Manuel Klimekc44ee892013-01-21 10:07:49 +00004369TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
4370 verifyFormat("return (a)(b) { 1, 2, 3 };");
4371}
4372
Manuel Klimek80829bd2013-05-23 09:41:43 +00004373TEST_F(FormatTest, LayoutCxx11ConstructorBraceInitializers) {
Daniel Jasper2424eef2013-05-23 10:15:45 +00004374 verifyFormat("vector<int> x{ 1, 2, 3, 4 };");
4375 verifyFormat("vector<T> x{ {}, {}, {}, {} };");
Manuel Klimek80829bd2013-05-23 09:41:43 +00004376 verifyFormat("f({ 1, 2 });");
Daniel Jasper2424eef2013-05-23 10:15:45 +00004377 verifyFormat("auto v = Foo{ 1 };");
Manuel Klimek80829bd2013-05-23 09:41:43 +00004378 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });");
Daniel Jasperde0d61f2013-05-23 18:29:16 +00004379 verifyFormat("Class::Class : member{ 1, 2, 3 } {}");
Daniel Jasperce933562013-05-23 21:35:49 +00004380 verifyFormat("new vector<int>{ 1, 2, 3 };");
4381 verifyFormat("new int[3]{ 1, 2, 3 };");
Daniel Jasperde0d61f2013-05-23 18:29:16 +00004382 verifyFormat("return { arg1, arg2 };");
Daniel Jasper88959b72013-05-28 18:50:02 +00004383 verifyFormat("return { arg1, SomeType{ parameter } };");
Daniel Jasperde0d61f2013-05-23 18:29:16 +00004384 verifyFormat("new T{ arg1, arg2 };");
Daniel Jasperac885cd2013-09-13 10:55:31 +00004385 verifyFormat("f(MyMap[{ composite, key }]);");
Daniel Jasperde0d61f2013-05-23 18:29:16 +00004386 verifyFormat("class Class {\n"
4387 " T member = { arg1, arg2 };\n"
4388 "};");
Daniel Jaspereb483662013-05-31 10:09:55 +00004389 verifyFormat(
4390 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4391 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
4392 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
4393 " bbbbbbbbbbbbbbbbbbbb, bbbbb };");
Daniel Jasper02eacc22013-07-01 09:15:46 +00004394 verifyFormat("DoSomethingWithVector({} /* No data */);");
Daniel Jasperf50dbfa2013-07-01 16:43:38 +00004395 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });");
Daniel Jasper0de1c4d2013-07-09 09:06:29 +00004396 verifyFormat(
4397 "someFunction(OtherParam, BracedList{\n"
Daniel Jasperb1491792013-07-09 11:57:27 +00004398 " // comment 1 (Forcing interesting break)\n"
Daniel Jasper0de1c4d2013-07-09 09:06:29 +00004399 " param1, param2,\n"
4400 " // comment 2\n"
4401 " param3, param4\n"
4402 " });");
Daniel Jasperf439dcb2013-08-28 07:50:37 +00004403 verifyFormat(
4404 "std::this_thread::sleep_for(\n"
4405 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);");
Daniel Jasper2424eef2013-05-23 10:15:45 +00004406
4407 FormatStyle NoSpaces = getLLVMStyle();
Daniel Jasperb5dc3f42013-07-16 18:22:10 +00004408 NoSpaces.Cpp11BracedListStyle = true;
Daniel Jasper2424eef2013-05-23 10:15:45 +00004409 verifyFormat("vector<int> x{1, 2, 3, 4};", NoSpaces);
4410 verifyFormat("vector<T> x{{}, {}, {}, {}};", NoSpaces);
4411 verifyFormat("f({1, 2});", NoSpaces);
Daniel Jasper1bee0732013-05-23 18:05:18 +00004412 verifyFormat("auto v = Foo{-1};", NoSpaces);
Daniel Jasper2424eef2013-05-23 10:15:45 +00004413 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});", NoSpaces);
Daniel Jasperde0d61f2013-05-23 18:29:16 +00004414 verifyFormat("Class::Class : member{1, 2, 3} {}", NoSpaces);
Daniel Jasperce933562013-05-23 21:35:49 +00004415 verifyFormat("new vector<int>{1, 2, 3};", NoSpaces);
4416 verifyFormat("new int[3]{1, 2, 3};", NoSpaces);
Daniel Jasperde0d61f2013-05-23 18:29:16 +00004417 verifyFormat("return {arg1, arg2};", NoSpaces);
Daniel Jasper88959b72013-05-28 18:50:02 +00004418 verifyFormat("return {arg1, SomeType{parameter}};", NoSpaces);
Daniel Jasperde0d61f2013-05-23 18:29:16 +00004419 verifyFormat("new T{arg1, arg2};", NoSpaces);
Daniel Jasperac885cd2013-09-13 10:55:31 +00004420 verifyFormat("f(MyMap[{composite, key}]);", NoSpaces);
Daniel Jasperde0d61f2013-05-23 18:29:16 +00004421 verifyFormat("class Class {\n"
4422 " T member = {arg1, arg2};\n"
4423 "};",
4424 NoSpaces);
Manuel Klimek80829bd2013-05-23 09:41:43 +00004425}
4426
Daniel Jasperd4a03db2013-08-22 15:00:41 +00004427TEST_F(FormatTest, FormatsBracedListsinColumnLayout) {
4428 verifyFormat("vector<int> x = { 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4429 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4430 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4431 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4432 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4433 " 1, 22, 333, 4444, 55555, 666666, 7777777 };");
4434 verifyFormat("vector<int> x = { 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4435 " // line comment\n"
4436 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4437 " 1, 22, 333, 4444, 55555,\n"
4438 " // line comment\n"
4439 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
4440 " 1, 22, 333, 4444, 55555, 666666, 7777777 };");
4441 verifyFormat(
4442 "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, // comment\n"
4445 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
4446 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
4447 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
4448 " 7777777 };");
4449 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
4450 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
4451 " X86::R8, X86::R9, X86::R10, X86::R11, 0\n"
4452 "};");
4453 verifyFormat("vector<int> x = { 1, 1, 1, 1,\n"
4454 " 1, 1, 1, 1 };",
4455 getLLVMStyleWithColumns(39));
4456 verifyFormat("vector<int> x = { 1, 1, 1, 1,\n"
4457 " 1, 1, 1, 1 };",
4458 getLLVMStyleWithColumns(38));
4459 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
4460 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1\n"
4461 "};",
4462 getLLVMStyleWithColumns(40));
Daniel Jaspered51c022013-08-23 10:05:49 +00004463
4464 // Trailing commas.
4465 verifyFormat("vector<int> x = { 1, 1, 1, 1,\n"
4466 " 1, 1, 1, 1, };",
4467 getLLVMStyleWithColumns(39));
4468 verifyFormat("vector<int> x = {\n"
4469 " 1, 1, 1, 1, 1, 1, 1, 1, //\n"
4470 "};",
4471 getLLVMStyleWithColumns(39));
Daniel Jasper332c6772013-08-26 08:10:17 +00004472 verifyFormat("vector<int> x = { 1, 1, 1, 1,\n"
4473 " 1, 1, 1, 1,\n"
4474 " /**/ /**/ };",
4475 getLLVMStyleWithColumns(39));
Daniel Jasper451f1e02013-08-27 08:43:47 +00004476 verifyFormat("return { { aaaaaaaaaaaaaaaaaaaaa }, { aaaaaaaaaaaaaaaaaaa },\n"
4477 " { aaaaaaaaaaaaaaaaaaaaa }, { aaaaaaaaaaaaaaaaa } };",
4478 getLLVMStyleWithColumns(60));
Daniel Jasperd4a03db2013-08-22 15:00:41 +00004479}
4480
Manuel Klimek517e8942013-01-11 17:54:10 +00004481TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
4482 verifyFormat("void f() { return 42; }");
4483 verifyFormat("void f() {\n"
4484 " // Comment\n"
4485 "}");
4486 verifyFormat("{\n"
4487 "#error {\n"
4488 " int a;\n"
4489 "}");
4490 verifyFormat("{\n"
4491 " int a;\n"
4492 "#error {\n"
4493 "}");
Daniel Jasper058f6f82013-05-16 10:17:39 +00004494 verifyFormat("void f() {} // comment");
4495 verifyFormat("void f() { int a; } // comment");
Daniel Jasper9e5b6c32013-05-16 16:54:34 +00004496 verifyFormat("void f() {\n"
4497 "} // comment",
4498 getLLVMStyleWithColumns(15));
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004499
4500 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
4501 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22));
4502
4503 verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
4504 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
Manuel Klimek517e8942013-01-11 17:54:10 +00004505}
4506
Manuel Klimek47ea7f62013-01-15 13:38:33 +00004507TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
4508 // Elaborate type variable declarations.
Manuel Klimek606e07e2013-01-11 18:13:04 +00004509 verifyFormat("struct foo a = { bar };\nint n;");
Manuel Klimek47ea7f62013-01-15 13:38:33 +00004510 verifyFormat("class foo a = { bar };\nint n;");
4511 verifyFormat("union foo a = { bar };\nint n;");
4512
4513 // Elaborate types inside function definitions.
4514 verifyFormat("struct foo f() {}\nint n;");
4515 verifyFormat("class foo f() {}\nint n;");
4516 verifyFormat("union foo f() {}\nint n;");
4517
4518 // Templates.
4519 verifyFormat("template <class X> void f() {}\nint n;");
4520 verifyFormat("template <struct X> void f() {}\nint n;");
4521 verifyFormat("template <union X> void f() {}\nint n;");
4522
4523 // Actual definitions...
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004524 verifyFormat("struct {\n} n;");
4525 verifyFormat(
4526 "template <template <class T, class Y>, class Z> class X {\n} n;");
Manuel Klimek47ea7f62013-01-15 13:38:33 +00004527 verifyFormat("union Z {\n int n;\n} x;");
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004528 verifyFormat("class MACRO Z {\n} n;");
4529 verifyFormat("class MACRO(X) Z {\n} n;");
4530 verifyFormat("class __attribute__(X) Z {\n} n;");
4531 verifyFormat("class __declspec(X) Z {\n} n;");
Manuel Klimekb8b1ce12013-02-06 15:57:54 +00004532 verifyFormat("class A##B##C {\n} n;");
Manuel Klimek3d712892013-10-07 09:15:41 +00004533 verifyFormat("class alignas(16) Z {\n} n;");
Manuel Klimek47ea7f62013-01-15 13:38:33 +00004534
Manuel Klimek7f5b0252013-01-21 10:17:14 +00004535 // Redefinition from nested context:
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004536 verifyFormat("class A::B::C {\n} n;");
Manuel Klimek7f5b0252013-01-21 10:17:14 +00004537
Manuel Klimek3a3408c2013-01-21 13:58:54 +00004538 // Template definitions.
Daniel Jasper5d823e32013-05-15 13:46:48 +00004539 verifyFormat(
4540 "template <typename F>\n"
4541 "Matcher(const Matcher<F> &Other,\n"
4542 " typename enable_if_c<is_base_of<F, T>::value &&\n"
4543 " !is_same<F, T>::value>::type * = 0)\n"
4544 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
4545
Manuel Klimek3a3408c2013-01-21 13:58:54 +00004546 // FIXME: This is still incorrectly handled at the formatter side.
Daniel Jasper0236dd02013-07-30 22:37:19 +00004547 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
Manuel Klimek3a3408c2013-01-21 13:58:54 +00004548
4549 // FIXME:
4550 // This now gets parsed incorrectly as class definition.
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004551 // verifyFormat("class A<int> f() {\n}\nint n;");
Manuel Klimek3a3408c2013-01-21 13:58:54 +00004552
Manuel Klimek47ea7f62013-01-15 13:38:33 +00004553 // Elaborate types where incorrectly parsing the structural element would
4554 // break the indent.
4555 verifyFormat("if (true)\n"
4556 " class X x;\n"
4557 "else\n"
4558 " f();\n");
Daniel Jasper6fe554e2013-03-20 15:12:38 +00004559
4560 // This is simply incomplete. Formatting is not important, but must not crash.
Daniel Jasper6315fec2013-08-13 10:58:30 +00004561 verifyFormat("class A:");
Manuel Klimek606e07e2013-01-11 18:13:04 +00004562}
4563
Manuel Klimek407a31a2013-01-15 15:50:27 +00004564TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
Manuel Klimekae76f7f2013-10-11 21:25:45 +00004565 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n",
4566 format("#error Leave all white!!!!! space* alone!\n"));
4567 EXPECT_EQ(
4568 "#warning Leave all white!!!!! space* alone!\n",
4569 format("#warning Leave all white!!!!! space* alone!\n"));
Manuel Klimek407a31a2013-01-15 15:50:27 +00004570 EXPECT_EQ("#error 1", format(" # error 1"));
4571 EXPECT_EQ("#warning 1", format(" # warning 1"));
4572}
4573
Daniel Jasperaae7bad2013-04-23 13:54:04 +00004574TEST_F(FormatTest, FormatHashIfExpressions) {
4575 // FIXME: Come up with a better indentation for #elif.
4576 verifyFormat(
4577 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n"
4578 " defined(BBBBBBBB)\n"
4579 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n"
4580 " defined(BBBBBBBB)\n"
4581 "#endif",
4582 getLLVMStyleWithColumns(65));
4583}
4584
Manuel Klimek525fe162013-01-18 14:04:34 +00004585TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
4586 FormatStyle AllowsMergedIf = getGoogleStyle();
4587 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true;
4588 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
4589 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
Manuel Klimek4c128122013-01-18 14:46:43 +00004590 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf);
4591 EXPECT_EQ("if (true) return 42;",
4592 format("if (true)\nreturn 42;", AllowsMergedIf));
4593 FormatStyle ShortMergedIf = AllowsMergedIf;
4594 ShortMergedIf.ColumnLimit = 25;
Daniel Jasper2972d042013-04-25 08:56:26 +00004595 verifyFormat("#define A \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004596 " if (true) return 42;",
4597 ShortMergedIf);
Daniel Jasper2972d042013-04-25 08:56:26 +00004598 verifyFormat("#define A \\\n"
4599 " f(); \\\n"
Manuel Klimek4c128122013-01-18 14:46:43 +00004600 " if (true)\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004601 "#define B",
4602 ShortMergedIf);
Daniel Jasper2972d042013-04-25 08:56:26 +00004603 verifyFormat("#define A \\\n"
4604 " f(); \\\n"
Manuel Klimek4c128122013-01-18 14:46:43 +00004605 " if (true)\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004606 "g();",
4607 ShortMergedIf);
Manuel Klimek0fbe0082013-01-21 14:16:56 +00004608 verifyFormat("{\n"
4609 "#ifdef A\n"
4610 " // Comment\n"
4611 " if (true) continue;\n"
4612 "#endif\n"
4613 " // Comment\n"
Manuel Klimekae76f7f2013-10-11 21:25:45 +00004614 " if (true) continue;\n"
4615 "}",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004616 ShortMergedIf);
Manuel Klimek525fe162013-01-18 14:04:34 +00004617}
4618
Manuel Klimek86721d22013-01-22 16:31:55 +00004619TEST_F(FormatTest, BlockCommentsInControlLoops) {
4620 verifyFormat("if (0) /* a comment in a strange place */ {\n"
4621 " f();\n"
4622 "}");
4623 verifyFormat("if (0) /* a comment in a strange place */ {\n"
4624 " f();\n"
4625 "} /* another comment */ else /* comment #3 */ {\n"
4626 " g();\n"
4627 "}");
4628 verifyFormat("while (0) /* a comment in a strange place */ {\n"
4629 " f();\n"
4630 "}");
4631 verifyFormat("for (;;) /* a comment in a strange place */ {\n"
4632 " f();\n"
4633 "}");
4634 verifyFormat("do /* a comment in a strange place */ {\n"
4635 " f();\n"
4636 "} /* another comment */ while (0);");
4637}
4638
4639TEST_F(FormatTest, BlockComments) {
4640 EXPECT_EQ("/* */ /* */ /* */\n/* */ /* */ /* */",
4641 format("/* *//* */ /* */\n/* *//* */ /* */"));
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004642 EXPECT_EQ("/* */ a /* */ b;", format(" /* */ a/* */ b;"));
Daniel Jasperc9346c92013-08-28 09:07:32 +00004643 EXPECT_EQ("#define A /*123*/ \\\n"
Manuel Klimek86721d22013-01-22 16:31:55 +00004644 " b\n"
4645 "/* */\n"
4646 "someCall(\n"
4647 " parameter);",
Alexander Kornienko7c22cf32013-03-21 12:28:10 +00004648 format("#define A /*123*/ b\n"
Manuel Klimek86721d22013-01-22 16:31:55 +00004649 "/* */\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004650 "someCall(parameter);",
4651 getLLVMStyleWithColumns(15)));
Manuel Klimek86721d22013-01-22 16:31:55 +00004652
4653 EXPECT_EQ("#define A\n"
4654 "/* */ someCall(\n"
4655 " parameter);",
4656 format("#define A\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004657 "/* */someCall(parameter);",
4658 getLLVMStyleWithColumns(15)));
Daniel Jaspere2c482f2013-05-30 06:40:07 +00004659 EXPECT_EQ("/*\n**\n*/", format("/*\n**\n*/"));
Daniel Jasper92092702013-05-30 15:20:29 +00004660 EXPECT_EQ("/*\n"
4661 "*\n"
4662 " * aaaaaa\n"
Alexander Kornienko1659ded2013-07-08 14:12:07 +00004663 "*aaaaaa\n"
Daniel Jasper92092702013-05-30 15:20:29 +00004664 "*/",
4665 format("/*\n"
4666 "*\n"
4667 " * aaaaaa aaaaaa\n"
4668 "*/",
4669 getLLVMStyleWithColumns(10)));
Daniel Jaspercb4b40b2013-05-30 17:27:48 +00004670 EXPECT_EQ("/*\n"
4671 "**\n"
4672 "* aaaaaa\n"
Alexander Kornienko1659ded2013-07-08 14:12:07 +00004673 "*aaaaaa\n"
Daniel Jaspercb4b40b2013-05-30 17:27:48 +00004674 "*/",
4675 format("/*\n"
4676 "**\n"
4677 "* aaaaaa aaaaaa\n"
4678 "*/",
4679 getLLVMStyleWithColumns(10)));
Daniel Jasper2752ff32013-02-04 07:32:14 +00004680
Daniel Jasperfaab0d32013-02-27 09:47:53 +00004681 FormatStyle NoBinPacking = getLLVMStyle();
4682 NoBinPacking.BinPackParameters = false;
Daniel Jasper2752ff32013-02-04 07:32:14 +00004683 EXPECT_EQ("someFunction(1, /* comment 1 */\n"
4684 " 2, /* comment 2 */\n"
4685 " 3, /* comment 3 */\n"
Daniel Jaspercda16502013-02-04 08:34:57 +00004686 " aaaa,\n"
4687 " bbbb);",
Daniel Jasper2752ff32013-02-04 07:32:14 +00004688 format("someFunction (1, /* comment 1 */\n"
4689 " 2, /* comment 2 */ \n"
4690 " 3, /* comment 3 */\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004691 "aaaa, bbbb );",
Daniel Jasperfaab0d32013-02-27 09:47:53 +00004692 NoBinPacking));
Daniel Jasper36ba0ff2013-02-06 15:23:09 +00004693 verifyFormat(
4694 "bool aaaaaaaaaaaaa = /* comment: */ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4695 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
4696 EXPECT_EQ(
4697 "bool aaaaaaaaaaaaa = /* trailing comment */\n"
4698 " aaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4699 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;",
4700 format(
4701 "bool aaaaaaaaaaaaa = /* trailing comment */\n"
4702 " aaaaaaaaaaaaaaaaaaaaaaaaaaa||aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4703 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;"));
Daniel Jasper15417ef2013-02-06 20:07:35 +00004704 EXPECT_EQ(
4705 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n"
4706 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n"
4707 "int cccccccccccccccccccccccccccccc; /* comment */\n",
4708 format("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n"
4709 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n"
4710 "int cccccccccccccccccccccccccccccc; /* comment */\n"));
Daniel Jasper3a1847e2013-07-01 09:34:09 +00004711
4712 verifyFormat("void f(int * /* unused */) {}");
Alexander Kornienko1659ded2013-07-08 14:12:07 +00004713
4714 EXPECT_EQ("/*\n"
4715 " **\n"
4716 " */",
4717 format("/*\n"
4718 " **\n"
4719 " */"));
4720 EXPECT_EQ("/*\n"
4721 " *q\n"
4722 " */",
4723 format("/*\n"
4724 " *q\n"
4725 " */"));
4726 EXPECT_EQ("/*\n"
4727 " * q\n"
4728 " */",
4729 format("/*\n"
4730 " * q\n"
4731 " */"));
4732 EXPECT_EQ("/*\n"
4733 " **/",
4734 format("/*\n"
4735 " **/"));
4736 EXPECT_EQ("/*\n"
4737 " ***/",
4738 format("/*\n"
4739 " ***/"));
Manuel Klimek86721d22013-01-22 16:31:55 +00004740}
4741
Manuel Klimekb3507cd2013-02-06 16:40:56 +00004742TEST_F(FormatTest, BlockCommentsInMacros) {
4743 EXPECT_EQ("#define A \\\n"
4744 " { \\\n"
4745 " /* one line */ \\\n"
4746 " someCall();",
4747 format("#define A { \\\n"
4748 " /* one line */ \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004749 " someCall();",
4750 getLLVMStyleWithColumns(20)));
Manuel Klimekb3507cd2013-02-06 16:40:56 +00004751 EXPECT_EQ("#define A \\\n"
4752 " { \\\n"
4753 " /* previous */ \\\n"
4754 " /* one line */ \\\n"
4755 " someCall();",
4756 format("#define A { \\\n"
4757 " /* previous */ \\\n"
4758 " /* one line */ \\\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004759 " someCall();",
4760 getLLVMStyleWithColumns(20)));
Manuel Klimekb3507cd2013-02-06 16:40:56 +00004761}
4762
Manuel Klimekbe9ed772013-05-29 22:06:18 +00004763TEST_F(FormatTest, BlockCommentsAtEndOfLine) {
4764 EXPECT_EQ("a = {\n"
4765 " 1111 /* */\n"
4766 "};",
Alexander Kornienkoe3f11972013-06-12 19:04:12 +00004767 format("a = {1111 /* */\n"
Manuel Klimekbe9ed772013-05-29 22:06:18 +00004768 "};",
4769 getLLVMStyleWithColumns(15)));
4770 EXPECT_EQ("a = {\n"
4771 " 1111 /* */\n"
4772 "};",
Alexander Kornienkoe3f11972013-06-12 19:04:12 +00004773 format("a = {1111 /* */\n"
Manuel Klimekbe9ed772013-05-29 22:06:18 +00004774 "};",
4775 getLLVMStyleWithColumns(15)));
4776
4777 // FIXME: The formatting is still wrong here.
4778 EXPECT_EQ("a = {\n"
4779 " 1111 /* a\n"
4780 " */\n"
4781 "};",
Alexander Kornienkoe3f11972013-06-12 19:04:12 +00004782 format("a = {1111 /* a */\n"
Manuel Klimekbe9ed772013-05-29 22:06:18 +00004783 "};",
4784 getLLVMStyleWithColumns(15)));
4785}
4786
Manuel Klimekb3507cd2013-02-06 16:40:56 +00004787TEST_F(FormatTest, IndentLineCommentsInStartOfBlockAtEndOfFile) {
4788 // FIXME: This is not what we want...
4789 verifyFormat("{\n"
4790 "// a"
4791 "// b");
4792}
4793
Manuel Klimek092a2c72013-01-23 10:09:28 +00004794TEST_F(FormatTest, FormatStarDependingOnContext) {
Manuel Klimek70b03f42013-01-23 09:32:48 +00004795 verifyFormat("void f(int *a);");
4796 verifyFormat("void f() { f(fint * b); }");
Manuel Klimek836b58f2013-01-23 11:03:04 +00004797 verifyFormat("class A {\n void f(int *a);\n};");
4798 verifyFormat("class A {\n int *a;\n};");
4799 verifyFormat("namespace a {\n"
4800 "namespace b {\n"
4801 "class A {\n"
4802 " void f() {}\n"
4803 " int *a;\n"
4804 "};\n"
4805 "}\n"
4806 "}");
Manuel Klimek70b03f42013-01-23 09:32:48 +00004807}
4808
Manuel Klimek092a2c72013-01-23 10:09:28 +00004809TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
4810 verifyFormat("while");
4811 verifyFormat("operator");
4812}
4813
Nico Webercf4a79c2013-01-08 17:56:31 +00004814//===----------------------------------------------------------------------===//
4815// Objective-C tests.
4816//===----------------------------------------------------------------------===//
4817
Fariborz Jahanian154120c2012-12-20 19:54:13 +00004818TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
4819 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
4820 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
4821 format("-(NSUInteger)indexOfObject:(id)anObject;"));
Daniel Jaspercd162382013-01-07 13:26:07 +00004822 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
Fariborz Jahanian154120c2012-12-20 19:54:13 +00004823 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
4824 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
4825 format("-(NSInteger)Method3:(id)anObject;"));
4826 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
4827 format("-(NSInteger)Method4:(id)anObject;"));
4828 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
4829 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
4830 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
4831 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
Daniel Jaspercd162382013-01-07 13:26:07 +00004832 EXPECT_EQ(
4833 "- (void)sendAction:(SEL)aSelector to:(id)anObject forAllCells:(BOOL)flag;",
Daniel Jasper66d19bd2013-02-18 11:59:17 +00004834 format(
4835 "- (void)sendAction:(SEL)aSelector to:(id)anObject forAllCells:(BOOL)flag;"));
Fariborz Jahanian9b3f02c2012-12-21 22:51:18 +00004836
4837 // Very long objectiveC method declaration.
Daniel Jasper63d7ced2013-02-05 10:07:47 +00004838 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
4839 " inRange:(NSRange)range\n"
4840 " outRange:(NSRange)out_range\n"
4841 " outRange1:(NSRange)out_range1\n"
4842 " outRange2:(NSRange)out_range2\n"
4843 " outRange3:(NSRange)out_range3\n"
4844 " outRange4:(NSRange)out_range4\n"
4845 " outRange5:(NSRange)out_range5\n"
4846 " outRange6:(NSRange)out_range6\n"
4847 " outRange7:(NSRange)out_range7\n"
4848 " outRange8:(NSRange)out_range8\n"
4849 " outRange9:(NSRange)out_range9;");
Nico Webere0fd4292013-01-10 20:18:33 +00004850
4851 verifyFormat("- (int)sum:(vector<int>)numbers;");
Nico Weberaab60052013-01-17 06:14:50 +00004852 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
Nico Webere0fd4292013-01-10 20:18:33 +00004853 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
4854 // protocol lists (but not for template classes):
4855 //verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
Nico Webercd52bda2013-01-10 23:11:41 +00004856
Daniel Jasper431f5912013-05-28 08:33:00 +00004857 verifyFormat("- (int (*)())foo:(int (*)())f;");
4858 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
Nico Webercd52bda2013-01-10 23:11:41 +00004859
4860 // If there's no return type (very rare in practice!), LLVM and Google style
4861 // agree.
Daniel Jasper627707b2013-03-22 16:55:40 +00004862 verifyFormat("- foo;");
Nico Webercd52bda2013-01-10 23:11:41 +00004863 verifyFormat("- foo:(int)f;");
4864 verifyGoogleFormat("- foo:(int)foo;");
Fariborz Jahanian154120c2012-12-20 19:54:13 +00004865}
4866
Daniel Jasper886568d2013-01-09 08:36:49 +00004867TEST_F(FormatTest, FormatObjCBlocks) {
Daniel Jasper46ef8522013-01-10 13:08:12 +00004868 verifyFormat("int (^Block)(int, int);");
4869 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)");
Daniel Jasper886568d2013-01-09 08:36:49 +00004870}
4871
Nico Weber27d13672013-01-09 20:25:35 +00004872TEST_F(FormatTest, FormatObjCInterface) {
Nico Weber5f500df2013-01-10 20:12:55 +00004873 verifyFormat("@interface Foo : NSObject <NSSomeDelegate> {\n"
Nico Weber27d13672013-01-09 20:25:35 +00004874 "@public\n"
4875 " int field1;\n"
4876 "@protected\n"
4877 " int field2;\n"
4878 "@private\n"
4879 " int field3;\n"
4880 "@package\n"
4881 " int field4;\n"
4882 "}\n"
4883 "+ (id)init;\n"
4884 "@end");
4885
Nico Weber27d13672013-01-09 20:25:35 +00004886 verifyGoogleFormat("@interface Foo : NSObject<NSSomeDelegate> {\n"
4887 " @public\n"
4888 " int field1;\n"
4889 " @protected\n"
4890 " int field2;\n"
4891 " @private\n"
4892 " int field3;\n"
4893 " @package\n"
4894 " int field4;\n"
4895 "}\n"
Nico Weberaab60052013-01-17 06:14:50 +00004896 "+ (id)init;\n"
Nico Weber27d13672013-01-09 20:25:35 +00004897 "@end");
4898
Nico Weberf5ecfa52013-01-22 16:53:59 +00004899 verifyFormat("@interface /* wait for it */ Foo\n"
Nico Weber27d13672013-01-09 20:25:35 +00004900 "+ (id)init;\n"
4901 "// Look, a comment!\n"
4902 "- (int)answerWith:(int)i;\n"
4903 "@end");
4904
4905 verifyFormat("@interface Foo\n"
Nico Weber049c4472013-01-09 21:42:32 +00004906 "@end\n"
4907 "@interface Bar\n"
Nico Weber27d13672013-01-09 20:25:35 +00004908 "@end");
4909
4910 verifyFormat("@interface Foo : Bar\n"
4911 "+ (id)init;\n"
4912 "@end");
4913
Nico Weberf5ecfa52013-01-22 16:53:59 +00004914 verifyFormat("@interface Foo : /**/ Bar /**/ <Baz, /**/ Quux>\n"
Nico Weber27d13672013-01-09 20:25:35 +00004915 "+ (id)init;\n"
4916 "@end");
4917
Nico Weber5f500df2013-01-10 20:12:55 +00004918 verifyGoogleFormat("@interface Foo : Bar<Baz, Quux>\n"
Nico Weberaab60052013-01-17 06:14:50 +00004919 "+ (id)init;\n"
Nico Weber5f500df2013-01-10 20:12:55 +00004920 "@end");
4921
Nico Webered91bba2013-01-10 19:19:14 +00004922 verifyFormat("@interface Foo (HackStuff)\n"
Nico Weber27d13672013-01-09 20:25:35 +00004923 "+ (id)init;\n"
4924 "@end");
4925
Nico Webered91bba2013-01-10 19:19:14 +00004926 verifyFormat("@interface Foo ()\n"
Nico Weber27d13672013-01-09 20:25:35 +00004927 "+ (id)init;\n"
4928 "@end");
4929
Nico Weber5f500df2013-01-10 20:12:55 +00004930 verifyFormat("@interface Foo (HackStuff) <MyProtocol>\n"
Nico Weber27d13672013-01-09 20:25:35 +00004931 "+ (id)init;\n"
4932 "@end");
4933
Nico Weber5f500df2013-01-10 20:12:55 +00004934 verifyGoogleFormat("@interface Foo (HackStuff)<MyProtocol>\n"
Nico Weberaab60052013-01-17 06:14:50 +00004935 "+ (id)init;\n"
Nico Weber5f500df2013-01-10 20:12:55 +00004936 "@end");
4937
Manuel Klimekd5688cf2013-01-11 19:17:44 +00004938 verifyFormat("@interface Foo {\n"
4939 " int _i;\n"
4940 "}\n"
Nico Weber27d13672013-01-09 20:25:35 +00004941 "+ (id)init;\n"
4942 "@end");
4943
Manuel Klimekd5688cf2013-01-11 19:17:44 +00004944 verifyFormat("@interface Foo : Bar {\n"
4945 " int _i;\n"
4946 "}\n"
Nico Weber27d13672013-01-09 20:25:35 +00004947 "+ (id)init;\n"
4948 "@end");
4949
Manuel Klimekd5688cf2013-01-11 19:17:44 +00004950 verifyFormat("@interface Foo : Bar <Baz, Quux> {\n"
4951 " int _i;\n"
4952 "}\n"
Nico Weber27d13672013-01-09 20:25:35 +00004953 "+ (id)init;\n"
4954 "@end");
4955
Manuel Klimekd5688cf2013-01-11 19:17:44 +00004956 verifyFormat("@interface Foo (HackStuff) {\n"
4957 " int _i;\n"
4958 "}\n"
Nico Weber27d13672013-01-09 20:25:35 +00004959 "+ (id)init;\n"
4960 "@end");
4961
Manuel Klimekd5688cf2013-01-11 19:17:44 +00004962 verifyFormat("@interface Foo () {\n"
4963 " int _i;\n"
4964 "}\n"
Nico Weber27d13672013-01-09 20:25:35 +00004965 "+ (id)init;\n"
4966 "@end");
4967
Manuel Klimekd5688cf2013-01-11 19:17:44 +00004968 verifyFormat("@interface Foo (HackStuff) <MyProtocol> {\n"
4969 " int _i;\n"
4970 "}\n"
Nico Weber27d13672013-01-09 20:25:35 +00004971 "+ (id)init;\n"
4972 "@end");
4973}
4974
Nico Weber50767d82013-01-09 23:25:37 +00004975TEST_F(FormatTest, FormatObjCImplementation) {
4976 verifyFormat("@implementation Foo : NSObject {\n"
4977 "@public\n"
4978 " int field1;\n"
4979 "@protected\n"
4980 " int field2;\n"
4981 "@private\n"
4982 " int field3;\n"
4983 "@package\n"
4984 " int field4;\n"
4985 "}\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004986 "+ (id)init {\n}\n"
Nico Weber50767d82013-01-09 23:25:37 +00004987 "@end");
4988
4989 verifyGoogleFormat("@implementation Foo : NSObject {\n"
4990 " @public\n"
4991 " int field1;\n"
4992 " @protected\n"
4993 " int field2;\n"
4994 " @private\n"
4995 " int field3;\n"
4996 " @package\n"
4997 " int field4;\n"
4998 "}\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00004999 "+ (id)init {\n}\n"
Nico Weber50767d82013-01-09 23:25:37 +00005000 "@end");
5001
5002 verifyFormat("@implementation Foo\n"
5003 "+ (id)init {\n"
Daniel Jasper6f5bb2c2013-01-14 16:24:39 +00005004 " if (true)\n"
5005 " return nil;\n"
Nico Weber50767d82013-01-09 23:25:37 +00005006 "}\n"
5007 "// Look, a comment!\n"
Manuel Klimekd5688cf2013-01-11 19:17:44 +00005008 "- (int)answerWith:(int)i {\n"
5009 " return i;\n"
5010 "}\n"
Nico Weber67015ed2013-01-11 21:14:08 +00005011 "+ (int)answerWith:(int)i {\n"
5012 " return i;\n"
5013 "}\n"
Nico Weber50767d82013-01-09 23:25:37 +00005014 "@end");
5015
5016 verifyFormat("@implementation Foo\n"
5017 "@end\n"
5018 "@implementation Bar\n"
5019 "@end");
5020
5021 verifyFormat("@implementation Foo : Bar\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00005022 "+ (id)init {\n}\n"
5023 "- (void)foo {\n}\n"
Nico Weber50767d82013-01-09 23:25:37 +00005024 "@end");
5025
Manuel Klimekd5688cf2013-01-11 19:17:44 +00005026 verifyFormat("@implementation Foo {\n"
5027 " int _i;\n"
5028 "}\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00005029 "+ (id)init {\n}\n"
Nico Weber50767d82013-01-09 23:25:37 +00005030 "@end");
5031
Manuel Klimekd5688cf2013-01-11 19:17:44 +00005032 verifyFormat("@implementation Foo : Bar {\n"
5033 " int _i;\n"
5034 "}\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00005035 "+ (id)init {\n}\n"
Nico Weber50767d82013-01-09 23:25:37 +00005036 "@end");
5037
Nico Webered91bba2013-01-10 19:19:14 +00005038 verifyFormat("@implementation Foo (HackStuff)\n"
Manuel Klimek2f1ac412013-01-21 16:42:44 +00005039 "+ (id)init {\n}\n"
Nico Weber50767d82013-01-09 23:25:37 +00005040 "@end");
Daniel Jasper7186ccc2013-08-28 08:04:23 +00005041 verifyFormat("@implementation ObjcClass\n"
5042 "- (void)method;\n"
5043 "{}\n"
5044 "@end");
Nico Weber50767d82013-01-09 23:25:37 +00005045}
5046
Nico Weber1abe6ea2013-01-09 21:15:03 +00005047TEST_F(FormatTest, FormatObjCProtocol) {
5048 verifyFormat("@protocol Foo\n"
5049 "@property(weak) id delegate;\n"
5050 "- (NSUInteger)numberOfThings;\n"
5051 "@end");
5052
Nico Weber5f500df2013-01-10 20:12:55 +00005053 verifyFormat("@protocol MyProtocol <NSObject>\n"
Nico Weber1abe6ea2013-01-09 21:15:03 +00005054 "- (NSUInteger)numberOfThings;\n"
5055 "@end");
5056
Nico Weber5f500df2013-01-10 20:12:55 +00005057 verifyGoogleFormat("@protocol MyProtocol<NSObject>\n"
Nico Weberaab60052013-01-17 06:14:50 +00005058 "- (NSUInteger)numberOfThings;\n"
Nico Weber5f500df2013-01-10 20:12:55 +00005059 "@end");
5060
Nico Weber1abe6ea2013-01-09 21:15:03 +00005061 verifyFormat("@protocol Foo;\n"
5062 "@protocol Bar;\n");
Nico Weber049c4472013-01-09 21:42:32 +00005063
5064 verifyFormat("@protocol Foo\n"
5065 "@end\n"
5066 "@protocol Bar\n"
5067 "@end");
Nico Weberb530fa32013-01-10 00:25:19 +00005068
5069 verifyFormat("@protocol myProtocol\n"
5070 "- (void)mandatoryWithInt:(int)i;\n"
5071 "@optional\n"
5072 "- (void)optional;\n"
5073 "@required\n"
5074 "- (void)required;\n"
Nico Weber880e5382013-01-10 00:42:07 +00005075 "@optional\n"
5076 "@property(assign) int madProp;\n"
Nico Weberb530fa32013-01-10 00:25:19 +00005077 "@end\n");
Daniel Jasperaa9e7b12013-08-01 13:46:58 +00005078
5079 verifyFormat("@property(nonatomic, assign, readonly)\n"
5080 " int *looooooooooooooooooooooooooooongNumber;\n"
5081 "@property(nonatomic, assign, readonly)\n"
5082 " NSString *looooooooooooooooooooooooooooongName;");
Nico Weber1abe6ea2013-01-09 21:15:03 +00005083}
5084
Daniel Jasper63d7ced2013-02-05 10:07:47 +00005085TEST_F(FormatTest, FormatObjCMethodDeclarations) {
5086 verifyFormat("- (void)doSomethingWith:(GTMFoo *)theFoo\n"
5087 " rect:(NSRect)theRect\n"
5088 " interval:(float)theInterval {\n"
5089 "}");
5090 verifyFormat("- (void)shortf:(GTMFoo *)theFoo\n"
5091 " longKeyword:(NSRect)theRect\n"
5092 " evenLongerKeyword:(float)theInterval\n"
5093 " error:(NSError **)theError {\n"
5094 "}");
5095}
5096
Nico Weberbcfdd262013-01-12 06:18:40 +00005097TEST_F(FormatTest, FormatObjCMethodExpr) {
5098 verifyFormat("[foo bar:baz];");
5099 verifyFormat("return [foo bar:baz];");
5100 verifyFormat("f([foo bar:baz]);");
5101 verifyFormat("f(2, [foo bar:baz]);");
5102 verifyFormat("f(2, a ? b : c);");
5103 verifyFormat("[[self initWithInt:4] bar:[baz quux:arrrr]];");
5104
Nico Weberee0feec2013-02-05 16:21:00 +00005105 // Unary operators.
5106 verifyFormat("int a = +[foo bar:baz];");
5107 verifyFormat("int a = -[foo bar:baz];");
5108 verifyFormat("int a = ![foo bar:baz];");
5109 verifyFormat("int a = ~[foo bar:baz];");
5110 verifyFormat("int a = ++[foo bar:baz];");
5111 verifyFormat("int a = --[foo bar:baz];");
5112 verifyFormat("int a = sizeof [foo bar:baz];");
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00005113 verifyFormat("int a = alignof [foo bar:baz];", getGoogleStyle());
Nico Webere8a97982013-02-06 06:20:11 +00005114 verifyFormat("int a = &[foo bar:baz];");
5115 verifyFormat("int a = *[foo bar:baz];");
Nico Weberee0feec2013-02-05 16:21:00 +00005116 // FIXME: Make casts work, without breaking f()[4].
Nico Weber4c2cc602013-02-13 03:48:27 +00005117 //verifyFormat("int a = (int)[foo bar:baz];");
Nico Webere0dc7c72013-02-13 04:40:03 +00005118 //verifyFormat("return (int)[foo bar:baz];");
5119 //verifyFormat("(void)[foo bar:baz];");
Nico Weber4c2cc602013-02-13 03:48:27 +00005120 verifyFormat("return (MyType *)[self.tableView cellForRowAtIndexPath:cell];");
Nico Weberee0feec2013-02-05 16:21:00 +00005121
5122 // Binary operators.
Nico Weberbcfdd262013-01-12 06:18:40 +00005123 verifyFormat("[foo bar:baz], [foo bar:baz];");
5124 verifyFormat("[foo bar:baz] = [foo bar:baz];");
5125 verifyFormat("[foo bar:baz] *= [foo bar:baz];");
5126 verifyFormat("[foo bar:baz] /= [foo bar:baz];");
5127 verifyFormat("[foo bar:baz] %= [foo bar:baz];");
5128 verifyFormat("[foo bar:baz] += [foo bar:baz];");
5129 verifyFormat("[foo bar:baz] -= [foo bar:baz];");
5130 verifyFormat("[foo bar:baz] <<= [foo bar:baz];");
5131 verifyFormat("[foo bar:baz] >>= [foo bar:baz];");
5132 verifyFormat("[foo bar:baz] &= [foo bar:baz];");
5133 verifyFormat("[foo bar:baz] ^= [foo bar:baz];");
5134 verifyFormat("[foo bar:baz] |= [foo bar:baz];");
5135 verifyFormat("[foo bar:baz] ? [foo bar:baz] : [foo bar:baz];");
5136 verifyFormat("[foo bar:baz] || [foo bar:baz];");
5137 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];");
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 // Whew!
5155
Nico Weberc2e6d2a2013-02-11 15:32:15 +00005156 verifyFormat("return in[42];");
5157 verifyFormat("for (id foo in [self getStuffFor:bla]) {\n"
5158 "}");
5159
Nico Weberbcfdd262013-01-12 06:18:40 +00005160 verifyFormat("[self stuffWithInt:(4 + 2) float:4.5];");
5161 verifyFormat("[self stuffWithInt:a ? b : c float:4.5];");
5162 verifyFormat("[self stuffWithInt:a ? [self foo:bar] : c];");
5163 verifyFormat("[self stuffWithInt:a ? (e ? f : g) : c];");
5164 verifyFormat("[cond ? obj1 : obj2 methodWithParam:param]");
Nico Weber6292dd42013-01-12 23:41:33 +00005165 verifyFormat("[button setAction:@selector(zoomOut:)];");
Nico Webercd458332013-01-12 23:48:49 +00005166 verifyFormat("[color getRed:&r green:&g blue:&b alpha:&a];");
Daniel Jasper63d7ced2013-02-05 10:07:47 +00005167
Nico Weberbcfdd262013-01-12 06:18:40 +00005168 verifyFormat("arr[[self indexForFoo:a]];");
5169 verifyFormat("throw [self errorFor:a];");
5170 verifyFormat("@throw [self errorFor:a];");
5171
Nico Weber465e8612013-06-25 00:55:57 +00005172 verifyFormat("[(id)foo bar:(id)baz quux:(id)snorf];");
5173 verifyFormat("[(id)foo bar:(id) ? baz : quux];");
5174 verifyFormat("4 > 4 ? (id)a : (id)baz;");
5175
Nico Webere8ccc812013-01-12 22:48:47 +00005176 // This tests that the formatter doesn't break after "backing" but before ":",
5177 // which would be at 80 columns.
Nico Weberbcfdd262013-01-12 06:18:40 +00005178 verifyFormat(
5179 "void f() {\n"
Daniel Jasper63d7ced2013-02-05 10:07:47 +00005180 " if ((self = [super initWithContentRect:contentRect\n"
Daniel Jasper1eaa9972013-08-01 23:13:03 +00005181 " styleMask:styleMask ?: otherMask\n"
Daniel Jasper63d7ced2013-02-05 10:07:47 +00005182 " backing:NSBackingStoreBuffered\n"
5183 " defer:YES]))");
5184
Daniel Jasper4e778092013-02-06 10:05:46 +00005185 verifyFormat(
5186 "[foo checkThatBreakingAfterColonWorksOk:\n"
Daniel Jasper1eaa9972013-08-01 23:13:03 +00005187 " [bar ifItDoes:reduceOverallLineLengthLikeInThisCase]];");
Daniel Jasper63d7ced2013-02-05 10:07:47 +00005188
5189 verifyFormat("[myObj short:arg1 // Force line break\n"
Daniel Jasper1eaa9972013-08-01 23:13:03 +00005190 " longKeyword:arg2 != nil ? arg2 : @\"longKeyword\"\n"
5191 " evenLongerKeyword:arg3 ?: @\"evenLongerKeyword\"\n"
Daniel Jasper63d7ced2013-02-05 10:07:47 +00005192 " error:arg4];");
5193 verifyFormat(
5194 "void f() {\n"
5195 " popup_window_.reset([[RenderWidgetPopupWindow alloc]\n"
5196 " initWithContentRect:NSMakeRect(origin_global.x, origin_global.y,\n"
5197 " pos.width(), pos.height())\n"
5198 " styleMask:NSBorderlessWindowMask\n"
5199 " backing:NSBackingStoreBuffered\n"
5200 " defer:NO]);\n"
5201 "}");
Daniel Jasper4e778092013-02-06 10:05:46 +00005202 verifyFormat("[contentsContainer replaceSubview:[subviews objectAtIndex:0]\n"
5203 " with:contentsNativeView];");
5204
5205 verifyFormat(
5206 "[pboard addTypes:[NSArray arrayWithObject:kBookmarkButtonDragType]\n"
5207 " owner:nillllll];");
5208
Daniel Jasper4e778092013-02-06 10:05:46 +00005209 verifyFormat(
Daniel Jasperce3d1a62013-02-08 08:22:00 +00005210 "[pboard setData:[NSData dataWithBytes:&button length:sizeof(button)]\n"
Daniel Jasper4e778092013-02-06 10:05:46 +00005211 " forType:kBookmarkButtonDragType];");
5212
5213 verifyFormat("[defaultCenter addObserver:self\n"
5214 " selector:@selector(willEnterFullscreen)\n"
5215 " name:kWillEnterFullscreenNotification\n"
5216 " object:nil];");
Daniel Jasper9e9e6e02013-02-06 16:00:26 +00005217 verifyFormat("[image_rep drawInRect:drawRect\n"
5218 " fromRect:NSZeroRect\n"
5219 " operation:NSCompositeCopy\n"
5220 " fraction:1.0\n"
5221 " respectFlipped:NO\n"
5222 " hints:nil];");
Nico Weber4ed7f3e2013-02-06 16:54:35 +00005223
5224 verifyFormat(
5225 "scoped_nsobject<NSTextField> message(\n"
5226 " // The frame will be fixed up when |-setMessageText:| is called.\n"
5227 " [[NSTextField alloc] initWithFrame:NSMakeRect(0, 0, 0, 0)]);");
Daniel Jasper1eaa9972013-08-01 23:13:03 +00005228 verifyFormat("[self aaaaaa:bbbbbbbbbbbbb\n"
5229 " aaaaaaaaaa:bbbbbbbbbbbbbbbbb\n"
5230 " aaaaa:bbbbbbbbbbb + bbbbbbbbbbbb\n"
5231 " aaaa:bbb];");
Nico Weberbcfdd262013-01-12 06:18:40 +00005232}
5233
Nico Weber581f5572013-01-07 15:56:25 +00005234TEST_F(FormatTest, ObjCAt) {
Nico Weber4a293a22013-01-07 16:07:07 +00005235 verifyFormat("@autoreleasepool");
Nico Weberd0af4b42013-01-07 16:14:28 +00005236 verifyFormat("@catch");
5237 verifyFormat("@class");
Nico Weber4a293a22013-01-07 16:07:07 +00005238 verifyFormat("@compatibility_alias");
5239 verifyFormat("@defs");
Nico Weberefcfe732013-01-07 15:17:23 +00005240 verifyFormat("@dynamic");
Nico Weber4a293a22013-01-07 16:07:07 +00005241 verifyFormat("@encode");
5242 verifyFormat("@end");
5243 verifyFormat("@finally");
5244 verifyFormat("@implementation");
5245 verifyFormat("@import");
5246 verifyFormat("@interface");
5247 verifyFormat("@optional");
5248 verifyFormat("@package");
Nico Weberd0af4b42013-01-07 16:14:28 +00005249 verifyFormat("@private");
Nico Weber4a293a22013-01-07 16:07:07 +00005250 verifyFormat("@property");
Nico Weberd0af4b42013-01-07 16:14:28 +00005251 verifyFormat("@protected");
Nico Weber4a293a22013-01-07 16:07:07 +00005252 verifyFormat("@protocol");
Nico Weberd0af4b42013-01-07 16:14:28 +00005253 verifyFormat("@public");
Nico Weber4a293a22013-01-07 16:07:07 +00005254 verifyFormat("@required");
5255 verifyFormat("@selector");
5256 verifyFormat("@synchronized");
5257 verifyFormat("@synthesize");
Nico Weberd0af4b42013-01-07 16:14:28 +00005258 verifyFormat("@throw");
5259 verifyFormat("@try");
Nico Weber4a293a22013-01-07 16:07:07 +00005260
Nico Weber581f5572013-01-07 15:56:25 +00005261 EXPECT_EQ("@interface", format("@ interface"));
5262
5263 // The precise formatting of this doesn't matter, nobody writes code like
5264 // this.
5265 verifyFormat("@ /*foo*/ interface");
Nico Weberefcfe732013-01-07 15:17:23 +00005266}
5267
Nico Weberc31689a2013-01-08 19:15:23 +00005268TEST_F(FormatTest, ObjCSnippets) {
Manuel Klimekd5688cf2013-01-11 19:17:44 +00005269 verifyFormat("@autoreleasepool {\n"
5270 " foo();\n"
5271 "}");
Nico Webercf4a79c2013-01-08 17:56:31 +00005272 verifyFormat("@class Foo, Bar;");
Nico Weberc31689a2013-01-08 19:15:23 +00005273 verifyFormat("@compatibility_alias AliasName ExistingClass;");
Nico Webercf4a79c2013-01-08 17:56:31 +00005274 verifyFormat("@dynamic textColor;");
Nico Weber5dfe9b42013-01-18 05:11:47 +00005275 verifyFormat("char *buf1 = @encode(int *);");
5276 verifyFormat("char *buf1 = @encode(typeof(4 * 5));");
Nico Weber95e8e462013-02-12 16:17:07 +00005277 verifyFormat("char *buf1 = @encode(int **);");
Nico Weber3a2673e2013-01-08 20:16:23 +00005278 verifyFormat("Protocol *proto = @protocol(p1);");
Nico Weber6a21a552013-01-18 02:43:57 +00005279 verifyFormat("SEL s = @selector(foo:);");
Manuel Klimekd5688cf2013-01-11 19:17:44 +00005280 verifyFormat("@synchronized(self) {\n"
5281 " f();\n"
5282 "}");
Nico Webercf4a79c2013-01-08 17:56:31 +00005283
Nico Weber70848232013-01-10 21:30:42 +00005284 verifyFormat("@synthesize dropArrowPosition = dropArrowPosition_;");
5285 verifyGoogleFormat("@synthesize dropArrowPosition = dropArrowPosition_;");
5286
Nico Webercf4a79c2013-01-08 17:56:31 +00005287 verifyFormat("@property(assign, nonatomic) CGFloat hoverAlpha;");
Nico Weber70848232013-01-10 21:30:42 +00005288 verifyFormat("@property(assign, getter=isEditable) BOOL editable;");
5289 verifyGoogleFormat("@property(assign, getter=isEditable) BOOL editable;");
Nico Weber10fc2c62013-06-25 00:25:40 +00005290
5291 verifyFormat("@import foo.bar;\n"
5292 "@import baz;");
Nico Webercf4a79c2013-01-08 17:56:31 +00005293}
5294
Nico Weber712f5b32013-02-07 00:19:29 +00005295TEST_F(FormatTest, ObjCLiterals) {
5296 verifyFormat("@\"String\"");
5297 verifyFormat("@1");
5298 verifyFormat("@+4.8");
5299 verifyFormat("@-4");
5300 verifyFormat("@1LL");
5301 verifyFormat("@.5");
5302 verifyFormat("@'c'");
5303 verifyFormat("@true");
5304
5305 verifyFormat("NSNumber *smallestInt = @(-INT_MAX - 1);");
5306 verifyFormat("NSNumber *piOverTwo = @(M_PI / 2);");
5307 verifyFormat("NSNumber *favoriteColor = @(Green);");
5308 verifyFormat("NSString *path = @(getenv(\"PATH\"));");
5309
Nico Weber712f5b32013-02-07 00:19:29 +00005310 verifyFormat("@[");
Nico Weber051860e2013-02-10 02:08:05 +00005311 verifyFormat("@[]");
5312 verifyFormat(
5313 "NSArray *array = @[ @\" Hey \", NSApp, [NSNumber numberWithInt:42] ];");
5314 verifyFormat("return @[ @3, @[], @[ @4, @5 ] ];");
5315
Nico Weber712f5b32013-02-07 00:19:29 +00005316 verifyFormat("@{");
Nico Weberd74fcdb2013-02-10 20:35:35 +00005317 verifyFormat("@{}");
5318 verifyFormat("@{ @\"one\" : @1 }");
5319 verifyFormat("return @{ @\"one\" : @1 };");
5320 verifyFormat("@{ @\"one\" : @1, }");
Manuel Klimek67d080d2013-04-12 14:13:36 +00005321
Daniel Jasper88959b72013-05-28 18:50:02 +00005322 verifyFormat("@{ @\"one\" : @{ @2 : @1 } }");
5323 verifyFormat("@{ @\"one\" : @{ @2 : @1 }, }");
Manuel Klimek67d080d2013-04-12 14:13:36 +00005324
Nico Weberd74fcdb2013-02-10 20:35:35 +00005325 verifyFormat("@{ 1 > 2 ? @\"one\" : @\"two\" : 1 > 2 ? @1 : @2 }");
5326 verifyFormat("[self setDict:@{}");
5327 verifyFormat("[self setDict:@{ @1 : @2 }");
5328 verifyFormat("NSLog(@\"%@\", @{ @1 : @2, @2 : @3 }[@1]);");
5329 verifyFormat(
5330 "NSDictionary *masses = @{ @\"H\" : @1.0078, @\"He\" : @4.0026 };");
Nico Webere6262002013-02-10 20:39:05 +00005331 verifyFormat(
5332 "NSDictionary *settings = @{ AVEncoderKey : @(AVAudioQualityMax) };");
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005333
Nico Weberd74fcdb2013-02-10 20:35:35 +00005334 // FIXME: Nested and multi-line array and dictionary literals need more work.
Nico Weber0ac717b2013-02-10 20:48:24 +00005335 verifyFormat(
5336 "NSDictionary *d = @{ @\"nam\" : NSUserNam(), @\"dte\" : [NSDate date],\n"
5337 " @\"processInfo\" : [NSProcessInfo processInfo] };");
Nico Weberf2ff8122013-05-26 05:39:26 +00005338 verifyFormat(
5339 "@{ NSFontAttributeNameeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee :\n"
5340 " regularFont, };");
5341
Nico Weber712f5b32013-02-07 00:19:29 +00005342}
5343
Manuel Klimek547d5db2013-02-08 17:38:27 +00005344TEST_F(FormatTest, ReformatRegionAdjustsIndent) {
5345 EXPECT_EQ("{\n"
5346 "{\n"
5347 "a;\n"
5348 "b;\n"
5349 "}\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005350 "}",
5351 format("{\n"
5352 "{\n"
5353 "a;\n"
5354 " b;\n"
5355 "}\n"
5356 "}",
5357 13, 2, getLLVMStyle()));
Manuel Klimek547d5db2013-02-08 17:38:27 +00005358 EXPECT_EQ("{\n"
5359 "{\n"
5360 " a;\n"
5361 "b;\n"
5362 "}\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005363 "}",
5364 format("{\n"
5365 "{\n"
5366 " a;\n"
5367 "b;\n"
5368 "}\n"
5369 "}",
5370 9, 2, getLLVMStyle()));
Manuel Klimek547d5db2013-02-08 17:38:27 +00005371 EXPECT_EQ("{\n"
5372 "{\n"
5373 "public:\n"
5374 " b;\n"
5375 "}\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005376 "}",
5377 format("{\n"
5378 "{\n"
5379 "public:\n"
5380 " b;\n"
5381 "}\n"
5382 "}",
5383 17, 2, getLLVMStyle()));
Manuel Klimek547d5db2013-02-08 17:38:27 +00005384 EXPECT_EQ("{\n"
5385 "{\n"
5386 "a;\n"
5387 "}\n"
5388 "{\n"
Daniel Jasper1fb8d882013-05-14 09:30:02 +00005389 " b; //\n"
Manuel Klimek547d5db2013-02-08 17:38:27 +00005390 "}\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005391 "}",
5392 format("{\n"
5393 "{\n"
5394 "a;\n"
5395 "}\n"
5396 "{\n"
Daniel Jasper1fb8d882013-05-14 09:30:02 +00005397 " b; //\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005398 "}\n"
5399 "}",
5400 22, 2, getLLVMStyle()));
Manuel Klimek52635ff2013-02-08 19:53:32 +00005401 EXPECT_EQ(" {\n"
Daniel Jasper1fb8d882013-05-14 09:30:02 +00005402 " a; //\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005403 " }",
5404 format(" {\n"
Daniel Jasper1fb8d882013-05-14 09:30:02 +00005405 "a; //\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005406 " }",
5407 4, 2, getLLVMStyle()));
Daniel Jasper9ece2bb2013-02-12 16:51:23 +00005408 EXPECT_EQ("void f() {}\n"
Daniel Jasper66d19bd2013-02-18 11:59:17 +00005409 "void g() {}",
5410 format("void f() {}\n"
5411 "void g() {}",
5412 13, 0, getLLVMStyle()));
Daniel Jasper83a90e52013-03-20 14:31:47 +00005413 EXPECT_EQ("int a; // comment\n"
5414 " // line 2\n"
5415 "int b;",
5416 format("int a; // comment\n"
5417 " // line 2\n"
5418 " int b;",
5419 35, 0, getLLVMStyle()));
Daniel Jasper15ec3a82013-07-11 21:27:40 +00005420 EXPECT_EQ(" int a;\n"
5421 " void\n"
5422 " ffffff() {\n"
5423 " }",
5424 format(" int a;\n"
5425 "void ffffff() {}",
5426 11, 0, getLLVMStyleWithColumns(11)));
Manuel Klimek52635ff2013-02-08 19:53:32 +00005427}
Manuel Klimek547d5db2013-02-08 17:38:27 +00005428
Manuel Klimek8092a942013-02-20 10:15:13 +00005429TEST_F(FormatTest, BreakStringLiterals) {
5430 EXPECT_EQ("\"some text \"\n"
5431 "\"other\";",
5432 format("\"some text other\";", getLLVMStyleWithColumns(12)));
Alexander Kornienko919398b2013-04-17 17:34:05 +00005433 EXPECT_EQ("\"some text \"\n"
5434 "\"other\";",
5435 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
Manuel Klimek8092a942013-02-20 10:15:13 +00005436 EXPECT_EQ(
5437 "#define A \\\n"
5438 " \"some \" \\\n"
5439 " \"text \" \\\n"
5440 " \"other\";",
5441 format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
5442 EXPECT_EQ(
5443 "#define A \\\n"
5444 " \"so \" \\\n"
5445 " \"text \" \\\n"
5446 " \"other\";",
5447 format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
5448
5449 EXPECT_EQ("\"some text\"",
5450 format("\"some text\"", getLLVMStyleWithColumns(1)));
5451 EXPECT_EQ("\"some text\"",
5452 format("\"some text\"", getLLVMStyleWithColumns(11)));
5453 EXPECT_EQ("\"some \"\n"
5454 "\"text\"",
5455 format("\"some text\"", getLLVMStyleWithColumns(10)));
5456 EXPECT_EQ("\"some \"\n"
5457 "\"text\"",
5458 format("\"some text\"", getLLVMStyleWithColumns(7)));
Manuel Klimekaf31fd72013-03-01 13:14:08 +00005459 EXPECT_EQ("\"some\"\n"
Alexander Kornienko70ce7882013-04-15 14:28:00 +00005460 "\" tex\"\n"
5461 "\"t\"",
Manuel Klimek8092a942013-02-20 10:15:13 +00005462 format("\"some text\"", getLLVMStyleWithColumns(6)));
Manuel Klimek00905912013-03-04 20:03:38 +00005463 EXPECT_EQ("\"some\"\n"
5464 "\" tex\"\n"
5465 "\" and\"",
5466 format("\"some tex and\"", getLLVMStyleWithColumns(6)));
5467 EXPECT_EQ("\"some\"\n"
5468 "\"/tex\"\n"
5469 "\"/and\"",
5470 format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
Manuel Klimek8092a942013-02-20 10:15:13 +00005471
5472 EXPECT_EQ("variable =\n"
5473 " \"long string \"\n"
5474 " \"literal\";",
5475 format("variable = \"long string literal\";",
5476 getLLVMStyleWithColumns(20)));
5477
5478 EXPECT_EQ("variable = f(\n"
5479 " \"long string \"\n"
Daniel Jasperfaab0d32013-02-27 09:47:53 +00005480 " \"literal\",\n"
5481 " short,\n"
Manuel Klimek8092a942013-02-20 10:15:13 +00005482 " loooooooooooooooooooong);",
5483 format("variable = f(\"long string literal\", short, "
5484 "loooooooooooooooooooong);",
5485 getLLVMStyleWithColumns(20)));
Alexander Kornienko22d0e292013-06-17 12:59:44 +00005486
5487 EXPECT_EQ("f(g(\"long string \"\n"
5488 " \"literal\"),\n"
5489 " b);",
5490 format("f(g(\"long string literal\"), b);",
5491 getLLVMStyleWithColumns(20)));
5492 EXPECT_EQ("f(g(\"long string \"\n"
5493 " \"literal\",\n"
5494 " a),\n"
5495 " b);",
5496 format("f(g(\"long string literal\", a), b);",
5497 getLLVMStyleWithColumns(20)));
Manuel Klimek8092a942013-02-20 10:15:13 +00005498 EXPECT_EQ(
5499 "f(\"one two\".split(\n"
Daniel Jasper13d2aa52013-08-30 08:29:25 +00005500 " variable));",
Manuel Klimek8092a942013-02-20 10:15:13 +00005501 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
5502 EXPECT_EQ("f(\"one two three four five six \"\n"
5503 " \"seven\".split(\n"
5504 " really_looooong_variable));",
5505 format("f(\"one two three four five six seven\"."
5506 "split(really_looooong_variable));",
5507 getLLVMStyleWithColumns(33)));
5508
5509 EXPECT_EQ("f(\"some \"\n"
5510 " \"text\",\n"
5511 " other);",
5512 format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
Daniel Jasper0fb382b2013-02-26 12:52:34 +00005513
5514 // Only break as a last resort.
5515 verifyFormat(
5516 "aaaaaaaaaaaaaaaaaaaa(\n"
5517 " aaaaaaaaaaaaaaaaaaaa,\n"
5518 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
Manuel Klimekaf31fd72013-03-01 13:14:08 +00005519
5520 EXPECT_EQ(
5521 "\"splitmea\"\n"
Manuel Klimekbc30c712013-03-01 13:29:19 +00005522 "\"trandomp\"\n"
5523 "\"oint\"",
Manuel Klimekaf31fd72013-03-01 13:14:08 +00005524 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
Manuel Klimekbc30c712013-03-01 13:29:19 +00005525
5526 EXPECT_EQ(
5527 "\"split/\"\n"
5528 "\"pathat/\"\n"
5529 "\"slashes\"",
5530 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
Daniel Jasper2972d042013-04-25 08:56:26 +00005531
Alexander Kornienkof2b2c7d2013-06-19 14:22:47 +00005532 EXPECT_EQ(
5533 "\"split/\"\n"
5534 "\"pathat/\"\n"
5535 "\"slashes\"",
5536 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
5537 EXPECT_EQ("\"split at \"\n"
5538 "\"spaces/at/\"\n"
5539 "\"slashes.at.any$\"\n"
5540 "\"non-alphanumeric%\"\n"
5541 "\"1111111111characte\"\n"
5542 "\"rs\"",
5543 format("\"split at "
5544 "spaces/at/"
5545 "slashes.at."
5546 "any$non-"
5547 "alphanumeric%"
5548 "1111111111characte"
5549 "rs\"",
5550 getLLVMStyleWithColumns(20)));
5551
Daniel Jasper0fde9502013-07-12 11:37:05 +00005552 // Verify that splitting the strings understands
5553 // Style::AlwaysBreakBeforeMultilineStrings.
5554 EXPECT_EQ("aaaaaaaaaaaa(aaaaaaaaaaaaa,\n"
5555 " \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
5556 " \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
5557 format("aaaaaaaaaaaa(aaaaaaaaaaaaa, \"aaaaaaaaaaaaaaaaaaaaaa "
5558 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa "
5559 "aaaaaaaaaaaaaaaaaaaaaa\");",
5560 getGoogleStyle()));
Daniel Jasper75e58bb2013-08-02 11:01:15 +00005561 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
5562 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
5563 format("llvm::outs() << "
5564 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
5565 "aaaaaaaaaaaaaaaaaaa\";"));
Daniel Jasper4df1ff92013-08-23 11:57:34 +00005566 EXPECT_EQ("ffff(\n"
5567 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
5568 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
5569 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
5570 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
5571 getGoogleStyle()));
Daniel Jasper0fde9502013-07-12 11:37:05 +00005572
Daniel Jasper2972d042013-04-25 08:56:26 +00005573 FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
5574 AlignLeft.AlignEscapedNewlinesLeft = true;
5575 EXPECT_EQ(
5576 "#define A \\\n"
5577 " \"some \" \\\n"
5578 " \"text \" \\\n"
5579 " \"other\";",
5580 format("#define A \"some text other\";", AlignLeft));
Manuel Klimek8092a942013-02-20 10:15:13 +00005581}
5582
Alexander Kornienko2c2f7292013-09-16 20:20:49 +00005583TEST_F(FormatTest, BreaksWideStringLiterals) {
5584 EXPECT_EQ(
5585 "u8\"utf8 string \"\n"
5586 "u8\"literal\";",
5587 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
5588 EXPECT_EQ(
5589 "u\"utf16 string \"\n"
5590 "u\"literal\";",
5591 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
5592 EXPECT_EQ(
5593 "U\"utf32 string \"\n"
5594 "U\"literal\";",
5595 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
5596 EXPECT_EQ("L\"wide string \"\n"
5597 "L\"literal\";",
5598 format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
5599}
5600
5601TEST_F(FormatTest, BreaksRawStringLiterals) {
5602 EXPECT_EQ("R\"x(raw )x\"\n"
5603 "R\"x(literal)x\";",
5604 format("R\"x(raw literal)x\";", getGoogleStyleWithColumns(15)));
5605 EXPECT_EQ("uR\"x(raw )x\"\n"
5606 "uR\"x(literal)x\";",
5607 format("uR\"x(raw literal)x\";", getGoogleStyleWithColumns(16)));
5608 EXPECT_EQ("u8R\"x(raw )x\"\n"
5609 "u8R\"x(literal)x\";",
5610 format("u8R\"x(raw literal)x\";", getGoogleStyleWithColumns(17)));
5611 EXPECT_EQ("LR\"x(raw )x\"\n"
5612 "LR\"x(literal)x\";",
5613 format("LR\"x(raw literal)x\";", getGoogleStyleWithColumns(16)));
5614 EXPECT_EQ("UR\"x(raw )x\"\n"
5615 "UR\"x(literal)x\";",
5616 format("UR\"x(raw literal)x\";", getGoogleStyleWithColumns(16)));
5617}
5618
5619TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
5620 FormatStyle Style = getLLVMStyleWithColumns(20);
5621 EXPECT_EQ(
5622 "_T(\"aaaaaaaaaaaaaa\")\n"
5623 "_T(\"aaaaaaaaaaaaaa\")\n"
5624 "_T(\"aaaaaaaaaaaa\")",
5625 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
5626 EXPECT_EQ("f(x, _T(\"aaaaaaaaa\")\n"
5627 " _T(\"aaaaaa\"),\n"
5628 " z);",
5629 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
5630
5631 // FIXME: Handle embedded spaces in one iteration.
5632 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
5633 // "_T(\"aaaaaaaaaaaaa\")\n"
5634 // "_T(\"aaaaaaaaaaaaa\")\n"
5635 // "_T(\"a\")",
5636 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
5637 // getLLVMStyleWithColumns(20)));
5638 EXPECT_EQ(
5639 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
5640 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
5641}
5642
Alexander Kornienko10c26b22013-07-16 21:06:13 +00005643TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
Alexander Kornienkodcc0c5b2013-08-29 17:32:57 +00005644 EXPECT_EQ(
5645 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
5646 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
5647 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
5648 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
5649 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
5650 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
5651}
5652
5653TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
5654 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
5655 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle()));
5656 EXPECT_EQ("fffffffffff(g(R\"x(\n"
5657 "multiline raw string literal xxxxxxxxxxxxxx\n"
5658 ")x\",\n"
5659 " a),\n"
5660 " b);",
5661 format("fffffffffff(g(R\"x(\n"
5662 "multiline raw string literal xxxxxxxxxxxxxx\n"
5663 ")x\", a), b);",
5664 getGoogleStyleWithColumns(20)));
5665 EXPECT_EQ("fffffffffff(\n"
5666 " g(R\"x(qqq\n"
5667 "multiline raw string literal xxxxxxxxxxxxxx\n"
5668 ")x\",\n"
5669 " a),\n"
5670 " b);",
5671 format("fffffffffff(g(R\"x(qqq\n"
5672 "multiline raw string literal xxxxxxxxxxxxxx\n"
5673 ")x\", a), b);",
5674 getGoogleStyleWithColumns(20)));
5675
5676 EXPECT_EQ("fffffffffff(R\"x(\n"
5677 "multiline raw string literal xxxxxxxxxxxxxx\n"
5678 ")x\");",
5679 format("fffffffffff(R\"x(\n"
5680 "multiline raw string literal xxxxxxxxxxxxxx\n"
5681 ")x\");",
5682 getGoogleStyleWithColumns(20)));
5683 EXPECT_EQ("fffffffffff(R\"x(\n"
5684 "multiline raw string literal xxxxxxxxxxxxxx\n"
5685 ")x\" +\n"
5686 " bbbbbb);",
5687 format("fffffffffff(R\"x(\n"
5688 "multiline raw string literal xxxxxxxxxxxxxx\n"
5689 ")x\" + bbbbbb);",
5690 getGoogleStyleWithColumns(20)));
Alexander Kornienko10c26b22013-07-16 21:06:13 +00005691}
5692
Alexander Kornienko16a0ec62013-06-14 11:46:10 +00005693TEST_F(FormatTest, SkipsUnknownStringLiterals) {
Daniel Jasper561211d2013-07-16 20:28:33 +00005694 verifyFormat("string a = \"unterminated;");
5695 EXPECT_EQ("function(\"unterminated,\n"
5696 " OtherParameter);",
5697 format("function( \"unterminated,\n"
5698 " OtherParameter);"));
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00005699}
5700
5701TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
5702 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
5703 format("#define x(_a) printf(\"foo\"_a);", getLLVMStyle()));
Alexander Kornienko16a0ec62013-06-14 11:46:10 +00005704}
5705
Manuel Klimek2a9805d2013-05-14 09:04:24 +00005706TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
5707 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
5708 " \"ddeeefff\");",
5709 format("someFunction(\"aaabbbcccdddeeefff\");",
5710 getLLVMStyleWithColumns(25)));
5711 EXPECT_EQ("someFunction1234567890(\n"
5712 " \"aaabbbcccdddeeefff\");",
5713 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
5714 getLLVMStyleWithColumns(26)));
5715 EXPECT_EQ("someFunction1234567890(\n"
5716 " \"aaabbbcccdddeeeff\"\n"
5717 " \"f\");",
5718 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
5719 getLLVMStyleWithColumns(25)));
5720 EXPECT_EQ("someFunction1234567890(\n"
5721 " \"aaabbbcccdddeeeff\"\n"
5722 " \"f\");",
5723 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
5724 getLLVMStyleWithColumns(24)));
Daniel Jasperf5461782013-08-28 10:03:58 +00005725 EXPECT_EQ("someFunction(\"aaabbbcc \"\n"
5726 " \"ddde \"\n"
5727 " \"efff\");",
5728 format("someFunction(\"aaabbbcc ddde efff\");",
Manuel Klimek2a9805d2013-05-14 09:04:24 +00005729 getLLVMStyleWithColumns(25)));
5730 EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
5731 " \"ddeeefff\");",
5732 format("someFunction(\"aaabbbccc ddeeefff\");",
5733 getLLVMStyleWithColumns(25)));
5734 EXPECT_EQ("someFunction1234567890(\n"
5735 " \"aaabb \"\n"
5736 " \"cccdddeeefff\");",
5737 format("someFunction1234567890(\"aaabb cccdddeeefff\");",
5738 getLLVMStyleWithColumns(25)));
5739 EXPECT_EQ("#define A \\\n"
5740 " string s = \\\n"
5741 " \"123456789\" \\\n"
5742 " \"0\"; \\\n"
5743 " int i;",
5744 format("#define A string s = \"1234567890\"; int i;",
5745 getLLVMStyleWithColumns(20)));
Daniel Jasperf5461782013-08-28 10:03:58 +00005746 // FIXME: Put additional penalties on breaking at non-whitespace locations.
5747 EXPECT_EQ("someFunction(\"aaabbbcc \"\n"
5748 " \"dddeeeff\"\n"
5749 " \"f\");",
5750 format("someFunction(\"aaabbbcc dddeeefff\");",
5751 getLLVMStyleWithColumns(25)));
Manuel Klimek2a9805d2013-05-14 09:04:24 +00005752}
5753
Manuel Klimekaa62d0c2013-03-08 18:59:48 +00005754TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
5755 EXPECT_EQ("\"\\a\"",
5756 format("\"\\a\"", getLLVMStyleWithColumns(3)));
5757 EXPECT_EQ("\"\\\"",
5758 format("\"\\\"", getLLVMStyleWithColumns(2)));
5759 EXPECT_EQ("\"test\"\n"
5760 "\"\\n\"",
5761 format("\"test\\n\"", getLLVMStyleWithColumns(7)));
5762 EXPECT_EQ("\"tes\\\\\"\n"
5763 "\"n\"",
5764 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
5765 EXPECT_EQ("\"\\\\\\\\\"\n"
5766 "\"\\n\"",
5767 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
5768 EXPECT_EQ("\"\\uff01\"",
5769 format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
5770 EXPECT_EQ("\"\\uff01\"\n"
5771 "\"test\"",
5772 format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
5773 EXPECT_EQ("\"\\Uff01ff02\"",
5774 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
5775 EXPECT_EQ("\"\\x000000000001\"\n"
5776 "\"next\"",
5777 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
5778 EXPECT_EQ("\"\\x000000000001next\"",
5779 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
5780 EXPECT_EQ("\"\\x000000000001\"",
5781 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
5782 EXPECT_EQ("\"test\"\n"
5783 "\"\\000000\"\n"
5784 "\"000001\"",
5785 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
5786 EXPECT_EQ("\"test\\000\"\n"
Alexander Kornienko70ce7882013-04-15 14:28:00 +00005787 "\"00000000\"\n"
5788 "\"1\"",
Manuel Klimekaa62d0c2013-03-08 18:59:48 +00005789 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
Alexander Kornienko2c2f7292013-09-16 20:20:49 +00005790 // FIXME: We probably don't need to care about escape sequences in raw
5791 // literals.
5792 EXPECT_EQ("R\"(\\x)\"\n"
5793 "R\"(\\x00)\"\n",
Alexander Kornienkoa1753f42013-06-28 12:51:24 +00005794 format("R\"(\\x\\x00)\"\n", getGoogleStyleWithColumns(7)));
Manuel Klimekaa62d0c2013-03-08 18:59:48 +00005795}
5796
Manuel Klimek423dd932013-04-10 09:52:05 +00005797TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
5798 verifyFormat("void f() {\n"
5799 " return g() {}\n"
5800 " void h() {}");
5801 verifyFormat("if (foo)\n"
5802 " return { forgot_closing_brace();\n"
5803 "test();");
Daniel Jasper88959b72013-05-28 18:50:02 +00005804 verifyFormat("int a[] = { void forgot_closing_brace() { f();\n"
5805 "g();\n"
Manuel Klimek423dd932013-04-10 09:52:05 +00005806 "}");
5807}
5808
Manuel Klimek07a64ec2013-05-13 08:42:42 +00005809TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
5810 verifyFormat("class X {\n"
5811 " void f() {\n"
5812 " }\n"
5813 "};",
5814 getLLVMStyleWithColumns(12));
5815}
5816
5817TEST_F(FormatTest, ConfigurableIndentWidth) {
5818 FormatStyle EightIndent = getLLVMStyleWithColumns(18);
5819 EightIndent.IndentWidth = 8;
5820 verifyFormat("void f() {\n"
5821 " someFunction();\n"
5822 " if (true) {\n"
5823 " f();\n"
5824 " }\n"
5825 "}",
5826 EightIndent);
5827 verifyFormat("class X {\n"
5828 " void f() {\n"
5829 " }\n"
5830 "};",
5831 EightIndent);
5832 verifyFormat("int x[] = {\n"
5833 " call(),\n"
5834 " call(),\n"
5835 "};",
5836 EightIndent);
5837}
5838
Alexander Kornienkoc1c76252013-06-22 01:35:36 +00005839TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
Manuel Klimeka9a7f102013-06-21 17:25:42 +00005840 verifyFormat("void\n"
5841 "f();",
5842 getLLVMStyleWithColumns(8));
5843}
5844
Manuel Klimek7c9a93e2013-05-13 09:22:11 +00005845TEST_F(FormatTest, ConfigurableUseOfTab) {
5846 FormatStyle Tab = getLLVMStyleWithColumns(42);
5847 Tab.IndentWidth = 8;
Alexander Kornienko3d9ffcf2013-09-27 16:14:22 +00005848 Tab.UseTab = FormatStyle::UT_Always;
Manuel Klimek7c9a93e2013-05-13 09:22:11 +00005849 Tab.AlignEscapedNewlinesLeft = true;
Alexander Kornienkoacf8e902013-09-27 09:45:40 +00005850
5851 EXPECT_EQ("if (aaaaaaaa && // q\n"
5852 " bb)\t\t// w\n"
5853 "\t;",
5854 format("if (aaaaaaaa &&// q\n"
5855 "bb)// w\n"
5856 ";",
5857 Tab));
5858 EXPECT_EQ("if (aaa && bbb) // w\n"
5859 "\t;",
5860 format("if(aaa&&bbb)// w\n"
5861 ";",
5862 Tab));
5863
Manuel Klimek7c9a93e2013-05-13 09:22:11 +00005864 verifyFormat("class X {\n"
5865 "\tvoid f() {\n"
5866 "\t\tsomeFunction(parameter1,\n"
5867 "\t\t\t parameter2);\n"
5868 "\t}\n"
5869 "};",
5870 Tab);
5871 verifyFormat("#define A \\\n"
5872 "\tvoid f() { \\\n"
5873 "\t\tsomeFunction( \\\n"
5874 "\t\t parameter1, \\\n"
5875 "\t\t parameter2); \\\n"
5876 "\t}",
5877 Tab);
Manuel Klimekc41e8192013-08-29 15:21:40 +00005878 EXPECT_EQ("void f() {\n"
5879 "\tf();\n"
5880 "\tg();\n"
5881 "}",
5882 format("void f() {\n"
5883 "\tf();\n"
5884 "\tg();\n"
5885 "}",
5886 0, 0, Tab));
5887 EXPECT_EQ("void f() {\n"
5888 "\tf();\n"
5889 "\tg();\n"
5890 "}",
5891 format("void f() {\n"
5892 "\tf();\n"
5893 "\tg();\n"
5894 "}",
5895 16, 0, Tab));
5896 EXPECT_EQ("void f() {\n"
5897 " \tf();\n"
5898 "\tg();\n"
5899 "}",
5900 format("void f() {\n"
5901 " \tf();\n"
5902 " \tg();\n"
5903 "}",
5904 21, 0, Tab));
Manuel Klimekd63312b2013-05-28 10:01:59 +00005905
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00005906 Tab.TabWidth = 4;
5907 Tab.IndentWidth = 8;
5908 verifyFormat("class TabWidth4Indent8 {\n"
5909 "\t\tvoid f() {\n"
5910 "\t\t\t\tsomeFunction(parameter1,\n"
5911 "\t\t\t\t\t\t\t parameter2);\n"
5912 "\t\t}\n"
5913 "};",
5914 Tab);
5915
5916 Tab.TabWidth = 4;
5917 Tab.IndentWidth = 4;
5918 verifyFormat("class TabWidth4Indent4 {\n"
5919 "\tvoid f() {\n"
5920 "\t\tsomeFunction(parameter1,\n"
5921 "\t\t\t\t\t parameter2);\n"
5922 "\t}\n"
5923 "};",
5924 Tab);
5925
5926 Tab.TabWidth = 8;
5927 Tab.IndentWidth = 4;
5928 verifyFormat("class TabWidth8Indent4 {\n"
5929 " void f() {\n"
5930 "\tsomeFunction(parameter1,\n"
5931 "\t\t parameter2);\n"
5932 " }\n"
5933 "};",
5934 Tab);
5935
Alexander Kornienko83a7dcd2013-09-10 09:38:25 +00005936 Tab.TabWidth = 8;
5937 Tab.IndentWidth = 8;
5938 EXPECT_EQ("/*\n"
5939 "\t a\t\tcomment\n"
5940 "\t in multiple lines\n"
5941 " */",
5942 format(" /*\t \t \n"
5943 " \t \t a\t\tcomment\t \t\n"
5944 " \t \t in multiple lines\t\n"
5945 " \t */",
5946 Tab));
Alexander Kornienkoacf8e902013-09-27 09:45:40 +00005947
Alexander Kornienko3d9ffcf2013-09-27 16:14:22 +00005948 Tab.UseTab = FormatStyle::UT_ForIndentation;
5949 EXPECT_EQ("if (aaaaaaaa && // q\n"
5950 " bb) // w\n"
5951 "\t;",
5952 format("if (aaaaaaaa &&// q\n"
5953 "bb)// w\n"
5954 ";",
5955 Tab));
5956 verifyFormat("class X {\n"
5957 "\tvoid f() {\n"
5958 "\t\tsomeFunction(parameter1,\n"
5959 "\t\t parameter2);\n"
5960 "\t}\n"
5961 "};",
5962 Tab);
5963 verifyFormat("{\n"
5964 "\tQ({\n"
5965 "\t\t int a;\n"
5966 "\t\t someFunction(aaaaaaaaaa,\n"
5967 "\t\t bbbbbbbbb);\n"
5968 "\t },\n"
5969 "\t p);\n"
5970 "}",
5971 Tab);
5972 EXPECT_EQ("{\n"
5973 "\t/* aaaa\n"
5974 "\t bbbb */\n"
5975 "}",
5976 format("{\n"
5977 "/* aaaa\n"
5978 " bbbb */\n"
5979 "}",
5980 Tab));
5981 EXPECT_EQ("{\n"
5982 "\t/*\n"
5983 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5984 "\t bbbbbbbbbbbbb\n"
5985 "\t*/\n"
5986 "}",
5987 format("{\n"
5988 "/*\n"
5989 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
5990 "*/\n"
5991 "}",
5992 Tab));
5993 EXPECT_EQ("{\n"
5994 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5995 "\t// bbbbbbbbbbbbb\n"
5996 "}",
5997 format("{\n"
5998 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
5999 "}",
6000 Tab));
6001 EXPECT_EQ("{\n"
6002 "\t/*\n"
6003 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6004 "\t bbbbbbbbbbbbb\n"
6005 "\t*/\n"
6006 "}",
6007 format("{\n"
6008 "\t/*\n"
6009 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
6010 "\t*/\n"
6011 "}",
6012 Tab));
6013 EXPECT_EQ("{\n"
6014 "\t/*\n"
6015 "\n"
6016 "\t*/\n"
6017 "}",
6018 format("{\n"
6019 "\t/*\n"
6020 "\n"
6021 "\t*/\n"
Alexander Kornienko6967e782013-09-27 16:40:11 +00006022 "}",
6023 Tab));
6024 EXPECT_EQ("{\n"
6025 "\t/*\n"
6026 " asdf\n"
6027 "\t*/\n"
6028 "}",
6029 format("{\n"
6030 "\t/*\n"
6031 " asdf\n"
6032 "\t*/\n"
6033 "}",
6034 Tab));
Alexander Kornienko3d9ffcf2013-09-27 16:14:22 +00006035
6036 Tab.UseTab = FormatStyle::UT_Never;
Alexander Kornienko83a7dcd2013-09-10 09:38:25 +00006037 EXPECT_EQ("/*\n"
6038 " a\t\tcomment\n"
6039 " in multiple lines\n"
6040 " */",
6041 format(" /*\t \t \n"
6042 " \t \t a\t\tcomment\t \t\n"
6043 " \t \t in multiple lines\t\n"
6044 " \t */",
6045 Tab));
6046 EXPECT_EQ("/* some\n"
6047 " comment */",
6048 format(" \t \t /* some\n"
6049 " \t \t comment */",
6050 Tab));
6051 EXPECT_EQ("int a; /* some\n"
6052 " comment */",
6053 format(" \t \t int a; /* some\n"
6054 " \t \t comment */",
6055 Tab));
Manuel Klimekd63312b2013-05-28 10:01:59 +00006056
Alexander Kornienko83a7dcd2013-09-10 09:38:25 +00006057 EXPECT_EQ("int a; /* some\n"
6058 "comment */",
6059 format(" \t \t int\ta; /* some\n"
6060 " \t \t comment */",
6061 Tab));
6062 EXPECT_EQ("f(\"\t\t\"); /* some\n"
6063 " comment */",
6064 format(" \t \t f(\"\t\t\"); /* some\n"
6065 " \t \t comment */",
6066 Tab));
Manuel Klimekd63312b2013-05-28 10:01:59 +00006067 EXPECT_EQ("{\n"
6068 " /*\n"
6069 " * Comment\n"
6070 " */\n"
6071 " int i;\n"
6072 "}",
6073 format("{\n"
6074 "\t/*\n"
6075 "\t * Comment\n"
6076 "\t */\n"
6077 "\t int i;\n"
6078 "}"));
Manuel Klimek7c9a93e2013-05-13 09:22:11 +00006079}
6080
Alexander Kornienko6f6154c2013-09-10 12:29:48 +00006081TEST_F(FormatTest, CalculatesOriginalColumn) {
6082 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
6083 "q\"; /* some\n"
6084 " comment */",
6085 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
6086 "q\"; /* some\n"
6087 " comment */",
6088 getLLVMStyle()));
6089 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
6090 "/* some\n"
6091 " comment */",
6092 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
6093 " /* some\n"
6094 " comment */",
6095 getLLVMStyle()));
6096 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
6097 "qqq\n"
6098 "/* some\n"
6099 " comment */",
6100 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
6101 "qqq\n"
6102 " /* some\n"
6103 " comment */",
6104 getLLVMStyle()));
6105 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
6106 "wwww; /* some\n"
6107 " comment */",
6108 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
6109 "wwww; /* some\n"
6110 " comment */",
6111 getLLVMStyle()));
6112}
6113
Daniel Jasper7df56bf2013-08-20 12:36:34 +00006114TEST_F(FormatTest, ConfigurableSpaceAfterControlStatementKeyword) {
6115 FormatStyle NoSpace = getLLVMStyle();
6116 NoSpace.SpaceAfterControlStatementKeyword = false;
6117
6118 verifyFormat("while(true)\n"
6119 " continue;", NoSpace);
6120 verifyFormat("for(;;)\n"
6121 " continue;", NoSpace);
6122 verifyFormat("if(true)\n"
6123 " f();\n"
6124 "else if(true)\n"
6125 " f();", NoSpace);
6126 verifyFormat("do {\n"
6127 " do_something();\n"
6128 "} while(something());", NoSpace);
6129 verifyFormat("switch(x) {\n"
6130 "default:\n"
6131 " break;\n"
6132 "}", NoSpace);
6133}
6134
6135TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
6136 FormatStyle Spaces = getLLVMStyle();
6137
6138 Spaces.SpacesInParentheses = true;
6139 verifyFormat("call( x, y, z );", Spaces);
6140 verifyFormat("while ( (bool)1 )\n"
6141 " continue;", Spaces);
6142 verifyFormat("for ( ;; )\n"
6143 " continue;", Spaces);
6144 verifyFormat("if ( true )\n"
6145 " f();\n"
6146 "else if ( true )\n"
6147 " f();", Spaces);
6148 verifyFormat("do {\n"
6149 " do_something( (int)i );\n"
6150 "} while ( something() );", Spaces);
6151 verifyFormat("switch ( x ) {\n"
6152 "default:\n"
6153 " break;\n"
6154 "}", Spaces);
6155
6156 Spaces.SpacesInParentheses = false;
6157 Spaces.SpacesInCStyleCastParentheses = true;
6158 verifyFormat("Type *A = ( Type * )P;", Spaces);
6159 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
6160 verifyFormat("x = ( int32 )y;", Spaces);
6161 verifyFormat("int a = ( int )(2.0f);", Spaces);
6162 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
6163 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
6164 verifyFormat("#define x (( int )-1)", Spaces);
6165
6166 Spaces.SpacesInParentheses = false;
6167 Spaces.SpaceInEmptyParentheses = true;
6168 verifyFormat("call(x, y, z);", Spaces);
6169 verifyFormat("call( )", Spaces);
6170
6171 // Run the first set of tests again with
6172 // Spaces.SpacesInParentheses = false,
6173 // Spaces.SpaceInEmptyParentheses = true and
6174 // Spaces.SpacesInCStyleCastParentheses = true
6175 Spaces.SpacesInParentheses = false,
6176 Spaces.SpaceInEmptyParentheses = true;
6177 Spaces.SpacesInCStyleCastParentheses = true;
6178 verifyFormat("call(x, y, z);", Spaces);
6179 verifyFormat("while (( bool )1)\n"
6180 " continue;", Spaces);
6181 verifyFormat("for (;;)\n"
6182 " continue;", Spaces);
6183 verifyFormat("if (true)\n"
6184 " f( );\n"
6185 "else if (true)\n"
6186 " f( );", Spaces);
6187 verifyFormat("do {\n"
6188 " do_something(( int )i);\n"
6189 "} while (something( ));", Spaces);
6190 verifyFormat("switch (x) {\n"
6191 "default:\n"
6192 " break;\n"
6193 "}", Spaces);
6194}
6195
Daniel Jasper9b4de852013-09-25 15:15:02 +00006196TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
6197 verifyFormat("int a = 5;");
6198 verifyFormat("a += 42;");
6199 verifyFormat("a or_eq 8;");
6200
6201 FormatStyle Spaces = getLLVMStyle();
6202 Spaces.SpaceBeforeAssignmentOperators = false;
6203 verifyFormat("int a= 5;", Spaces);
6204 verifyFormat("a+= 42;", Spaces);
6205 verifyFormat("a or_eq 8;", Spaces);
6206}
6207
Manuel Klimek44135b82013-05-13 12:51:40 +00006208TEST_F(FormatTest, LinuxBraceBreaking) {
6209 FormatStyle BreakBeforeBrace = getLLVMStyle();
6210 BreakBeforeBrace.BreakBeforeBraces = FormatStyle::BS_Linux;
6211 verifyFormat("namespace a\n"
6212 "{\n"
6213 "class A\n"
6214 "{\n"
6215 " void f()\n"
6216 " {\n"
6217 " if (true) {\n"
6218 " a();\n"
6219 " b();\n"
6220 " }\n"
6221 " }\n"
Daniel Jasper9f321612013-05-15 08:30:06 +00006222 " void g()\n"
6223 " {\n"
6224 " return;\n"
6225 " }\n"
Manuel Klimek44135b82013-05-13 12:51:40 +00006226 "}\n"
6227 "}",
6228 BreakBeforeBrace);
6229}
6230
6231TEST_F(FormatTest, StroustrupBraceBreaking) {
6232 FormatStyle BreakBeforeBrace = getLLVMStyle();
6233 BreakBeforeBrace.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
6234 verifyFormat("namespace a {\n"
6235 "class A {\n"
6236 " void f()\n"
6237 " {\n"
6238 " if (true) {\n"
6239 " a();\n"
6240 " b();\n"
6241 " }\n"
6242 " }\n"
Daniel Jasper9f321612013-05-15 08:30:06 +00006243 " void g()\n"
6244 " {\n"
6245 " return;\n"
6246 " }\n"
Manuel Klimek44135b82013-05-13 12:51:40 +00006247 "}\n"
6248 "}",
6249 BreakBeforeBrace);
6250}
6251
Manuel Klimeke4907052013-08-02 21:31:59 +00006252TEST_F(FormatTest, AllmanBraceBreaking) {
6253 FormatStyle BreakBeforeBrace = getLLVMStyle();
6254 BreakBeforeBrace.BreakBeforeBraces = FormatStyle::BS_Allman;
6255 verifyFormat("namespace a\n"
6256 "{\n"
6257 "class A\n"
6258 "{\n"
6259 " void f()\n"
6260 " {\n"
6261 " if (true)\n"
6262 " {\n"
6263 " a();\n"
6264 " b();\n"
6265 " }\n"
6266 " }\n"
6267 " void g()\n"
6268 " {\n"
6269 " return;\n"
6270 " }\n"
6271 "}\n"
6272 "}",
6273 BreakBeforeBrace);
6274
6275 verifyFormat("void f()\n"
6276 "{\n"
6277 " if (true)\n"
6278 " {\n"
6279 " a();\n"
6280 " }\n"
6281 " else if (false)\n"
6282 " {\n"
6283 " b();\n"
6284 " }\n"
6285 " else\n"
6286 " {\n"
6287 " c();\n"
6288 " }\n"
6289 "}\n",
6290 BreakBeforeBrace);
6291
6292 verifyFormat("void f()\n"
6293 "{\n"
6294 " for (int i = 0; i < 10; ++i)\n"
6295 " {\n"
6296 " a();\n"
6297 " }\n"
6298 " while (false)\n"
6299 " {\n"
6300 " b();\n"
6301 " }\n"
6302 " do\n"
6303 " {\n"
6304 " c();\n"
6305 " } while (false)\n"
6306 "}\n",
6307 BreakBeforeBrace);
6308
6309 verifyFormat("void f(int a)\n"
6310 "{\n"
6311 " switch (a)\n"
6312 " {\n"
6313 " case 0:\n"
6314 " break;\n"
6315 " case 1:\n"
6316 " {\n"
6317 " break;\n"
6318 " }\n"
6319 " case 2:\n"
6320 " {\n"
6321 " }\n"
6322 " break;\n"
6323 " default:\n"
6324 " break;\n"
6325 " }\n"
6326 "}\n",
6327 BreakBeforeBrace);
Manuel Klimekd3a247c2013-08-07 19:20:45 +00006328
6329 verifyFormat("enum X\n"
6330 "{\n"
6331 " Y = 0,\n"
6332 "}\n",
6333 BreakBeforeBrace);
6334
6335 FormatStyle BreakBeforeBraceShortIfs = BreakBeforeBrace;
6336 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = true;
6337 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
6338 verifyFormat("void f(bool b)\n"
6339 "{\n"
6340 " if (b)\n"
6341 " {\n"
6342 " return;\n"
6343 " }\n"
6344 "}\n",
6345 BreakBeforeBraceShortIfs);
6346 verifyFormat("void f(bool b)\n"
6347 "{\n"
6348 " if (b) return;\n"
6349 "}\n",
6350 BreakBeforeBraceShortIfs);
6351 verifyFormat("void f(bool b)\n"
6352 "{\n"
6353 " while (b)\n"
6354 " {\n"
6355 " return;\n"
6356 " }\n"
6357 "}\n",
6358 BreakBeforeBraceShortIfs);
Manuel Klimeke4907052013-08-02 21:31:59 +00006359}
6360
Manuel Klimek2530fd52013-08-12 03:51:17 +00006361TEST_F(FormatTest, CatchExceptionReferenceBinding) {
6362 verifyFormat("void f() {\n"
6363 " try {\n"
6364 " }\n"
6365 " catch (const Exception &e) {\n"
6366 " }\n"
6367 "}\n",
6368 getLLVMStyle());
6369}
6370
Daniel Jasper1dc6f742013-08-07 16:29:23 +00006371TEST_F(FormatTest, UnderstandsPragmas) {
6372 verifyFormat("#pragma omp reduction(| : var)");
6373 verifyFormat("#pragma omp reduction(+ : var)");
6374}
6375
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006376bool allStylesEqual(ArrayRef<FormatStyle> Styles) {
6377 for (size_t i = 1; i < Styles.size(); ++i)
6378 if (!(Styles[0] == Styles[i]))
6379 return false;
6380 return true;
6381}
6382
6383TEST_F(FormatTest, GetsPredefinedStyleByName) {
Alexander Kornienko885f87b2013-05-19 00:53:30 +00006384 FormatStyle Styles[3];
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006385
Alexander Kornienko885f87b2013-05-19 00:53:30 +00006386 Styles[0] = getLLVMStyle();
6387 EXPECT_TRUE(getPredefinedStyle("LLVM", &Styles[1]));
6388 EXPECT_TRUE(getPredefinedStyle("lLvM", &Styles[2]));
6389 EXPECT_TRUE(allStylesEqual(Styles));
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006390
Alexander Kornienko885f87b2013-05-19 00:53:30 +00006391 Styles[0] = getGoogleStyle();
6392 EXPECT_TRUE(getPredefinedStyle("Google", &Styles[1]));
6393 EXPECT_TRUE(getPredefinedStyle("gOOgle", &Styles[2]));
6394 EXPECT_TRUE(allStylesEqual(Styles));
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006395
Alexander Kornienko885f87b2013-05-19 00:53:30 +00006396 Styles[0] = getChromiumStyle();
6397 EXPECT_TRUE(getPredefinedStyle("Chromium", &Styles[1]));
6398 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", &Styles[2]));
6399 EXPECT_TRUE(allStylesEqual(Styles));
6400
6401 Styles[0] = getMozillaStyle();
6402 EXPECT_TRUE(getPredefinedStyle("Mozilla", &Styles[1]));
6403 EXPECT_TRUE(getPredefinedStyle("moZILla", &Styles[2]));
6404 EXPECT_TRUE(allStylesEqual(Styles));
6405
Daniel Jaspere05dc6d2013-07-24 13:10:59 +00006406 Styles[0] = getWebKitStyle();
6407 EXPECT_TRUE(getPredefinedStyle("WebKit", &Styles[1]));
6408 EXPECT_TRUE(getPredefinedStyle("wEbKit", &Styles[2]));
6409 EXPECT_TRUE(allStylesEqual(Styles));
6410
Alexander Kornienko885f87b2013-05-19 00:53:30 +00006411 EXPECT_FALSE(getPredefinedStyle("qwerty", &Styles[0]));
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006412}
6413
6414TEST_F(FormatTest, ParsesConfiguration) {
6415 FormatStyle Style = {};
6416#define CHECK_PARSE(TEXT, FIELD, VALUE) \
6417 EXPECT_NE(VALUE, Style.FIELD); \
6418 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \
6419 EXPECT_EQ(VALUE, Style.FIELD)
6420
6421#define CHECK_PARSE_BOOL(FIELD) \
6422 Style.FIELD = false; \
6423 EXPECT_EQ(0, parseConfiguration(#FIELD ": true", &Style).value()); \
Alexander Kornienko885f87b2013-05-19 00:53:30 +00006424 EXPECT_TRUE(Style.FIELD); \
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006425 EXPECT_EQ(0, parseConfiguration(#FIELD ": false", &Style).value()); \
Patrik Hagglund33717112013-05-14 07:53:53 +00006426 EXPECT_FALSE(Style.FIELD);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006427
6428 CHECK_PARSE_BOOL(AlignEscapedNewlinesLeft);
Daniel Jasper893ea8d2013-07-31 23:55:15 +00006429 CHECK_PARSE_BOOL(AlignTrailingComments);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006430 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
6431 CHECK_PARSE_BOOL(AllowShortIfStatementsOnASingleLine);
Daniel Jasper2a2579a2013-05-16 12:16:23 +00006432 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
Daniel Jasperbbc87762013-05-29 12:07:31 +00006433 CHECK_PARSE_BOOL(AlwaysBreakTemplateDeclarations);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006434 CHECK_PARSE_BOOL(BinPackParameters);
Daniel Jaspere8b10d32013-07-26 16:56:36 +00006435 CHECK_PARSE_BOOL(BreakBeforeBinaryOperators);
6436 CHECK_PARSE_BOOL(BreakConstructorInitializersBeforeComma);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006437 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
6438 CHECK_PARSE_BOOL(DerivePointerBinding);
6439 CHECK_PARSE_BOOL(IndentCaseLabels);
6440 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
6441 CHECK_PARSE_BOOL(PointerBindsToType);
Daniel Jasperb5dc3f42013-07-16 18:22:10 +00006442 CHECK_PARSE_BOOL(Cpp11BracedListStyle);
Manuel Klimeka9a7f102013-06-21 17:25:42 +00006443 CHECK_PARSE_BOOL(IndentFunctionDeclarationAfterType);
Daniel Jasper7df56bf2013-08-20 12:36:34 +00006444 CHECK_PARSE_BOOL(SpacesInParentheses);
6445 CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
6446 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
6447 CHECK_PARSE_BOOL(SpaceAfterControlStatementKeyword);
Daniel Jasper9b4de852013-09-25 15:15:02 +00006448 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006449
6450 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
Daniel Jasper6315fec2013-08-13 10:58:30 +00006451 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
6452 ConstructorInitializerIndentWidth, 1234u);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006453 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
6454 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
6455 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
6456 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
6457 PenaltyReturnTypeOnItsOwnLine, 1234u);
6458 CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
6459 SpacesBeforeTrailingComments, 1234u);
Manuel Klimek07a64ec2013-05-13 08:42:42 +00006460 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006461
6462 Style.Standard = FormatStyle::LS_Auto;
Alexander Kornienko9321e872013-09-04 14:09:13 +00006463 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
6464 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Cpp11);
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006465 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
6466 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
6467 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
6468
Alexander Kornienko3d9ffcf2013-09-27 16:14:22 +00006469 Style.UseTab = FormatStyle::UT_ForIndentation;
6470 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
6471 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
6472 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
6473 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
6474 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
6475
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006476 Style.ColumnLimit = 123;
6477 FormatStyle BaseStyle = getLLVMStyle();
6478 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
6479 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
6480
Manuel Klimek44135b82013-05-13 12:51:40 +00006481 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
6482 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
6483 FormatStyle::BS_Attach);
6484 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
6485 FormatStyle::BS_Linux);
6486 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
6487 FormatStyle::BS_Stroustrup);
6488
Daniel Jaspereff18b92013-07-31 23:16:02 +00006489 Style.NamespaceIndentation = FormatStyle::NI_All;
6490 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
6491 FormatStyle::NI_None);
6492 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
6493 FormatStyle::NI_Inner);
6494 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
6495 FormatStyle::NI_All);
6496
Alexander Kornienkod71ec162013-05-07 15:32:14 +00006497#undef CHECK_PARSE
6498#undef CHECK_PARSE_BOOL
6499}
6500
6501TEST_F(FormatTest, ConfigurationRoundTripTest) {
6502 FormatStyle Style = getLLVMStyle();
6503 std::string YAML = configurationAsText(Style);
6504 FormatStyle ParsedStyle = {};
6505 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
6506 EXPECT_EQ(Style, ParsedStyle);
6507}
6508
Alexander Kornienko00895102013-06-05 14:09:10 +00006509TEST_F(FormatTest, WorksFor8bitEncodings) {
6510 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
6511 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
6512 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
6513 "\"\xef\xee\xf0\xf3...\"",
6514 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
6515 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
6516 "\xef\xee\xf0\xf3...\"",
6517 getLLVMStyleWithColumns(12)));
6518}
6519
NAKAMURA Takumi07eda942013-06-06 01:14:58 +00006520// FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
6521#if !defined(_MSC_VER)
6522
Alexander Kornienko00895102013-06-05 14:09:10 +00006523TEST_F(FormatTest, CountsUTF8CharactersProperly) {
6524 verifyFormat("\"Однажды в студёную зимнюю пору...\"",
6525 getLLVMStyleWithColumns(35));
6526 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00006527 getLLVMStyleWithColumns(31));
Alexander Kornienko00895102013-06-05 14:09:10 +00006528 verifyFormat("// Однажды в студёную зимнюю пору...",
6529 getLLVMStyleWithColumns(36));
6530 verifyFormat("// 一 二 三 四 五 六 七 八 九 十",
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00006531 getLLVMStyleWithColumns(32));
Alexander Kornienko00895102013-06-05 14:09:10 +00006532 verifyFormat("/* Однажды в студёную зимнюю пору... */",
6533 getLLVMStyleWithColumns(39));
6534 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00006535 getLLVMStyleWithColumns(35));
Alexander Kornienko00895102013-06-05 14:09:10 +00006536}
6537
6538TEST_F(FormatTest, SplitsUTF8Strings) {
6539 EXPECT_EQ(
6540 "\"Однажды, в \"\n"
6541 "\"студёную \"\n"
6542 "\"зимнюю \"\n"
6543 "\"пору,\"",
6544 format("\"Однажды, в студёную зимнюю пору,\"",
6545 getLLVMStyleWithColumns(13)));
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00006546 EXPECT_EQ("\"一 二 三 \"\n"
6547 "\"四 五六 \"\n"
6548 "\"七 八 九 \"\n"
6549 "\"十\"",
6550 format("\"一 二 三 四 五六 七 八 九 十\"",
6551 getLLVMStyleWithColumns(11)));
6552 EXPECT_EQ("\"一\t二 \"\n"
6553 "\"\t三 \"\n"
6554 "\"四 五\t六 \"\n"
6555 "\"\t七 \"\n"
6556 "\"八九十\tqq\"",
6557 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
6558 getLLVMStyleWithColumns(11)));
6559}
6560
6561
6562TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
6563 EXPECT_EQ("const char *sssss =\n"
6564 " \"一二三四五六七八\\\n"
6565 " 九 十\";",
6566 format("const char *sssss = \"一二三四五六七八\\\n"
6567 " 九 十\";",
6568 getLLVMStyleWithColumns(30)));
Alexander Kornienko00895102013-06-05 14:09:10 +00006569}
6570
6571TEST_F(FormatTest, SplitsUTF8LineComments) {
6572 EXPECT_EQ("// Я из лесу\n"
6573 "// вышел; был\n"
6574 "// сильный\n"
6575 "// мороз.",
6576 format("// Я из лесу вышел; был сильный мороз.",
6577 getLLVMStyleWithColumns(13)));
6578 EXPECT_EQ("// 一二三\n"
6579 "// 四五六七\n"
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00006580 "// 八 九\n"
6581 "// 十",
6582 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9)));
Alexander Kornienko00895102013-06-05 14:09:10 +00006583}
6584
6585TEST_F(FormatTest, SplitsUTF8BlockComments) {
6586 EXPECT_EQ("/* Гляжу,\n"
6587 " * поднимается\n"
6588 " * медленно в\n"
6589 " * гору\n"
6590 " * Лошадка,\n"
6591 " * везущая\n"
6592 " * хворосту\n"
6593 " * воз. */",
6594 format("/* Гляжу, поднимается медленно в гору\n"
6595 " * Лошадка, везущая хворосту воз. */",
6596 getLLVMStyleWithColumns(13)));
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00006597 EXPECT_EQ(
6598 "/* 一二三\n"
6599 " * 四五六七\n"
6600 " * 八 九\n"
6601 " * 十 */",
6602 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9)));
Alexander Kornienkodda770b2013-06-05 15:08:20 +00006603 EXPECT_EQ("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯\n"
6604 " * 𝕓𝕪𝕥𝕖\n"
6605 " * 𝖀𝕿𝕱-𝟠 */",
6606 format("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯 𝕓𝕪𝕥𝕖 𝖀𝕿𝕱-𝟠 */", getLLVMStyleWithColumns(12)));
Alexander Kornienko00895102013-06-05 14:09:10 +00006607}
6608
Alexander Kornienko0b62cc32013-09-05 14:08:34 +00006609#endif // _MSC_VER
6610
Daniel Jasper6315fec2013-08-13 10:58:30 +00006611TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
6612 FormatStyle Style = getLLVMStyle();
6613
6614 Style.ConstructorInitializerIndentWidth = 4;
6615 verifyFormat(
6616 "SomeClass::Constructor()\n"
6617 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
6618 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
6619 Style);
6620
6621 Style.ConstructorInitializerIndentWidth = 2;
6622 verifyFormat(
6623 "SomeClass::Constructor()\n"
6624 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
6625 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
6626 Style);
6627
6628 Style.ConstructorInitializerIndentWidth = 0;
6629 verifyFormat(
6630 "SomeClass::Constructor()\n"
6631 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
6632 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
6633 Style);
6634
6635 Style.BreakConstructorInitializersBeforeComma = true;
6636 Style.ConstructorInitializerIndentWidth = 4;
6637 verifyFormat("SomeClass::Constructor()\n"
6638 " : a(a)\n"
6639 " , b(b)\n"
6640 " , c(c) {}",
6641 Style);
6642
6643 Style.ConstructorInitializerIndentWidth = 2;
6644 verifyFormat("SomeClass::Constructor()\n"
6645 " : a(a)\n"
6646 " , b(b)\n"
6647 " , c(c) {}",
6648 Style);
6649
6650 Style.ConstructorInitializerIndentWidth = 0;
6651 verifyFormat("SomeClass::Constructor()\n"
6652 ": a(a)\n"
6653 ", b(b)\n"
6654 ", c(c) {}",
6655 Style);
Daniel Jasper19ccb122013-10-08 05:11:18 +00006656
6657 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
6658 Style.ConstructorInitializerIndentWidth = 4;
6659 verifyFormat(
6660 "SomeClass::Constructor()\n"
6661 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
6662 Style);
6663 Style.ConstructorInitializerIndentWidth = 4;
6664 Style.ColumnLimit = 60;
6665 verifyFormat("SomeClass::Constructor()\n"
6666 " : aaaaaaaa(aaaaaaaa)\n"
6667 " , aaaaaaaa(aaaaaaaa)\n"
6668 " , aaaaaaaa(aaaaaaaa) {}",
6669 Style);
Daniel Jasper6315fec2013-08-13 10:58:30 +00006670}
6671
Daniel Jaspere05dc6d2013-07-24 13:10:59 +00006672TEST_F(FormatTest, FormatsWithWebKitStyle) {
6673 FormatStyle Style = getWebKitStyle();
6674
6675 // Don't indent in outer namespaces.
6676 verifyFormat("namespace outer {\n"
6677 "int i;\n"
6678 "namespace inner {\n"
Daniel Jaspereff18b92013-07-31 23:16:02 +00006679 " int i;\n"
Daniel Jaspere05dc6d2013-07-24 13:10:59 +00006680 "} // namespace inner\n"
6681 "} // namespace outer\n"
6682 "namespace other_outer {\n"
6683 "int i;\n"
6684 "}",
6685 Style);
6686
6687 // Don't indent case labels.
6688 verifyFormat("switch (variable) {\n"
6689 "case 1:\n"
6690 "case 2:\n"
6691 " doSomething();\n"
6692 " break;\n"
6693 "default:\n"
6694 " ++variable;\n"
6695 "}",
6696 Style);
6697
6698 // Wrap before binary operators.
6699 EXPECT_EQ(
6700 "void f()\n"
6701 "{\n"
6702 " if (aaaaaaaaaaaaaaaa\n"
6703 " && bbbbbbbbbbbbbbbbbbbbbbbb\n"
6704 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
6705 " return;\n"
6706 "}",
6707 format(
6708 "void f() {\n"
6709 "if (aaaaaaaaaaaaaaaa\n"
6710 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
6711 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
6712 "return;\n"
6713 "}",
6714 Style));
6715
6716 // Constructor initializers are formatted one per line with the "," on the
6717 // new line.
Daniel Jaspere8b10d32013-07-26 16:56:36 +00006718 verifyFormat("Constructor()\n"
6719 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6720 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
6721 " aaaaaaaaaaaaaa)\n"
6722 " , aaaaaaaaaaaaaaaaaaaaaaa()\n{\n}",
6723 Style);
Daniel Jaspere05dc6d2013-07-24 13:10:59 +00006724
Daniel Jaspereff18b92013-07-31 23:16:02 +00006725 // Access specifiers should be aligned left.
6726 verifyFormat("class C {\n"
6727 "public:\n"
6728 " int i;\n"
6729 "};",
6730 Style);
6731
Daniel Jaspere05dc6d2013-07-24 13:10:59 +00006732 // Do not align comments.
Daniel Jasper893ea8d2013-07-31 23:55:15 +00006733 verifyFormat("int a; // Do not\n"
6734 "double b; // align comments.",
6735 Style);
Daniel Jaspere05dc6d2013-07-24 13:10:59 +00006736
6737 // Accept input's line breaks.
6738 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
6739 " || bbbbbbbbbbbbbbb) {\n"
6740 " i++;\n"
6741 "}",
6742 format("if (aaaaaaaaaaaaaaa\n"
6743 "|| bbbbbbbbbbbbbbb) { i++; }",
6744 Style));
6745 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
6746 " i++;\n"
6747 "}",
6748 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
6749}
6750
Daniel Jasperec172262013-08-30 10:36:58 +00006751TEST_F(FormatTest, FormatsProtocolBufferDefinitions) {
6752 // It seems that clang-format can format protocol buffer definitions
6753 // (see https://code.google.com/p/protobuf/).
6754 verifyFormat("message SomeMessage {\n"
6755 " required int32 field1 = 1;\n"
6756 " optional string field2 = 2 [default = \"2\"]\n"
6757 "}");
6758}
6759
Manuel Klimekb61a8af2013-09-03 15:10:01 +00006760TEST_F(FormatTest, FormatsLambdas) {
Daniel Jasper567dcf92013-09-05 09:29:45 +00006761 verifyFormat("int c = [b]() mutable {\n"
6762 " return [&b] { return b++; }();\n"
6763 "}();\n");
6764 verifyFormat("int c = [&] {\n"
6765 " [=] { return b++; }();\n"
6766 "}();\n");
6767 verifyFormat("int c = [&, &a, a] {\n"
6768 " [=, c, &d] { return b++; }();\n"
6769 "}();\n");
6770 verifyFormat("int c = [&a, &a, a] {\n"
6771 " [=, a, b, &c] { return b++; }();\n"
6772 "}();\n");
6773 verifyFormat("auto c = { [&a, &a, a] {\n"
6774 " [=, a, b, &c] { return b++; }();\n"
6775 "} }\n");
Daniel Jasper14e25c02013-09-08 14:07:57 +00006776 verifyFormat("auto c = { [&a, &a, a] { [=, a, b, &c] {}(); } }\n");
Daniel Jasper567dcf92013-09-05 09:29:45 +00006777 verifyFormat("void f() {\n"
6778 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
6779 "}\n");
Daniel Jasper567dcf92013-09-05 09:29:45 +00006780 verifyFormat("void f() {\n"
6781 " other(x.begin(), //\n"
6782 " x.end(), //\n"
Daniel Jasperac2c9742013-09-05 10:04:31 +00006783 " [&](int, int) { return 1; });\n"
Daniel Jasper567dcf92013-09-05 09:29:45 +00006784 "}\n");
Daniel Jasper2d657052013-09-05 11:49:39 +00006785
6786 // Not lambdas.
6787 verifyFormat("constexpr char hello[]{ \"hello\" };");
Daniel Jasper520cca82013-09-06 21:25:51 +00006788 verifyFormat("double &operator[](int i) { return 0; }\n"
6789 "int i;");
Manuel Klimekb61a8af2013-09-03 15:10:01 +00006790}
6791
Manuel Klimek753a5112013-09-04 13:25:30 +00006792TEST_F(FormatTest, FormatsBlocks) {
6793 // FIXME: Make whitespace formatting consistent. Ask a ObjC dev how
6794 // it would ideally look.
Daniel Jasper567dcf92013-09-05 09:29:45 +00006795 verifyFormat("[operation setCompletionBlock:^{ [self onOperationDone]; }];");
6796 verifyFormat("int i = {[operation setCompletionBlock : ^{ [self "
6797 "onOperationDone]; }] };");
Manuel Klimek753a5112013-09-04 13:25:30 +00006798}
6799
Alexander Kornienko73d845c2013-09-11 12:25:57 +00006800TEST_F(FormatTest, SupportsCRLF) {
6801 EXPECT_EQ("int a;\r\n"
6802 "int b;\r\n"
6803 "int c;\r\n",
6804 format("int a;\r\n"
6805 " int b;\r\n"
6806 " int c;\r\n",
6807 getLLVMStyle()));
6808 EXPECT_EQ("int a;\r\n"
6809 "int b;\r\n"
6810 "int c;\r\n",
6811 format("int a;\r\n"
6812 " int b;\n"
6813 " int c;\r\n",
6814 getLLVMStyle()));
6815 EXPECT_EQ("int a;\n"
6816 "int b;\n"
6817 "int c;\n",
6818 format("int a;\r\n"
6819 " int b;\n"
6820 " int c;\n",
6821 getLLVMStyle()));
6822 EXPECT_EQ("\"aaaaaaa \"\r\n"
6823 "\"bbbbbbb\";\r\n",
6824 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
6825 EXPECT_EQ("#define A \\\r\n"
6826 " b; \\\r\n"
6827 " c; \\\r\n"
6828 " d;\r\n",
6829 format("#define A \\\r\n"
6830 " b; \\\r\n"
6831 " c; d; \r\n",
6832 getGoogleStyle()));
6833}
6834
Daniel Jaspercd162382013-01-07 13:26:07 +00006835} // end namespace tooling
6836} // end namespace clang