blob: 1b7f699ef304e6db463818f04e3f0720438bfe6f [file] [log] [blame]
Daniel Jasperf7935112012-12-03 18:12:45 +00001//===- unittest/Format/FormatTest.cpp - Formatting unit tests -------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
Manuel Klimek24998102013-01-16 14:55:28 +000010#define DEBUG_TYPE "format-test"
11
Chandler Carruth320d9662012-12-04 09:45:34 +000012#include "clang/Format/Format.h"
Chandler Carruth4b417452013-01-19 08:09:44 +000013#include "clang/Lex/Lexer.h"
14#include "llvm/Support/Debug.h"
15#include "gtest/gtest.h"
Manuel Klimek24998102013-01-16 14:55:28 +000016
Daniel Jasperf7935112012-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 Klimek24998102013-01-16 14:55:28 +000024 DEBUG(llvm::errs() << "---\n");
Daniel Jasperec04c0d2013-05-16 10:40:07 +000025 std::vector<tooling::Range> Ranges(1, tooling::Range(Offset, Length));
26 tooling::Replacements Replaces = reformat(Style, Code, Ranges);
27 ReplacementCount = Replaces.size();
28 std::string Result = applyAllReplacements(Code, Replaces);
29 EXPECT_NE("", Result);
30 DEBUG(llvm::errs() << "\n" << Result << "\n\n");
31 return Result;
Daniel Jasperf7935112012-12-03 18:12:45 +000032 }
33
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +000034 std::string
35 format(llvm::StringRef Code, const FormatStyle &Style = getLLVMStyle()) {
Daniel Jasperf7935112012-12-03 18:12:45 +000036 return format(Code, 0, Code.size(), Style);
37 }
38
Daniel Jasper3f69a1b2012-12-18 19:56:56 +000039 std::string messUp(llvm::StringRef Code) {
40 std::string MessedUp(Code.str());
41 bool InComment = false;
Manuel Klimek52b15152013-01-09 15:25:02 +000042 bool InPreprocessorDirective = false;
Daniel Jasper3f69a1b2012-12-18 19:56:56 +000043 bool JustReplacedNewline = false;
44 for (unsigned i = 0, e = MessedUp.size() - 1; i != e; ++i) {
45 if (MessedUp[i] == '/' && MessedUp[i + 1] == '/') {
46 if (JustReplacedNewline)
47 MessedUp[i - 1] = '\n';
48 InComment = true;
Daniel Jasper39825ea2013-01-14 15:40:57 +000049 } else if (MessedUp[i] == '#' && (JustReplacedNewline || i == 0)) {
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +000050 if (i != 0)
51 MessedUp[i - 1] = '\n';
Manuel Klimek52b15152013-01-09 15:25:02 +000052 InPreprocessorDirective = true;
Manuel Klimek1abf7892013-01-04 23:34:14 +000053 } else if (MessedUp[i] == '\\' && MessedUp[i + 1] == '\n') {
54 MessedUp[i] = ' ';
Manuel Klimek52b15152013-01-09 15:25:02 +000055 MessedUp[i + 1] = ' ';
Daniel Jasper3f69a1b2012-12-18 19:56:56 +000056 } else if (MessedUp[i] == '\n') {
57 if (InComment) {
58 InComment = false;
Manuel Klimek52b15152013-01-09 15:25:02 +000059 } else if (InPreprocessorDirective) {
60 InPreprocessorDirective = false;
Daniel Jasper3f69a1b2012-12-18 19:56:56 +000061 } else {
62 JustReplacedNewline = true;
63 MessedUp[i] = ' ';
64 }
Manuel Klimek1abf7892013-01-04 23:34:14 +000065 } else if (MessedUp[i] != ' ') {
66 JustReplacedNewline = false;
Daniel Jasper3f69a1b2012-12-18 19:56:56 +000067 }
Daniel Jasperf7935112012-12-03 18:12:45 +000068 }
Daniel Jasper3f69a1b2012-12-18 19:56:56 +000069 return MessedUp;
70 }
71
Manuel Klimekb69e3c62013-01-02 18:33:23 +000072 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) {
73 FormatStyle Style = getLLVMStyle();
74 Style.ColumnLimit = ColumnLimit;
75 return Style;
76 }
77
Daniel Jasper1b750ed2013-01-14 16:24:39 +000078 FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) {
79 FormatStyle Style = getGoogleStyle();
80 Style.ColumnLimit = ColumnLimit;
81 return Style;
82 }
83
Manuel Klimekb69e3c62013-01-02 18:33:23 +000084 void verifyFormat(llvm::StringRef Code,
85 const FormatStyle &Style = getLLVMStyle()) {
86 EXPECT_EQ(Code.str(), format(messUp(Code), Style));
Daniel Jasperf7935112012-12-03 18:12:45 +000087 }
88
89 void verifyGoogleFormat(llvm::StringRef Code) {
Manuel Klimekb69e3c62013-01-02 18:33:23 +000090 verifyFormat(Code, getGoogleStyle());
Daniel Jasperf7935112012-12-03 18:12:45 +000091 }
Daniel Jasper5b49f472013-01-23 12:10:53 +000092
93 void verifyIndependentOfContext(llvm::StringRef text) {
94 verifyFormat(text);
95 verifyFormat(llvm::Twine("void f() { " + text + " }").str());
96 }
Daniel Jasper7b038a22013-01-30 09:46:12 +000097
98 int ReplacementCount;
Daniel Jasperf7935112012-12-03 18:12:45 +000099};
100
Manuel Klimek52b15152013-01-09 15:25:02 +0000101TEST_F(FormatTest, MessUp) {
102 EXPECT_EQ("1 2 3", messUp("1 2 3"));
103 EXPECT_EQ("1 2 3\n", messUp("1\n2\n3\n"));
104 EXPECT_EQ("a\n//b\nc", messUp("a\n//b\nc"));
105 EXPECT_EQ("a\n#b\nc", messUp("a\n#b\nc"));
106 EXPECT_EQ("a\n#b c d\ne", messUp("a\n#b\\\nc\\\nd\ne"));
107}
108
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000109//===----------------------------------------------------------------------===//
110// Basic function tests.
111//===----------------------------------------------------------------------===//
112
Daniel Jasperf7935112012-12-03 18:12:45 +0000113TEST_F(FormatTest, DoesNotChangeCorrectlyFormatedCode) {
114 EXPECT_EQ(";", format(";"));
115}
116
117TEST_F(FormatTest, FormatsGlobalStatementsAt0) {
118 EXPECT_EQ("int i;", format(" int i;"));
119 EXPECT_EQ("\nint i;", format(" \n\t \r int i;"));
120 EXPECT_EQ("int i;\nint j;", format(" int i; int j;"));
121 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;"));
122}
123
124TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) {
125 EXPECT_EQ("int i;", format("int\ni;"));
126}
127
128TEST_F(FormatTest, FormatsNestedBlockStatements) {
Manuel Klimeke7d10a12013-01-10 13:24:24 +0000129 EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}"));
Daniel Jasperf7935112012-12-03 18:12:45 +0000130}
131
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000132TEST_F(FormatTest, FormatsNestedCall) {
133 verifyFormat("Method(f1, f2(f3));");
134 verifyFormat("Method(f1(f2, f3()));");
Daniel Jasper48cb3b92013-01-13 08:19:51 +0000135 verifyFormat("Method(f1(f2, (f3())));");
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000136}
137
Daniel Jasper14556742013-02-07 21:08:36 +0000138TEST_F(FormatTest, NestedNameSpecifiers) {
Daniel Jasper736c14f2013-01-16 07:19:28 +0000139 verifyFormat("vector< ::Type> v;");
Daniel Jasper14556742013-02-07 21:08:36 +0000140 verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())");
Daniel Jasper736c14f2013-01-16 07:19:28 +0000141}
142
Daniel Jasper7b038a22013-01-30 09:46:12 +0000143TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) {
144 EXPECT_EQ("if (a) {\n"
145 " f();\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000146 "}",
147 format("if(a){f();}"));
Daniel Jasper7b038a22013-01-30 09:46:12 +0000148 EXPECT_EQ(4, ReplacementCount);
149 EXPECT_EQ("if (a) {\n"
150 " f();\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000151 "}",
152 format("if (a) {\n"
153 " f();\n"
154 "}"));
Daniel Jasper7b038a22013-01-30 09:46:12 +0000155 EXPECT_EQ(0, ReplacementCount);
156}
157
Daniel Jasper24570102013-02-14 09:58:41 +0000158TEST_F(FormatTest, RemovesTrailingWhitespaceOfFormattedLine) {
159 EXPECT_EQ("int a;\nint b;", format("int a; \nint b;", 0, 0, getLLVMStyle()));
Daniel Jaspera79064a2013-03-01 18:11:39 +0000160 EXPECT_EQ("int a;", format("int a; "));
161 EXPECT_EQ("int a;\n", format("int a; \n \n \n "));
162 EXPECT_EQ("int a;\nint b; ",
163 format("int a; \nint b; ", 0, 0, getLLVMStyle()));
Daniel Jasper24570102013-02-14 09:58:41 +0000164}
165
Daniel Jasper973c9422013-03-04 13:43:19 +0000166TEST_F(FormatTest, FormatsCorrectRegionForLeadingWhitespace) {
167 EXPECT_EQ("int b;\nint a;",
168 format("int b;\n int a;", 7, 0, getLLVMStyle()));
169 EXPECT_EQ("int b;\n int a;",
170 format("int b;\n int a;", 6, 0, getLLVMStyle()));
171
172 EXPECT_EQ("#define A \\\n"
173 " int a; \\\n"
174 " int b;",
175 format("#define A \\\n"
176 " int a; \\\n"
177 " int b;",
178 26, 0, getLLVMStyleWithColumns(12)));
179 EXPECT_EQ("#define A \\\n"
180 " int a; \\\n"
181 " int b;",
182 format("#define A \\\n"
183 " int a; \\\n"
184 " int b;",
185 25, 0, getLLVMStyleWithColumns(12)));
186}
187
Daniel Jasperf71cf3b2013-03-07 20:50:00 +0000188TEST_F(FormatTest, RemovesWhitespaceWhenTriggeredOnEmptyLine) {
189 EXPECT_EQ("int a;\n\n int b;",
190 format("int a;\n \n\n int b;", 7, 0, getLLVMStyle()));
191 EXPECT_EQ("int a;\n\n int b;",
192 format("int a;\n \n\n int b;", 9, 0, getLLVMStyle()));
193}
194
Daniel Jasper1027c6e2013-06-03 16:16:41 +0000195TEST_F(FormatTest, RemovesEmptyLines) {
196 EXPECT_EQ("class C {\n"
197 " int i;\n"
198 "};",
199 format("class C {\n"
200 " int i;\n"
201 "\n"
202 "};"));
203
204 // Don't remove empty lines in more complex control statements.
205 EXPECT_EQ("void f() {\n"
206 " if (a) {\n"
207 " f();\n"
208 "\n"
209 " } else if (b) {\n"
210 " f();\n"
211 " }\n"
212 "}",
213 format("void f() {\n"
214 " if (a) {\n"
215 " f();\n"
216 "\n"
217 " } else if (b) {\n"
218 " f();\n"
219 "\n"
220 " }\n"
221 "\n"
222 "}"));
223
224 // FIXME: This is slightly inconsistent.
225 EXPECT_EQ("namespace {\n"
226 "int i;\n"
227 "}",
228 format("namespace {\n"
229 "int i;\n"
230 "\n"
231 "}"));
232 EXPECT_EQ("namespace {\n"
233 "int i;\n"
234 "\n"
235 "} // namespace",
236 format("namespace {\n"
237 "int i;\n"
238 "\n"
239 "} // namespace"));
240}
241
Daniel Jasper55d7ba62013-02-18 13:08:03 +0000242TEST_F(FormatTest, ReformatsMovedLines) {
243 EXPECT_EQ(
244 "template <typename T> T *getFETokenInfo() const {\n"
245 " return static_cast<T *>(FETokenInfo);\n"
246 "}\n"
247 " int a; // <- Should not be formatted",
248 format(
249 "template<typename T>\n"
250 "T *getFETokenInfo() const { return static_cast<T*>(FETokenInfo); }\n"
251 " int a; // <- Should not be formatted",
252 9, 5, getLLVMStyle()));
253}
254
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000255//===----------------------------------------------------------------------===//
256// Tests for control statements.
257//===----------------------------------------------------------------------===//
258
Daniel Jaspercdd06622013-05-14 10:31:09 +0000259TEST_F(FormatTest, FormatIfWithoutCompoundStatement) {
Daniel Jasper1b750ed2013-01-14 16:24:39 +0000260 verifyFormat("if (true)\n f();\ng();");
261 verifyFormat("if (a)\n if (b)\n if (c)\n g();\nh();");
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000262 verifyFormat("if (a)\n if (b) {\n f();\n }\ng();");
Daniel Jasperced17f82013-01-16 15:44:34 +0000263
Daniel Jasper3a685df2013-05-16 12:12:21 +0000264 FormatStyle AllowsMergedIf = getLLVMStyle();
Daniel Jasperced17f82013-01-16 15:44:34 +0000265 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true;
266 verifyFormat("if (a)\n"
267 " // comment\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000268 " f();",
269 AllowsMergedIf);
Daniel Jasper3a685df2013-05-16 12:12:21 +0000270 verifyFormat("if (a)\n"
271 " ;",
272 AllowsMergedIf);
273 verifyFormat("if (a)\n"
274 " if (b) return;",
275 AllowsMergedIf);
Daniel Jasperced17f82013-01-16 15:44:34 +0000276
Daniel Jasper3a685df2013-05-16 12:12:21 +0000277 verifyFormat("if (a) // Can't merge this\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000278 " f();\n",
279 AllowsMergedIf);
Daniel Jasperced17f82013-01-16 15:44:34 +0000280 verifyFormat("if (a) /* still don't merge */\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000281 " f();",
282 AllowsMergedIf);
Daniel Jasper3a685df2013-05-16 12:12:21 +0000283 verifyFormat("if (a) { // Never merge this\n"
Daniel Jasperced17f82013-01-16 15:44:34 +0000284 " f();\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000285 "}",
286 AllowsMergedIf);
Daniel Jasperced17f82013-01-16 15:44:34 +0000287 verifyFormat("if (a) { /* Never merge this */\n"
288 " f();\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000289 "}",
290 AllowsMergedIf);
Daniel Jasperced17f82013-01-16 15:44:34 +0000291
Daniel Jasper12f9d8e2013-05-14 09:30:02 +0000292 EXPECT_EQ("if (a) return;", format("if(a)\nreturn;", 7, 1, AllowsMergedIf));
Daniel Jasper3a685df2013-05-16 12:12:21 +0000293 EXPECT_EQ("if (a) return; // comment",
Daniel Jaspercdd06622013-05-14 10:31:09 +0000294 format("if(a)\nreturn; // comment", 20, 1, AllowsMergedIf));
Daniel Jasper12f9d8e2013-05-14 09:30:02 +0000295
Daniel Jasperced17f82013-01-16 15:44:34 +0000296 AllowsMergedIf.ColumnLimit = 14;
297 verifyFormat("if (a) return;", AllowsMergedIf);
Daniel Jasper3e9218e2013-01-14 16:02:06 +0000298 verifyFormat("if (aaaaaaaaa)\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000299 " return;",
300 AllowsMergedIf);
Daniel Jasperced17f82013-01-16 15:44:34 +0000301
302 AllowsMergedIf.ColumnLimit = 13;
303 verifyFormat("if (a)\n return;", AllowsMergedIf);
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000304}
305
Daniel Jasper3a685df2013-05-16 12:12:21 +0000306TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) {
307 FormatStyle AllowsMergedLoops = getLLVMStyle();
308 AllowsMergedLoops.AllowShortLoopsOnASingleLine = true;
309 verifyFormat("while (true) continue;", AllowsMergedLoops);
310 verifyFormat("for (;;) continue;", AllowsMergedLoops);
311 verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops);
312 verifyFormat("while (true)\n"
313 " ;",
314 AllowsMergedLoops);
315 verifyFormat("for (;;)\n"
316 " ;",
317 AllowsMergedLoops);
318 verifyFormat("for (;;)\n"
319 " for (;;) continue;",
320 AllowsMergedLoops);
321 verifyFormat("for (;;) // Can't merge this\n"
322 " continue;",
323 AllowsMergedLoops);
324 verifyFormat("for (;;) /* still don't merge */\n"
325 " continue;",
326 AllowsMergedLoops);
327}
328
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000329TEST_F(FormatTest, ParseIfElse) {
330 verifyFormat("if (true)\n"
331 " if (true)\n"
332 " if (true)\n"
333 " f();\n"
334 " else\n"
335 " g();\n"
336 " else\n"
337 " h();\n"
338 "else\n"
339 " i();");
340 verifyFormat("if (true)\n"
341 " if (true)\n"
342 " if (true) {\n"
Daniel Jasper1b750ed2013-01-14 16:24:39 +0000343 " if (true)\n"
344 " f();\n"
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000345 " } else {\n"
346 " g();\n"
347 " }\n"
348 " else\n"
349 " h();\n"
350 "else {\n"
351 " i();\n"
352 "}");
353}
354
355TEST_F(FormatTest, ElseIf) {
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000356 verifyFormat("if (a) {\n} else if (b) {\n}");
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000357 verifyFormat("if (a)\n"
358 " f();\n"
359 "else if (b)\n"
360 " g();\n"
361 "else\n"
362 " h();");
363}
364
Daniel Jasperf7935112012-12-03 18:12:45 +0000365TEST_F(FormatTest, FormatsForLoop) {
366 verifyFormat(
367 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n"
Alexander Kornienko37d6c942012-12-05 15:06:06 +0000368 " ++VeryVeryLongLoopVariable)\n"
369 " ;");
370 verifyFormat("for (;;)\n"
371 " f();");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000372 verifyFormat("for (;;) {\n}");
Alexander Kornienko37d6c942012-12-05 15:06:06 +0000373 verifyFormat("for (;;) {\n"
374 " f();\n"
375 "}");
Daniel Jasper72463d32013-05-03 14:50:50 +0000376 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}");
Daniel Jasperfbde69e2012-12-21 14:37:20 +0000377
378 verifyFormat(
379 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
380 " E = UnwrappedLines.end();\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000381 " I != E; ++I) {\n}");
Daniel Jasperfbde69e2012-12-21 14:37:20 +0000382
383 verifyFormat(
384 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000385 " ++IIIII) {\n}");
Daniel Jaspera628c982013-04-03 13:36:17 +0000386 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n"
387 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000388 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}");
Daniel Jasper37905f72013-02-21 15:00:29 +0000389 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n"
390 " I = FD->getDeclsInPrototypeScope().begin(),\n"
391 " E = FD->getDeclsInPrototypeScope().end();\n"
392 " I != E; ++I) {\n}");
Daniel Jasper48c62f92013-01-28 17:30:17 +0000393
394 // FIXME: Not sure whether we want extra identation in line 3 here:
395 verifyFormat(
396 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
397 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n"
Daniel Jasperd1ae3582013-03-20 12:37:50 +0000398 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
399 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
Daniel Jasper48c62f92013-01-28 17:30:17 +0000400 " ++aaaaaaaaaaa) {\n}");
Daniel Jasper2cf17bf2013-02-27 09:47:53 +0000401 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n"
402 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
403 "}");
Daniel Jaspera628c982013-04-03 13:36:17 +0000404 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n"
405 " aaaaaaaaaa);\n"
406 " iter; ++iter) {\n"
407 "}");
Daniel Jasperf7f13c02013-02-04 07:30:30 +0000408
Daniel Jasper2cf17bf2013-02-27 09:47:53 +0000409 FormatStyle NoBinPacking = getLLVMStyle();
410 NoBinPacking.BinPackParameters = false;
411 verifyFormat("for (int aaaaaaaaaaa = 1;\n"
412 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n"
413 " aaaaaaaaaaaaaaaa,\n"
414 " aaaaaaaaaaaaaaaa,\n"
415 " aaaaaaaaaaaaaaaa);\n"
416 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
417 "}",
418 NoBinPacking);
419 verifyFormat(
Daniel Jaspercd8599e2013-02-23 21:01:55 +0000420 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
421 " E = UnwrappedLines.end();\n"
422 " I != E;\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +0000423 " ++I) {\n}",
424 NoBinPacking);
Daniel Jasperf7935112012-12-03 18:12:45 +0000425}
426
Daniel Jasper0b41cbb2013-01-28 13:21:16 +0000427TEST_F(FormatTest, RangeBasedForLoops) {
428 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
429 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
430 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n"
431 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}");
Daniel Jasper16b35622013-02-26 13:18:08 +0000432 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n"
433 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasper0b41cbb2013-01-28 13:21:16 +0000434}
435
Daniel Jasperf7935112012-12-03 18:12:45 +0000436TEST_F(FormatTest, FormatsWhileLoop) {
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000437 verifyFormat("while (true) {\n}");
Alexander Kornienko37d6c942012-12-05 15:06:06 +0000438 verifyFormat("while (true)\n"
439 " f();");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000440 verifyFormat("while () {\n}");
Alexander Kornienko37d6c942012-12-05 15:06:06 +0000441 verifyFormat("while () {\n"
442 " f();\n"
443 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +0000444}
445
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000446TEST_F(FormatTest, FormatsDoWhile) {
447 verifyFormat("do {\n"
448 " do_something();\n"
449 "} while (something());");
450 verifyFormat("do\n"
451 " do_something();\n"
452 "while (something());");
Daniel Jasperf7935112012-12-03 18:12:45 +0000453}
454
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000455TEST_F(FormatTest, FormatsSwitchStatement) {
Daniel Jasperf7935112012-12-03 18:12:45 +0000456 verifyFormat("switch (x) {\n"
457 "case 1:\n"
458 " f();\n"
459 " break;\n"
460 "case kFoo:\n"
461 "case ns::kBar:\n"
462 "case kBaz:\n"
463 " break;\n"
464 "default:\n"
465 " g();\n"
466 " break;\n"
467 "}");
468 verifyFormat("switch (x) {\n"
469 "case 1: {\n"
470 " f();\n"
471 " break;\n"
472 "}\n"
473 "}");
Nico Webera5510af2013-01-18 05:50:57 +0000474 verifyFormat("switch (x) {\n"
475 "case 1: {\n"
476 " f();\n"
477 " {\n"
478 " g();\n"
479 " h();\n"
480 " }\n"
481 " break;\n"
482 "}\n"
483 "}");
484 verifyFormat("switch (x) {\n"
485 "case 1: {\n"
486 " f();\n"
487 " if (foo) {\n"
488 " g();\n"
489 " h();\n"
490 " }\n"
491 " break;\n"
492 "}\n"
493 "}");
494 verifyFormat("switch (x) {\n"
495 "case 1: {\n"
496 " f();\n"
497 " g();\n"
498 "} break;\n"
499 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +0000500 verifyFormat("switch (test)\n"
501 " ;");
Daniel Jasper18104652013-03-12 12:26:55 +0000502 verifyFormat("switch (x) {\n"
503 "default: {\n"
504 " // Do nothing.\n"
Manuel Klimek1a18c402013-04-12 14:13:36 +0000505 "}\n"
Daniel Jasper18104652013-03-12 12:26:55 +0000506 "}");
Daniel Jasper0f8ed9e2013-03-13 15:53:12 +0000507 verifyFormat("switch (x) {\n"
Daniel Jasperb67cc422013-04-09 17:46:55 +0000508 "// comment\n"
Daniel Jasper0f8ed9e2013-03-13 15:53:12 +0000509 "// if 1, do f()\n"
510 "case 1:\n"
511 " f();\n"
512 "}");
Daniel Jasper2bd32ca2013-03-19 18:33:58 +0000513 verifyFormat("switch (x) {\n"
514 "case 1:\n"
515 " // Do amazing stuff\n"
516 " {\n"
517 " f();\n"
518 " g();\n"
519 " }\n"
520 " break;\n"
521 "}");
Daniel Jaspera1275122013-03-20 10:23:53 +0000522 verifyFormat("#define A \\\n"
523 " switch (x) { \\\n"
524 " case a: \\\n"
525 " foo = b; \\\n"
526 " }", getLLVMStyleWithColumns(20));
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000527
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000528 verifyGoogleFormat("switch (x) {\n"
529 " case 1:\n"
530 " f();\n"
531 " break;\n"
532 " case kFoo:\n"
533 " case ns::kBar:\n"
534 " case kBaz:\n"
535 " break;\n"
536 " default:\n"
537 " g();\n"
538 " break;\n"
539 "}");
540 verifyGoogleFormat("switch (x) {\n"
541 " case 1: {\n"
542 " f();\n"
543 " break;\n"
544 " }\n"
545 "}");
546 verifyGoogleFormat("switch (test)\n"
547 " ;");
Daniel Jasperf7935112012-12-03 18:12:45 +0000548}
549
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000550TEST_F(FormatTest, FormatsLabels) {
Daniel Jasperf7935112012-12-03 18:12:45 +0000551 verifyFormat("void f() {\n"
552 " some_code();\n"
553 "test_label:\n"
554 " some_other_code();\n"
555 " {\n"
556 " some_more_code();\n"
557 " another_label:\n"
558 " some_more_code();\n"
559 " }\n"
560 "}");
561 verifyFormat("some_code();\n"
562 "test_label:\n"
563 "some_other_code();");
564}
565
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000566//===----------------------------------------------------------------------===//
567// Tests for comments.
568//===----------------------------------------------------------------------===//
569
570TEST_F(FormatTest, UnderstandsSingleLineComments) {
Daniel Jasper55213652013-03-22 10:01:29 +0000571 verifyFormat("//* */");
Daniel Jasper3f69a1b2012-12-18 19:56:56 +0000572 verifyFormat("// line 1\n"
573 "// line 2\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +0000574 "void f() {}\n");
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000575
Daniel Jasper3f69a1b2012-12-18 19:56:56 +0000576 verifyFormat("void f() {\n"
577 " // Doesn't do anything\n"
578 "}");
Daniel Jasperaa701fa2013-01-18 08:44:07 +0000579 verifyFormat("void f(int i, // some comment (probably for i)\n"
580 " int j, // some comment (probably for j)\n"
Daniel Jasper942ee722013-01-13 16:10:20 +0000581 " int k); // some comment (probably for k)");
582 verifyFormat("void f(int i,\n"
583 " // some comment (probably for j)\n"
584 " int j,\n"
585 " // some comment (probably for k)\n"
586 " int k);");
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000587
Daniel Jasperaa701fa2013-01-18 08:44:07 +0000588 verifyFormat("int i // This is a fancy variable\n"
589 " = 5; // with nicely aligned comment.");
590
591 verifyFormat("// Leading comment.\n"
592 "int a; // Trailing comment.");
593 verifyFormat("int a; // Trailing comment\n"
594 " // on 2\n"
595 " // or 3 lines.\n"
596 "int b;");
597 verifyFormat("int a; // Trailing comment\n"
598 "\n"
599 "// Leading comment.\n"
600 "int b;");
601 verifyFormat("int a; // Comment.\n"
602 " // More details.\n"
603 "int bbbb; // Another comment.");
604 verifyFormat(
605 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; // comment\n"
606 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; // comment\n"
607 "int cccccccccccccccccccccccccccccc; // comment\n"
608 "int ddd; // looooooooooooooooooooooooong comment\n"
609 "int aaaaaaaaaaaaaaaaaaaaaaa; // comment\n"
610 "int bbbbbbbbbbbbbbbbbbbbb; // comment\n"
611 "int ccccccccccccccccccc; // comment");
612
Daniel Jasper997b08c2013-01-18 09:19:33 +0000613 verifyFormat("#include \"a\" // comment\n"
614 "#include \"a/b/c\" // comment");
615 verifyFormat("#include <a> // comment\n"
616 "#include <a/b/c> // comment");
Manuel Klimek5c24cca2013-05-23 10:56:37 +0000617 EXPECT_EQ("#include \\\n"
618 " \"a\" // comment\n"
619 "#include \"a/b/c\" // comment",
620 format("#include \\\n"
621 " \"a\" // comment\n"
622 "#include \"a/b/c\" // comment"));
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000623
Daniel Jasper3f69a1b2012-12-18 19:56:56 +0000624 verifyFormat("enum E {\n"
625 " // comment\n"
Daniel Jasper5ad1e192013-01-07 11:09:06 +0000626 " VAL_A, // comment\n"
Daniel Jasper3f69a1b2012-12-18 19:56:56 +0000627 " VAL_B\n"
628 "};");
Daniel Jaspere25509f2012-12-17 11:29:41 +0000629
630 verifyFormat(
631 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Daniel Jasper5ad1e192013-01-07 11:09:06 +0000632 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; // Trailing comment");
Daniel Jasperd8bb2db2013-01-09 09:33:39 +0000633 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
634 " // Comment inside a statement.\n"
635 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
Daniel Jasper38396592013-02-06 15:23:09 +0000636 verifyFormat(
637 "bool aaaaaaaaaaaaa = // comment\n"
638 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
639 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Manuel Klimekc74d2922013-01-07 08:54:53 +0000640
Daniel Jasper525264c2013-02-13 19:25:54 +0000641 verifyFormat("int aaaa; // aaaaa\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +0000642 "int aa; // aaaaaaa",
643 getLLVMStyleWithColumns(20));
Daniel Jasper525264c2013-02-13 19:25:54 +0000644
Daniel Jasper304a9862013-01-21 22:49:20 +0000645 EXPECT_EQ("void f() { // This does something ..\n"
646 "}\n"
647 "int a; // This is unrelated",
648 format("void f() { // This does something ..\n"
649 " }\n"
650 "int a; // This is unrelated"));
651 EXPECT_EQ("void f() { // This does something ..\n"
652 "} // awesome..\n"
653 "\n"
654 "int a; // This is unrelated",
655 format("void f() { // This does something ..\n"
656 " } // awesome..\n"
657 " \n"
658 "int a; // This is unrelated"));
659
Daniel Jasper5ad1e192013-01-07 11:09:06 +0000660 EXPECT_EQ("int i; // single line trailing comment",
Manuel Klimekc74d2922013-01-07 08:54:53 +0000661 format("int i;\\\n// single line trailing comment"));
Daniel Jasper5ad1e192013-01-07 11:09:06 +0000662
663 verifyGoogleFormat("int a; // Trailing comment.");
Daniel Jasperddaa9be2013-01-29 19:41:55 +0000664
665 verifyFormat("someFunction(anotherFunction( // Force break.\n"
666 " parameter));");
Daniel Jaspera885dbe2013-02-05 09:34:14 +0000667
668 verifyGoogleFormat("#endif // HEADER_GUARD");
Daniel Jasperf79f9352013-02-06 22:04:05 +0000669
670 verifyFormat("const char *test[] = {\n"
671 " // A\n"
672 " \"aaaa\",\n"
673 " // B\n"
674 " \"aaaaa\",\n"
675 "};");
Daniel Jaspereef30492013-02-11 12:36:37 +0000676 verifyGoogleFormat(
677 "aaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Alexander Kornienkodd7ece52013-06-07 16:02:52 +0000678 " aaaaaaaaaaaaaaaaaaaaaa); // 81_cols_with_this_comment");
Alexander Kornienkob1be9d62013-04-03 12:38:53 +0000679 EXPECT_EQ("D(a, {\n"
680 " // test\n"
681 " int a;\n"
682 "});",
683 format("D(a, {\n"
684 "// test\n"
685 "int a;\n"
686 "});"));
Manuel Klimekc5730802013-05-23 11:42:52 +0000687
688 EXPECT_EQ("lineWith(); // comment\n"
689 "// at start\n"
690 "otherLine();",
691 format("lineWith(); // comment\n"
692 "// at start\n"
693 "otherLine();"));
694 EXPECT_EQ("lineWith(); // comment\n"
695 " // at start\n"
696 "otherLine();",
697 format("lineWith(); // comment\n"
698 " // at start\n"
699 "otherLine();"));
Manuel Klimekb27375f2013-05-23 19:54:43 +0000700
701 EXPECT_EQ("lineWith(); // comment\n"
702 "// at start\n"
703 "otherLine(); // comment",
704 format("lineWith(); // comment\n"
705 "// at start\n"
706 "otherLine(); // comment"));
Manuel Klimek75ef31f2013-05-23 20:46:07 +0000707 EXPECT_EQ("lineWith();\n"
708 "// at start\n"
709 "otherLine(); // comment",
710 format("lineWith();\n"
711 " // at start\n"
712 "otherLine(); // comment"));
713 EXPECT_EQ("// first\n"
714 "// at start\n"
715 "otherLine(); // comment",
716 format("// first\n"
717 " // at start\n"
718 "otherLine(); // comment"));
719 EXPECT_EQ("f();\n"
720 "// first\n"
721 "// at start\n"
722 "otherLine(); // comment",
723 format("f();\n"
724 "// first\n"
725 " // at start\n"
726 "otherLine(); // comment"));
Daniel Jaspere25509f2012-12-17 11:29:41 +0000727}
728
Daniel Jasperbc0fa392013-03-22 16:25:51 +0000729TEST_F(FormatTest, CanFormatCommentsLocally) {
730 EXPECT_EQ("int a; // comment\n"
731 "int b; // comment",
732 format("int a; // comment\n"
733 "int b; // comment",
734 0, 0, getLLVMStyle()));
735 EXPECT_EQ("int a; // comment\n"
736 " // line 2\n"
737 "int b;",
738 format("int a; // comment\n"
739 " // line 2\n"
740 "int b;",
741 28, 0, getLLVMStyle()));
Daniel Jasper770eb7c2013-04-24 06:33:59 +0000742 EXPECT_EQ("int aaaaaa; // comment\n"
743 "int b;\n"
744 "int c; // unrelated comment",
745 format("int aaaaaa; // comment\n"
746 "int b;\n"
747 "int c; // unrelated comment",
748 31, 0, getLLVMStyle()));
Daniel Jasperbc0fa392013-03-22 16:25:51 +0000749}
750
Daniel Jasper3324cbe2013-03-01 16:45:59 +0000751TEST_F(FormatTest, RemovesTrailingWhitespaceOfComments) {
752 EXPECT_EQ("// comment", format("// comment "));
753 EXPECT_EQ("int aaaaaaa, bbbbbbb; // comment",
754 format("int aaaaaaa, bbbbbbb; // comment ",
755 getLLVMStyleWithColumns(33)));
756}
757
Daniel Jaspere25509f2012-12-17 11:29:41 +0000758TEST_F(FormatTest, UnderstandsMultiLineComments) {
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000759 verifyFormat("f(/*test=*/ true);");
Daniel Jasper11cb81c2013-01-17 12:53:34 +0000760 EXPECT_EQ(
761 "f(aaaaaaaaaaaaaaaaaaaaaaaaa, /* Trailing comment for aa... */\n"
762 " bbbbbbbbbbbbbbbbbbbbbbbbb);",
Alexander Kornienko9e90b622013-04-17 17:34:05 +0000763 format("f(aaaaaaaaaaaaaaaaaaaaaaaaa , \\\n/* Trailing comment for aa... */\n"
Daniel Jasper11cb81c2013-01-17 12:53:34 +0000764 " bbbbbbbbbbbbbbbbbbbbbbbbb);"));
765 EXPECT_EQ(
766 "f(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
767 " /* Leading comment for bb... */ bbbbbbbbbbbbbbbbbbbbbbbbb);",
768 format("f(aaaaaaaaaaaaaaaaaaaaaaaaa , \n"
769 "/* Leading comment for bb... */ bbbbbbbbbbbbbbbbbbbbbbbbb);"));
Daniel Jasper61a40782013-06-06 16:08:57 +0000770 EXPECT_EQ(
771 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
772 " aaaaaaaaaaaaaaaaaa,\n"
773 " aaaaaaaaaaaaaaaaaa) { /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaa */\n"
774 "}",
775 format("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
776 " aaaaaaaaaaaaaaaaaa ,\n"
777 " aaaaaaaaaaaaaaaaaa) { /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaa */\n"
778 "}"));
Daniel Jasperddaa9be2013-01-29 19:41:55 +0000779
Daniel Jasper2cf17bf2013-02-27 09:47:53 +0000780 FormatStyle NoBinPacking = getLLVMStyle();
781 NoBinPacking.BinPackParameters = false;
782 verifyFormat("aaaaaaaa(/* parameter 1 */ aaaaaa,\n"
783 " /* parameter 2 */ aaaaaa,\n"
784 " /* parameter 3 */ aaaaaa,\n"
785 " /* parameter 4 */ aaaaaa);",
786 NoBinPacking);
Daniel Jasper11cb81c2013-01-17 12:53:34 +0000787}
788
Alexander Kornienkodd8ed852013-03-14 16:10:54 +0000789TEST_F(FormatTest, AlignsMultiLineComments) {
790 EXPECT_EQ("/*\n"
791 " * Really multi-line\n"
792 " * comment.\n"
793 " */\n"
794 "void f() {}",
795 format(" /*\n"
796 " * Really multi-line\n"
797 " * comment.\n"
798 " */\n"
799 " void f() {}"));
Alexander Kornienkodd8ed852013-03-14 16:10:54 +0000800 EXPECT_EQ("class C {\n"
801 " /*\n"
802 " * Another multi-line\n"
803 " * comment.\n"
804 " */\n"
805 " void f() {}\n"
806 "};",
807 format("class C {\n"
808 "/*\n"
809 " * Another multi-line\n"
810 " * comment.\n"
811 " */\n"
812 "void f() {}\n"
813 "};"));
Alexander Kornienko79d6c722013-03-15 13:42:02 +0000814 EXPECT_EQ("/*\n"
815 " 1. This is a comment with non-trivial formatting.\n"
816 " 1.1. We have to indent/outdent all lines equally\n"
817 " 1.1.1. to keep the formatting.\n"
818 " */",
819 format(" /*\n"
820 " 1. This is a comment with non-trivial formatting.\n"
821 " 1.1. We have to indent/outdent all lines equally\n"
822 " 1.1.1. to keep the formatting.\n"
823 " */"));
824 EXPECT_EQ("/*\n"
Manuel Klimek9043c742013-05-27 15:23:34 +0000825 "Don't try to outdent if there's not enough inentation.\n"
826 "*/",
Alexander Kornienko79d6c722013-03-15 13:42:02 +0000827 format(" /*\n"
828 " Don't try to outdent if there's not enough inentation.\n"
829 " */"));
Manuel Klimek281dcbe2013-05-28 08:55:01 +0000830
831 EXPECT_EQ("int i; /* Comment with empty...\n"
832 " *\n"
833 " * line. */",
834 format("int i; /* Comment with empty...\n"
835 " *\n"
836 " * line. */"));
Alexander Kornienkodd8ed852013-03-14 16:10:54 +0000837}
838
Alexander Kornienkoffd6d042013-03-27 11:52:18 +0000839TEST_F(FormatTest, SplitsLongCxxComments) {
840 EXPECT_EQ("// A comment that\n"
841 "// doesn't fit on\n"
842 "// one line",
843 format("// A comment that doesn't fit on one line",
844 getLLVMStyleWithColumns(20)));
Alexander Kornienko9e90b622013-04-17 17:34:05 +0000845 EXPECT_EQ("// a b c d\n"
846 "// e f g\n"
847 "// h i j k",
848 format("// a b c d e f g h i j k",
849 getLLVMStyleWithColumns(10)));
850 EXPECT_EQ("// a b c d\n"
851 "// e f g\n"
852 "// h i j k",
853 format("\\\n// a b c d e f g h i j k",
854 getLLVMStyleWithColumns(10)));
Alexander Kornienkoffd6d042013-03-27 11:52:18 +0000855 EXPECT_EQ("if (true) // A comment that\n"
856 " // doesn't fit on\n"
857 " // one line",
858 format("if (true) // A comment that doesn't fit on one line ",
859 getLLVMStyleWithColumns(30)));
860 EXPECT_EQ("// Don't_touch_leading_whitespace",
861 format("// Don't_touch_leading_whitespace",
862 getLLVMStyleWithColumns(20)));
863 EXPECT_EQ(
864 "//Don't add leading\n"
865 "//whitespace",
866 format("//Don't add leading whitespace", getLLVMStyleWithColumns(20)));
Alexander Kornienkoefd98382013-03-28 18:40:55 +0000867 EXPECT_EQ("// A comment before\n"
868 "// a macro\n"
869 "// definition\n"
870 "#define a b",
871 format("// A comment before a macro definition\n"
872 "#define a b",
873 getLLVMStyleWithColumns(20)));
Alexander Kornienkodd7ece52013-06-07 16:02:52 +0000874}
Manuel Klimek9043c742013-05-27 15:23:34 +0000875
Alexander Kornienkodd7ece52013-06-07 16:02:52 +0000876TEST_F(FormatTest, PriorityOfCommentBreaking) {
877 EXPECT_EQ("if (xxx == yyy && // aaaaaaaaaaaa\n"
878 " // bbbbbbbbb\n"
879 " zzz)\n"
880 " q();",
881 format("if (xxx == yyy && // aaaaaaaaaaaa bbbbbbbbb\n"
882 " zzz) q();",
883 getLLVMStyleWithColumns(40)));
884 EXPECT_EQ("if (xxxxxxxxxx ==\n"
885 " yyy && // aaaaaa bbbbbbbb cccc\n"
886 " zzz)\n"
887 " q();",
888 format("if (xxxxxxxxxx == yyy && // aaaaaa bbbbbbbb cccc\n"
889 " zzz) q();",
890 getLLVMStyleWithColumns(40)));
891 EXPECT_EQ("if (xxxxxxxxxx &&\n"
892 " yyy || // aaaaaa bbbbbbbb cccc\n"
893 " zzz)\n"
894 " q();",
895 format("if (xxxxxxxxxx && yyy || // aaaaaa bbbbbbbb cccc\n"
896 " zzz) q();",
897 getLLVMStyleWithColumns(40)));
898 EXPECT_EQ("fffffffff(&xxx, // aaaaaaaaaaaa\n"
899 " // bbbbbbbbbbb\n"
900 " zzz);",
901 format("fffffffff(&xxx, // aaaaaaaaaaaa bbbbbbbbbbb\n"
902 " zzz);",
903 getLLVMStyleWithColumns(40)));
Manuel Klimek9043c742013-05-27 15:23:34 +0000904}
905
906TEST_F(FormatTest, MultiLineCommentsInDefines) {
907 // FIXME: The line breaks are still suboptimal (current guess
908 // is that this is due to the token length being misused), but
909 // the comment handling is correct.
910 EXPECT_EQ("#define A( \\\n"
911 " x) /* \\\n"
912 "a comment \\\n"
913 "inside */ \\\n"
914 " f();",
915 format("#define A(x) /* \\\n"
916 " a comment \\\n"
917 " inside */ \\\n"
918 " f();",
919 getLLVMStyleWithColumns(17)));
920 EXPECT_EQ("#define A(x) /* \\\n"
921 " a \\\n"
922 " comment \\\n"
923 " inside \\\n"
924 " */ \\\n"
925 " f();",
926 format("#define A( \\\n"
927 " x) /* \\\n"
928 " a comment \\\n"
929 " inside */ \\\n"
930 " f();",
931 getLLVMStyleWithColumns(17)));
Alexander Kornienkoffd6d042013-03-27 11:52:18 +0000932}
933
Alexander Kornienkob5dad752013-04-02 13:04:06 +0000934TEST_F(FormatTest, ParsesCommentsAdjacentToPPDirectives) {
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +0000935 EXPECT_EQ("namespace {}\n// Test\n#define A",
Alexander Kornienkob5dad752013-04-02 13:04:06 +0000936 format("namespace {}\n // Test\n#define A"));
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +0000937 EXPECT_EQ("namespace {}\n/* Test */\n#define A",
Alexander Kornienkob5dad752013-04-02 13:04:06 +0000938 format("namespace {}\n /* Test */\n#define A"));
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +0000939 EXPECT_EQ("namespace {}\n/* Test */ #define A",
Alexander Kornienkob5dad752013-04-02 13:04:06 +0000940 format("namespace {}\n /* Test */ #define A"));
941}
942
Alexander Kornienkoafcef332013-03-19 17:41:36 +0000943TEST_F(FormatTest, SplitsLongLinesInComments) {
944 EXPECT_EQ("/* This is a long\n"
Alexander Kornienko547a9f522013-03-21 12:28:10 +0000945 " * comment that\n"
946 " * doesn't\n"
947 " * fit on one line.\n"
948 " */",
Alexander Kornienkoafcef332013-03-19 17:41:36 +0000949 format("/* "
950 "This is a long "
Alexander Kornienko547a9f522013-03-21 12:28:10 +0000951 "comment that "
952 "doesn't "
Alexander Kornienkoafcef332013-03-19 17:41:36 +0000953 "fit on one line. */",
954 getLLVMStyleWithColumns(20)));
Alexander Kornienko9e90b622013-04-17 17:34:05 +0000955 EXPECT_EQ("/* a b c d\n"
956 " * e f g\n"
957 " * h i j k\n"
958 " */",
959 format("/* a b c d e f g h i j k */",
960 getLLVMStyleWithColumns(10)));
961 EXPECT_EQ("/* a b c d\n"
962 " * e f g\n"
963 " * h i j k\n"
964 " */",
965 format("\\\n/* a b c d e f g h i j k */",
966 getLLVMStyleWithColumns(10)));
Alexander Kornienkoafcef332013-03-19 17:41:36 +0000967 EXPECT_EQ("/*\n"
968 "This is a long\n"
969 "comment that doesn't\n"
970 "fit on one line.\n"
971 "*/",
972 format("/*\n"
973 "This is a long "
974 "comment that doesn't "
975 "fit on one line. \n"
976 "*/", getLLVMStyleWithColumns(20)));
977 EXPECT_EQ("/*\n"
978 " * This is a long\n"
979 " * comment that\n"
980 " * doesn't fit on\n"
981 " * one line.\n"
982 " */",
Alexander Kornienko547a9f522013-03-21 12:28:10 +0000983 format("/* \n"
Alexander Kornienkoafcef332013-03-19 17:41:36 +0000984 " * This is a long "
985 " comment that "
986 " doesn't fit on "
987 " one line. \n"
988 " */", getLLVMStyleWithColumns(20)));
989 EXPECT_EQ("/*\n"
990 " * This_is_a_comment_with_words_that_dont_fit_on_one_line\n"
991 " * so_it_should_be_broken\n"
992 " * wherever_a_space_occurs\n"
993 " */",
994 format("/*\n"
995 " * This_is_a_comment_with_words_that_dont_fit_on_one_line "
996 " so_it_should_be_broken "
997 " wherever_a_space_occurs \n"
998 " */",
999 getLLVMStyleWithColumns(20)));
1000 EXPECT_EQ("/*\n"
Alexander Kornienkoffd6d042013-03-27 11:52:18 +00001001 " * This_comment_can_not_be_broken_into_lines\n"
Alexander Kornienkoafcef332013-03-19 17:41:36 +00001002 " */",
1003 format("/*\n"
Alexander Kornienkoffd6d042013-03-27 11:52:18 +00001004 " * This_comment_can_not_be_broken_into_lines\n"
Alexander Kornienkoafcef332013-03-19 17:41:36 +00001005 " */",
1006 getLLVMStyleWithColumns(20)));
1007 EXPECT_EQ("{\n"
1008 " /*\n"
1009 " This is another\n"
1010 " long comment that\n"
1011 " doesn't fit on one\n"
1012 " line 1234567890\n"
1013 " */\n"
1014 "}",
1015 format("{\n"
1016 "/*\n"
1017 "This is another "
1018 " long comment that "
1019 " doesn't fit on one"
1020 " line 1234567890\n"
1021 "*/\n"
1022 "}", getLLVMStyleWithColumns(20)));
1023 EXPECT_EQ("{\n"
1024 " /*\n"
1025 " * This i s\n"
1026 " * another comment\n"
1027 " * t hat doesn' t\n"
1028 " * fit on one l i\n"
1029 " * n e\n"
1030 " */\n"
1031 "}",
1032 format("{\n"
1033 "/*\n"
1034 " * This i s"
1035 " another comment"
1036 " t hat doesn' t"
1037 " fit on one l i"
1038 " n e\n"
1039 " */\n"
1040 "}", getLLVMStyleWithColumns(20)));
1041 EXPECT_EQ("/*\n"
1042 " * This is a long\n"
1043 " * comment that\n"
1044 " * doesn't fit on\n"
1045 " * one line\n"
1046 " */",
1047 format(" /*\n"
1048 " * This is a long comment that doesn't fit on one line\n"
1049 " */", getLLVMStyleWithColumns(20)));
Alexander Kornienko547a9f522013-03-21 12:28:10 +00001050 EXPECT_EQ("{\n"
1051 " if (something) /* This is a\n"
Manuel Klimek9043c742013-05-27 15:23:34 +00001052 " long\n"
1053 " comment */\n"
Alexander Kornienko547a9f522013-03-21 12:28:10 +00001054 " ;\n"
1055 "}",
1056 format("{\n"
1057 " if (something) /* This is a long comment */\n"
1058 " ;\n"
1059 "}",
1060 getLLVMStyleWithColumns(30)));
Alexander Kornienkodd7ece52013-06-07 16:02:52 +00001061
1062 EXPECT_EQ("/* A comment before\n"
1063 " * a macro\n"
1064 " * definition */\n"
1065 "#define a b",
1066 format("/* A comment before a macro definition */\n"
1067 "#define a b",
1068 getLLVMStyleWithColumns(20)));
1069
1070 EXPECT_EQ("/* some comment\n"
1071 " * a comment\n"
1072 "* that we break\n"
1073 " * another comment\n"
1074 "* we have to break\n"
1075 "* a left comment\n"
1076 " */",
1077 format(" /* some comment\n"
1078 " * a comment that we break\n"
1079 " * another comment we have to break\n"
1080 "* a left comment\n"
1081 " */",
1082 getLLVMStyleWithColumns(20)));
1083
1084 EXPECT_EQ("/*\n"
1085 "\n"
1086 "\n"
1087 " */\n",
1088 format(" /* \n"
1089 " \n"
1090 " \n"
1091 " */\n"));
Alexander Kornienkoafcef332013-03-19 17:41:36 +00001092}
1093
1094TEST_F(FormatTest, SplitsLongLinesInCommentsInPreprocessor) {
1095 EXPECT_EQ("#define X \\\n"
Alexander Kornienko547a9f522013-03-21 12:28:10 +00001096 " /* \\\n"
1097 " Test \\\n"
Alexander Kornienkoafcef332013-03-19 17:41:36 +00001098 " Macro comment \\\n"
1099 " with a long \\\n"
1100 " line \\\n"
Alexander Kornienkocb45bc12013-04-15 14:28:00 +00001101 " */ \\\n"
Alexander Kornienkoafcef332013-03-19 17:41:36 +00001102 " A + B",
1103 format("#define X \\\n"
1104 " /*\n"
Alexander Kornienko547a9f522013-03-21 12:28:10 +00001105 " Test\n"
Alexander Kornienkoafcef332013-03-19 17:41:36 +00001106 " Macro comment with a long line\n"
1107 " */ \\\n"
1108 " A + B",
1109 getLLVMStyleWithColumns(20)));
1110 EXPECT_EQ("#define X \\\n"
1111 " /* Macro comment \\\n"
Alexander Kornienko547a9f522013-03-21 12:28:10 +00001112 " with a long \\\n"
Alexander Kornienkocb45bc12013-04-15 14:28:00 +00001113 " line */ \\\n"
Alexander Kornienko547a9f522013-03-21 12:28:10 +00001114 " A + B",
1115 format("#define X \\\n"
1116 " /* Macro comment with a long\n"
1117 " line */ \\\n"
1118 " A + B",
1119 getLLVMStyleWithColumns(20)));
1120 EXPECT_EQ("#define X \\\n"
1121 " /* Macro comment \\\n"
1122 " * with a long \\\n"
Alexander Kornienkocb45bc12013-04-15 14:28:00 +00001123 " * line */ \\\n"
Alexander Kornienkoafcef332013-03-19 17:41:36 +00001124 " A + B",
1125 format("#define X \\\n"
1126 " /* Macro comment with a long line */ \\\n"
1127 " A + B",
1128 getLLVMStyleWithColumns(20)));
1129}
1130
Daniel Jasper11cb81c2013-01-17 12:53:34 +00001131TEST_F(FormatTest, CommentsInStaticInitializers) {
1132 EXPECT_EQ(
1133 "static SomeType type = { aaaaaaaaaaaaaaaaaaaa, /* comment */\n"
1134 " aaaaaaaaaaaaaaaaaaaa /* comment */,\n"
1135 " /* comment */ aaaaaaaaaaaaaaaaaaaa,\n"
1136 " aaaaaaaaaaaaaaaaaaaa, // comment\n"
1137 " aaaaaaaaaaaaaaaaaaaa };",
1138 format("static SomeType type = { aaaaaaaaaaaaaaaaaaaa , /* comment */\n"
1139 " aaaaaaaaaaaaaaaaaaaa /* comment */ ,\n"
1140 " /* comment */ aaaaaaaaaaaaaaaaaaaa ,\n"
1141 " aaaaaaaaaaaaaaaaaaaa , // comment\n"
1142 " aaaaaaaaaaaaaaaaaaaa };"));
1143 verifyFormat("static SomeType type = { aaaaaaaaaaa, // comment for aa...\n"
1144 " bbbbbbbbbbb, ccccccccccc };");
1145 verifyFormat("static SomeType type = { aaaaaaaaaaa,\n"
1146 " // comment for bb....\n"
1147 " bbbbbbbbbbb, ccccccccccc };");
1148 verifyGoogleFormat(
Daniel Jaspere5777d22013-05-23 10:15:45 +00001149 "static SomeType type = {aaaaaaaaaaa, // comment for aa...\n"
1150 " bbbbbbbbbbb, ccccccccccc};");
1151 verifyGoogleFormat("static SomeType type = {aaaaaaaaaaa,\n"
1152 " // comment for bb....\n"
1153 " bbbbbbbbbbb, ccccccccccc};");
Daniel Jasper11cb81c2013-01-17 12:53:34 +00001154
Daniel Jasper8a8ce242013-01-31 14:59:26 +00001155 verifyFormat("S s = { { a, b, c }, // Group #1\n"
1156 " { d, e, f }, // Group #2\n"
1157 " { g, h, i } }; // Group #3");
1158 verifyFormat("S s = { { // Group #1\n"
1159 " a, b, c },\n"
1160 " { // Group #2\n"
1161 " d, e, f },\n"
1162 " { // Group #3\n"
1163 " g, h, i } };");
Daniel Jasperdc7d5812013-02-20 12:56:39 +00001164
1165 EXPECT_EQ("S s = {\n"
1166 " // Some comment\n"
Daniel Jasperfb5e2412013-02-26 13:10:34 +00001167 " a,\n"
Daniel Jasperdc7d5812013-02-20 12:56:39 +00001168 "\n"
1169 " // Comment after empty line\n"
1170 " b\n"
Daniel Jasperfb5e2412013-02-26 13:10:34 +00001171 "}",
1172 format("S s = {\n"
1173 " // Some comment\n"
1174 " a,\n"
1175 " \n"
1176 " // Comment after empty line\n"
1177 " b\n"
1178 "}"));
1179 EXPECT_EQ("S s = { a, b };", format("S s = {\n"
Daniel Jasper16b35622013-02-26 13:18:08 +00001180 " a,\n"
1181 "\n"
1182 " b\n"
1183 "};"));
Daniel Jaspera400cab2013-02-28 15:04:12 +00001184 verifyFormat("const uint8_t aaaaaaaaaaaaaaaaaaaaaa[0] = {\n"
1185 " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n"
1186 " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n"
1187 " 0x00, 0x00, 0x00, 0x00 // comment\n"
1188 "};");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001189}
1190
Alexander Kornienkof2e02122013-05-24 18:24:24 +00001191TEST_F(FormatTest, IgnoresIf0Contents) {
1192 EXPECT_EQ("#if 0\n"
1193 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n"
1194 "#endif\n"
1195 "void f() {}",
1196 format("#if 0\n"
1197 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n"
1198 "#endif\n"
1199 "void f( ) { }"));
1200 EXPECT_EQ("#if false\n"
1201 "void f( ) { }\n"
1202 "#endif\n"
1203 "void g() {}\n",
1204 format("#if false\n"
1205 "void f( ) { }\n"
1206 "#endif\n"
1207 "void g( ) { }\n"));
1208 EXPECT_EQ("enum E {\n"
1209 " One,\n"
1210 " Two,\n"
1211 "#if 0\n"
1212 "Three,\n"
1213 " Four,\n"
1214 "#endif\n"
1215 " Five\n"
1216 "};",
1217 format("enum E {\n"
1218 " One,Two,\n"
1219 "#if 0\n"
1220 "Three,\n"
1221 " Four,\n"
1222 "#endif\n"
1223 " Five};"));
1224 EXPECT_EQ("enum F {\n"
1225 " One,\n"
1226 "#if 1\n"
1227 " Two,\n"
1228 "#if 0\n"
1229 "Three,\n"
1230 " Four,\n"
1231 "#endif\n"
1232 " Five\n"
1233 "#endif\n"
1234 "};",
1235 format("enum F {\n"
1236 "One,\n"
1237 "#if 1\n"
1238 "Two,\n"
1239 "#if 0\n"
1240 "Three,\n"
1241 " Four,\n"
1242 "#endif\n"
1243 "Five\n"
1244 "#endif\n"
1245 "};"));
1246 EXPECT_EQ("enum G {\n"
1247 " One,\n"
1248 "#if 0\n"
1249 "Two,\n"
1250 "#else\n"
1251 " Three,\n"
1252 "#endif\n"
1253 " Four\n"
1254 "};",
1255 format("enum G {\n"
1256 "One,\n"
1257 "#if 0\n"
1258 "Two,\n"
1259 "#else\n"
1260 "Three,\n"
1261 "#endif\n"
1262 "Four\n"
1263 "};"));
1264 EXPECT_EQ("enum H {\n"
1265 " One,\n"
1266 "#if 0\n"
1267 "#ifdef Q\n"
1268 "Two,\n"
1269 "#else\n"
1270 "Three,\n"
1271 "#endif\n"
1272 "#endif\n"
1273 " Four\n"
1274 "};",
1275 format("enum H {\n"
1276 "One,\n"
1277 "#if 0\n"
1278 "#ifdef Q\n"
1279 "Two,\n"
1280 "#else\n"
1281 "Three,\n"
1282 "#endif\n"
1283 "#endif\n"
1284 "Four\n"
1285 "};"));
1286 EXPECT_EQ("enum I {\n"
1287 " One,\n"
1288 "#if /* test */ 0 || 1\n"
1289 "Two,\n"
1290 "Three,\n"
1291 "#endif\n"
1292 " Four\n"
1293 "};",
1294 format("enum I {\n"
1295 "One,\n"
1296 "#if /* test */ 0 || 1\n"
1297 "Two,\n"
1298 "Three,\n"
1299 "#endif\n"
1300 "Four\n"
1301 "};"));
1302 EXPECT_EQ("enum J {\n"
1303 " One,\n"
1304 "#if 0\n"
1305 "#if 0\n"
1306 "Two,\n"
1307 "#else\n"
1308 "Three,\n"
1309 "#endif\n"
1310 "Four,\n"
1311 "#endif\n"
1312 " Five\n"
1313 "};",
1314 format("enum J {\n"
1315 "One,\n"
1316 "#if 0\n"
1317 "#if 0\n"
1318 "Two,\n"
1319 "#else\n"
1320 "Three,\n"
1321 "#endif\n"
1322 "Four,\n"
1323 "#endif\n"
1324 "Five\n"
1325 "};"));
1326
1327}
1328
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001329//===----------------------------------------------------------------------===//
1330// Tests for classes, namespaces, etc.
1331//===----------------------------------------------------------------------===//
1332
1333TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) {
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001334 verifyFormat("class A {};");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001335}
1336
1337TEST_F(FormatTest, UnderstandsAccessSpecifiers) {
1338 verifyFormat("class A {\n"
1339 "public:\n"
Daniel Jasperc04baae2013-04-10 09:49:49 +00001340 "public: // comment\n"
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001341 "protected:\n"
1342 "private:\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00001343 " void f() {}\n"
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001344 "};");
1345 verifyGoogleFormat("class A {\n"
1346 " public:\n"
1347 " protected:\n"
1348 " private:\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00001349 " void f() {}\n"
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001350 "};");
1351}
1352
Alexander Kornienkofd433362013-03-27 17:08:02 +00001353TEST_F(FormatTest, SeparatesLogicalBlocks) {
1354 EXPECT_EQ("class A {\n"
1355 "public:\n"
1356 " void f();\n"
1357 "\n"
1358 "private:\n"
1359 " void g() {}\n"
1360 " // test\n"
1361 "protected:\n"
1362 " int h;\n"
1363 "};",
1364 format("class A {\n"
1365 "public:\n"
1366 "void f();\n"
1367 "private:\n"
1368 "void g() {}\n"
1369 "// test\n"
1370 "protected:\n"
1371 "int h;\n"
1372 "};"));
1373}
1374
Daniel Jasper83193602013-04-05 17:22:09 +00001375TEST_F(FormatTest, FormatsClasses) {
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001376 verifyFormat("class A : public B {};");
1377 verifyFormat("class A : public ::B {};");
Daniel Jaspereead02b2013-02-14 08:42:54 +00001378
1379 verifyFormat(
1380 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001381 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
Daniel Jaspera61aefb2013-05-06 06:45:09 +00001382 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
1383 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001384 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
Daniel Jaspereead02b2013-02-14 08:42:54 +00001385 verifyFormat(
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001386 "class A : public B, public C, public D, public E, public F {};");
Daniel Jaspereead02b2013-02-14 08:42:54 +00001387 verifyFormat("class AAAAAAAAAAAA : public B,\n"
1388 " public C,\n"
1389 " public D,\n"
1390 " public E,\n"
1391 " public F,\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001392 " public G {};");
Daniel Jasper83193602013-04-05 17:22:09 +00001393
1394 verifyFormat("class\n"
1395 " ReallyReallyLongClassName {\n};",
1396 getLLVMStyleWithColumns(32));
Daniel Jasperf7935112012-12-03 18:12:45 +00001397}
1398
Manuel Klimek28cacc72013-01-07 18:10:23 +00001399TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) {
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00001400 verifyFormat("class A {\n} a, b;");
1401 verifyFormat("struct A {\n} a, b;");
1402 verifyFormat("union A {\n} a;");
Manuel Klimek28cacc72013-01-07 18:10:23 +00001403}
1404
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001405TEST_F(FormatTest, FormatsEnum) {
Alexander Kornienkob7076a22012-12-04 14:46:19 +00001406 verifyFormat("enum {\n"
1407 " Zero,\n"
1408 " One = 1,\n"
1409 " Two = One + 1,\n"
1410 " Three = (One + Two),\n"
1411 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1412 " Five = (One, Two, Three, Four, 5)\n"
1413 "};");
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001414 verifyFormat("enum Enum {};");
1415 verifyFormat("enum {};");
Manuel Klimek2cec0192013-01-21 19:17:52 +00001416 verifyFormat("enum X E {\n} d;");
1417 verifyFormat("enum __attribute__((...)) E {\n} d;");
1418 verifyFormat("enum __declspec__((...)) E {\n} d;");
1419 verifyFormat("enum X f() {\n a();\n return 42;\n}");
Alexander Kornienkob7076a22012-12-04 14:46:19 +00001420}
1421
Nico Weber7769a902013-01-14 05:49:49 +00001422TEST_F(FormatTest, FormatsBitfields) {
1423 verifyFormat("struct Bitfields {\n"
1424 " unsigned sClass : 8;\n"
1425 " unsigned ValueKind : 2;\n"
1426 "};");
1427}
1428
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001429TEST_F(FormatTest, FormatsNamespaces) {
1430 verifyFormat("namespace some_namespace {\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001431 "class A {};\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00001432 "void f() { f(); }\n"
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001433 "}");
1434 verifyFormat("namespace {\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001435 "class A {};\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00001436 "void f() { f(); }\n"
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001437 "}");
Dmitri Gribenko58d64e22012-12-30 21:27:25 +00001438 verifyFormat("inline namespace X {\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001439 "class A {};\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00001440 "void f() { f(); }\n"
Dmitri Gribenko58d64e22012-12-30 21:27:25 +00001441 "}");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001442 verifyFormat("using namespace some_namespace;\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001443 "class A {};\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00001444 "void f() { f(); }");
Manuel Klimek046b9302013-02-06 16:08:09 +00001445
1446 // This code is more common than we thought; if we
1447 // layout this correctly the semicolon will go into
1448 // its own line, which is undesireable.
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001449 verifyFormat("namespace {};");
Manuel Klimek046b9302013-02-06 16:08:09 +00001450 verifyFormat("namespace {\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001451 "class A {};\n"
Manuel Klimek046b9302013-02-06 16:08:09 +00001452 "};");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001453}
1454
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001455TEST_F(FormatTest, FormatsExternC) { verifyFormat("extern \"C\" {\nint a;"); }
Manuel Klimekae610d12013-01-21 14:32:05 +00001456
Daniel Jasper40aacf42013-03-14 13:45:21 +00001457TEST_F(FormatTest, FormatsInlineASM) {
1458 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));");
1459 verifyFormat(
1460 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
1461 " \"cpuid\\n\\t\"\n"
1462 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
Daniel Jasper5dad58e2013-05-15 07:51:51 +00001463 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n"
Daniel Jasper40aacf42013-03-14 13:45:21 +00001464 " : \"a\"(value));");
1465}
1466
Nico Weberd5650bd2013-01-07 16:36:17 +00001467TEST_F(FormatTest, FormatTryCatch) {
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00001468 // FIXME: Handle try-catch explicitly in the UnwrappedLineParser, then we'll
1469 // also not create single-line-blocks.
Nico Weberd5650bd2013-01-07 16:36:17 +00001470 verifyFormat("try {\n"
1471 " throw a * b;\n"
1472 "}\n"
1473 "catch (int a) {\n"
1474 " // Do nothing.\n"
1475 "}\n"
1476 "catch (...) {\n"
1477 " exit(42);\n"
1478 "}");
1479
1480 // Function-level try statements.
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00001481 verifyFormat("int f() try { return 4; }\n"
Nico Weberd5650bd2013-01-07 16:36:17 +00001482 "catch (...) {\n"
1483 " return 5;\n"
1484 "}");
1485 verifyFormat("class A {\n"
1486 " int a;\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00001487 " A() try : a(0) {}\n"
Nico Weberd5650bd2013-01-07 16:36:17 +00001488 " catch (...) {\n"
1489 " throw;\n"
1490 " }\n"
1491 "};\n");
1492}
1493
1494TEST_F(FormatTest, FormatObjCTryCatch) {
Manuel Klimek2acb7b72013-01-11 19:17:44 +00001495 verifyFormat("@try {\n"
1496 " f();\n"
1497 "}\n"
1498 "@catch (NSException e) {\n"
1499 " @throw;\n"
1500 "}\n"
1501 "@finally {\n"
1502 " exit(42);\n"
1503 "}");
Nico Weberd5650bd2013-01-07 16:36:17 +00001504}
1505
Daniel Jaspere25509f2012-12-17 11:29:41 +00001506TEST_F(FormatTest, StaticInitializers) {
1507 verifyFormat("static SomeClass SC = { 1, 'a' };");
1508
Daniel Jaspere25509f2012-12-17 11:29:41 +00001509 verifyFormat(
Daniel Jasper206df732013-01-07 13:08:40 +00001510 "static SomeClass WithALoooooooooooooooooooongName = {\n"
Manuel Klimek0ddd57a2013-01-10 15:58:26 +00001511 " 100000000, \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
1512 "};");
1513
1514 verifyFormat(
1515 "static SomeClass = { a, b, c, d, e, f, g, h, i, j,\n"
1516 " looooooooooooooooooooooooooooooooooongname,\n"
1517 " looooooooooooooooooooooooooooooong };");
Daniel Jasper8a8ce242013-01-31 14:59:26 +00001518 // Allow bin-packing in static initializers as this would often lead to
1519 // terrible results, e.g.:
1520 verifyGoogleFormat(
Daniel Jaspere5777d22013-05-23 10:15:45 +00001521 "static SomeClass = {a, b, c, d, e, f, g, h, i, j,\n"
1522 " looooooooooooooooooooooooooooooooooongname,\n"
1523 " looooooooooooooooooooooooooooooong};");
Daniel Jasper473c62c2013-05-17 09:35:01 +00001524 // Here, everything other than the "}" would fit on a line.
1525 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
1526 " 100000000000000000000000\n"
1527 "};");
1528
1529 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first
1530 // line. However, the formatting looks a bit off and this probably doesn't
1531 // happen often in practice.
1532 verifyFormat("static int Variable[1] = {\n"
1533 " { 1000000000000000000000000000000000000 }\n"
1534 "};",
1535 getLLVMStyleWithColumns(40));
Daniel Jaspere25509f2012-12-17 11:29:41 +00001536}
1537
Daniel Jasperbca4bbe2013-05-28 11:30:49 +00001538TEST_F(FormatTest, DesignatedInitializers) {
1539 verifyFormat("const struct A a = { .a = 1, .b = 2 };");
1540 verifyFormat("const struct A a = { .aaaaaaaaaa = 1,\n"
1541 " .bbbbbbbbbb = 2,\n"
1542 " .cccccccccc = 3,\n"
1543 " .dddddddddd = 4,\n"
1544 " .eeeeeeeeee = 5 };");
1545 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
1546 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n"
1547 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n"
1548 " .ccccccccccccccccccccccccccc = 3,\n"
1549 " .ddddddddddddddddddddddddddd = 4,\n"
1550 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5\n"
1551 "};");
1552
1553 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};");
1554}
1555
Manuel Klimeka54d1a92013-01-14 16:41:43 +00001556TEST_F(FormatTest, NestedStaticInitializers) {
1557 verifyFormat("static A x = { { {} } };\n");
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001558 verifyFormat("static A x = { { { init1, init2, init3, init4 },\n"
1559 " { init1, init2, init3, init4 } } };");
Daniel Jasper9278eb92013-01-16 14:59:02 +00001560
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001561 verifyFormat("somes Status::global_reps[3] = {\n"
1562 " { kGlobalRef, OK_CODE, NULL, NULL, NULL },\n"
1563 " { kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL },\n"
1564 " { kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL }\n"
1565 "};");
Daniel Jaspere5777d22013-05-23 10:15:45 +00001566 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n"
1567 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
1568 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
1569 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001570 "};");
Manuel Klimeka54d1a92013-01-14 16:41:43 +00001571 verifyFormat(
1572 "CGRect cg_rect = { { rect.fLeft, rect.fTop },\n"
1573 " { rect.fRight - rect.fLeft, rect.fBottom - rect.fTop"
1574 " } };");
1575
Daniel Jasper8a8ce242013-01-31 14:59:26 +00001576 verifyFormat(
1577 "SomeArrayOfSomeType a = { { { 1, 2, 3 }, { 1, 2, 3 },\n"
1578 " { 111111111111111111111111111111,\n"
1579 " 222222222222222222222222222222,\n"
1580 " 333333333333333333333333333333 },\n"
1581 " { 1, 2, 3 }, { 1, 2, 3 } } };");
Daniel Jasper1ca05cc2013-02-03 18:07:15 +00001582 verifyFormat(
1583 "SomeArrayOfSomeType a = { { { 1, 2, 3 } }, { { 1, 2, 3 } },\n"
1584 " { { 111111111111111111111111111111,\n"
1585 " 222222222222222222222222222222,\n"
1586 " 333333333333333333333333333333 } },\n"
1587 " { { 1, 2, 3 } }, { { 1, 2, 3 } } };");
Daniel Jaspere5777d22013-05-23 10:15:45 +00001588 verifyGoogleFormat(
1589 "SomeArrayOfSomeType a = {{{1, 2, 3}}, {{1, 2, 3}},\n"
1590 " {{111111111111111111111111111111,\n"
1591 " 222222222222222222222222222222,\n"
1592 " 333333333333333333333333333333}},\n"
1593 " {{1, 2, 3}}, {{1, 2, 3}}};");
Daniel Jasper8a8ce242013-01-31 14:59:26 +00001594
Nico Weber250fe712013-01-18 02:43:57 +00001595 // FIXME: We might at some point want to handle this similar to parameter
Manuel Klimeka54d1a92013-01-14 16:41:43 +00001596 // lists, where we have an option to put each on a single line.
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001597 verifyFormat(
1598 "struct {\n"
1599 " unsigned bit;\n"
1600 " const char *const name;\n"
1601 "} kBitsToOs[] = { { kOsMac, \"Mac\" }, { kOsWin, \"Windows\" },\n"
1602 " { kOsLinux, \"Linux\" }, { kOsCrOS, \"Chrome OS\" } };");
Manuel Klimeka54d1a92013-01-14 16:41:43 +00001603}
1604
Manuel Klimeka71e5d82013-01-02 16:30:12 +00001605TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) {
1606 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("
1607 " \\\n"
1608 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)");
1609}
1610
Daniel Jasperda16db32013-01-07 10:48:50 +00001611TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) {
Daniel Jaspera628c982013-04-03 13:36:17 +00001612 verifyFormat(
Daniel Jasper6728fc12013-04-11 14:29:13 +00001613 "virtual void write(ELFWriter *writerrr,\n"
1614 " OwningPtr<FileOutputBuffer> &buffer) = 0;");
Daniel Jasperda16db32013-01-07 10:48:50 +00001615}
1616
Manuel Klimek591b5802013-01-31 15:58:48 +00001617TEST_F(FormatTest, LayoutUnknownPPDirective) {
1618 EXPECT_EQ("#123 \"A string literal\"",
1619 format(" # 123 \"A string literal\""));
1620 EXPECT_EQ("#;", format("#;"));
Manuel Klimek78725712013-01-07 10:03:37 +00001621 verifyFormat("#\n;\n;\n;");
Manuel Klimeka71e5d82013-01-02 16:30:12 +00001622}
1623
1624TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) {
1625 EXPECT_EQ("#line 42 \"test\"\n",
1626 format("# \\\n line \\\n 42 \\\n \"test\"\n"));
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001627 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n",
1628 getLLVMStyleWithColumns(12)));
Manuel Klimeka71e5d82013-01-02 16:30:12 +00001629}
1630
1631TEST_F(FormatTest, EndOfFileEndsPPDirective) {
1632 EXPECT_EQ("#line 42 \"test\"",
1633 format("# \\\n line \\\n 42 \\\n \"test\""));
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001634 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B"));
Manuel Klimeka71e5d82013-01-02 16:30:12 +00001635}
1636
Manuel Klimekb69e3c62013-01-02 18:33:23 +00001637TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {
Daniel Jasperc22f5b42013-02-28 11:05:57 +00001638 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
1639 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12));
Manuel Klimekb69e3c62013-01-02 18:33:23 +00001640 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12));
Daniel Jasperc22f5b42013-02-28 11:05:57 +00001641 // FIXME: We never break before the macro name.
1642 verifyFormat("#define AA(\\\n B)", getLLVMStyleWithColumns(12));
Daniel Jasper39825ea2013-01-14 15:40:57 +00001643
1644 verifyFormat("#define A A\n#define A A");
1645 verifyFormat("#define A(X) A\n#define A A");
1646
Daniel Jasperc22f5b42013-02-28 11:05:57 +00001647 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
1648 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22));
Manuel Klimekb69e3c62013-01-02 18:33:23 +00001649}
1650
1651TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {
Alexander Kornienkoefd98382013-03-28 18:40:55 +00001652 EXPECT_EQ("// somecomment\n"
Manuel Klimek1abf7892013-01-04 23:34:14 +00001653 "#include \"a.h\"\n"
Daniel Jasperc22f5b42013-02-28 11:05:57 +00001654 "#define A( \\\n"
1655 " A, B)\n"
Manuel Klimek1abf7892013-01-04 23:34:14 +00001656 "#include \"b.h\"\n"
Alexander Kornienkoffd6d042013-03-27 11:52:18 +00001657 "// somecomment\n",
Alexander Kornienkoefd98382013-03-28 18:40:55 +00001658 format(" // somecomment\n"
Manuel Klimek1abf7892013-01-04 23:34:14 +00001659 " #include \"a.h\"\n"
1660 "#define A(A,\\\n"
1661 " B)\n"
1662 " #include \"b.h\"\n"
Alexander Kornienkoffd6d042013-03-27 11:52:18 +00001663 " // somecomment\n",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001664 getLLVMStyleWithColumns(13)));
Manuel Klimekb69e3c62013-01-02 18:33:23 +00001665}
1666
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001667TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
Manuel Klimek1abf7892013-01-04 23:34:14 +00001668
1669TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
1670 EXPECT_EQ("#define A \\\n"
1671 " c; \\\n"
1672 " e;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001673 "f;",
1674 format("#define A c; e;\n"
1675 "f;",
1676 getLLVMStyleWithColumns(14)));
Manuel Klimek1abf7892013-01-04 23:34:14 +00001677}
1678
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001679TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
Manuel Klimek1abf7892013-01-04 23:34:14 +00001680
Daniel Jasper1cb530f2013-05-10 13:00:49 +00001681TEST_F(FormatTest, AlwaysFormatsEntireMacroDefinitions) {
1682 EXPECT_EQ("int i;\n"
1683 "#define A \\\n"
1684 " int i; \\\n"
1685 " int j\n"
1686 "int k;",
1687 format("int i;\n"
1688 "#define A \\\n"
1689 " int i ; \\\n"
1690 " int j\n"
1691 "int k;",
1692 8, 0, getGoogleStyle())); // 8: position of "#define".
1693 EXPECT_EQ("int i;\n"
1694 "#define A \\\n"
1695 " int i; \\\n"
1696 " int j\n"
1697 "int k;",
1698 format("int i;\n"
1699 "#define A \\\n"
1700 " int i ; \\\n"
1701 " int j\n"
1702 "int k;",
1703 45, 0, getGoogleStyle())); // 45: position of "j".
Manuel Klimek1abf7892013-01-04 23:34:14 +00001704}
1705
1706TEST_F(FormatTest, MacroDefinitionInsideStatement) {
Manuel Klimek52b15152013-01-09 15:25:02 +00001707 EXPECT_EQ("int x,\n"
1708 "#define A\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001709 " y;",
1710 format("int x,\n#define A\ny;"));
Manuel Klimek1abf7892013-01-04 23:34:14 +00001711}
1712
Manuel Klimek09e07972013-01-05 21:34:55 +00001713TEST_F(FormatTest, HashInMacroDefinition) {
1714 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11));
1715 verifyFormat("#define A \\\n"
1716 " { \\\n"
1717 " f(#c);\\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001718 " }",
1719 getLLVMStyleWithColumns(11));
Daniel Jasper4f397152013-01-08 16:17:54 +00001720
1721 verifyFormat("#define A(X) \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001722 " void function##X()",
1723 getLLVMStyleWithColumns(22));
Daniel Jasper4f397152013-01-08 16:17:54 +00001724
1725 verifyFormat("#define A(a, b, c) \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001726 " void a##b##c()",
1727 getLLVMStyleWithColumns(22));
Daniel Jasper4f397152013-01-08 16:17:54 +00001728
Daniel Jasper39825ea2013-01-14 15:40:57 +00001729 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
Manuel Klimek09e07972013-01-05 21:34:55 +00001730}
1731
Manuel Klimekd053c5b2013-01-23 14:37:36 +00001732TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) {
1733 verifyFormat("#define A (1)");
1734}
1735
Manuel Klimek0c137952013-02-11 12:33:24 +00001736TEST_F(FormatTest, EmptyLinesInMacroDefinitions) {
1737 EXPECT_EQ("#define A b;", format("#define A \\\n"
1738 " \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001739 " b;",
1740 getLLVMStyleWithColumns(25)));
Manuel Klimek0c137952013-02-11 12:33:24 +00001741 EXPECT_EQ("#define A \\\n"
1742 " \\\n"
1743 " a; \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001744 " b;",
1745 format("#define A \\\n"
1746 " \\\n"
1747 " a; \\\n"
1748 " b;",
1749 getLLVMStyleWithColumns(11)));
Manuel Klimek0c137952013-02-11 12:33:24 +00001750 EXPECT_EQ("#define A \\\n"
1751 " a; \\\n"
1752 " \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001753 " b;",
1754 format("#define A \\\n"
1755 " a; \\\n"
1756 " \\\n"
1757 " b;",
1758 getLLVMStyleWithColumns(11)));
Manuel Klimek0c137952013-02-11 12:33:24 +00001759}
1760
Daniel Jasper00475962013-02-19 17:14:38 +00001761TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
Daniel Jasper850677d2013-03-18 12:50:26 +00001762 verifyFormat("#define A :");
Daniel Jasper00475962013-02-19 17:14:38 +00001763 verifyFormat("#define SOMECASES \\\n"
Daniel Jaspera1275122013-03-20 10:23:53 +00001764 " case 1: \\\n"
Daniel Jasper00475962013-02-19 17:14:38 +00001765 " case 2\n",
1766 getLLVMStyleWithColumns(20));
Daniel Jasper00475962013-02-19 17:14:38 +00001767 verifyFormat("#define A template <typename T>");
Daniel Jasper6db1b7c2013-02-19 20:05:41 +00001768 verifyFormat("#define STR(x) #x\n"
1769 "f(STR(this_is_a_string_literal{));");
Daniel Jasper00475962013-02-19 17:14:38 +00001770}
1771
Daniel Jasper40e19212013-05-29 13:16:10 +00001772TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) {
1773 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
1774 EXPECT_EQ("class A : public QObject {\n"
1775 " Q_OBJECT\n"
1776 "\n"
1777 " A() {}\n"
1778 "};",
1779 format("class A : public QObject {\n"
1780 " Q_OBJECT\n"
1781 "\n"
1782 " A() {\n}\n"
1783 "} ;"));
Daniel Jasper41a0f782013-05-29 14:09:17 +00001784 EXPECT_EQ("SOME_MACRO\n"
1785 "namespace {\n"
1786 "void f();\n"
1787 "}",
1788 format("SOME_MACRO\n"
1789 " namespace {\n"
1790 "void f( );\n"
1791 "}"));
Daniel Jasper40e19212013-05-29 13:16:10 +00001792 // Only if the identifier contains at least 5 characters.
1793 EXPECT_EQ("HTTP f();",
1794 format("HTTP\nf();"));
1795 EXPECT_EQ("MACRO\nf();",
1796 format("MACRO\nf();"));
1797 // Only if everything is upper case.
1798 EXPECT_EQ("class A : public QObject {\n"
1799 " Q_Object A() {}\n"
1800 "};",
1801 format("class A : public QObject {\n"
1802 " Q_Object\n"
1803 "\n"
1804 " A() {\n}\n"
1805 "} ;"));
1806}
1807
Alexander Kornienkode644272013-04-08 22:16:06 +00001808TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) {
1809 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
1810 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
1811 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00001812 "class X {};\n"
Alexander Kornienkode644272013-04-08 22:16:06 +00001813 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
1814 "int *createScopDetectionPass() { return 0; }",
1815 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
1816 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
1817 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
1818 " class X {};\n"
1819 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
1820 " int *createScopDetectionPass() { return 0; }"));
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +00001821 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as
1822 // braces, so that inner block is indented one level more.
1823 EXPECT_EQ("int q() {\n"
1824 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
1825 " IPC_MESSAGE_HANDLER(xxx, qqq)\n"
1826 " IPC_END_MESSAGE_MAP()\n"
1827 "}",
1828 format("int q() {\n"
1829 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
1830 " IPC_MESSAGE_HANDLER(xxx, qqq)\n"
1831 " IPC_END_MESSAGE_MAP()\n"
1832 "}"));
1833 EXPECT_EQ("int q() {\n"
1834 " f(x);\n"
1835 " f(x) {}\n"
1836 " f(x)->g();\n"
1837 " f(x)->*g();\n"
1838 " f(x).g();\n"
1839 " f(x) = x;\n"
1840 " f(x) += x;\n"
1841 " f(x) -= x;\n"
1842 " f(x) *= x;\n"
1843 " f(x) /= x;\n"
1844 " f(x) %= x;\n"
1845 " f(x) &= x;\n"
1846 " f(x) |= x;\n"
1847 " f(x) ^= x;\n"
1848 " f(x) >>= x;\n"
1849 " f(x) <<= x;\n"
1850 " f(x)[y].z();\n"
1851 " LOG(INFO) << x;\n"
1852 " ifstream(x) >> x;\n"
1853 "}\n",
1854 format("int q() {\n"
1855 " f(x)\n;\n"
1856 " f(x)\n {}\n"
1857 " f(x)\n->g();\n"
1858 " f(x)\n->*g();\n"
1859 " f(x)\n.g();\n"
1860 " f(x)\n = x;\n"
1861 " f(x)\n += x;\n"
1862 " f(x)\n -= x;\n"
1863 " f(x)\n *= x;\n"
1864 " f(x)\n /= x;\n"
1865 " f(x)\n %= x;\n"
1866 " f(x)\n &= x;\n"
1867 " f(x)\n |= x;\n"
1868 " f(x)\n ^= x;\n"
1869 " f(x)\n >>= x;\n"
1870 " f(x)\n <<= x;\n"
1871 " f(x)\n[y].z();\n"
1872 " LOG(INFO)\n << x;\n"
1873 " ifstream(x)\n >> x;\n"
1874 "}\n"));
1875 EXPECT_EQ("int q() {\n"
1876 " f(x)\n"
1877 " if (1) {\n"
1878 " }\n"
1879 " f(x)\n"
1880 " while (1) {\n"
1881 " }\n"
1882 " f(x)\n"
1883 " g(x);\n"
1884 " f(x)\n"
1885 " try {\n"
1886 " q();\n"
1887 " }\n"
1888 " catch (...) {\n"
1889 " }\n"
1890 "}\n",
1891 format("int q() {\n"
1892 "f(x)\n"
1893 "if (1) {}\n"
1894 "f(x)\n"
1895 "while (1) {}\n"
1896 "f(x)\n"
1897 "g(x);\n"
1898 "f(x)\n"
1899 "try { q(); } catch (...) {}\n"
1900 "}\n"));
1901 EXPECT_EQ("class A {\n"
1902 " A() : t(0) {}\n"
1903 " A(X x)\n" // FIXME: function-level try blocks are broken.
1904 " try : t(0) {\n"
1905 " }\n"
1906 " catch (...) {\n"
1907 " }\n"
1908 "};",
1909 format("class A {\n"
1910 " A()\n : t(0) {}\n"
1911 " A(X x)\n"
1912 " try : t(0) {} catch (...) {}\n"
1913 "};"));
Alexander Kornienkode644272013-04-08 22:16:06 +00001914}
1915
Manuel Klimek4fe43002013-05-22 12:51:29 +00001916TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) {
1917 verifyFormat("#define A \\\n"
1918 " f({ \\\n"
1919 " g(); \\\n"
1920 " });", getLLVMStyleWithColumns(11));
1921}
1922
Manuel Klimekef2cfb12013-01-05 22:14:16 +00001923TEST_F(FormatTest, IndentPreprocessorDirectivesAtZero) {
1924 EXPECT_EQ("{\n {\n#define A\n }\n}", format("{{\n#define A\n}}"));
1925}
1926
Manuel Klimek52d0fd82013-01-05 22:56:06 +00001927TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) {
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00001928 verifyFormat("{\n { a #c; }\n}");
Manuel Klimek52d0fd82013-01-05 22:56:06 +00001929}
1930
Manuel Klimek1058d982013-01-06 20:07:31 +00001931TEST_F(FormatTest, FormatUnbalancedStructuralElements) {
1932 EXPECT_EQ("#define A \\\n { \\\n {\nint i;",
1933 format("#define A { {\nint i;", getLLVMStyleWithColumns(11)));
1934 EXPECT_EQ("#define A \\\n } \\\n }\nint i;",
1935 format("#define A } }\nint i;", getLLVMStyleWithColumns(11)));
1936}
Manuel Klimek1abf7892013-01-04 23:34:14 +00001937
Alexander Kornienkoee4ca9b2013-06-07 17:45:07 +00001938TEST_F(FormatTest, EscapedNewlineAtStartOfToken) {
Daniel Jasper8d1832e2013-01-07 13:26:07 +00001939 EXPECT_EQ(
1940 "#define A \\\n int i; \\\n int j;",
1941 format("#define A \\\nint i;\\\n int j;", getLLVMStyleWithColumns(11)));
Alexander Kornienkoee4ca9b2013-06-07 17:45:07 +00001942 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
Manuel Klimekef920692013-01-07 07:56:50 +00001943}
1944
Manuel Klimek38ba11e2013-01-07 09:24:17 +00001945TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) {
1946 verifyFormat("#define A \\\n"
1947 " int v( \\\n"
1948 " a); \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001949 " int i;",
1950 getLLVMStyleWithColumns(11));
Manuel Klimek38ba11e2013-01-07 09:24:17 +00001951}
1952
Manuel Klimeka71e5d82013-01-02 16:30:12 +00001953TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) {
Manuel Klimek1abf7892013-01-04 23:34:14 +00001954 EXPECT_EQ(
1955 "#define ALooooooooooooooooooooooooooooooooooooooongMacro("
1956 " \\\n"
1957 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
1958 "\n"
1959 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
1960 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n",
1961 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro("
1962 "\\\n"
1963 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
1964 " \n"
1965 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
1966 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n"));
Manuel Klimeka71e5d82013-01-02 16:30:12 +00001967}
1968
Manuel Klimek52b15152013-01-09 15:25:02 +00001969TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {
1970 EXPECT_EQ("int\n"
1971 "#define A\n"
Daniel Jasper8e357692013-05-06 08:27:33 +00001972 " a;",
Manuel Klimek52b15152013-01-09 15:25:02 +00001973 format("int\n#define A\na;"));
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001974 verifyFormat("functionCallTo(\n"
1975 " someOtherFunction(\n"
1976 " withSomeParameters, whichInSequence,\n"
1977 " areLongerThanALine(andAnotherCall,\n"
1978 "#define A B\n"
1979 " withMoreParamters,\n"
1980 " whichStronglyInfluenceTheLayout),\n"
Daniel Jasper37905f72013-02-21 15:00:29 +00001981 " andMoreParameters),\n"
1982 " trailing);",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001983 getLLVMStyleWithColumns(69));
Manuel Klimek52b15152013-01-09 15:25:02 +00001984}
1985
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00001986TEST_F(FormatTest, LayoutBlockInsideParens) {
1987 EXPECT_EQ("functionCall({\n"
1988 " int i;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00001989 "});",
1990 format(" functionCall ( {int i;} );"));
Daniel Jasper393564f2013-05-31 14:56:29 +00001991
1992 // FIXME: This is bad, find a better and more generic solution.
1993 EXPECT_EQ("functionCall({\n"
1994 " int i;\n"
1995 "},\n"
1996 " aaaa, bbbb, cccc);",
1997 format(" functionCall ( {int i;}, aaaa, bbbb, cccc);"));
1998 verifyFormat(
1999 "Aaa({\n"
2000 " int i;\n"
2001 "},\n"
2002 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
2003 " ccccccccccccccccc));");
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00002004}
2005
2006TEST_F(FormatTest, LayoutBlockInsideStatement) {
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00002007 EXPECT_EQ("SOME_MACRO { int i; }\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002008 "int i;",
2009 format(" SOME_MACRO {int i;} int i;"));
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00002010}
2011
2012TEST_F(FormatTest, LayoutNestedBlocks) {
2013 verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
2014 " struct s {\n"
2015 " int i;\n"
2016 " };\n"
2017 " s kBitsToOs[] = { { 10 } };\n"
2018 " for (int i = 0; i < 10; ++i)\n"
2019 " return;\n"
2020 "}");
2021}
2022
Manuel Klimeke7d10a12013-01-10 13:24:24 +00002023TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) {
2024 EXPECT_EQ("{}", format("{}"));
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00002025 verifyFormat("enum E {};");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00002026 verifyFormat("enum E {}");
Manuel Klimeke7d10a12013-01-10 13:24:24 +00002027}
2028
Alexander Kornienko578fdd82012-12-06 18:03:27 +00002029//===----------------------------------------------------------------------===//
2030// Line break tests.
2031//===----------------------------------------------------------------------===//
2032
Alexander Kornienko578fdd82012-12-06 18:03:27 +00002033TEST_F(FormatTest, FormatsAwesomeMethodCall) {
2034 verifyFormat(
Daniel Jasper7b5773e92013-01-28 07:35:34 +00002035 "SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n"
2036 " parameter, parameter, parameter)),\n"
Daniel Jasper6d822722012-12-24 16:43:00 +00002037 " SecondLongCall(parameter));");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00002038}
2039
Daniel Jasper20b09ef2013-01-28 09:35:24 +00002040TEST_F(FormatTest, PreventConfusingIndents) {
Daniel Jasper7b5773e92013-01-28 07:35:34 +00002041 verifyFormat(
2042 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2043 " aaaaaaaaaaaaaaaaaaaaaaaa(\n"
2044 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
2045 " aaaaaaaaaaaaaaaaaaaaaaaa);");
2046 verifyFormat(
2047 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[\n"
2048 " aaaaaaaaaaaaaaaaaaaaaaaa[\n"
2049 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa],\n"
2050 " aaaaaaaaaaaaaaaaaaaaaaaa];");
2051 verifyFormat(
2052 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
2053 " aaaaaaaaaaaaaaaaaaaaaaaa<\n"
2054 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n"
2055 " aaaaaaaaaaaaaaaaaaaaaaaa>;");
Daniel Jasper20b09ef2013-01-28 09:35:24 +00002056 verifyFormat("int a = bbbb && ccc && fffff(\n"
2057 "#define A Just forcing a new line\n"
2058 " ddd);");
Daniel Jasper7b5773e92013-01-28 07:35:34 +00002059}
2060
Daniel Jasperd69fc772013-05-08 14:12:04 +00002061TEST_F(FormatTest, LineBreakingInBinaryExpressions) {
2062 verifyFormat(
2063 "bool aaaaaaa =\n"
2064 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n"
2065 " bbbbbbbb();");
2066 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
2067 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n"
2068 " ccccccccc == ddddddddddd;");
2069
2070 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
2071 " aaaaaa) &&\n"
2072 " bbbbbb && cccccc;");
Daniel Jasper9f82df22013-05-28 07:42:44 +00002073 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
2074 " aaaaaa) >>\n"
2075 " bbbbbb;");
Daniel Jasperd69fc772013-05-08 14:12:04 +00002076 verifyFormat("Whitespaces.addUntouchableComment(\n"
2077 " SourceMgr.getSpellingColumnNumber(\n"
2078 " TheLine.Last->FormatTok.Tok.getLocation()) -\n"
2079 " 1);");
Daniel Jasper571f1af2013-05-14 20:39:56 +00002080
Daniel Jasper68d888c2013-06-03 08:42:05 +00002081 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
2082 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n"
2083 " cccccc) {\n}");
2084
Daniel Jasper571f1af2013-05-14 20:39:56 +00002085 FormatStyle OnePerLine = getLLVMStyle();
2086 OnePerLine.BinPackParameters = false;
2087 verifyFormat(
2088 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
2089 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
2090 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}",
2091 OnePerLine);
Daniel Jasperd69fc772013-05-08 14:12:04 +00002092}
2093
Daniel Jasper6bee6822013-04-08 20:33:42 +00002094TEST_F(FormatTest, ExpressionIndentation) {
2095 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2096 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2097 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2098 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2099 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
2100 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n"
2101 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2102 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n"
2103 " ccccccccccccccccccccccccccccccccccccccccc;");
2104 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2105 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2106 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2107 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
2108 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2109 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2110 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2111 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
2112 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
2113 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
2114 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2115 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
Daniel Jasper6dcecb62013-06-06 09:11:58 +00002116 verifyFormat("if () {\n"
2117 "} else if (aaaaa && bbbbb > // break\n"
2118 " ccccc) {\n"
2119 "}");
Daniel Jasper6bee6822013-04-08 20:33:42 +00002120}
2121
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00002122TEST_F(FormatTest, ConstructorInitializers) {
Manuel Klimeke7d10a12013-01-10 13:24:24 +00002123 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
Daniel Jasper2408a8c2013-01-11 11:37:55 +00002124 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
2125 getLLVMStyleWithColumns(45));
Daniel Jasper12ef4e52013-02-21 21:33:55 +00002126 verifyFormat("Constructor()\n"
2127 " : Inttializer(FitsOnTheLine) {}",
Daniel Jasper2408a8c2013-01-11 11:37:55 +00002128 getLLVMStyleWithColumns(44));
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00002129 verifyFormat("Constructor()\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00002130 " : Inttializer(FitsOnTheLine) {}",
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00002131 getLLVMStyleWithColumns(43));
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00002132
2133 verifyFormat(
2134 "SomeClass::Constructor()\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00002135 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00002136
2137 verifyFormat(
2138 "SomeClass::Constructor()\n"
Daniel Jasper2408a8c2013-01-11 11:37:55 +00002139 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00002140 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}");
Daniel Jasper2408a8c2013-01-11 11:37:55 +00002141 verifyFormat(
2142 "SomeClass::Constructor()\n"
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00002143 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00002144 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00002145
2146 verifyFormat("Constructor()\n"
2147 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
2148 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2149 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00002150 " aaaaaaaaaaaaaaaaaaaaaaa() {}");
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00002151
Daniel Jasper65585ed2013-01-28 13:31:35 +00002152 verifyFormat("Constructor()\n"
2153 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00002154 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasper65585ed2013-01-28 13:31:35 +00002155
Daniel Jasper62e68172013-02-25 15:59:54 +00002156 verifyFormat("Constructor(int Parameter = 0)\n"
2157 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
2158 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}");
2159
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00002160 // Here a line could be saved by splitting the second initializer onto two
2161 // lines, but that is not desireable.
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00002162 verifyFormat("Constructor()\n"
2163 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
2164 " aaaaaaaaaaa(aaaaaaaaaaa),\n"
2165 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00002166
Daniel Jasper23e8e0c2013-02-15 16:49:44 +00002167 FormatStyle OnePerLine = getLLVMStyle();
2168 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
2169 verifyFormat("SomeClass::Constructor()\n"
2170 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
2171 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00002172 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002173 OnePerLine);
Daniel Jasper23e8e0c2013-02-15 16:49:44 +00002174 verifyFormat("SomeClass::Constructor()\n"
2175 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
2176 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00002177 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002178 OnePerLine);
Daniel Jasper23e8e0c2013-02-15 16:49:44 +00002179 verifyFormat("MyClass::MyClass(int var)\n"
2180 " : some_var_(var), // 4 space indent\n"
2181 " some_other_var_(var + 1) { // lined up\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002182 "}",
2183 OnePerLine);
Daniel Jasperead41b62013-02-28 09:39:12 +00002184 verifyFormat("Constructor()\n"
2185 " : aaaaa(aaaaaa),\n"
2186 " aaaaa(aaaaaa),\n"
2187 " aaaaa(aaaaaa),\n"
2188 " aaaaa(aaaaaa),\n"
2189 " aaaaa(aaaaaa) {}",
2190 OnePerLine);
Daniel Jaspercc960fa2013-04-22 07:59:53 +00002191 verifyFormat("Constructor()\n"
2192 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
2193 " aaaaaaaaaaaaaaaaaaaaaa) {}",
2194 OnePerLine);
Daniel Jaspere3c0e012013-04-25 13:31:51 +00002195}
2196
2197TEST_F(FormatTest, MemoizationTests) {
2198 // This breaks if the memoization lookup does not take \c Indent and
2199 // \c LastSpace into account.
2200 verifyFormat(
2201 "extern CFRunLoopTimerRef\n"
2202 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
2203 " CFTimeInterval interval, CFOptionFlags flags,\n"
2204 " CFIndex order, CFRunLoopTimerCallBack callout,\n"
Daniel Jasper8e357692013-05-06 08:27:33 +00002205 " CFRunLoopTimerContext *context) {}");
Daniel Jaspere3c0e012013-04-25 13:31:51 +00002206
2207 // Deep nesting somewhat works around our memoization.
2208 verifyFormat(
2209 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
2210 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
2211 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
2212 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
2213 " aaaaa())))))))))))))))))))))))))))))))))))))));",
2214 getLLVMStyleWithColumns(65));
Daniel Jaspercc3044c2013-05-13 09:19:24 +00002215 verifyFormat(
2216 "aaaaa(\n"
2217 " aaaaa,\n"
2218 " aaaaa(\n"
2219 " aaaaa,\n"
2220 " aaaaa(\n"
2221 " aaaaa,\n"
2222 " aaaaa(\n"
2223 " aaaaa,\n"
2224 " aaaaa(\n"
2225 " aaaaa,\n"
2226 " aaaaa(\n"
2227 " aaaaa,\n"
2228 " aaaaa(\n"
2229 " aaaaa,\n"
2230 " aaaaa(\n"
2231 " aaaaa,\n"
2232 " aaaaa(\n"
2233 " aaaaa,\n"
2234 " aaaaa(\n"
2235 " aaaaa,\n"
2236 " aaaaa(\n"
2237 " aaaaa,\n"
2238 " aaaaa(\n"
2239 " aaaaa,\n"
2240 " aaaaa))))))))))));",
2241 getLLVMStyleWithColumns(65));
Daniel Jasperf8114cf2013-05-22 05:27:42 +00002242 verifyFormat(
2243 "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"
2244 " a),\n"
2245 " a),\n"
2246 " a),\n"
2247 " a),\n"
2248 " a),\n"
2249 " a),\n"
2250 " a),\n"
2251 " a),\n"
2252 " a),\n"
2253 " a),\n"
2254 " a),\n"
2255 " a),\n"
2256 " a),\n"
2257 " a),\n"
2258 " a),\n"
2259 " a),\n"
2260 " a)",
2261 getLLVMStyleWithColumns(65));
Daniel Jasper7b7877a2013-01-12 07:36:22 +00002262
2263 // This test takes VERY long when memoization is broken.
Daniel Jaspere3c0e012013-04-25 13:31:51 +00002264 FormatStyle OnePerLine = getLLVMStyle();
2265 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00002266 OnePerLine.BinPackParameters = false;
Daniel Jasper9278eb92013-01-16 14:59:02 +00002267 std::string input = "Constructor()\n"
Daniel Jasper7a31af12013-01-25 15:43:32 +00002268 " : aaaa(a,\n";
Daniel Jasper9278eb92013-01-16 14:59:02 +00002269 for (unsigned i = 0, e = 80; i != e; ++i) {
2270 input += " a,\n";
2271 }
Daniel Jasper12ef4e52013-02-21 21:33:55 +00002272 input += " a) {}";
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00002273 verifyFormat(input, OnePerLine);
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00002274}
2275
Alexander Kornienko578fdd82012-12-06 18:03:27 +00002276TEST_F(FormatTest, BreaksAsHighAsPossible) {
2277 verifyFormat(
Alexander Kornienkoa5151272013-03-12 16:28:18 +00002278 "void f() {\n"
2279 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
2280 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
2281 " f();\n"
2282 "}");
Daniel Jasper70bc8742013-02-26 13:59:14 +00002283 verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00002284 " Intervals[i - 1].getRange().getLast()) {\n}");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00002285}
2286
Daniel Jasper6728fc12013-04-11 14:29:13 +00002287TEST_F(FormatTest, BreaksFunctionDeclarations) {
2288 // Principially, we break function declarations in a certain order:
2289 // 1) break amongst arguments.
2290 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
2291 " Cccccccccccccc cccccccccccccc);");
2292
2293 // 2) break after return type.
Daniel Jasper8e357692013-05-06 08:27:33 +00002294 verifyFormat(
2295 "Aaaaaaaaaaaaaaaaaaaaaaaa\n"
2296 " bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);");
Daniel Jasper6728fc12013-04-11 14:29:13 +00002297
2298 // 3) break after (.
2299 verifyFormat(
2300 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
2301 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);");
2302
2303 // 4) break before after nested name specifiers.
2304 verifyFormat(
2305 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8e357692013-05-06 08:27:33 +00002306 " SomeClasssssssssssssssssssssssssssssssssssssss::\n"
2307 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);");
Daniel Jasper6728fc12013-04-11 14:29:13 +00002308
2309 // However, there are exceptions, if a sufficient amount of lines can be
2310 // saved.
2311 // FIXME: The precise cut-offs wrt. the number of saved lines might need some
2312 // more adjusting.
2313 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
2314 " Cccccccccccccc cccccccccc,\n"
2315 " Cccccccccccccc cccccccccc,\n"
2316 " Cccccccccccccc cccccccccc,\n"
2317 " Cccccccccccccc cccccccccc);");
2318 verifyFormat(
2319 "Aaaaaaaaaaaaaaaaaa\n"
Daniel Jasper8e357692013-05-06 08:27:33 +00002320 " bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
2321 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
2322 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
Daniel Jasper6728fc12013-04-11 14:29:13 +00002323 verifyFormat(
2324 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
2325 " Cccccccccccccc cccccccccc,\n"
2326 " Cccccccccccccc cccccccccc,\n"
2327 " Cccccccccccccc cccccccccc,\n"
2328 " Cccccccccccccc cccccccccc,\n"
2329 " Cccccccccccccc cccccccccc,\n"
2330 " Cccccccccccccc cccccccccc);");
2331 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
2332 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
2333 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
2334 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
2335 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
Daniel Jasper1b8e76f2013-04-15 22:36:37 +00002336
2337 // Break after multi-line parameters.
2338 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2339 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2340 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2341 " bbbb bbbb);");
Daniel Jasper6728fc12013-04-11 14:29:13 +00002342}
2343
Daniel Jasper5be31f72013-05-21 09:16:31 +00002344TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) {
Daniel Jasper13c37b32013-05-22 08:28:26 +00002345 verifyFormat("void someLongFunction(\n"
2346 " int someLongParameter) const {}",
2347 getLLVMStyleWithColumns(46));
2348 FormatStyle Style = getGoogleStyle();
2349 Style.ColumnLimit = 47;
2350 verifyFormat("void\n"
2351 "someLongFunction(int someLongParameter) const {\n}",
2352 getLLVMStyleWithColumns(47));
2353 verifyFormat("void someLongFunction(\n"
2354 " int someLongParameter) const {}",
2355 Style);
2356 verifyFormat("LoooooongReturnType\n"
2357 "someLoooooooongFunction() const {}",
2358 getLLVMStyleWithColumns(47));
2359 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
2360 " const {}",
2361 Style);
Daniel Jasper5be31f72013-05-21 09:16:31 +00002362
2363 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
2364 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
2365 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
2366 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
2367 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
2368 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}");
2369
2370 verifyFormat(
2371 "void aaaaaaaaaaaaaaaaaa()\n"
2372 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
2373 " aaaaaaaaaaaaaaaaaaaaaaaaa));");
2374 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2375 " __attribute__((unused));");
2376 verifyFormat(
2377 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2378 " GUARDED_BY(aaaaaaaaaaaa);");
2379}
2380
2381
Daniel Jasperf7935112012-12-03 18:12:45 +00002382TEST_F(FormatTest, BreaksDesireably) {
2383 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
2384 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00002385 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
Daniel Jasper39e27382013-01-23 20:41:06 +00002386 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2387 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
2388 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +00002389
2390 verifyFormat(
2391 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00002392 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
Daniel Jasperf7935112012-12-03 18:12:45 +00002393
2394 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2395 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2396 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jasper9b155472012-12-04 10:50:12 +00002397
2398 verifyFormat(
2399 "aaaaaaaa(aaaaaaaaaaaaa, aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2400 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
2401 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2402 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));");
Daniel Jasperaa1c9202012-12-05 14:57:28 +00002403
2404 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
2405 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
2406
Daniel Jasper3d0c75c2013-01-02 14:40:02 +00002407 verifyFormat(
Alexander Kornienkoa5151272013-03-12 16:28:18 +00002408 "void f() {\n"
2409 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
2410 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
2411 "}");
Daniel Jasper7a31af12013-01-25 15:43:32 +00002412 verifyFormat(
2413 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2414 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
2415 verifyFormat(
2416 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2417 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jasperaab220f2013-03-20 13:53:11 +00002418 verifyFormat(
2419 "aaaaaaaaaaaaaaaaa(\n"
2420 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2421 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper3d0c75c2013-01-02 14:40:02 +00002422
Daniel Jasperaa1c9202012-12-05 14:57:28 +00002423 // This test case breaks on an incorrect memoization, i.e. an optimization not
2424 // taking into account the StopAt value.
2425 verifyFormat(
2426 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
Daniel Jasper2eda23e2012-12-24 13:43:52 +00002427 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
2428 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
2429 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper6d822722012-12-24 16:43:00 +00002430
Daniel Jasper8d1832e2013-01-07 13:26:07 +00002431 verifyFormat("{\n {\n {\n"
2432 " Annotation.SpaceRequiredBefore =\n"
2433 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
2434 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
2435 " }\n }\n}");
Daniel Jasperf7935112012-12-03 18:12:45 +00002436}
2437
Daniel Jasper9278eb92013-01-16 14:59:02 +00002438TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
Daniel Jaspera628c982013-04-03 13:36:17 +00002439 FormatStyle NoBinPacking = getGoogleStyle();
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00002440 NoBinPacking.BinPackParameters = false;
2441 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
2442 " aaaaaaaaaaaaaaaaaaaa,\n"
2443 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);",
2444 NoBinPacking);
2445 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
2446 " aaaaaaaaaaaaa,\n"
2447 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));",
2448 NoBinPacking);
2449 verifyFormat(
Daniel Jasper9278eb92013-01-16 14:59:02 +00002450 "aaaaaaaa(aaaaaaaaaaaaa,\n"
2451 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2452 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
2453 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00002454 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));",
2455 NoBinPacking);
2456 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
2457 " .aaaaaaaaaaaaaaaaaa();",
2458 NoBinPacking);
2459 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2460 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);",
2461 NoBinPacking);
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002462
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00002463 verifyFormat(
Daniel Jaspere941b162013-01-23 10:08:28 +00002464 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2465 " aaaaaaaaaaaa,\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00002466 " aaaaaaaaaaaa);",
2467 NoBinPacking);
2468 verifyFormat(
Daniel Jasper9278eb92013-01-16 14:59:02 +00002469 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
2470 " ddddddddddddddddddddddddddddd),\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00002471 " test);",
2472 NoBinPacking);
Daniel Jasper9278eb92013-01-16 14:59:02 +00002473
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00002474 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
2475 " aaaaaaaaaaaaaaaaaaaaaaa,\n"
2476 " aaaaaaaaaaaaaaaaaaaaaaa> aaaaaaaaaaaaaaaaaa;",
2477 NoBinPacking);
2478 verifyFormat("a(\"a\"\n"
2479 " \"a\",\n"
2480 " a);");
Daniel Jaspere941b162013-01-23 10:08:28 +00002481
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00002482 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
Daniel Jasperf7db4332013-01-29 16:03:49 +00002483 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
Daniel Jaspere941b162013-01-23 10:08:28 +00002484 " aaaaaaaaa,\n"
Daniel Jasperf7db4332013-01-29 16:03:49 +00002485 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00002486 NoBinPacking);
Daniel Jasper687af3b2013-02-14 14:26:07 +00002487 verifyFormat(
2488 "void f() {\n"
2489 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
2490 " .aaaaaaa();\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002491 "}",
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00002492 NoBinPacking);
Daniel Jasper53e8d852013-05-22 08:55:55 +00002493 verifyFormat(
2494 "template <class SomeType, class SomeOtherType>\n"
2495 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
2496 NoBinPacking);
Daniel Jasper9278eb92013-01-16 14:59:02 +00002497}
2498
Daniel Jasper04468962013-01-18 10:56:38 +00002499TEST_F(FormatTest, FormatsBuilderPattern) {
2500 verifyFormat(
2501 "return llvm::StringSwitch<Reference::Kind>(name)\n"
Daniel Jaspere7de2a32013-04-08 10:45:44 +00002502 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
2503 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME).StartsWith(\".init\", ORDER_INIT)\n"
2504 " .StartsWith(\".fini\", ORDER_FINI).StartsWith(\".hash\", ORDER_HASH)\n"
2505 " .Default(ORDER_TEXT);\n");
Daniel Jasperc6fbc212013-05-15 09:35:08 +00002506
Daniel Jaspereb50c672013-02-15 20:33:06 +00002507 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00002508 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
Daniel Jasper9ed9ade2013-02-18 13:24:21 +00002509 verifyFormat(
2510 "aaaaaaa->aaaaaaa\n"
2511 " ->aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
2512 " ->aaaaaaaa(aaaaaaaaaaaaaaa);");
Daniel Jaspere53beb22013-02-18 13:52:06 +00002513 verifyFormat(
2514 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
Daniel Jasperf9a84b52013-03-01 16:48:32 +00002515 " aaaaaaaaaaaaaa);");
Daniel Jaspere53beb22013-02-18 13:52:06 +00002516 verifyFormat(
2517 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa = aaaaaa->aaaaaaaaaaaa()\n"
2518 " ->aaaaaaaaaaaaaaaa(\n"
Daniel Jasper66e4f832013-05-10 13:37:16 +00002519 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
Daniel Jaspere53beb22013-02-18 13:52:06 +00002520 " ->aaaaaaaaaaaaaaaaa();");
Daniel Jasper04468962013-01-18 10:56:38 +00002521}
2522
Daniel Jasperde5c2072012-12-24 00:13:23 +00002523TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) {
2524 verifyFormat(
2525 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00002526 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
Daniel Jasper8d1832e2013-01-07 13:26:07 +00002527 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00002528 " ccccccccccccccccccccccccc) {\n}");
Daniel Jasper8d1832e2013-01-07 13:26:07 +00002529 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00002530 " ccccccccccccccccccccccccc) {\n}");
Daniel Jasperde5c2072012-12-24 00:13:23 +00002531 verifyFormat(
2532 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00002533 " ccccccccccccccccccccccccc) {\n}");
Daniel Jasper400adc62013-02-08 15:28:42 +00002534 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
2535 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
2536 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
2537 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
2538 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
2539 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
2540 " aaaaaaaaaaaaaaa != aa) {\n}");
Daniel Jasperde5c2072012-12-24 00:13:23 +00002541}
2542
Daniel Jasper43b65482013-01-23 12:27:43 +00002543TEST_F(FormatTest, BreaksAfterAssignments) {
Daniel Jasper206df732013-01-07 13:08:40 +00002544 verifyFormat(
Daniel Jasper43b65482013-01-23 12:27:43 +00002545 "unsigned Cost =\n"
2546 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
2547 " SI->getPointerAddressSpaceee());\n");
Daniel Jasper206df732013-01-07 13:08:40 +00002548 verifyFormat(
Daniel Jasper1565eb32013-01-23 15:55:19 +00002549 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
2550 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
Daniel Jaspera836b902013-01-23 16:58:21 +00002551
2552 verifyFormat(
2553 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa()\n"
2554 " .aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper7b27a102013-05-27 12:45:09 +00002555 verifyFormat("unsigned OriginalStartColumn =\n"
2556 " SourceMgr.getSpellingColumnNumber(\n"
2557 " Current.FormatTok.getStartOfNonWhitespace()) -\n"
2558 " 1;");
Daniel Jasper206df732013-01-07 13:08:40 +00002559}
2560
Daniel Jasper2eda23e2012-12-24 13:43:52 +00002561TEST_F(FormatTest, AlignsAfterAssignments) {
2562 verifyFormat(
2563 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper206df732013-01-07 13:08:40 +00002564 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00002565 verifyFormat(
2566 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper206df732013-01-07 13:08:40 +00002567 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00002568 verifyFormat(
2569 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper206df732013-01-07 13:08:40 +00002570 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00002571 verifyFormat(
2572 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
Daniel Jasper206df732013-01-07 13:08:40 +00002573 " aaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002574 verifyFormat("double LooooooooooooooooooooooooongResult =\n"
2575 " aaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaa +\n"
2576 " aaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00002577}
2578
2579TEST_F(FormatTest, AlignsAfterReturn) {
2580 verifyFormat(
2581 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2582 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
2583 verifyFormat(
2584 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
2585 " aaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperc238c872013-04-02 14:33:13 +00002586 verifyFormat(
2587 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00002588 " aaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasperc238c872013-04-02 14:33:13 +00002589 verifyFormat(
2590 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00002591 " aaaaaaaaaaaaaaaaaaaaaa());");
2592 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2593 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
2594 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2595 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
2596 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper2eda23e2012-12-24 13:43:52 +00002597}
2598
Daniel Jasper399d24b2013-01-09 07:06:56 +00002599TEST_F(FormatTest, BreaksConditionalExpressions) {
2600 verifyFormat(
2601 "aaaa(aaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasperca6623b2013-01-28 12:45:14 +00002602 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2603 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper8c5fba92013-01-16 16:23:19 +00002604 verifyFormat(
Daniel Jasperca6623b2013-01-28 12:45:14 +00002605 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2606 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
2607 verifyFormat(
2608 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
2609 " : aaaaaaaaaaaaa);");
2610 verifyFormat(
2611 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasperaab220f2013-03-20 13:53:11 +00002612 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
Daniel Jasperca6623b2013-01-28 12:45:14 +00002613 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2614 " aaaaaaaaaaaaa);");
2615 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2616 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2617 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
2618 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2619 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
2620 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2621 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2622 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2623 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
2624 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2625 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
2626 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper54a86022013-02-15 11:07:25 +00002627
2628 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2629 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2630 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasperc238c872013-04-02 14:33:13 +00002631 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
2632 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2633 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2634 " : aaaaaaaaaaaaaaaa;");
Daniel Jaspercd8599e2013-02-23 21:01:55 +00002635 verifyFormat(
2636 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2637 " ? aaaaaaaaaaaaaaa\n"
2638 " : aaaaaaaaaaaaaaa;");
2639 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00002640 " aaaaaaaaa\n"
Daniel Jaspere7de2a32013-04-08 10:45:44 +00002641 " ? b\n"
2642 " : c);");
Daniel Jasper8360a862013-02-08 16:49:27 +00002643 verifyFormat(
Daniel Jasper54a86022013-02-15 11:07:25 +00002644 "unsigned Indent =\n"
2645 " format(TheLine.First, IndentForLevel[TheLine.Level] >= 0\n"
2646 " ? IndentForLevel[TheLine.Level]\n"
Daniel Jasper37905f72013-02-21 15:00:29 +00002647 " : TheLine * 2,\n"
2648 " TheLine.InPPDirective, PreviousEndOfLineColumn);",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002649 getLLVMStyleWithColumns(70));
Daniel Jasper2c611c02013-05-31 14:56:12 +00002650 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
2651 " ? aaaaaaaaaaaaaaa\n"
2652 " : bbbbbbbbbbbbbbb //\n"
2653 " ? ccccccccccccccc\n"
2654 " : ddddddddddddddd;");
2655 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
2656 " ? aaaaaaaaaaaaaaa\n"
2657 " : (bbbbbbbbbbbbbbb //\n"
2658 " ? ccccccccccccccc\n"
2659 " : ddddddddddddddd);");
Daniel Jasper54a86022013-02-15 11:07:25 +00002660
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00002661 FormatStyle NoBinPacking = getLLVMStyle();
2662 NoBinPacking.BinPackParameters = false;
2663 verifyFormat(
Daniel Jaspercd8599e2013-02-23 21:01:55 +00002664 "void f() {\n"
2665 " g(aaa,\n"
2666 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
2667 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2668 " ? aaaaaaaaaaaaaaa\n"
2669 " : aaaaaaaaaaaaaaa);\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00002670 "}",
2671 NoBinPacking);
Daniel Jasper399d24b2013-01-09 07:06:56 +00002672}
2673
Daniel Jasper38c11ce2013-01-29 11:21:01 +00002674TEST_F(FormatTest, DeclarationsOfMultipleVariables) {
2675 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
2676 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();");
2677 verifyFormat("bool a = true, b = false;");
2678
Daniel Jasper38c11ce2013-01-29 11:21:01 +00002679 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Daniel Jaspera628c982013-04-03 13:36:17 +00002680 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
Daniel Jasper38c11ce2013-01-29 11:21:01 +00002681 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
Daniel Jasperc238c872013-04-02 14:33:13 +00002682 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);");
Daniel Jasper38c11ce2013-01-29 11:21:01 +00002683 verifyFormat(
Daniel Jasper37905f72013-02-21 15:00:29 +00002684 "bool aaaaaaaaaaaaaaaaaaaaa =\n"
Daniel Jaspera628c982013-04-03 13:36:17 +00002685 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
Daniel Jasper37905f72013-02-21 15:00:29 +00002686 " d = e && f;");
Daniel Jasper31c96b92013-04-05 09:38:50 +00002687 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
2688 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;");
2689 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
2690 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;");
2691 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
2692 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;");
2693 // FIXME: If multiple variables are defined, the "*" needs to move to the new
2694 // line. Also fix indent for breaking after the type, this looks bad.
2695 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
Daniel Jasper8e357692013-05-06 08:27:33 +00002696 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
2697 " *b = bbbbbbbbbbbbbbbbbbb;");
Daniel Jasper38c11ce2013-01-29 11:21:01 +00002698
Daniel Jasper31c96b92013-04-05 09:38:50 +00002699 // Not ideal, but pointer-with-type does not allow much here.
2700 verifyGoogleFormat(
2701 "aaaaaaaaa* a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
2702 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;");
Daniel Jasper38c11ce2013-01-29 11:21:01 +00002703}
2704
Nico Weber4a5030c2013-01-12 01:28:06 +00002705TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
2706 verifyFormat("arr[foo ? bar : baz];");
2707 verifyFormat("f()[foo ? bar : baz];");
2708 verifyFormat("(a + b)[foo ? bar : baz];");
2709 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
2710}
2711
Daniel Jasperf7935112012-12-03 18:12:45 +00002712TEST_F(FormatTest, AlignsStringLiterals) {
2713 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
2714 " \"short literal\");");
2715 verifyFormat(
2716 "looooooooooooooooooooooooongFunction(\n"
2717 " \"short literal\"\n"
2718 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002719 verifyFormat("someFunction(\"Always break between multi-line\"\n"
2720 " \" string literals\",\n"
2721 " and, other, parameters);");
Manuel Klimek02f640a2013-02-20 15:25:48 +00002722 EXPECT_EQ("fun + \"1243\" /* comment */\n"
2723 " \"5678\";",
2724 format("fun + \"1243\" /* comment */\n"
2725 " \"5678\";",
2726 getLLVMStyleWithColumns(28)));
2727 EXPECT_EQ(
2728 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
2729 " \"aaaaaaaaaaaaaaaaaaaaa\"\n"
2730 " \"aaaaaaaaaaaaaaaa\";",
2731 format("aaaaaa ="
2732 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
2733 "aaaaaaaaaaaaaaaaaaaaa\" "
2734 "\"aaaaaaaaaaaaaaaa\";"));
Manuel Klimek0c915712013-02-20 15:32:58 +00002735 verifyFormat("a = a + \"a\"\n"
2736 " \"a\"\n"
2737 " \"a\";");
Daniel Jasper7dd22c51b2013-05-16 04:26:02 +00002738 verifyFormat("f(\"a\", \"b\"\n"
2739 " \"c\");");
Daniel Jasperaf5ba0e2013-02-23 07:46:38 +00002740
2741 verifyFormat(
2742 "#define LL_FORMAT \"ll\"\n"
2743 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
2744 " \"d, ddddddddd: %\" LL_FORMAT \"d\");");
Daniel Jasper47a04442013-05-13 20:50:15 +00002745
2746 verifyFormat("#define A(X) \\\n"
2747 " \"aaaaa\" #X \"bbbbbb\" \\\n"
2748 " \"ccccc\"",
2749 getLLVMStyleWithColumns(23));
2750 verifyFormat("#define A \"def\"\n"
2751 "f(\"abc\" A \"ghi\"\n"
2752 " \"jkl\");");
Daniel Jasperf7935112012-12-03 18:12:45 +00002753}
2754
Alexander Kornienko578fdd82012-12-06 18:03:27 +00002755TEST_F(FormatTest, AlignsPipes) {
2756 verifyFormat(
2757 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2758 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2759 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
2760 verifyFormat(
2761 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
2762 " << aaaaaaaaaaaaaaaaaaaa;");
2763 verifyFormat(
2764 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2765 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
2766 verifyFormat(
2767 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
2768 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
2769 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";");
2770 verifyFormat(
2771 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2772 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
2773 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper2603ee02013-02-04 07:34:48 +00002774
2775 verifyFormat("return out << \"somepacket = {\\n\"\n"
2776 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
2777 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
2778 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
2779 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
2780 " << \"}\";");
Daniel Jasperba9ddb62013-02-06 21:04:05 +00002781
2782 verifyFormat(
2783 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
2784 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
2785 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
2786 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
2787 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;");
Daniel Jasperf38a0ac2013-03-14 14:00:17 +00002788 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
2789 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
Daniel Jaspera4c571c2013-05-22 09:13:26 +00002790 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaa: \"\n"
2791 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperc238c872013-04-02 14:33:13 +00002792
2793 verifyFormat(
2794 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2795 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Alexander Kornienko578fdd82012-12-06 18:03:27 +00002796}
2797
Daniel Jasperf7935112012-12-03 18:12:45 +00002798TEST_F(FormatTest, UnderstandsEquals) {
2799 verifyFormat(
2800 "aaaaaaaaaaaaaaaaa =\n"
2801 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
2802 verifyFormat(
2803 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00002804 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasperf7935112012-12-03 18:12:45 +00002805 verifyFormat(
2806 "if (a) {\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00002807 " f();\n"
Daniel Jasperf7935112012-12-03 18:12:45 +00002808 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00002809 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
2810 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +00002811
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002812 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
2813 " 100000000 + 10000000) {\n}");
Daniel Jasperf7935112012-12-03 18:12:45 +00002814}
2815
Daniel Jasper5485d0c2012-12-17 14:34:14 +00002816TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00002817 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
2818 " .looooooooooooooooooooooooooooooooooooooongFunction();");
Daniel Jasper5485d0c2012-12-17 14:34:14 +00002819
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00002820 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
2821 " ->looooooooooooooooooooooooooooooooooooooongFunction();");
Daniel Jasper5485d0c2012-12-17 14:34:14 +00002822
2823 verifyFormat(
2824 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
2825 " Parameter2);");
2826
2827 verifyFormat(
2828 "ShortObject->shortFunction(\n"
2829 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
2830 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);");
2831
2832 verifyFormat("loooooooooooooongFunction(\n"
2833 " LoooooooooooooongObject->looooooooooooooooongFunction());");
2834
2835 verifyFormat(
2836 "function(LoooooooooooooooooooooooooooooooooooongObject\n"
2837 " ->loooooooooooooooooooooooooooooooooooooooongFunction());");
2838
Daniel Jasper687af3b2013-02-14 14:26:07 +00002839 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
2840 " .WillRepeatedly(Return(SomeValue));");
2841 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)]\n"
2842 " .insert(ccccccccccccccccccccccc);");
Daniel Jasper32a796b2013-05-27 11:50:16 +00002843 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2844 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa).aaaaa(aaaaa),\n"
2845 " aaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper9b334242013-03-15 14:57:30 +00002846 verifyFormat(
2847 "aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2848 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
2849 " .aaaaaaaaaaaaaaa(\n"
Daniel Jasper66e4f832013-05-10 13:37:16 +00002850 " aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2851 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
Daniel Jasperc238c872013-04-02 14:33:13 +00002852 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2853 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2854 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2855 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
2856 "}");
Daniel Jasper687af3b2013-02-14 14:26:07 +00002857
Daniel Jasperc7345cc2013-01-07 07:13:20 +00002858 // Here, it is not necessary to wrap at "." or "->".
Daniel Jasper2af6bbe2012-12-18 21:05:13 +00002859 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00002860 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
Daniel Jasperc7345cc2013-01-07 07:13:20 +00002861 verifyFormat(
2862 "aaaaaaaaaaa->aaaaaaaaa(\n"
2863 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2864 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
Daniel Jaspere11095a2013-02-14 15:01:34 +00002865
2866 verifyFormat(
2867 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2868 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
Daniel Jasper8f6ae192013-03-13 15:37:48 +00002869 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
2870 " aaaaaaaaa()->aaaaaa()->aaaaa());");
2871 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
2872 " aaaaaaaaa()->aaaaaa()->aaaaa());");
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00002873
Daniel Jasper9b334242013-03-15 14:57:30 +00002874 // FIXME: Should we break before .a()?
2875 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2876 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa).a();");
2877
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00002878 FormatStyle NoBinPacking = getLLVMStyle();
2879 NoBinPacking.BinPackParameters = false;
2880 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
2881 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
2882 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
2883 " aaaaaaaaaaaaaaaaaaa,\n"
2884 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
2885 NoBinPacking);
Daniel Jasper5485d0c2012-12-17 14:34:14 +00002886}
2887
Daniel Jasperac5c1c22013-01-02 15:08:56 +00002888TEST_F(FormatTest, WrapsTemplateDeclarations) {
2889 verifyFormat("template <typename T>\n"
2890 "virtual void loooooooooooongFunction(int Param1, int Param2);");
2891 verifyFormat(
Daniel Jasper04468962013-01-18 10:56:38 +00002892 "template <typename T>\n"
Daniel Jasper400adc62013-02-08 15:28:42 +00002893 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;");
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002894 verifyFormat("template <typename T>\n"
2895 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
2896 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);");
Daniel Jasperac5c1c22013-01-02 15:08:56 +00002897 verifyFormat(
2898 "template <typename T>\n"
2899 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
2900 " int Paaaaaaaaaaaaaaaaaaaaram2);");
Daniel Jasper90e51fd2013-01-02 18:30:06 +00002901 verifyFormat(
2902 "template <typename T>\n"
2903 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
2904 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
2905 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper89058942013-01-09 09:50:48 +00002906 verifyFormat("template <typename T>\n"
2907 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
Daniel Jaspera628c982013-04-03 13:36:17 +00002908 " int aaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperbcab4302013-01-09 10:40:23 +00002909 verifyFormat(
2910 "template <typename T1, typename T2 = char, typename T3 = char,\n"
2911 " typename T4 = char>\n"
2912 "void f();");
Daniel Jasper7a31af12013-01-25 15:43:32 +00002913 verifyFormat(
2914 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
2915 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasper3a9370c2013-02-04 07:21:18 +00002916
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00002917 verifyFormat("a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
2918 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));");
Daniel Jasper61e6bbf2013-05-29 12:07:31 +00002919
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00002920 verifyFormat("template <typename T> class C {};");
Daniel Jasper61e6bbf2013-05-29 12:07:31 +00002921 verifyFormat("template <typename T> void f();");
2922 verifyFormat("template <typename T> void f() {}");
2923
2924 FormatStyle AlwaysBreak = getLLVMStyle();
2925 AlwaysBreak.AlwaysBreakTemplateDeclarations = true;
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00002926 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
Daniel Jasper61e6bbf2013-05-29 12:07:31 +00002927 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
2928 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
Daniel Jasper80503952013-06-03 09:54:46 +00002929 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2930 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
2931 " ccccccccccccccccccccccccccccccccccccccccccccccc);");
Daniel Jasperac5c1c22013-01-02 15:08:56 +00002932}
2933
Daniel Jasper45797022013-01-25 10:57:27 +00002934TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
2935 verifyFormat(
2936 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
2937 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
2938 verifyFormat(
2939 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
2940 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2941 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
2942
Daniel Jasper0f0234e2013-05-08 10:00:18 +00002943 // FIXME: Should we have the extra indent after the second break?
Daniel Jasper45797022013-01-25 10:57:27 +00002944 verifyFormat(
2945 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
2946 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
Daniel Jasper0f0234e2013-05-08 10:00:18 +00002947 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper45797022013-01-25 10:57:27 +00002948
Daniel Jasper45797022013-01-25 10:57:27 +00002949 verifyFormat(
2950 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
Daniel Jasper4ad42352013-01-28 07:43:15 +00002951 " cccccccccccccccccccccccccccccccccccccccccccccc());");
Daniel Jasper45797022013-01-25 10:57:27 +00002952
2953 // Breaking at nested name specifiers is generally not desirable.
2954 verifyFormat(
2955 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2956 " aaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperca6623b2013-01-28 12:45:14 +00002957
2958 verifyFormat(
2959 "aaaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
2960 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2961 " aaaaaaaaaaaaaaaaaaaaa);",
2962 getLLVMStyleWithColumns(74));
Daniel Jasperc238c872013-04-02 14:33:13 +00002963
2964 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
2965 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
2966 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
Daniel Jasper45797022013-01-25 10:57:27 +00002967}
2968
Daniel Jasperf7935112012-12-03 18:12:45 +00002969TEST_F(FormatTest, UnderstandsTemplateParameters) {
2970 verifyFormat("A<int> a;");
2971 verifyFormat("A<A<A<int> > > a;");
2972 verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
2973 verifyFormat("bool x = a < 1 || 2 > a;");
2974 verifyFormat("bool x = 5 < f<int>();");
2975 verifyFormat("bool x = f<int>() > 5;");
2976 verifyFormat("bool x = 5 < a<int>::x;");
2977 verifyFormat("bool x = a < 4 ? a > 2 : false;");
2978 verifyFormat("bool x = f() ? a < 2 : a > 2;");
2979
2980 verifyGoogleFormat("A<A<int>> a;");
2981 verifyGoogleFormat("A<A<A<int>>> a;");
2982 verifyGoogleFormat("A<A<A<A<int>>>> a;");
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00002983 verifyGoogleFormat("A<A<int> > a;");
2984 verifyGoogleFormat("A<A<A<int> > > a;");
2985 verifyGoogleFormat("A<A<A<A<int> > > > a;");
2986 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
2987 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
Daniel Jasperf7935112012-12-03 18:12:45 +00002988
2989 verifyFormat("test >> a >> b;");
2990 verifyFormat("test << a >> b;");
2991
2992 verifyFormat("f<int>();");
Manuel Klimeke7d10a12013-01-10 13:24:24 +00002993 verifyFormat("template <typename T> void f() {}");
Daniel Jasperd5893912013-06-01 18:56:00 +00002994
2995 // Not template parameters.
2996 verifyFormat("return a < b && c > d;");
2997 verifyFormat("void f() {\n"
2998 " while (a < b && c > d) {\n"
2999 " }\n"
3000 "}");
Daniel Jasperf7935112012-12-03 18:12:45 +00003001}
3002
Daniel Jasperd8ffcfa2013-02-28 09:21:10 +00003003TEST_F(FormatTest, UnderstandsBinaryOperators) {
3004 verifyFormat("COMPARE(a, ==, b);");
Alexander Kornienko674be0a2013-03-20 16:41:56 +00003005}
3006
3007TEST_F(FormatTest, UnderstandsPointersToMembers) {
3008 verifyFormat("int A::*x;");
Daniel Jaspercfda5172013-05-08 14:58:20 +00003009 verifyFormat("int (S::*func)(void *);");
Daniel Jasper37194282013-05-28 08:33:00 +00003010 verifyFormat("void f() { int (S::*func)(void *); }");
Daniel Jasper2f34cac2013-05-08 15:06:58 +00003011 verifyFormat("typedef bool *(Class::*Member)() const;");
Daniel Jaspercfda5172013-05-08 14:58:20 +00003012 verifyFormat("void f() {\n"
3013 " (a->*f)();\n"
3014 " a->*x;\n"
3015 " (a.*f)();\n"
3016 " ((*a).*f)();\n"
3017 " a.*x;\n"
3018 "}");
Daniel Jasper2f34cac2013-05-08 15:06:58 +00003019 FormatStyle Style = getLLVMStyle();
3020 Style.PointerBindsToType = true;
3021 verifyFormat("typedef bool* (Class::*Member)() const;", Style);
Daniel Jasperd8ffcfa2013-02-28 09:21:10 +00003022}
3023
Daniel Jasper8dd40472012-12-21 09:41:31 +00003024TEST_F(FormatTest, UnderstandsUnaryOperators) {
Daniel Jasperf7935112012-12-03 18:12:45 +00003025 verifyFormat("int a = -2;");
Daniel Jasper8b529712012-12-04 13:02:32 +00003026 verifyFormat("f(-1, -2, -3);");
3027 verifyFormat("a[-1] = 5;");
3028 verifyFormat("int a = 5 + -2;");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003029 verifyFormat("if (i == -1) {\n}");
3030 verifyFormat("if (i != -1) {\n}");
3031 verifyFormat("if (i > -1) {\n}");
3032 verifyFormat("if (i < -1) {\n}");
Daniel Jasper26333c32012-12-06 13:16:39 +00003033 verifyFormat("++(a->f());");
3034 verifyFormat("--(a->f());");
Daniel Jasper13f23e12013-01-14 12:18:19 +00003035 verifyFormat("(a->f())++;");
3036 verifyFormat("a[42]++;");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003037 verifyFormat("if (!(a->f())) {\n}");
Daniel Jasper8dd40472012-12-21 09:41:31 +00003038
3039 verifyFormat("a-- > b;");
3040 verifyFormat("b ? -a : c;");
3041 verifyFormat("n * sizeof char16;");
Daniel Jasper3c0431c2013-01-02 17:21:36 +00003042 verifyFormat("n * alignof char16;");
Daniel Jasper8dd40472012-12-21 09:41:31 +00003043 verifyFormat("sizeof(char);");
Daniel Jasper3c0431c2013-01-02 17:21:36 +00003044 verifyFormat("alignof(char);");
Daniel Jasperda1c68a2013-01-02 15:26:16 +00003045
3046 verifyFormat("return -1;");
3047 verifyFormat("switch (a) {\n"
3048 "case -1:\n"
3049 " break;\n"
3050 "}");
Daniel Jasper399d1ee2013-03-22 10:44:43 +00003051 verifyFormat("#define X -1");
3052 verifyFormat("#define X -kConstant");
Nico Weber63a54eb2013-01-12 05:41:23 +00003053
3054 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = { -5, +3 };");
3055 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = { +5, -3 };");
Daniel Jasper71945272013-01-15 14:27:39 +00003056
3057 verifyFormat("int a = /* confusing comment */ -1;");
3058 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case.
3059 verifyFormat("int a = i /* confusing comment */++;");
Daniel Jasperf7935112012-12-03 18:12:45 +00003060}
3061
3062TEST_F(FormatTest, UndestandsOverloadedOperators) {
Daniel Jasper537a2962012-12-24 10:56:04 +00003063 verifyFormat("bool operator<();");
3064 verifyFormat("bool operator>();");
3065 verifyFormat("bool operator=();");
3066 verifyFormat("bool operator==();");
3067 verifyFormat("bool operator!=();");
3068 verifyFormat("int operator+();");
3069 verifyFormat("int operator++();");
3070 verifyFormat("bool operator();");
3071 verifyFormat("bool operator()();");
3072 verifyFormat("bool operator[]();");
3073 verifyFormat("operator bool();");
Daniel Jasper35d2dc72013-02-11 08:01:18 +00003074 verifyFormat("operator int();");
3075 verifyFormat("operator void *();");
Daniel Jasper537a2962012-12-24 10:56:04 +00003076 verifyFormat("operator SomeType<int>();");
Daniel Jasper35d2dc72013-02-11 08:01:18 +00003077 verifyFormat("operator SomeType<int, int>();");
3078 verifyFormat("operator SomeType<SomeType<int> >();");
Daniel Jasper537a2962012-12-24 10:56:04 +00003079 verifyFormat("void *operator new(std::size_t size);");
3080 verifyFormat("void *operator new[](std::size_t size);");
3081 verifyFormat("void operator delete(void *ptr);");
3082 verifyFormat("void operator delete[](void *ptr);");
Daniel Jasper8f9624b2013-05-10 07:59:58 +00003083 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
3084 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);");
Daniel Jasper35d2dc72013-02-11 08:01:18 +00003085
Daniel Jasper0af92eb2013-02-15 19:24:08 +00003086 verifyFormat(
3087 "ostream &operator<<(ostream &OutputStream,\n"
3088 " SomeReallyLongType WithSomeReallyLongValue);");
Daniel Jasper54ac8202013-04-05 17:21:59 +00003089 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
3090 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
3091 " return left.group < right.group;\n"
3092 "}");
Daniel Jasper6e8f4ed2013-04-11 08:48:20 +00003093 verifyFormat("SomeType &operator=(const SomeType &S);");
Daniel Jasper0af92eb2013-02-15 19:24:08 +00003094
Daniel Jasper35d2dc72013-02-11 08:01:18 +00003095 verifyGoogleFormat("operator void*();");
3096 verifyGoogleFormat("operator SomeType<SomeType<int>>();");
Daniel Jasperf7935112012-12-03 18:12:45 +00003097}
3098
Daniel Jasperd6a947f2013-01-11 16:09:04 +00003099TEST_F(FormatTest, UnderstandsNewAndDelete) {
Daniel Jasperba0bda92013-02-23 08:07:18 +00003100 verifyFormat("void f() {\n"
3101 " A *a = new A;\n"
3102 " A *a = new (placement) A;\n"
3103 " delete a;\n"
3104 " delete (A *)a;\n"
3105 "}");
Daniel Jasperd6a947f2013-01-11 16:09:04 +00003106}
3107
Daniel Jasper22bcf8a2013-01-02 08:57:10 +00003108TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
Manuel Klimeke7d10a12013-01-10 13:24:24 +00003109 verifyFormat("int *f(int *a) {}");
Manuel Klimeke7d10a12013-01-10 13:24:24 +00003110 verifyFormat("int main(int argc, char **argv) {}");
Daniel Jasper5065bc42013-02-18 12:44:35 +00003111 verifyFormat("Test::Test(int b) : a(b * b) {}");
Daniel Jasper5b49f472013-01-23 12:10:53 +00003112 verifyIndependentOfContext("f(a, *a);");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00003113 verifyFormat("void g() { f(*a); }");
Daniel Jasper5b49f472013-01-23 12:10:53 +00003114 verifyIndependentOfContext("int a = b * 10;");
3115 verifyIndependentOfContext("int a = 10 * b;");
3116 verifyIndependentOfContext("int a = b * c;");
3117 verifyIndependentOfContext("int a += b * c;");
3118 verifyIndependentOfContext("int a -= b * c;");
3119 verifyIndependentOfContext("int a *= b * c;");
3120 verifyIndependentOfContext("int a /= b * c;");
3121 verifyIndependentOfContext("int a = *b;");
3122 verifyIndependentOfContext("int a = *b * c;");
3123 verifyIndependentOfContext("int a = b * *c;");
3124 verifyIndependentOfContext("return 10 * b;");
3125 verifyIndependentOfContext("return *b * *c;");
3126 verifyIndependentOfContext("return a & ~b;");
3127 verifyIndependentOfContext("f(b ? *c : *d);");
3128 verifyIndependentOfContext("int a = b ? *c : *d;");
3129 verifyIndependentOfContext("*b = a;");
3130 verifyIndependentOfContext("a * ~b;");
3131 verifyIndependentOfContext("a * !b;");
3132 verifyIndependentOfContext("a * +b;");
3133 verifyIndependentOfContext("a * -b;");
3134 verifyIndependentOfContext("a * ++b;");
3135 verifyIndependentOfContext("a * --b;");
3136 verifyIndependentOfContext("a[4] * b;");
Daniel Jasper8e559272013-02-27 11:43:50 +00003137 verifyIndependentOfContext("a[a * a] = 1;");
Daniel Jasper5b49f472013-01-23 12:10:53 +00003138 verifyIndependentOfContext("f() * b;");
3139 verifyIndependentOfContext("a * [self dostuff];");
Daniel Jasper6e42b1e2013-04-01 17:13:26 +00003140 verifyIndependentOfContext("int x = a * (a + b);");
Daniel Jasper5b49f472013-01-23 12:10:53 +00003141 verifyIndependentOfContext("(a *)(a + b);");
3142 verifyIndependentOfContext("int *pa = (int *)&a;");
Nico Weber44449172013-02-12 16:17:07 +00003143 verifyIndependentOfContext("return sizeof(int **);");
3144 verifyIndependentOfContext("return sizeof(int ******);");
3145 verifyIndependentOfContext("return (int **&)a;");
Daniel Jasper4d03d3b2013-05-28 15:27:10 +00003146 verifyIndependentOfContext("f((*PointerToArray)[10]);");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00003147 verifyFormat("void f(Type (*parameter)[10]) {}");
Nico Weber44449172013-02-12 16:17:07 +00003148 verifyGoogleFormat("return sizeof(int**);");
3149 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);");
3150 verifyGoogleFormat("Type** A = static_cast<Type**>(P);");
Manuel Klimekab419912013-05-23 09:41:43 +00003151 verifyFormat("auto a = [](int **&, int ***) {};");
Daniel Jasper27234032012-12-07 09:52:15 +00003152
Daniel Jasper5b49f472013-01-23 12:10:53 +00003153 verifyIndependentOfContext("InvalidRegions[*R] = 0;");
Daniel Jasper3c2557d2013-01-04 20:46:38 +00003154
Daniel Jasper5b49f472013-01-23 12:10:53 +00003155 verifyIndependentOfContext("A<int *> a;");
3156 verifyIndependentOfContext("A<int **> a;");
3157 verifyIndependentOfContext("A<int *, int *> a;");
Daniel Jasperc697ad22013-02-06 10:05:46 +00003158 verifyIndependentOfContext(
3159 "const char *const p = reinterpret_cast<const char *const>(q);");
Daniel Jasper5b49f472013-01-23 12:10:53 +00003160 verifyIndependentOfContext("A<int **, int **> a;");
Daniel Jasper8035b0a2013-02-06 10:57:42 +00003161 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);");
Daniel Jasperae907642013-03-14 10:50:25 +00003162 verifyFormat("for (char **a = b; *a; ++a) {\n}");
Daniel Jasperc37de302013-05-03 14:41:24 +00003163 verifyFormat("for (; a && b;) {\n}");
Daniel Jaspera4396862012-12-10 18:59:13 +00003164
Daniel Jasper66dcb1c2013-01-08 20:03:18 +00003165 verifyFormat(
3166 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3167 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
3168
Manuel Klimeke7d10a12013-01-10 13:24:24 +00003169 verifyGoogleFormat("int main(int argc, char** argv) {}");
Daniel Jaspera4396862012-12-10 18:59:13 +00003170 verifyGoogleFormat("A<int*> a;");
3171 verifyGoogleFormat("A<int**> a;");
3172 verifyGoogleFormat("A<int*, int*> a;");
3173 verifyGoogleFormat("A<int**, int**> a;");
Daniel Jasper22bcf8a2013-01-02 08:57:10 +00003174 verifyGoogleFormat("f(b ? *c : *d);");
3175 verifyGoogleFormat("int a = b ? *c : *d;");
Daniel Jaspera1dc93a2013-01-16 16:04:06 +00003176 verifyGoogleFormat("Type* t = **x;");
3177 verifyGoogleFormat("Type* t = *++*x;");
3178 verifyGoogleFormat("*++*x;");
3179 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);");
3180 verifyGoogleFormat("Type* t = x++ * y;");
Daniel Jasperc697ad22013-02-06 10:05:46 +00003181 verifyGoogleFormat(
3182 "const char* const p = reinterpret_cast<const char* const>(q);");
Manuel Klimek557811f2013-01-14 10:58:01 +00003183
Daniel Jasper5b49f472013-01-23 12:10:53 +00003184 verifyIndependentOfContext("a = *(x + y);");
3185 verifyIndependentOfContext("a = &(x + y);");
3186 verifyIndependentOfContext("*(x + y).call();");
3187 verifyIndependentOfContext("&(x + y)->call();");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00003188 verifyFormat("void f() { &(*I).first; }");
Daniel Jasper71945272013-01-15 14:27:39 +00003189
Daniel Jasper5b49f472013-01-23 12:10:53 +00003190 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
Daniel Jasper71945272013-01-15 14:27:39 +00003191 verifyFormat(
3192 "int *MyValues = {\n"
3193 " *A, // Operator detection might be confused by the '{'\n"
3194 " *BB // Operator detection might be confused by previous comment\n"
3195 "};");
Nico Weber80a82762013-01-17 17:17:19 +00003196
Daniel Jasper5b49f472013-01-23 12:10:53 +00003197 verifyIndependentOfContext("if (int *a = &b)");
3198 verifyIndependentOfContext("if (int &a = *b)");
3199 verifyIndependentOfContext("if (a & b[i])");
3200 verifyIndependentOfContext("if (a::b::c::d & b[i])");
3201 verifyIndependentOfContext("if (*b[i])");
3202 verifyIndependentOfContext("if (int *a = (&b))");
3203 verifyIndependentOfContext("while (int *a = &b)");
Daniel Jasper420d7d32013-01-23 12:58:14 +00003204 verifyFormat("void f() {\n"
3205 " for (const int &v : Values) {\n"
3206 " }\n"
3207 "}");
Daniel Jasper5065bc42013-02-18 12:44:35 +00003208 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
3209 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
Daniel Jasper0b820602013-01-22 11:46:26 +00003210
Daniel Jasperb910bbb2013-05-13 07:14:40 +00003211 verifyFormat("#define MACRO \\\n"
3212 " int *i = a * b; \\\n"
3213 " void f(a *b);",
3214 getLLVMStyleWithColumns(19));
3215
Daniel Jasper97b89482013-03-13 07:49:51 +00003216 verifyIndependentOfContext("A = new SomeType *[Length];");
Daniel Jasper5b49f472013-01-23 12:10:53 +00003217 verifyIndependentOfContext("A = new SomeType *[Length]();");
Daniel Jasper0b820602013-01-22 11:46:26 +00003218 verifyGoogleFormat("A = new SomeType* [Length]();");
Daniel Jasper97b89482013-03-13 07:49:51 +00003219 verifyGoogleFormat("A = new SomeType* [Length];");
Daniel Jasperb910bbb2013-05-13 07:14:40 +00003220
Daniel Jasper990ff972013-05-07 14:17:18 +00003221 FormatStyle PointerLeft = getLLVMStyle();
3222 PointerLeft.PointerBindsToType = true;
3223 verifyFormat("delete *x;", PointerLeft);
Daniel Jasper8eb371b2013-03-01 17:13:29 +00003224}
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00003225
Daniel Jasper10cd5812013-05-06 06:35:44 +00003226TEST_F(FormatTest, UnderstandsEllipsis) {
3227 verifyFormat("int printf(const char *fmt, ...);");
3228 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
3229}
3230
Daniel Jasper8eb371b2013-03-01 17:13:29 +00003231TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00003232 EXPECT_EQ("int *a;\n"
3233 "int *a;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003234 "int *a;",
3235 format("int *a;\n"
3236 "int* a;\n"
3237 "int *a;",
3238 getGoogleStyle()));
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00003239 EXPECT_EQ("int* a;\n"
3240 "int* a;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003241 "int* a;",
3242 format("int* a;\n"
3243 "int* a;\n"
3244 "int *a;",
3245 getGoogleStyle()));
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00003246 EXPECT_EQ("int *a;\n"
3247 "int *a;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003248 "int *a;",
3249 format("int *a;\n"
3250 "int * a;\n"
3251 "int * a;",
3252 getGoogleStyle()));
Daniel Jasperf7935112012-12-03 18:12:45 +00003253}
3254
Alexander Kornienkoa5151272013-03-12 16:28:18 +00003255TEST_F(FormatTest, UnderstandsRvalueReferences) {
3256 verifyFormat("int f(int &&a) {}");
3257 verifyFormat("int f(int a, char &&b) {}");
3258 verifyFormat("void f() { int &&a = b; }");
3259 verifyGoogleFormat("int f(int a, char&& b) {}");
3260 verifyGoogleFormat("void f() { int&& a = b; }");
3261
Daniel Jasper1eff9082013-05-27 16:36:33 +00003262 verifyIndependentOfContext("A<int &&> a;");
3263 verifyIndependentOfContext("A<int &&, int &&> a;");
3264 verifyGoogleFormat("A<int&&> a;");
3265 verifyGoogleFormat("A<int&&, int&&> a;");
Alexander Kornienkoa5151272013-03-12 16:28:18 +00003266}
3267
Manuel Klimekc1237a82013-01-23 14:08:21 +00003268TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
3269 verifyFormat("void f() {\n"
3270 " x[aaaaaaaaa -\n"
Daniel Jasper6bee6822013-04-08 20:33:42 +00003271 " b] = 23;\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003272 "}",
3273 getLLVMStyleWithColumns(15));
Manuel Klimekc1237a82013-01-23 14:08:21 +00003274}
3275
Daniel Jasperef906a92013-01-13 08:01:36 +00003276TEST_F(FormatTest, FormatsCasts) {
3277 verifyFormat("Type *A = static_cast<Type *>(P);");
3278 verifyFormat("Type *A = (Type *)P;");
3279 verifyFormat("Type *A = (vector<Type *, int *>)P;");
3280 verifyFormat("int a = (int)(2.0f);");
Daniel Jasperda6f2252013-05-31 16:14:28 +00003281 verifyFormat("int a = (int)2.0f;");
3282 verifyFormat("x[(int32)y];");
3283 verifyFormat("x = (int32)y;");
3284 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
3285 verifyFormat("int a = (int)*b;");
3286 verifyFormat("int a = (int)2.0f;");
3287 verifyFormat("int a = (int)~0;");
3288 verifyFormat("int a = (int)++a;");
3289 verifyFormat("int a = (int)sizeof(int);");
3290 verifyFormat("int a = (int)+2;");
3291 verifyFormat("my_int a = (my_int)2.0f;");
3292 verifyFormat("my_int a = (my_int)sizeof(int);");
Daniel Jasper05866372013-06-06 08:20:20 +00003293 verifyFormat("return (my_int)aaa;");
Daniel Jasperef906a92013-01-13 08:01:36 +00003294
Daniel Jasperda6f2252013-05-31 16:14:28 +00003295 // FIXME: Without type knowledge, this can still fall apart miserably.
3296 verifyFormat("void f() { my_int a = (my_int) * b; }");
Alexander Kornienkodd7ece52013-06-07 16:02:52 +00003297 verifyFormat("void f() { return P ? (my_int) * P : (my_int)0; }");
Daniel Jasperda6f2252013-05-31 16:14:28 +00003298 verifyFormat("my_int a = (my_int) ~0;");
3299 verifyFormat("my_int a = (my_int)++ a;");
3300 verifyFormat("my_int a = (my_int) + 2;");
Daniel Jasperef906a92013-01-13 08:01:36 +00003301
3302 // These are not casts.
3303 verifyFormat("void f(int *) {}");
Nico Weber4401b2a2013-02-13 04:32:57 +00003304 verifyFormat("f(foo)->b;");
3305 verifyFormat("f(foo).b;");
3306 verifyFormat("f(foo)(b);");
3307 verifyFormat("f(foo)[b];");
3308 verifyFormat("[](foo) { return 4; }(bar)];");
3309 verifyFormat("(*funptr)(foo)[4];");
3310 verifyFormat("funptrs[4](foo)[4];");
Daniel Jasperef906a92013-01-13 08:01:36 +00003311 verifyFormat("void f(int *);");
3312 verifyFormat("void f(int *) = 0;");
3313 verifyFormat("void f(SmallVector<int>) {}");
3314 verifyFormat("void f(SmallVector<int>);");
3315 verifyFormat("void f(SmallVector<int>) = 0;");
Nico Weber06fcec12013-02-09 18:02:07 +00003316 verifyFormat("void f(int i = (kValue) * kMask) {}");
3317 verifyFormat("void f(int i = (kA * kB) & kMask) {}");
Nico Weber4401b2a2013-02-13 04:32:57 +00003318 verifyFormat("int a = sizeof(int) * b;");
3319 verifyFormat("int a = alignof(int) * b;");
Daniel Jasper05866372013-06-06 08:20:20 +00003320 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
3321 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003322
Daniel Jasperba0bda92013-02-23 08:07:18 +00003323 // These are not casts, but at some point were confused with casts.
3324 verifyFormat("virtual void foo(int *) override;");
3325 verifyFormat("virtual void foo(char &) const;");
3326 verifyFormat("virtual void foo(int *a, char *) const;");
Daniel Jasper8a68b952013-03-13 17:13:53 +00003327 verifyFormat("int a = sizeof(int *) + b;");
3328 verifyFormat("int a = alignof(int *) + b;");
Daniel Jasperef906a92013-01-13 08:01:36 +00003329}
3330
Daniel Jasperc1fa2812013-01-10 13:08:12 +00003331TEST_F(FormatTest, FormatsFunctionTypes) {
Daniel Jasperc1fa2812013-01-10 13:08:12 +00003332 verifyFormat("A<bool()> a;");
3333 verifyFormat("A<SomeType()> a;");
Daniel Jasper37194282013-05-28 08:33:00 +00003334 verifyFormat("A<void (*)(int, std::string)> a;");
Daniel Jasperb8914dd2013-03-20 09:53:18 +00003335 verifyFormat("A<void *(int)>;");
Daniel Jasper6e42b1e2013-04-01 17:13:26 +00003336 verifyFormat("void *(*a)(int *, SomeType *);");
Daniel Jasper8eb371b2013-03-01 17:13:29 +00003337 verifyFormat("int (*func)(void *);");
Daniel Jasper37194282013-05-28 08:33:00 +00003338 verifyFormat("void f() { int (*func)(void *); }");
Daniel Jasperb8914dd2013-03-20 09:53:18 +00003339
Daniel Jasper6e42b1e2013-04-01 17:13:26 +00003340 verifyGoogleFormat("A<void*(int*, SomeType*)>;");
3341 verifyGoogleFormat("void* (*a)(int);");
Daniel Jasperabc34212013-05-14 08:34:47 +00003342
Daniel Jasper5dad58e2013-05-15 07:51:51 +00003343 // Other constructs can look somewhat like function types:
Daniel Jasperabc34212013-05-14 08:34:47 +00003344 verifyFormat("A<sizeof(*x)> a;");
Daniel Jasper5dad58e2013-05-15 07:51:51 +00003345 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
Daniel Jasperc1fa2812013-01-10 13:08:12 +00003346}
3347
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00003348TEST_F(FormatTest, BreaksLongDeclarations) {
Daniel Jasper8e357692013-05-06 08:27:33 +00003349 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
3350 " AnotherNameForTheLongType;");
3351 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
3352 " LoooooooooooooooooooooooooooooooooooooooongVariable;");
3353 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
3354 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
3355 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
3356 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
3357
3358 // FIXME: Without the comment, this breaks after "(".
3359 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n"
3360 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();");
3361
Daniel Jasperd2639ef2013-01-28 15:16:31 +00003362 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003363 " int LoooooooooooooooooooongParam2) {}");
Daniel Jasperd1926a32013-01-02 08:44:14 +00003364 verifyFormat(
Daniel Jasper6728fc12013-04-11 14:29:13 +00003365 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
3366 " SourceLocation L, IdentifierIn *II,\n"
3367 " Type *T) {}");
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00003368 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
3369 "ReallyReallyLongFunctionName(\n"
3370 " const std::string &SomeParameter,\n"
3371 " const SomeType<string, SomeOtherTemplateParameter> &\n"
3372 " ReallyReallyLongParameterName,\n"
3373 " const SomeType<string, SomeOtherTemplateParameter> &\n"
3374 " AnotherLongParameterName) {}");
Daniel Jasperc6fbc212013-05-15 09:35:08 +00003375 verifyFormat("template <typename A>\n"
3376 "SomeLoooooooooooooooooooooongType<\n"
3377 " typename some_namespace::SomeOtherType<A>::Type>\n"
3378 "Function() {}");
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00003379 verifyFormat(
3380 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
Daniel Jasper8e357692013-05-06 08:27:33 +00003381 " aaaaaaaaaaaaaaaaaaaaaaa;");
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00003382
Daniel Jasperd36ef5e2013-01-28 15:40:20 +00003383 verifyGoogleFormat(
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003384 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
3385 " SourceLocation L) {}");
Daniel Jasperb9caeac2013-02-13 20:33:44 +00003386 verifyGoogleFormat(
3387 "some_namespace::LongReturnType\n"
3388 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003389 " int first_long_parameter, int second_parameter) {}");
Daniel Jasperb9caeac2013-02-13 20:33:44 +00003390
3391 verifyGoogleFormat("template <typename T>\n"
3392 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
Daniel Jasper12ef4e52013-02-21 21:33:55 +00003393 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
Daniel Jasper57d4a582013-02-28 10:06:05 +00003394 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3395 " int aaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperd1926a32013-01-02 08:44:14 +00003396}
3397
Daniel Jaspere9de2602012-12-06 09:56:08 +00003398TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
3399 verifyFormat("(a)->b();");
3400 verifyFormat("--a;");
3401}
3402
Daniel Jasper8b529712012-12-04 13:02:32 +00003403TEST_F(FormatTest, HandlesIncludeDirectives) {
Daniel Jasper2ab0d012013-01-14 15:52:06 +00003404 verifyFormat("#include <string>\n"
3405 "#include <a/b/c.h>\n"
3406 "#include \"a/b/string\"\n"
3407 "#include \"string.h\"\n"
3408 "#include \"string.h\"\n"
Manuel Klimek99c7baa2013-01-15 15:50:27 +00003409 "#include <a-a>\n"
Daniel Jasperaf5ba0e2013-02-23 07:46:38 +00003410 "#include < path with space >\n"
Daniel Jasper4a4be012013-05-06 10:24:51 +00003411 "#include \"abc.h\" // this is included for ABC\n"
Daniel Jasper8bb99e82013-05-16 12:59:13 +00003412 "#include \"some long include\" // with a comment\n"
Daniel Jasperaf5ba0e2013-02-23 07:46:38 +00003413 "#include \"some very long include paaaaaaaaaaaaaaaaaaaaaaath\"",
3414 getLLVMStyleWithColumns(35));
Nico Weber8f83ee42012-12-21 18:21:56 +00003415
Daniel Jasper5ef433f2013-01-13 08:12:18 +00003416 verifyFormat("#import <string>");
3417 verifyFormat("#import <a/b/c.h>");
3418 verifyFormat("#import \"a/b/string\"");
3419 verifyFormat("#import \"string.h\"");
3420 verifyFormat("#import \"string.h\"");
Daniel Jasper8b529712012-12-04 13:02:32 +00003421}
3422
Alexander Kornienko578fdd82012-12-06 18:03:27 +00003423//===----------------------------------------------------------------------===//
3424// Error recovery tests.
3425//===----------------------------------------------------------------------===//
3426
Daniel Jasper66e9dee2013-02-14 09:19:04 +00003427TEST_F(FormatTest, IncompleteParameterLists) {
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003428 FormatStyle NoBinPacking = getLLVMStyle();
3429 NoBinPacking.BinPackParameters = false;
3430 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
3431 " double *min_x,\n"
3432 " double *max_x,\n"
3433 " double *min_y,\n"
3434 " double *max_y,\n"
3435 " double *min_z,\n"
3436 " double *max_z, ) {}",
3437 NoBinPacking);
Daniel Jasper66e9dee2013-02-14 09:19:04 +00003438}
3439
Daniel Jasper83a54d22013-01-10 09:26:47 +00003440TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
Alexander Kornienkoae6e53c2013-01-16 11:45:16 +00003441 verifyFormat("void f() { return; }\n42");
3442 verifyFormat("void f() {\n"
3443 " if (0)\n"
3444 " return;\n"
3445 "}\n"
3446 "42");
Alexander Kornienko1231e062013-01-16 11:43:46 +00003447 verifyFormat("void f() { return }\n42");
3448 verifyFormat("void f() {\n"
3449 " if (0)\n"
3450 " return\n"
3451 "}\n"
3452 "42");
3453}
3454
3455TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
3456 EXPECT_EQ("void f() { return }", format("void f ( ) { return }"));
3457 EXPECT_EQ("void f() {\n"
3458 " if (a)\n"
3459 " return\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003460 "}",
3461 format("void f ( ) { if ( a ) return }"));
Daniel Jasperabca58c2013-05-15 14:09:55 +00003462 EXPECT_EQ("namespace N {\n"
3463 "void f()\n"
3464 "}",
3465 format("namespace N { void f() }"));
Alexander Kornienko1231e062013-01-16 11:43:46 +00003466 EXPECT_EQ("namespace N {\n"
3467 "void f() {}\n"
3468 "void g()\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003469 "}",
3470 format("namespace N { void f( ) { } void g( ) }"));
Daniel Jasper83a54d22013-01-10 09:26:47 +00003471}
3472
Daniel Jasper2df93312013-01-09 10:16:05 +00003473TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
3474 verifyFormat("int aaaaaaaa =\n"
Alexander Kornienkoffd6d042013-03-27 11:52:18 +00003475 " // Overlylongcomment\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003476 " b;",
3477 getLLVMStyleWithColumns(20));
Daniel Jasper2df93312013-01-09 10:16:05 +00003478 verifyFormat("function(\n"
3479 " ShortArgument,\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003480 " LoooooooooooongArgument);\n",
3481 getLLVMStyleWithColumns(20));
Daniel Jasper2df93312013-01-09 10:16:05 +00003482}
3483
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00003484TEST_F(FormatTest, IncorrectAccessSpecifier) {
3485 verifyFormat("public:");
3486 verifyFormat("class A {\n"
3487 "public\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00003488 " void f() {}\n"
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00003489 "};");
3490 verifyFormat("public\n"
3491 "int qwerty;");
3492 verifyFormat("public\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00003493 "B {}");
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00003494 verifyFormat("public\n"
Manuel Klimeke7d10a12013-01-10 13:24:24 +00003495 "{}");
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00003496 verifyFormat("public\n"
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00003497 "B { int x; }");
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00003498}
Daniel Jasperf7935112012-12-03 18:12:45 +00003499
Daniel Jasper291f9362013-03-20 15:58:10 +00003500TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
3501 verifyFormat("{");
3502 verifyFormat("#})");
3503}
Alexander Kornienko0ea8e102012-12-04 15:40:36 +00003504
3505TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003506 verifyFormat("do {\n}");
3507 verifyFormat("do {\n}\n"
Alexander Kornienko0ea8e102012-12-04 15:40:36 +00003508 "f();");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003509 verifyFormat("do {\n}\n"
Alexander Kornienko0ea8e102012-12-04 15:40:36 +00003510 "wheeee(fun);");
3511 verifyFormat("do {\n"
3512 " f();\n"
Manuel Klimek28cacc72013-01-07 18:10:23 +00003513 "}");
Alexander Kornienko0ea8e102012-12-04 15:40:36 +00003514}
3515
Manuel Klimek9fa8d552013-01-11 19:23:05 +00003516TEST_F(FormatTest, IncorrectCodeMissingParens) {
Manuel Klimekadededf2013-01-11 18:28:36 +00003517 verifyFormat("if {\n foo;\n foo();\n}");
Manuel Klimek9fa8d552013-01-11 19:23:05 +00003518 verifyFormat("switch {\n foo;\n foo();\n}");
3519 verifyFormat("for {\n foo;\n foo();\n}");
3520 verifyFormat("while {\n foo;\n foo();\n}");
3521 verifyFormat("do {\n foo;\n foo();\n} while;");
Manuel Klimekadededf2013-01-11 18:28:36 +00003522}
3523
Daniel Jasperc0880a92013-01-04 18:52:56 +00003524TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
3525 verifyFormat("namespace {\n"
Daniel Jasper393564f2013-05-31 14:56:29 +00003526 "class Foo { Foo (\n"
3527 "};\n"
3528 "} // comment");
Daniel Jasperc0880a92013-01-04 18:52:56 +00003529}
3530
Alexander Kornienko870f9eb2012-12-04 17:27:50 +00003531TEST_F(FormatTest, IncorrectCodeErrorDetection) {
Manuel Klimeke7d10a12013-01-10 13:24:24 +00003532 EXPECT_EQ("{\n{}\n", format("{\n{\n}\n"));
3533 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n"));
3534 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n"));
3535 EXPECT_EQ("{\n {}\n }\n}\n", format("{\n {\n }\n }\n}\n"));
Alexander Kornienko870f9eb2012-12-04 17:27:50 +00003536
Alexander Kornienko870f9eb2012-12-04 17:27:50 +00003537 EXPECT_EQ("{\n"
3538 " {\n"
3539 " breakme(\n"
3540 " qwe);\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003541 "}\n",
3542 format("{\n"
3543 " {\n"
3544 " breakme(qwe);\n"
3545 "}\n",
3546 getLLVMStyleWithColumns(10)));
Alexander Kornienko870f9eb2012-12-04 17:27:50 +00003547}
3548
Manuel Klimek73a2fdf2013-01-10 14:36:46 +00003549TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003550 verifyFormat("int x = {\n"
3551 " avariable,\n"
3552 " b(alongervariable)\n"
3553 "};",
3554 getLLVMStyleWithColumns(25));
Manuel Klimek73a2fdf2013-01-10 14:36:46 +00003555}
3556
Manuel Klimek762dd182013-01-21 10:07:49 +00003557TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
3558 verifyFormat("return (a)(b) { 1, 2, 3 };");
3559}
3560
Manuel Klimekab419912013-05-23 09:41:43 +00003561TEST_F(FormatTest, LayoutCxx11ConstructorBraceInitializers) {
Daniel Jaspere5777d22013-05-23 10:15:45 +00003562 verifyFormat("vector<int> x{ 1, 2, 3, 4 };");
3563 verifyFormat("vector<T> x{ {}, {}, {}, {} };");
Manuel Klimekab419912013-05-23 09:41:43 +00003564 verifyFormat("f({ 1, 2 });");
Daniel Jaspere5777d22013-05-23 10:15:45 +00003565 verifyFormat("auto v = Foo{ 1 };");
Manuel Klimekab419912013-05-23 09:41:43 +00003566 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });");
Daniel Jasperd4432392013-05-23 18:29:16 +00003567 verifyFormat("Class::Class : member{ 1, 2, 3 } {}");
Daniel Jasperf632f692013-05-23 21:35:49 +00003568 verifyFormat("new vector<int>{ 1, 2, 3 };");
3569 verifyFormat("new int[3]{ 1, 2, 3 };");
Daniel Jasperd4432392013-05-23 18:29:16 +00003570 verifyFormat("return { arg1, arg2 };");
Daniel Jasper1ec31062013-05-28 18:50:02 +00003571 verifyFormat("return { arg1, SomeType{ parameter } };");
Daniel Jasperd4432392013-05-23 18:29:16 +00003572 verifyFormat("new T{ arg1, arg2 };");
3573 verifyFormat("class Class {\n"
3574 " T member = { arg1, arg2 };\n"
3575 "};");
Daniel Jasper5648cb32013-05-31 10:09:55 +00003576 verifyFormat(
3577 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3578 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
3579 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
3580 " bbbbbbbbbbbbbbbbbbbb, bbbbb };");
Daniel Jaspere5777d22013-05-23 10:15:45 +00003581
3582 FormatStyle NoSpaces = getLLVMStyle();
3583 NoSpaces.SpacesInBracedLists = false;
3584 verifyFormat("vector<int> x{1, 2, 3, 4};", NoSpaces);
3585 verifyFormat("vector<T> x{{}, {}, {}, {}};", NoSpaces);
3586 verifyFormat("f({1, 2});", NoSpaces);
Daniel Jasper5bd0b9e2013-05-23 18:05:18 +00003587 verifyFormat("auto v = Foo{-1};", NoSpaces);
Daniel Jaspere5777d22013-05-23 10:15:45 +00003588 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});", NoSpaces);
Daniel Jasperd4432392013-05-23 18:29:16 +00003589 verifyFormat("Class::Class : member{1, 2, 3} {}", NoSpaces);
Daniel Jasperf632f692013-05-23 21:35:49 +00003590 verifyFormat("new vector<int>{1, 2, 3};", NoSpaces);
3591 verifyFormat("new int[3]{1, 2, 3};", NoSpaces);
Daniel Jasperd4432392013-05-23 18:29:16 +00003592 verifyFormat("return {arg1, arg2};", NoSpaces);
Daniel Jasper1ec31062013-05-28 18:50:02 +00003593 verifyFormat("return {arg1, SomeType{parameter}};", NoSpaces);
Daniel Jasperd4432392013-05-23 18:29:16 +00003594 verifyFormat("new T{arg1, arg2};", NoSpaces);
3595 verifyFormat("class Class {\n"
3596 " T member = {arg1, arg2};\n"
3597 "};",
3598 NoSpaces);
Manuel Klimekab419912013-05-23 09:41:43 +00003599}
3600
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00003601TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
3602 verifyFormat("void f() { return 42; }");
3603 verifyFormat("void f() {\n"
3604 " // Comment\n"
3605 "}");
3606 verifyFormat("{\n"
3607 "#error {\n"
3608 " int a;\n"
3609 "}");
3610 verifyFormat("{\n"
3611 " int a;\n"
3612 "#error {\n"
3613 "}");
Daniel Jasperf9eb9b12013-05-16 10:17:39 +00003614 verifyFormat("void f() {} // comment");
3615 verifyFormat("void f() { int a; } // comment");
Daniel Jasper92716502013-05-16 16:54:34 +00003616 verifyFormat("void f() {\n"
3617 "} // comment",
3618 getLLVMStyleWithColumns(15));
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003619
3620 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
3621 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22));
3622
3623 verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
3624 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
Manuel Klimekf4ab9ef2013-01-11 17:54:10 +00003625}
3626
Manuel Klimeke01bab52013-01-15 13:38:33 +00003627TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
3628 // Elaborate type variable declarations.
Manuel Klimekd5e5f8f2013-01-11 18:13:04 +00003629 verifyFormat("struct foo a = { bar };\nint n;");
Manuel Klimeke01bab52013-01-15 13:38:33 +00003630 verifyFormat("class foo a = { bar };\nint n;");
3631 verifyFormat("union foo a = { bar };\nint n;");
3632
3633 // Elaborate types inside function definitions.
3634 verifyFormat("struct foo f() {}\nint n;");
3635 verifyFormat("class foo f() {}\nint n;");
3636 verifyFormat("union foo f() {}\nint n;");
3637
3638 // Templates.
3639 verifyFormat("template <class X> void f() {}\nint n;");
3640 verifyFormat("template <struct X> void f() {}\nint n;");
3641 verifyFormat("template <union X> void f() {}\nint n;");
3642
3643 // Actual definitions...
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003644 verifyFormat("struct {\n} n;");
3645 verifyFormat(
3646 "template <template <class T, class Y>, class Z> class X {\n} n;");
Manuel Klimeke01bab52013-01-15 13:38:33 +00003647 verifyFormat("union Z {\n int n;\n} x;");
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003648 verifyFormat("class MACRO Z {\n} n;");
3649 verifyFormat("class MACRO(X) Z {\n} n;");
3650 verifyFormat("class __attribute__(X) Z {\n} n;");
3651 verifyFormat("class __declspec(X) Z {\n} n;");
Manuel Klimekd2650902013-02-06 15:57:54 +00003652 verifyFormat("class A##B##C {\n} n;");
Manuel Klimeke01bab52013-01-15 13:38:33 +00003653
Manuel Klimek3c6b7c72013-01-21 10:17:14 +00003654 // Redefinition from nested context:
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003655 verifyFormat("class A::B::C {\n} n;");
Manuel Klimek3c6b7c72013-01-21 10:17:14 +00003656
Manuel Klimekcdee74d2013-01-21 13:58:54 +00003657 // Template definitions.
Daniel Jasper6f05e592013-05-15 13:46:48 +00003658 verifyFormat(
3659 "template <typename F>\n"
3660 "Matcher(const Matcher<F> &Other,\n"
3661 " typename enable_if_c<is_base_of<F, T>::value &&\n"
3662 " !is_same<F, T>::value>::type * = 0)\n"
3663 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
3664
Manuel Klimekcdee74d2013-01-21 13:58:54 +00003665 // FIXME: This is still incorrectly handled at the formatter side.
Daniel Jaspera9eb2aa2013-05-31 14:56:20 +00003666 verifyFormat("template <> struct X < 15, i < 3 && 42 < 50 && 33<28> {};");
Manuel Klimekcdee74d2013-01-21 13:58:54 +00003667
3668 // FIXME:
3669 // This now gets parsed incorrectly as class definition.
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00003670 // verifyFormat("class A<int> f() {\n}\nint n;");
Manuel Klimekcdee74d2013-01-21 13:58:54 +00003671
Manuel Klimeke01bab52013-01-15 13:38:33 +00003672 // Elaborate types where incorrectly parsing the structural element would
3673 // break the indent.
3674 verifyFormat("if (true)\n"
3675 " class X x;\n"
3676 "else\n"
3677 " f();\n");
Daniel Jasper1a32a612013-03-20 15:12:38 +00003678
3679 // This is simply incomplete. Formatting is not important, but must not crash.
3680 verifyFormat("class A:");
Manuel Klimekd5e5f8f2013-01-11 18:13:04 +00003681}
3682
Manuel Klimek99c7baa2013-01-15 15:50:27 +00003683TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
3684 verifyFormat("#error Leave all white!!!!! space* alone!\n");
3685 verifyFormat("#warning Leave all white!!!!! space* alone!\n");
3686 EXPECT_EQ("#error 1", format(" # error 1"));
3687 EXPECT_EQ("#warning 1", format(" # warning 1"));
3688}
3689
Daniel Jasper4431aa92013-04-23 13:54:04 +00003690TEST_F(FormatTest, FormatHashIfExpressions) {
3691 // FIXME: Come up with a better indentation for #elif.
3692 verifyFormat(
3693 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n"
3694 " defined(BBBBBBBB)\n"
3695 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n"
3696 " defined(BBBBBBBB)\n"
3697 "#endif",
3698 getLLVMStyleWithColumns(65));
3699}
3700
Manuel Klimekd3b92fa2013-01-18 14:04:34 +00003701TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
3702 FormatStyle AllowsMergedIf = getGoogleStyle();
3703 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true;
3704 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
3705 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
Manuel Klimekda087612013-01-18 14:46:43 +00003706 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf);
3707 EXPECT_EQ("if (true) return 42;",
3708 format("if (true)\nreturn 42;", AllowsMergedIf));
3709 FormatStyle ShortMergedIf = AllowsMergedIf;
3710 ShortMergedIf.ColumnLimit = 25;
Daniel Jasper6fe2f002013-04-25 08:56:26 +00003711 verifyFormat("#define A \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003712 " if (true) return 42;",
3713 ShortMergedIf);
Daniel Jasper6fe2f002013-04-25 08:56:26 +00003714 verifyFormat("#define A \\\n"
3715 " f(); \\\n"
Manuel Klimekda087612013-01-18 14:46:43 +00003716 " if (true)\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003717 "#define B",
3718 ShortMergedIf);
Daniel Jasper6fe2f002013-04-25 08:56:26 +00003719 verifyFormat("#define A \\\n"
3720 " f(); \\\n"
Manuel Klimekda087612013-01-18 14:46:43 +00003721 " if (true)\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003722 "g();",
3723 ShortMergedIf);
Manuel Klimekd5e782b2013-01-21 14:16:56 +00003724 verifyFormat("{\n"
3725 "#ifdef A\n"
3726 " // Comment\n"
3727 " if (true) continue;\n"
3728 "#endif\n"
3729 " // Comment\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003730 " if (true) continue;",
3731 ShortMergedIf);
Manuel Klimekd3b92fa2013-01-18 14:04:34 +00003732}
3733
Manuel Klimekf92f7bc2013-01-22 16:31:55 +00003734TEST_F(FormatTest, BlockCommentsInControlLoops) {
3735 verifyFormat("if (0) /* a comment in a strange place */ {\n"
3736 " f();\n"
3737 "}");
3738 verifyFormat("if (0) /* a comment in a strange place */ {\n"
3739 " f();\n"
3740 "} /* another comment */ else /* comment #3 */ {\n"
3741 " g();\n"
3742 "}");
3743 verifyFormat("while (0) /* a comment in a strange place */ {\n"
3744 " f();\n"
3745 "}");
3746 verifyFormat("for (;;) /* a comment in a strange place */ {\n"
3747 " f();\n"
3748 "}");
3749 verifyFormat("do /* a comment in a strange place */ {\n"
3750 " f();\n"
3751 "} /* another comment */ while (0);");
3752}
3753
3754TEST_F(FormatTest, BlockComments) {
3755 EXPECT_EQ("/* */ /* */ /* */\n/* */ /* */ /* */",
3756 format("/* *//* */ /* */\n/* *//* */ /* */"));
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003757 EXPECT_EQ("/* */ a /* */ b;", format(" /* */ a/* */ b;"));
Alexander Kornienko547a9f522013-03-21 12:28:10 +00003758 EXPECT_EQ("#define A /*123*/\\\n"
Manuel Klimekf92f7bc2013-01-22 16:31:55 +00003759 " b\n"
3760 "/* */\n"
3761 "someCall(\n"
3762 " parameter);",
Alexander Kornienko547a9f522013-03-21 12:28:10 +00003763 format("#define A /*123*/ b\n"
Manuel Klimekf92f7bc2013-01-22 16:31:55 +00003764 "/* */\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003765 "someCall(parameter);",
3766 getLLVMStyleWithColumns(15)));
Manuel Klimekf92f7bc2013-01-22 16:31:55 +00003767
3768 EXPECT_EQ("#define A\n"
3769 "/* */ someCall(\n"
3770 " parameter);",
3771 format("#define A\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003772 "/* */someCall(parameter);",
3773 getLLVMStyleWithColumns(15)));
Daniel Jasper51fb2b22013-05-30 06:40:07 +00003774 EXPECT_EQ("/*\n**\n*/", format("/*\n**\n*/"));
Daniel Jasper58dd2f02013-05-30 15:20:29 +00003775 EXPECT_EQ("/*\n"
3776 "*\n"
3777 " * aaaaaa\n"
Daniel Jasperce257f22013-05-30 17:27:48 +00003778 "* aaaaaa\n"
Daniel Jasper58dd2f02013-05-30 15:20:29 +00003779 "*/",
3780 format("/*\n"
3781 "*\n"
3782 " * aaaaaa aaaaaa\n"
3783 "*/",
3784 getLLVMStyleWithColumns(10)));
Daniel Jasperce257f22013-05-30 17:27:48 +00003785 EXPECT_EQ("/*\n"
3786 "**\n"
3787 "* aaaaaa\n"
3788 "* aaaaaa\n"
3789 "*/",
3790 format("/*\n"
3791 "**\n"
3792 "* aaaaaa aaaaaa\n"
3793 "*/",
3794 getLLVMStyleWithColumns(10)));
Daniel Jasper1f140982013-02-04 07:32:14 +00003795
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003796 FormatStyle NoBinPacking = getLLVMStyle();
3797 NoBinPacking.BinPackParameters = false;
Daniel Jasper1f140982013-02-04 07:32:14 +00003798 EXPECT_EQ("someFunction(1, /* comment 1 */\n"
3799 " 2, /* comment 2 */\n"
3800 " 3, /* comment 3 */\n"
Daniel Jasper14e40ec2013-02-04 08:34:57 +00003801 " aaaa,\n"
3802 " bbbb);",
Daniel Jasper1f140982013-02-04 07:32:14 +00003803 format("someFunction (1, /* comment 1 */\n"
3804 " 2, /* comment 2 */ \n"
3805 " 3, /* comment 3 */\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003806 "aaaa, bbbb );",
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00003807 NoBinPacking));
Daniel Jasper38396592013-02-06 15:23:09 +00003808 verifyFormat(
3809 "bool aaaaaaaaaaaaa = /* comment: */ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3810 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
3811 EXPECT_EQ(
3812 "bool aaaaaaaaaaaaa = /* trailing comment */\n"
3813 " aaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3814 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;",
3815 format(
3816 "bool aaaaaaaaaaaaa = /* trailing comment */\n"
3817 " aaaaaaaaaaaaaaaaaaaaaaaaaaa||aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3818 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;"));
Daniel Jasper94f0e132013-02-06 20:07:35 +00003819 EXPECT_EQ(
3820 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n"
3821 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n"
3822 "int cccccccccccccccccccccccccccccc; /* comment */\n",
3823 format("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n"
3824 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n"
3825 "int cccccccccccccccccccccccccccccc; /* comment */\n"));
Manuel Klimekf92f7bc2013-01-22 16:31:55 +00003826}
3827
Manuel Klimek82b836a2013-02-06 16:40:56 +00003828TEST_F(FormatTest, BlockCommentsInMacros) {
3829 EXPECT_EQ("#define A \\\n"
3830 " { \\\n"
3831 " /* one line */ \\\n"
3832 " someCall();",
3833 format("#define A { \\\n"
3834 " /* one line */ \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003835 " someCall();",
3836 getLLVMStyleWithColumns(20)));
Manuel Klimek82b836a2013-02-06 16:40:56 +00003837 EXPECT_EQ("#define A \\\n"
3838 " { \\\n"
3839 " /* previous */ \\\n"
3840 " /* one line */ \\\n"
3841 " someCall();",
3842 format("#define A { \\\n"
3843 " /* previous */ \\\n"
3844 " /* one line */ \\\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003845 " someCall();",
3846 getLLVMStyleWithColumns(20)));
Manuel Klimek82b836a2013-02-06 16:40:56 +00003847}
3848
Manuel Klimekae1fbfb2013-05-29 22:06:18 +00003849TEST_F(FormatTest, BlockCommentsAtEndOfLine) {
3850 EXPECT_EQ("a = {\n"
3851 " 1111 /* */\n"
3852 "};",
3853 format("a = {1111\n"
3854 "/* */\n"
3855 "};",
3856 getLLVMStyleWithColumns(15)));
3857 EXPECT_EQ("a = {\n"
3858 " 1111 /* */\n"
3859 "};",
3860 format("a = {1111\n"
3861 "/* */\n"
3862 "};",
3863 getLLVMStyleWithColumns(15)));
3864
3865 // FIXME: The formatting is still wrong here.
3866 EXPECT_EQ("a = {\n"
3867 " 1111 /* a\n"
3868 " */\n"
3869 "};",
3870 format("a = {1111\n"
3871 "/* a */\n"
3872 "};",
3873 getLLVMStyleWithColumns(15)));
3874}
3875
Manuel Klimek82b836a2013-02-06 16:40:56 +00003876TEST_F(FormatTest, IndentLineCommentsInStartOfBlockAtEndOfFile) {
3877 // FIXME: This is not what we want...
3878 verifyFormat("{\n"
3879 "// a"
3880 "// b");
3881}
3882
Manuel Klimekd33516e2013-01-23 10:09:28 +00003883TEST_F(FormatTest, FormatStarDependingOnContext) {
Manuel Klimek0a3a3c92013-01-23 09:32:48 +00003884 verifyFormat("void f(int *a);");
3885 verifyFormat("void f() { f(fint * b); }");
Manuel Klimek39080572013-01-23 11:03:04 +00003886 verifyFormat("class A {\n void f(int *a);\n};");
3887 verifyFormat("class A {\n int *a;\n};");
3888 verifyFormat("namespace a {\n"
3889 "namespace b {\n"
3890 "class A {\n"
3891 " void f() {}\n"
3892 " int *a;\n"
3893 "};\n"
3894 "}\n"
3895 "}");
Manuel Klimek0a3a3c92013-01-23 09:32:48 +00003896}
3897
Manuel Klimekd33516e2013-01-23 10:09:28 +00003898TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
3899 verifyFormat("while");
3900 verifyFormat("operator");
3901}
3902
Nico Weber7e6a7a12013-01-08 17:56:31 +00003903//===----------------------------------------------------------------------===//
3904// Objective-C tests.
3905//===----------------------------------------------------------------------===//
3906
Fariborz Jahanian68a542a2012-12-20 19:54:13 +00003907TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
3908 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
3909 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
3910 format("-(NSUInteger)indexOfObject:(id)anObject;"));
Daniel Jasper8d1832e2013-01-07 13:26:07 +00003911 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
Fariborz Jahanian68a542a2012-12-20 19:54:13 +00003912 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
3913 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
3914 format("-(NSInteger)Method3:(id)anObject;"));
3915 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
3916 format("-(NSInteger)Method4:(id)anObject;"));
3917 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
3918 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
3919 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
3920 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
Daniel Jasper8d1832e2013-01-07 13:26:07 +00003921 EXPECT_EQ(
3922 "- (void)sendAction:(SEL)aSelector to:(id)anObject forAllCells:(BOOL)flag;",
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00003923 format(
3924 "- (void)sendAction:(SEL)aSelector to:(id)anObject forAllCells:(BOOL)flag;"));
Fariborz Jahanian9017ec32012-12-21 22:51:18 +00003925
3926 // Very long objectiveC method declaration.
Daniel Jasper1ac3e052013-02-05 10:07:47 +00003927 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
3928 " inRange:(NSRange)range\n"
3929 " outRange:(NSRange)out_range\n"
3930 " outRange1:(NSRange)out_range1\n"
3931 " outRange2:(NSRange)out_range2\n"
3932 " outRange3:(NSRange)out_range3\n"
3933 " outRange4:(NSRange)out_range4\n"
3934 " outRange5:(NSRange)out_range5\n"
3935 " outRange6:(NSRange)out_range6\n"
3936 " outRange7:(NSRange)out_range7\n"
3937 " outRange8:(NSRange)out_range8\n"
3938 " outRange9:(NSRange)out_range9;");
Nico Weberd6f962f2013-01-10 20:18:33 +00003939
3940 verifyFormat("- (int)sum:(vector<int>)numbers;");
Nico Weber772fbfd2013-01-17 06:14:50 +00003941 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
Nico Weberd6f962f2013-01-10 20:18:33 +00003942 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
3943 // protocol lists (but not for template classes):
3944 //verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
Nico Weber9efe2912013-01-10 23:11:41 +00003945
Daniel Jasper37194282013-05-28 08:33:00 +00003946 verifyFormat("- (int (*)())foo:(int (*)())f;");
3947 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
Nico Weber9efe2912013-01-10 23:11:41 +00003948
3949 // If there's no return type (very rare in practice!), LLVM and Google style
3950 // agree.
Daniel Jasperdd9276e2013-03-22 16:55:40 +00003951 verifyFormat("- foo;");
Nico Weber9efe2912013-01-10 23:11:41 +00003952 verifyFormat("- foo:(int)f;");
3953 verifyGoogleFormat("- foo:(int)foo;");
Fariborz Jahanian68a542a2012-12-20 19:54:13 +00003954}
3955
Daniel Jasperfb3f2482013-01-09 08:36:49 +00003956TEST_F(FormatTest, FormatObjCBlocks) {
Daniel Jasperc1fa2812013-01-10 13:08:12 +00003957 verifyFormat("int (^Block)(int, int);");
3958 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)");
Daniel Jasperfb3f2482013-01-09 08:36:49 +00003959}
3960
Nico Weber7eecf4b2013-01-09 20:25:35 +00003961TEST_F(FormatTest, FormatObjCInterface) {
Nico Webera6087752013-01-10 20:12:55 +00003962 verifyFormat("@interface Foo : NSObject <NSSomeDelegate> {\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00003963 "@public\n"
3964 " int field1;\n"
3965 "@protected\n"
3966 " int field2;\n"
3967 "@private\n"
3968 " int field3;\n"
3969 "@package\n"
3970 " int field4;\n"
3971 "}\n"
3972 "+ (id)init;\n"
3973 "@end");
3974
Nico Weber7eecf4b2013-01-09 20:25:35 +00003975 verifyGoogleFormat("@interface Foo : NSObject<NSSomeDelegate> {\n"
3976 " @public\n"
3977 " int field1;\n"
3978 " @protected\n"
3979 " int field2;\n"
3980 " @private\n"
3981 " int field3;\n"
3982 " @package\n"
3983 " int field4;\n"
3984 "}\n"
Nico Weber772fbfd2013-01-17 06:14:50 +00003985 "+ (id)init;\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00003986 "@end");
3987
Nico Weber6029d4f2013-01-22 16:53:59 +00003988 verifyFormat("@interface /* wait for it */ Foo\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00003989 "+ (id)init;\n"
3990 "// Look, a comment!\n"
3991 "- (int)answerWith:(int)i;\n"
3992 "@end");
3993
3994 verifyFormat("@interface Foo\n"
Nico Weberd8ffe752013-01-09 21:42:32 +00003995 "@end\n"
3996 "@interface Bar\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00003997 "@end");
3998
3999 verifyFormat("@interface Foo : Bar\n"
4000 "+ (id)init;\n"
4001 "@end");
4002
Nico Weber6029d4f2013-01-22 16:53:59 +00004003 verifyFormat("@interface Foo : /**/ Bar /**/ <Baz, /**/ Quux>\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00004004 "+ (id)init;\n"
4005 "@end");
4006
Nico Webera6087752013-01-10 20:12:55 +00004007 verifyGoogleFormat("@interface Foo : Bar<Baz, Quux>\n"
Nico Weber772fbfd2013-01-17 06:14:50 +00004008 "+ (id)init;\n"
Nico Webera6087752013-01-10 20:12:55 +00004009 "@end");
4010
Nico Weber2bb00742013-01-10 19:19:14 +00004011 verifyFormat("@interface Foo (HackStuff)\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00004012 "+ (id)init;\n"
4013 "@end");
4014
Nico Weber2bb00742013-01-10 19:19:14 +00004015 verifyFormat("@interface Foo ()\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00004016 "+ (id)init;\n"
4017 "@end");
4018
Nico Webera6087752013-01-10 20:12:55 +00004019 verifyFormat("@interface Foo (HackStuff) <MyProtocol>\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00004020 "+ (id)init;\n"
4021 "@end");
4022
Nico Webera6087752013-01-10 20:12:55 +00004023 verifyGoogleFormat("@interface Foo (HackStuff)<MyProtocol>\n"
Nico Weber772fbfd2013-01-17 06:14:50 +00004024 "+ (id)init;\n"
Nico Webera6087752013-01-10 20:12:55 +00004025 "@end");
4026
Manuel Klimek2acb7b72013-01-11 19:17:44 +00004027 verifyFormat("@interface Foo {\n"
4028 " int _i;\n"
4029 "}\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00004030 "+ (id)init;\n"
4031 "@end");
4032
Manuel Klimek2acb7b72013-01-11 19:17:44 +00004033 verifyFormat("@interface Foo : Bar {\n"
4034 " int _i;\n"
4035 "}\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00004036 "+ (id)init;\n"
4037 "@end");
4038
Manuel Klimek2acb7b72013-01-11 19:17:44 +00004039 verifyFormat("@interface Foo : Bar <Baz, Quux> {\n"
4040 " int _i;\n"
4041 "}\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00004042 "+ (id)init;\n"
4043 "@end");
4044
Manuel Klimek2acb7b72013-01-11 19:17:44 +00004045 verifyFormat("@interface Foo (HackStuff) {\n"
4046 " int _i;\n"
4047 "}\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00004048 "+ (id)init;\n"
4049 "@end");
4050
Manuel Klimek2acb7b72013-01-11 19:17:44 +00004051 verifyFormat("@interface Foo () {\n"
4052 " int _i;\n"
4053 "}\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00004054 "+ (id)init;\n"
4055 "@end");
4056
Manuel Klimek2acb7b72013-01-11 19:17:44 +00004057 verifyFormat("@interface Foo (HackStuff) <MyProtocol> {\n"
4058 " int _i;\n"
4059 "}\n"
Nico Weber7eecf4b2013-01-09 20:25:35 +00004060 "+ (id)init;\n"
4061 "@end");
4062}
4063
Nico Weber2ce0ac52013-01-09 23:25:37 +00004064TEST_F(FormatTest, FormatObjCImplementation) {
4065 verifyFormat("@implementation Foo : NSObject {\n"
4066 "@public\n"
4067 " int field1;\n"
4068 "@protected\n"
4069 " int field2;\n"
4070 "@private\n"
4071 " int field3;\n"
4072 "@package\n"
4073 " int field4;\n"
4074 "}\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004075 "+ (id)init {\n}\n"
Nico Weber2ce0ac52013-01-09 23:25:37 +00004076 "@end");
4077
4078 verifyGoogleFormat("@implementation Foo : NSObject {\n"
4079 " @public\n"
4080 " int field1;\n"
4081 " @protected\n"
4082 " int field2;\n"
4083 " @private\n"
4084 " int field3;\n"
4085 " @package\n"
4086 " int field4;\n"
4087 "}\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004088 "+ (id)init {\n}\n"
Nico Weber2ce0ac52013-01-09 23:25:37 +00004089 "@end");
4090
4091 verifyFormat("@implementation Foo\n"
4092 "+ (id)init {\n"
Daniel Jasper1b750ed2013-01-14 16:24:39 +00004093 " if (true)\n"
4094 " return nil;\n"
Nico Weber2ce0ac52013-01-09 23:25:37 +00004095 "}\n"
4096 "// Look, a comment!\n"
Manuel Klimek2acb7b72013-01-11 19:17:44 +00004097 "- (int)answerWith:(int)i {\n"
4098 " return i;\n"
4099 "}\n"
Nico Webera21aaae2013-01-11 21:14:08 +00004100 "+ (int)answerWith:(int)i {\n"
4101 " return i;\n"
4102 "}\n"
Nico Weber2ce0ac52013-01-09 23:25:37 +00004103 "@end");
4104
4105 verifyFormat("@implementation Foo\n"
4106 "@end\n"
4107 "@implementation Bar\n"
4108 "@end");
4109
4110 verifyFormat("@implementation Foo : Bar\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004111 "+ (id)init {\n}\n"
4112 "- (void)foo {\n}\n"
Nico Weber2ce0ac52013-01-09 23:25:37 +00004113 "@end");
4114
Manuel Klimek2acb7b72013-01-11 19:17:44 +00004115 verifyFormat("@implementation Foo {\n"
4116 " int _i;\n"
4117 "}\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004118 "+ (id)init {\n}\n"
Nico Weber2ce0ac52013-01-09 23:25:37 +00004119 "@end");
4120
Manuel Klimek2acb7b72013-01-11 19:17:44 +00004121 verifyFormat("@implementation Foo : Bar {\n"
4122 " int _i;\n"
4123 "}\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004124 "+ (id)init {\n}\n"
Nico Weber2ce0ac52013-01-09 23:25:37 +00004125 "@end");
4126
Nico Weber2bb00742013-01-10 19:19:14 +00004127 verifyFormat("@implementation Foo (HackStuff)\n"
Manuel Klimeka4fe1c12013-01-21 16:42:44 +00004128 "+ (id)init {\n}\n"
Nico Weber2ce0ac52013-01-09 23:25:37 +00004129 "@end");
4130}
4131
Nico Weber8696a8d2013-01-09 21:15:03 +00004132TEST_F(FormatTest, FormatObjCProtocol) {
4133 verifyFormat("@protocol Foo\n"
4134 "@property(weak) id delegate;\n"
4135 "- (NSUInteger)numberOfThings;\n"
4136 "@end");
4137
Nico Webera6087752013-01-10 20:12:55 +00004138 verifyFormat("@protocol MyProtocol <NSObject>\n"
Nico Weber8696a8d2013-01-09 21:15:03 +00004139 "- (NSUInteger)numberOfThings;\n"
4140 "@end");
4141
Nico Webera6087752013-01-10 20:12:55 +00004142 verifyGoogleFormat("@protocol MyProtocol<NSObject>\n"
Nico Weber772fbfd2013-01-17 06:14:50 +00004143 "- (NSUInteger)numberOfThings;\n"
Nico Webera6087752013-01-10 20:12:55 +00004144 "@end");
4145
Nico Weber8696a8d2013-01-09 21:15:03 +00004146 verifyFormat("@protocol Foo;\n"
4147 "@protocol Bar;\n");
Nico Weberd8ffe752013-01-09 21:42:32 +00004148
4149 verifyFormat("@protocol Foo\n"
4150 "@end\n"
4151 "@protocol Bar\n"
4152 "@end");
Nico Weber51306d22013-01-10 00:25:19 +00004153
4154 verifyFormat("@protocol myProtocol\n"
4155 "- (void)mandatoryWithInt:(int)i;\n"
4156 "@optional\n"
4157 "- (void)optional;\n"
4158 "@required\n"
4159 "- (void)required;\n"
Nico Weberbbe28b32013-01-10 00:42:07 +00004160 "@optional\n"
4161 "@property(assign) int madProp;\n"
Nico Weber51306d22013-01-10 00:25:19 +00004162 "@end\n");
Nico Weber8696a8d2013-01-09 21:15:03 +00004163}
4164
Daniel Jasper1ac3e052013-02-05 10:07:47 +00004165TEST_F(FormatTest, FormatObjCMethodDeclarations) {
4166 verifyFormat("- (void)doSomethingWith:(GTMFoo *)theFoo\n"
4167 " rect:(NSRect)theRect\n"
4168 " interval:(float)theInterval {\n"
4169 "}");
4170 verifyFormat("- (void)shortf:(GTMFoo *)theFoo\n"
4171 " longKeyword:(NSRect)theRect\n"
4172 " evenLongerKeyword:(float)theInterval\n"
4173 " error:(NSError **)theError {\n"
4174 "}");
4175}
4176
Nico Webera7252d82013-01-12 06:18:40 +00004177TEST_F(FormatTest, FormatObjCMethodExpr) {
4178 verifyFormat("[foo bar:baz];");
4179 verifyFormat("return [foo bar:baz];");
4180 verifyFormat("f([foo bar:baz]);");
4181 verifyFormat("f(2, [foo bar:baz]);");
4182 verifyFormat("f(2, a ? b : c);");
4183 verifyFormat("[[self initWithInt:4] bar:[baz quux:arrrr]];");
4184
Nico Weberb76de882013-02-05 16:21:00 +00004185 // Unary operators.
4186 verifyFormat("int a = +[foo bar:baz];");
4187 verifyFormat("int a = -[foo bar:baz];");
4188 verifyFormat("int a = ![foo bar:baz];");
4189 verifyFormat("int a = ~[foo bar:baz];");
4190 verifyFormat("int a = ++[foo bar:baz];");
4191 verifyFormat("int a = --[foo bar:baz];");
4192 verifyFormat("int a = sizeof [foo bar:baz];");
4193 verifyFormat("int a = alignof [foo bar:baz];");
Nico Weber5d2624e2013-02-06 06:20:11 +00004194 verifyFormat("int a = &[foo bar:baz];");
4195 verifyFormat("int a = *[foo bar:baz];");
Nico Weberb76de882013-02-05 16:21:00 +00004196 // FIXME: Make casts work, without breaking f()[4].
Nico Webera7892392013-02-13 03:48:27 +00004197 //verifyFormat("int a = (int)[foo bar:baz];");
Nico Weber71800c42013-02-13 04:40:03 +00004198 //verifyFormat("return (int)[foo bar:baz];");
4199 //verifyFormat("(void)[foo bar:baz];");
Nico Webera7892392013-02-13 03:48:27 +00004200 verifyFormat("return (MyType *)[self.tableView cellForRowAtIndexPath:cell];");
Nico Weberb76de882013-02-05 16:21:00 +00004201
4202 // Binary operators.
Nico Webera7252d82013-01-12 06:18:40 +00004203 verifyFormat("[foo bar:baz], [foo bar:baz];");
4204 verifyFormat("[foo bar:baz] = [foo bar:baz];");
4205 verifyFormat("[foo bar:baz] *= [foo bar:baz];");
4206 verifyFormat("[foo bar:baz] /= [foo bar:baz];");
4207 verifyFormat("[foo bar:baz] %= [foo bar:baz];");
4208 verifyFormat("[foo bar:baz] += [foo bar:baz];");
4209 verifyFormat("[foo bar:baz] -= [foo bar:baz];");
4210 verifyFormat("[foo bar:baz] <<= [foo bar:baz];");
4211 verifyFormat("[foo bar:baz] >>= [foo bar:baz];");
4212 verifyFormat("[foo bar:baz] &= [foo bar:baz];");
4213 verifyFormat("[foo bar:baz] ^= [foo bar:baz];");
4214 verifyFormat("[foo bar:baz] |= [foo bar:baz];");
4215 verifyFormat("[foo bar:baz] ? [foo bar:baz] : [foo bar:baz];");
4216 verifyFormat("[foo bar:baz] || [foo bar:baz];");
4217 verifyFormat("[foo bar:baz] && [foo bar:baz];");
4218 verifyFormat("[foo bar:baz] | [foo bar:baz];");
4219 verifyFormat("[foo bar:baz] ^ [foo bar:baz];");
4220 verifyFormat("[foo bar:baz] & [foo bar:baz];");
4221 verifyFormat("[foo bar:baz] == [foo bar:baz];");
4222 verifyFormat("[foo bar:baz] != [foo bar:baz];");
4223 verifyFormat("[foo bar:baz] >= [foo bar:baz];");
4224 verifyFormat("[foo bar:baz] <= [foo bar:baz];");
4225 verifyFormat("[foo bar:baz] > [foo bar:baz];");
4226 verifyFormat("[foo bar:baz] < [foo bar:baz];");
4227 verifyFormat("[foo bar:baz] >> [foo bar:baz];");
4228 verifyFormat("[foo bar:baz] << [foo bar:baz];");
4229 verifyFormat("[foo bar:baz] - [foo bar:baz];");
4230 verifyFormat("[foo bar:baz] + [foo bar:baz];");
4231 verifyFormat("[foo bar:baz] * [foo bar:baz];");
4232 verifyFormat("[foo bar:baz] / [foo bar:baz];");
4233 verifyFormat("[foo bar:baz] % [foo bar:baz];");
4234 // Whew!
4235
Nico Weber29f9dea2013-02-11 15:32:15 +00004236 verifyFormat("return in[42];");
4237 verifyFormat("for (id foo in [self getStuffFor:bla]) {\n"
4238 "}");
4239
Nico Webera7252d82013-01-12 06:18:40 +00004240 verifyFormat("[self stuffWithInt:(4 + 2) float:4.5];");
4241 verifyFormat("[self stuffWithInt:a ? b : c float:4.5];");
4242 verifyFormat("[self stuffWithInt:a ? [self foo:bar] : c];");
4243 verifyFormat("[self stuffWithInt:a ? (e ? f : g) : c];");
4244 verifyFormat("[cond ? obj1 : obj2 methodWithParam:param]");
Nico Weber5c8709b2013-01-12 23:41:33 +00004245 verifyFormat("[button setAction:@selector(zoomOut:)];");
Nico Weber2827a7e2013-01-12 23:48:49 +00004246 verifyFormat("[color getRed:&r green:&g blue:&b alpha:&a];");
Daniel Jasper1ac3e052013-02-05 10:07:47 +00004247
Nico Webera7252d82013-01-12 06:18:40 +00004248 verifyFormat("arr[[self indexForFoo:a]];");
4249 verifyFormat("throw [self errorFor:a];");
4250 verifyFormat("@throw [self errorFor:a];");
4251
Nico Weberc9d73612013-01-12 22:48:47 +00004252 // This tests that the formatter doesn't break after "backing" but before ":",
4253 // which would be at 80 columns.
Nico Webera7252d82013-01-12 06:18:40 +00004254 verifyFormat(
4255 "void f() {\n"
Daniel Jasper1ac3e052013-02-05 10:07:47 +00004256 " if ((self = [super initWithContentRect:contentRect\n"
4257 " styleMask:styleMask\n"
4258 " backing:NSBackingStoreBuffered\n"
4259 " defer:YES]))");
4260
Daniel Jasperc697ad22013-02-06 10:05:46 +00004261 verifyFormat(
4262 "[foo checkThatBreakingAfterColonWorksOk:\n"
4263 " [bar ifItDoes:reduceOverallLineLengthLikeInThisCase]];");
Daniel Jasper1ac3e052013-02-05 10:07:47 +00004264
4265 verifyFormat("[myObj short:arg1 // Force line break\n"
4266 " longKeyword:arg2\n"
4267 " evenLongerKeyword:arg3\n"
4268 " error:arg4];");
4269 verifyFormat(
4270 "void f() {\n"
4271 " popup_window_.reset([[RenderWidgetPopupWindow alloc]\n"
4272 " initWithContentRect:NSMakeRect(origin_global.x, origin_global.y,\n"
4273 " pos.width(), pos.height())\n"
4274 " styleMask:NSBorderlessWindowMask\n"
4275 " backing:NSBackingStoreBuffered\n"
4276 " defer:NO]);\n"
4277 "}");
Daniel Jasperc697ad22013-02-06 10:05:46 +00004278 verifyFormat("[contentsContainer replaceSubview:[subviews objectAtIndex:0]\n"
4279 " with:contentsNativeView];");
4280
4281 verifyFormat(
4282 "[pboard addTypes:[NSArray arrayWithObject:kBookmarkButtonDragType]\n"
4283 " owner:nillllll];");
4284
Daniel Jasperc697ad22013-02-06 10:05:46 +00004285 verifyFormat(
Daniel Jasperacc33662013-02-08 08:22:00 +00004286 "[pboard setData:[NSData dataWithBytes:&button length:sizeof(button)]\n"
Daniel Jasperc697ad22013-02-06 10:05:46 +00004287 " forType:kBookmarkButtonDragType];");
4288
4289 verifyFormat("[defaultCenter addObserver:self\n"
4290 " selector:@selector(willEnterFullscreen)\n"
4291 " name:kWillEnterFullscreenNotification\n"
4292 " object:nil];");
Daniel Jasperc485b4e2013-02-06 16:00:26 +00004293 verifyFormat("[image_rep drawInRect:drawRect\n"
4294 " fromRect:NSZeroRect\n"
4295 " operation:NSCompositeCopy\n"
4296 " fraction:1.0\n"
4297 " respectFlipped:NO\n"
4298 " hints:nil];");
Nico Weberac9bde22013-02-06 16:54:35 +00004299
4300 verifyFormat(
4301 "scoped_nsobject<NSTextField> message(\n"
4302 " // The frame will be fixed up when |-setMessageText:| is called.\n"
4303 " [[NSTextField alloc] initWithFrame:NSMakeRect(0, 0, 0, 0)]);");
Nico Webera7252d82013-01-12 06:18:40 +00004304}
4305
Nico Weber12d5bab2013-01-07 15:56:25 +00004306TEST_F(FormatTest, ObjCAt) {
Nico Weber803d61d2013-01-07 16:07:07 +00004307 verifyFormat("@autoreleasepool");
Nico Webere89c42f2013-01-07 16:14:28 +00004308 verifyFormat("@catch");
4309 verifyFormat("@class");
Nico Weber803d61d2013-01-07 16:07:07 +00004310 verifyFormat("@compatibility_alias");
4311 verifyFormat("@defs");
Nico Webera8876502013-01-07 15:17:23 +00004312 verifyFormat("@dynamic");
Nico Weber803d61d2013-01-07 16:07:07 +00004313 verifyFormat("@encode");
4314 verifyFormat("@end");
4315 verifyFormat("@finally");
4316 verifyFormat("@implementation");
4317 verifyFormat("@import");
4318 verifyFormat("@interface");
4319 verifyFormat("@optional");
4320 verifyFormat("@package");
Nico Webere89c42f2013-01-07 16:14:28 +00004321 verifyFormat("@private");
Nico Weber803d61d2013-01-07 16:07:07 +00004322 verifyFormat("@property");
Nico Webere89c42f2013-01-07 16:14:28 +00004323 verifyFormat("@protected");
Nico Weber803d61d2013-01-07 16:07:07 +00004324 verifyFormat("@protocol");
Nico Webere89c42f2013-01-07 16:14:28 +00004325 verifyFormat("@public");
Nico Weber803d61d2013-01-07 16:07:07 +00004326 verifyFormat("@required");
4327 verifyFormat("@selector");
4328 verifyFormat("@synchronized");
4329 verifyFormat("@synthesize");
Nico Webere89c42f2013-01-07 16:14:28 +00004330 verifyFormat("@throw");
4331 verifyFormat("@try");
Nico Weber803d61d2013-01-07 16:07:07 +00004332
Nico Weber12d5bab2013-01-07 15:56:25 +00004333 EXPECT_EQ("@interface", format("@ interface"));
4334
4335 // The precise formatting of this doesn't matter, nobody writes code like
4336 // this.
4337 verifyFormat("@ /*foo*/ interface");
Nico Webera8876502013-01-07 15:17:23 +00004338}
4339
Nico Weberd8cdb532013-01-08 19:15:23 +00004340TEST_F(FormatTest, ObjCSnippets) {
Manuel Klimek2acb7b72013-01-11 19:17:44 +00004341 verifyFormat("@autoreleasepool {\n"
4342 " foo();\n"
4343 "}");
Nico Weber7e6a7a12013-01-08 17:56:31 +00004344 verifyFormat("@class Foo, Bar;");
Nico Weberd8cdb532013-01-08 19:15:23 +00004345 verifyFormat("@compatibility_alias AliasName ExistingClass;");
Nico Weber7e6a7a12013-01-08 17:56:31 +00004346 verifyFormat("@dynamic textColor;");
Nico Webere3025672013-01-18 05:11:47 +00004347 verifyFormat("char *buf1 = @encode(int *);");
4348 verifyFormat("char *buf1 = @encode(typeof(4 * 5));");
Nico Weber44449172013-02-12 16:17:07 +00004349 verifyFormat("char *buf1 = @encode(int **);");
Nico Weber4cc98742013-01-08 20:16:23 +00004350 verifyFormat("Protocol *proto = @protocol(p1);");
Nico Weber250fe712013-01-18 02:43:57 +00004351 verifyFormat("SEL s = @selector(foo:);");
Manuel Klimek2acb7b72013-01-11 19:17:44 +00004352 verifyFormat("@synchronized(self) {\n"
4353 " f();\n"
4354 "}");
Nico Weber7e6a7a12013-01-08 17:56:31 +00004355
Nico Webera2a84952013-01-10 21:30:42 +00004356 verifyFormat("@synthesize dropArrowPosition = dropArrowPosition_;");
4357 verifyGoogleFormat("@synthesize dropArrowPosition = dropArrowPosition_;");
4358
Nico Weber7e6a7a12013-01-08 17:56:31 +00004359 verifyFormat("@property(assign, nonatomic) CGFloat hoverAlpha;");
Nico Webera2a84952013-01-10 21:30:42 +00004360 verifyFormat("@property(assign, getter=isEditable) BOOL editable;");
4361 verifyGoogleFormat("@property(assign, getter=isEditable) BOOL editable;");
Nico Weber7e6a7a12013-01-08 17:56:31 +00004362}
4363
Nico Weber0588b502013-02-07 00:19:29 +00004364TEST_F(FormatTest, ObjCLiterals) {
4365 verifyFormat("@\"String\"");
4366 verifyFormat("@1");
4367 verifyFormat("@+4.8");
4368 verifyFormat("@-4");
4369 verifyFormat("@1LL");
4370 verifyFormat("@.5");
4371 verifyFormat("@'c'");
4372 verifyFormat("@true");
4373
4374 verifyFormat("NSNumber *smallestInt = @(-INT_MAX - 1);");
4375 verifyFormat("NSNumber *piOverTwo = @(M_PI / 2);");
4376 verifyFormat("NSNumber *favoriteColor = @(Green);");
4377 verifyFormat("NSString *path = @(getenv(\"PATH\"));");
4378
Nico Weber0588b502013-02-07 00:19:29 +00004379 verifyFormat("@[");
Nico Weber2a726b62013-02-10 02:08:05 +00004380 verifyFormat("@[]");
4381 verifyFormat(
4382 "NSArray *array = @[ @\" Hey \", NSApp, [NSNumber numberWithInt:42] ];");
4383 verifyFormat("return @[ @3, @[], @[ @4, @5 ] ];");
4384
Nico Weber0588b502013-02-07 00:19:29 +00004385 verifyFormat("@{");
Nico Weber372d8dc2013-02-10 20:35:35 +00004386 verifyFormat("@{}");
4387 verifyFormat("@{ @\"one\" : @1 }");
4388 verifyFormat("return @{ @\"one\" : @1 };");
4389 verifyFormat("@{ @\"one\" : @1, }");
Manuel Klimek1a18c402013-04-12 14:13:36 +00004390
Daniel Jasper1ec31062013-05-28 18:50:02 +00004391 verifyFormat("@{ @\"one\" : @{ @2 : @1 } }");
4392 verifyFormat("@{ @\"one\" : @{ @2 : @1 }, }");
Manuel Klimek1a18c402013-04-12 14:13:36 +00004393
Nico Weber372d8dc2013-02-10 20:35:35 +00004394 verifyFormat("@{ 1 > 2 ? @\"one\" : @\"two\" : 1 > 2 ? @1 : @2 }");
4395 verifyFormat("[self setDict:@{}");
4396 verifyFormat("[self setDict:@{ @1 : @2 }");
4397 verifyFormat("NSLog(@\"%@\", @{ @1 : @2, @2 : @3 }[@1]);");
4398 verifyFormat(
4399 "NSDictionary *masses = @{ @\"H\" : @1.0078, @\"He\" : @4.0026 };");
Nico Weber33c68e92013-02-10 20:39:05 +00004400 verifyFormat(
4401 "NSDictionary *settings = @{ AVEncoderKey : @(AVAudioQualityMax) };");
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00004402
Nico Weber372d8dc2013-02-10 20:35:35 +00004403 // FIXME: Nested and multi-line array and dictionary literals need more work.
Nico Weber0448b4d2013-02-10 20:48:24 +00004404 verifyFormat(
4405 "NSDictionary *d = @{ @\"nam\" : NSUserNam(), @\"dte\" : [NSDate date],\n"
4406 " @\"processInfo\" : [NSProcessInfo processInfo] };");
Nico Weberced7d412013-05-26 05:39:26 +00004407 verifyFormat(
4408 "@{ NSFontAttributeNameeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee :\n"
4409 " regularFont, };");
4410
Nico Weber0588b502013-02-07 00:19:29 +00004411}
4412
Manuel Klimekb95f5452013-02-08 17:38:27 +00004413TEST_F(FormatTest, ReformatRegionAdjustsIndent) {
4414 EXPECT_EQ("{\n"
4415 "{\n"
4416 "a;\n"
4417 "b;\n"
4418 "}\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00004419 "}",
4420 format("{\n"
4421 "{\n"
4422 "a;\n"
4423 " b;\n"
4424 "}\n"
4425 "}",
4426 13, 2, getLLVMStyle()));
Manuel Klimekb95f5452013-02-08 17:38:27 +00004427 EXPECT_EQ("{\n"
4428 "{\n"
4429 " a;\n"
4430 "b;\n"
4431 "}\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00004432 "}",
4433 format("{\n"
4434 "{\n"
4435 " a;\n"
4436 "b;\n"
4437 "}\n"
4438 "}",
4439 9, 2, getLLVMStyle()));
Manuel Klimekb95f5452013-02-08 17:38:27 +00004440 EXPECT_EQ("{\n"
4441 "{\n"
4442 "public:\n"
4443 " b;\n"
4444 "}\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00004445 "}",
4446 format("{\n"
4447 "{\n"
4448 "public:\n"
4449 " b;\n"
4450 "}\n"
4451 "}",
4452 17, 2, getLLVMStyle()));
Manuel Klimekb95f5452013-02-08 17:38:27 +00004453 EXPECT_EQ("{\n"
4454 "{\n"
4455 "a;\n"
4456 "}\n"
4457 "{\n"
Daniel Jasper12f9d8e2013-05-14 09:30:02 +00004458 " b; //\n"
Manuel Klimekb95f5452013-02-08 17:38:27 +00004459 "}\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00004460 "}",
4461 format("{\n"
4462 "{\n"
4463 "a;\n"
4464 "}\n"
4465 "{\n"
Daniel Jasper12f9d8e2013-05-14 09:30:02 +00004466 " b; //\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00004467 "}\n"
4468 "}",
4469 22, 2, getLLVMStyle()));
Manuel Klimekd076dcd2013-02-08 19:53:32 +00004470 EXPECT_EQ(" {\n"
Daniel Jasper12f9d8e2013-05-14 09:30:02 +00004471 " a; //\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00004472 " }",
4473 format(" {\n"
Daniel Jasper12f9d8e2013-05-14 09:30:02 +00004474 "a; //\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00004475 " }",
4476 4, 2, getLLVMStyle()));
Daniel Jasper22045622013-02-12 16:51:23 +00004477 EXPECT_EQ("void f() {}\n"
Daniel Jasper2ec3ffb82013-02-18 11:59:17 +00004478 "void g() {}",
4479 format("void f() {}\n"
4480 "void g() {}",
4481 13, 0, getLLVMStyle()));
Daniel Jasper66dc2ec2013-03-20 14:31:47 +00004482 EXPECT_EQ("int a; // comment\n"
4483 " // line 2\n"
4484 "int b;",
4485 format("int a; // comment\n"
4486 " // line 2\n"
4487 " int b;",
4488 35, 0, getLLVMStyle()));
Manuel Klimekd076dcd2013-02-08 19:53:32 +00004489}
Manuel Klimekb95f5452013-02-08 17:38:27 +00004490
Manuel Klimek1998ea22013-02-20 10:15:13 +00004491TEST_F(FormatTest, BreakStringLiterals) {
4492 EXPECT_EQ("\"some text \"\n"
4493 "\"other\";",
4494 format("\"some text other\";", getLLVMStyleWithColumns(12)));
Alexander Kornienko9e90b622013-04-17 17:34:05 +00004495 EXPECT_EQ("\"some text \"\n"
4496 "\"other\";",
4497 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
Manuel Klimek1998ea22013-02-20 10:15:13 +00004498 EXPECT_EQ(
4499 "#define A \\\n"
4500 " \"some \" \\\n"
4501 " \"text \" \\\n"
4502 " \"other\";",
4503 format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
4504 EXPECT_EQ(
4505 "#define A \\\n"
4506 " \"so \" \\\n"
4507 " \"text \" \\\n"
4508 " \"other\";",
4509 format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
4510
4511 EXPECT_EQ("\"some text\"",
4512 format("\"some text\"", getLLVMStyleWithColumns(1)));
4513 EXPECT_EQ("\"some text\"",
4514 format("\"some text\"", getLLVMStyleWithColumns(11)));
4515 EXPECT_EQ("\"some \"\n"
4516 "\"text\"",
4517 format("\"some text\"", getLLVMStyleWithColumns(10)));
4518 EXPECT_EQ("\"some \"\n"
4519 "\"text\"",
4520 format("\"some text\"", getLLVMStyleWithColumns(7)));
Manuel Klimekb176cff2013-03-01 13:14:08 +00004521 EXPECT_EQ("\"some\"\n"
Alexander Kornienkocb45bc12013-04-15 14:28:00 +00004522 "\" tex\"\n"
4523 "\"t\"",
Manuel Klimek1998ea22013-02-20 10:15:13 +00004524 format("\"some text\"", getLLVMStyleWithColumns(6)));
Manuel Klimekabf6e032013-03-04 20:03:38 +00004525 EXPECT_EQ("\"some\"\n"
4526 "\" tex\"\n"
4527 "\" and\"",
4528 format("\"some tex and\"", getLLVMStyleWithColumns(6)));
4529 EXPECT_EQ("\"some\"\n"
4530 "\"/tex\"\n"
4531 "\"/and\"",
4532 format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
Manuel Klimek1998ea22013-02-20 10:15:13 +00004533
4534 EXPECT_EQ("variable =\n"
4535 " \"long string \"\n"
4536 " \"literal\";",
4537 format("variable = \"long string literal\";",
4538 getLLVMStyleWithColumns(20)));
4539
4540 EXPECT_EQ("variable = f(\n"
4541 " \"long string \"\n"
Daniel Jasper2cf17bf2013-02-27 09:47:53 +00004542 " \"literal\",\n"
4543 " short,\n"
Manuel Klimek1998ea22013-02-20 10:15:13 +00004544 " loooooooooooooooooooong);",
4545 format("variable = f(\"long string literal\", short, "
4546 "loooooooooooooooooooong);",
4547 getLLVMStyleWithColumns(20)));
4548 EXPECT_EQ(
4549 "f(\"one two\".split(\n"
4550 " variable));",
4551 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
4552 EXPECT_EQ("f(\"one two three four five six \"\n"
4553 " \"seven\".split(\n"
4554 " really_looooong_variable));",
4555 format("f(\"one two three four five six seven\"."
4556 "split(really_looooong_variable));",
4557 getLLVMStyleWithColumns(33)));
4558
4559 EXPECT_EQ("f(\"some \"\n"
4560 " \"text\",\n"
4561 " other);",
4562 format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
Daniel Jasper5497fce2013-02-26 12:52:34 +00004563
4564 // Only break as a last resort.
4565 verifyFormat(
4566 "aaaaaaaaaaaaaaaaaaaa(\n"
4567 " aaaaaaaaaaaaaaaaaaaa,\n"
4568 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
Manuel Klimekb176cff2013-03-01 13:14:08 +00004569
4570 EXPECT_EQ(
4571 "\"splitmea\"\n"
Manuel Klimeke317d1b2013-03-01 13:29:19 +00004572 "\"trandomp\"\n"
4573 "\"oint\"",
Manuel Klimekb176cff2013-03-01 13:14:08 +00004574 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
Manuel Klimeke317d1b2013-03-01 13:29:19 +00004575
4576 EXPECT_EQ(
4577 "\"split/\"\n"
4578 "\"pathat/\"\n"
4579 "\"slashes\"",
4580 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
Daniel Jasper6fe2f002013-04-25 08:56:26 +00004581
4582 FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
4583 AlignLeft.AlignEscapedNewlinesLeft = true;
4584 EXPECT_EQ(
4585 "#define A \\\n"
4586 " \"some \" \\\n"
4587 " \"text \" \\\n"
4588 " \"other\";",
4589 format("#define A \"some text other\";", AlignLeft));
Manuel Klimek1998ea22013-02-20 10:15:13 +00004590}
4591
Manuel Klimek5ecb5fd2013-05-14 09:04:24 +00004592TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
4593 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
4594 " \"ddeeefff\");",
4595 format("someFunction(\"aaabbbcccdddeeefff\");",
4596 getLLVMStyleWithColumns(25)));
4597 EXPECT_EQ("someFunction1234567890(\n"
4598 " \"aaabbbcccdddeeefff\");",
4599 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
4600 getLLVMStyleWithColumns(26)));
4601 EXPECT_EQ("someFunction1234567890(\n"
4602 " \"aaabbbcccdddeeeff\"\n"
4603 " \"f\");",
4604 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
4605 getLLVMStyleWithColumns(25)));
4606 EXPECT_EQ("someFunction1234567890(\n"
4607 " \"aaabbbcccdddeeeff\"\n"
4608 " \"f\");",
4609 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
4610 getLLVMStyleWithColumns(24)));
4611 EXPECT_EQ("someFunction(\n"
4612 " \"aaabbbcc \"\n"
4613 " \"dddeeefff\");",
4614 format("someFunction(\"aaabbbcc dddeeefff\");",
4615 getLLVMStyleWithColumns(25)));
4616 EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
4617 " \"ddeeefff\");",
4618 format("someFunction(\"aaabbbccc ddeeefff\");",
4619 getLLVMStyleWithColumns(25)));
4620 EXPECT_EQ("someFunction1234567890(\n"
4621 " \"aaabb \"\n"
4622 " \"cccdddeeefff\");",
4623 format("someFunction1234567890(\"aaabb cccdddeeefff\");",
4624 getLLVMStyleWithColumns(25)));
4625 EXPECT_EQ("#define A \\\n"
4626 " string s = \\\n"
4627 " \"123456789\" \\\n"
4628 " \"0\"; \\\n"
4629 " int i;",
4630 format("#define A string s = \"1234567890\"; int i;",
4631 getLLVMStyleWithColumns(20)));
4632}
4633
Manuel Klimek5085d9b2013-03-08 18:59:48 +00004634TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
4635 EXPECT_EQ("\"\\a\"",
4636 format("\"\\a\"", getLLVMStyleWithColumns(3)));
4637 EXPECT_EQ("\"\\\"",
4638 format("\"\\\"", getLLVMStyleWithColumns(2)));
4639 EXPECT_EQ("\"test\"\n"
4640 "\"\\n\"",
4641 format("\"test\\n\"", getLLVMStyleWithColumns(7)));
4642 EXPECT_EQ("\"tes\\\\\"\n"
4643 "\"n\"",
4644 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
4645 EXPECT_EQ("\"\\\\\\\\\"\n"
4646 "\"\\n\"",
4647 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
4648 EXPECT_EQ("\"\\uff01\"",
4649 format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
4650 EXPECT_EQ("\"\\uff01\"\n"
4651 "\"test\"",
4652 format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
4653 EXPECT_EQ("\"\\Uff01ff02\"",
4654 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
4655 EXPECT_EQ("\"\\x000000000001\"\n"
4656 "\"next\"",
4657 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
4658 EXPECT_EQ("\"\\x000000000001next\"",
4659 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
4660 EXPECT_EQ("\"\\x000000000001\"",
4661 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
4662 EXPECT_EQ("\"test\"\n"
4663 "\"\\000000\"\n"
4664 "\"000001\"",
4665 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
4666 EXPECT_EQ("\"test\\000\"\n"
Alexander Kornienkocb45bc12013-04-15 14:28:00 +00004667 "\"00000000\"\n"
4668 "\"1\"",
Manuel Klimek5085d9b2013-03-08 18:59:48 +00004669 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
4670 EXPECT_EQ("R\"(\\x\\x00)\"\n",
4671 format("R\"(\\x\\x00)\"\n", getLLVMStyleWithColumns(7)));
4672}
4673
Manuel Klimeka3ff45e2013-04-10 09:52:05 +00004674TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
4675 verifyFormat("void f() {\n"
4676 " return g() {}\n"
4677 " void h() {}");
4678 verifyFormat("if (foo)\n"
4679 " return { forgot_closing_brace();\n"
4680 "test();");
Daniel Jasper1ec31062013-05-28 18:50:02 +00004681 verifyFormat("int a[] = { void forgot_closing_brace() { f();\n"
4682 "g();\n"
Manuel Klimeka3ff45e2013-04-10 09:52:05 +00004683 "}");
4684}
4685
Manuel Klimek13b97d82013-05-13 08:42:42 +00004686TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
4687 verifyFormat("class X {\n"
4688 " void f() {\n"
4689 " }\n"
4690 "};",
4691 getLLVMStyleWithColumns(12));
4692}
4693
4694TEST_F(FormatTest, ConfigurableIndentWidth) {
4695 FormatStyle EightIndent = getLLVMStyleWithColumns(18);
4696 EightIndent.IndentWidth = 8;
4697 verifyFormat("void f() {\n"
4698 " someFunction();\n"
4699 " if (true) {\n"
4700 " f();\n"
4701 " }\n"
4702 "}",
4703 EightIndent);
4704 verifyFormat("class X {\n"
4705 " void f() {\n"
4706 " }\n"
4707 "};",
4708 EightIndent);
4709 verifyFormat("int x[] = {\n"
4710 " call(),\n"
4711 " call(),\n"
4712 "};",
4713 EightIndent);
4714}
4715
Manuel Klimekb9eae4c2013-05-13 09:22:11 +00004716TEST_F(FormatTest, ConfigurableUseOfTab) {
4717 FormatStyle Tab = getLLVMStyleWithColumns(42);
4718 Tab.IndentWidth = 8;
4719 Tab.UseTab = true;
4720 Tab.AlignEscapedNewlinesLeft = true;
4721 verifyFormat("class X {\n"
4722 "\tvoid f() {\n"
4723 "\t\tsomeFunction(parameter1,\n"
4724 "\t\t\t parameter2);\n"
4725 "\t}\n"
4726 "};",
4727 Tab);
4728 verifyFormat("#define A \\\n"
4729 "\tvoid f() { \\\n"
4730 "\t\tsomeFunction( \\\n"
4731 "\t\t parameter1, \\\n"
4732 "\t\t parameter2); \\\n"
4733 "\t}",
4734 Tab);
Manuel Klimek9043c742013-05-27 15:23:34 +00004735
Manuel Klimek34d15152013-05-28 10:01:59 +00004736
4737 // FIXME: To correctly count mixed whitespace we need to
4738 // also correctly count mixed whitespace in front of the comment.
4739 //
4740 // EXPECT_EQ("/*\n"
4741 // "\t a\t\tcomment\n"
4742 // "\t in multiple lines\n"
4743 // " */",
4744 // format(" /*\t \t \n"
4745 // " \t \t a\t\tcomment\t \t\n"
4746 // " \t \t in multiple lines\t\n"
4747 // " \t */",
4748 // Tab));
4749 // Tab.UseTab = false;
4750 // EXPECT_EQ("/*\n"
4751 // " a\t\tcomment\n"
4752 // " in multiple lines\n"
4753 // " */",
4754 // format(" /*\t \t \n"
4755 // " \t \t a\t\tcomment\t \t\n"
4756 // " \t \t in multiple lines\t\n"
4757 // " \t */",
4758 // Tab));
Manuel Klimek9043c742013-05-27 15:23:34 +00004759 // EXPECT_EQ("/* some\n"
4760 // " comment */",
4761 // format(" \t \t /* some\n"
4762 // " \t \t comment */",
4763 // Tab));
Manuel Klimek34d15152013-05-28 10:01:59 +00004764
4765 EXPECT_EQ("{\n"
4766 " /*\n"
4767 " * Comment\n"
4768 " */\n"
4769 " int i;\n"
4770 "}",
4771 format("{\n"
4772 "\t/*\n"
4773 "\t * Comment\n"
4774 "\t */\n"
4775 "\t int i;\n"
4776 "}"));
Manuel Klimekb9eae4c2013-05-13 09:22:11 +00004777}
4778
Manuel Klimeka8eb9142013-05-13 12:51:40 +00004779TEST_F(FormatTest, LinuxBraceBreaking) {
4780 FormatStyle BreakBeforeBrace = getLLVMStyle();
4781 BreakBeforeBrace.BreakBeforeBraces = FormatStyle::BS_Linux;
4782 verifyFormat("namespace a\n"
4783 "{\n"
4784 "class A\n"
4785 "{\n"
4786 " void f()\n"
4787 " {\n"
4788 " if (true) {\n"
4789 " a();\n"
4790 " b();\n"
4791 " }\n"
4792 " }\n"
Daniel Jasper00aca702013-05-15 08:30:06 +00004793 " void g()\n"
4794 " {\n"
4795 " return;\n"
4796 " }\n"
Manuel Klimeka8eb9142013-05-13 12:51:40 +00004797 "}\n"
4798 "}",
4799 BreakBeforeBrace);
4800}
4801
4802TEST_F(FormatTest, StroustrupBraceBreaking) {
4803 FormatStyle BreakBeforeBrace = getLLVMStyle();
4804 BreakBeforeBrace.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
4805 verifyFormat("namespace a {\n"
4806 "class A {\n"
4807 " void f()\n"
4808 " {\n"
4809 " if (true) {\n"
4810 " a();\n"
4811 " b();\n"
4812 " }\n"
4813 " }\n"
Daniel Jasper00aca702013-05-15 08:30:06 +00004814 " void g()\n"
4815 " {\n"
4816 " return;\n"
4817 " }\n"
Manuel Klimeka8eb9142013-05-13 12:51:40 +00004818 "}\n"
4819 "}",
4820 BreakBeforeBrace);
4821}
4822
Alexander Kornienkod6538332013-05-07 15:32:14 +00004823bool allStylesEqual(ArrayRef<FormatStyle> Styles) {
4824 for (size_t i = 1; i < Styles.size(); ++i)
4825 if (!(Styles[0] == Styles[i]))
4826 return false;
4827 return true;
4828}
4829
4830TEST_F(FormatTest, GetsPredefinedStyleByName) {
Alexander Kornienko006b5c82013-05-19 00:53:30 +00004831 FormatStyle Styles[3];
Alexander Kornienkod6538332013-05-07 15:32:14 +00004832
Alexander Kornienko006b5c82013-05-19 00:53:30 +00004833 Styles[0] = getLLVMStyle();
4834 EXPECT_TRUE(getPredefinedStyle("LLVM", &Styles[1]));
4835 EXPECT_TRUE(getPredefinedStyle("lLvM", &Styles[2]));
4836 EXPECT_TRUE(allStylesEqual(Styles));
Alexander Kornienkod6538332013-05-07 15:32:14 +00004837
Alexander Kornienko006b5c82013-05-19 00:53:30 +00004838 Styles[0] = getGoogleStyle();
4839 EXPECT_TRUE(getPredefinedStyle("Google", &Styles[1]));
4840 EXPECT_TRUE(getPredefinedStyle("gOOgle", &Styles[2]));
4841 EXPECT_TRUE(allStylesEqual(Styles));
Alexander Kornienkod6538332013-05-07 15:32:14 +00004842
Alexander Kornienko006b5c82013-05-19 00:53:30 +00004843 Styles[0] = getChromiumStyle();
4844 EXPECT_TRUE(getPredefinedStyle("Chromium", &Styles[1]));
4845 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", &Styles[2]));
4846 EXPECT_TRUE(allStylesEqual(Styles));
4847
4848 Styles[0] = getMozillaStyle();
4849 EXPECT_TRUE(getPredefinedStyle("Mozilla", &Styles[1]));
4850 EXPECT_TRUE(getPredefinedStyle("moZILla", &Styles[2]));
4851 EXPECT_TRUE(allStylesEqual(Styles));
4852
4853 EXPECT_FALSE(getPredefinedStyle("qwerty", &Styles[0]));
Alexander Kornienkod6538332013-05-07 15:32:14 +00004854}
4855
4856TEST_F(FormatTest, ParsesConfiguration) {
4857 FormatStyle Style = {};
4858#define CHECK_PARSE(TEXT, FIELD, VALUE) \
4859 EXPECT_NE(VALUE, Style.FIELD); \
4860 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \
4861 EXPECT_EQ(VALUE, Style.FIELD)
4862
4863#define CHECK_PARSE_BOOL(FIELD) \
4864 Style.FIELD = false; \
4865 EXPECT_EQ(0, parseConfiguration(#FIELD ": true", &Style).value()); \
Alexander Kornienko006b5c82013-05-19 00:53:30 +00004866 EXPECT_TRUE(Style.FIELD); \
Alexander Kornienkod6538332013-05-07 15:32:14 +00004867 EXPECT_EQ(0, parseConfiguration(#FIELD ": false", &Style).value()); \
Patrik Hagglund76aca642013-05-14 07:53:53 +00004868 EXPECT_FALSE(Style.FIELD);
Alexander Kornienkod6538332013-05-07 15:32:14 +00004869
4870 CHECK_PARSE_BOOL(AlignEscapedNewlinesLeft);
4871 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
4872 CHECK_PARSE_BOOL(AllowShortIfStatementsOnASingleLine);
Daniel Jasper997af662013-05-16 12:16:23 +00004873 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
Daniel Jasper61e6bbf2013-05-29 12:07:31 +00004874 CHECK_PARSE_BOOL(AlwaysBreakTemplateDeclarations);
Alexander Kornienkod6538332013-05-07 15:32:14 +00004875 CHECK_PARSE_BOOL(BinPackParameters);
4876 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
4877 CHECK_PARSE_BOOL(DerivePointerBinding);
4878 CHECK_PARSE_BOOL(IndentCaseLabels);
4879 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
4880 CHECK_PARSE_BOOL(PointerBindsToType);
Daniel Jaspere5777d22013-05-23 10:15:45 +00004881 CHECK_PARSE_BOOL(SpacesInBracedLists);
Manuel Klimekb9eae4c2013-05-13 09:22:11 +00004882 CHECK_PARSE_BOOL(UseTab);
Alexander Kornienkod6538332013-05-07 15:32:14 +00004883
4884 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
4885 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
4886 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
4887 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
4888 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
4889 PenaltyReturnTypeOnItsOwnLine, 1234u);
4890 CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
4891 SpacesBeforeTrailingComments, 1234u);
Manuel Klimek13b97d82013-05-13 08:42:42 +00004892 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
Alexander Kornienkod6538332013-05-07 15:32:14 +00004893
4894 Style.Standard = FormatStyle::LS_Auto;
4895 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
4896 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
4897 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
4898
4899 Style.ColumnLimit = 123;
4900 FormatStyle BaseStyle = getLLVMStyle();
4901 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
4902 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
4903
Manuel Klimeka8eb9142013-05-13 12:51:40 +00004904 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
4905 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
4906 FormatStyle::BS_Attach);
4907 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
4908 FormatStyle::BS_Linux);
4909 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
4910 FormatStyle::BS_Stroustrup);
4911
Alexander Kornienkod6538332013-05-07 15:32:14 +00004912#undef CHECK_PARSE
4913#undef CHECK_PARSE_BOOL
4914}
4915
4916TEST_F(FormatTest, ConfigurationRoundTripTest) {
4917 FormatStyle Style = getLLVMStyle();
4918 std::string YAML = configurationAsText(Style);
4919 FormatStyle ParsedStyle = {};
4920 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
4921 EXPECT_EQ(Style, ParsedStyle);
4922}
4923
Alexander Kornienkoffcc0102013-06-05 14:09:10 +00004924TEST_F(FormatTest, WorksFor8bitEncodings) {
4925 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
4926 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
4927 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
4928 "\"\xef\xee\xf0\xf3...\"",
4929 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
4930 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
4931 "\xef\xee\xf0\xf3...\"",
4932 getLLVMStyleWithColumns(12)));
4933}
4934
NAKAMURA Takumi5238eba2013-06-06 01:14:58 +00004935// FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
4936#if !defined(_MSC_VER)
4937
Alexander Kornienkoffcc0102013-06-05 14:09:10 +00004938TEST_F(FormatTest, CountsUTF8CharactersProperly) {
4939 verifyFormat("\"Однажды в студёную зимнюю пору...\"",
4940 getLLVMStyleWithColumns(35));
4941 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
4942 getLLVMStyleWithColumns(21));
4943 verifyFormat("// Однажды в студёную зимнюю пору...",
4944 getLLVMStyleWithColumns(36));
4945 verifyFormat("// 一 二 三 四 五 六 七 八 九 十",
4946 getLLVMStyleWithColumns(22));
4947 verifyFormat("/* Однажды в студёную зимнюю пору... */",
4948 getLLVMStyleWithColumns(39));
4949 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
4950 getLLVMStyleWithColumns(25));
4951}
4952
4953TEST_F(FormatTest, SplitsUTF8Strings) {
4954 EXPECT_EQ(
4955 "\"Однажды, в \"\n"
4956 "\"студёную \"\n"
4957 "\"зимнюю \"\n"
4958 "\"пору,\"",
4959 format("\"Однажды, в студёную зимнюю пору,\"",
4960 getLLVMStyleWithColumns(13)));
4961 EXPECT_EQ("\"一 二 三 四 \"\n"
4962 "\"五 六 七 八 \"\n"
4963 "\"九 十\"",
4964 format("\"一 二 三 四 五 六 七 八 九 十\"",
4965 getLLVMStyleWithColumns(10)));
4966}
4967
4968TEST_F(FormatTest, SplitsUTF8LineComments) {
4969 EXPECT_EQ("// Я из лесу\n"
4970 "// вышел; был\n"
4971 "// сильный\n"
4972 "// мороз.",
4973 format("// Я из лесу вышел; был сильный мороз.",
4974 getLLVMStyleWithColumns(13)));
4975 EXPECT_EQ("// 一二三\n"
4976 "// 四五六七\n"
4977 "// 八\n"
4978 "// 九 十",
4979 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(6)));
4980}
4981
4982TEST_F(FormatTest, SplitsUTF8BlockComments) {
4983 EXPECT_EQ("/* Гляжу,\n"
4984 " * поднимается\n"
4985 " * медленно в\n"
4986 " * гору\n"
4987 " * Лошадка,\n"
4988 " * везущая\n"
4989 " * хворосту\n"
4990 " * воз. */",
4991 format("/* Гляжу, поднимается медленно в гору\n"
4992 " * Лошадка, везущая хворосту воз. */",
4993 getLLVMStyleWithColumns(13)));
4994 EXPECT_EQ("/* 一二三\n"
4995 " * 四五六七\n"
4996 " * 八\n"
4997 " * 九 十\n"
4998 " */",
4999 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(6)));
Alexander Kornienkoff73c202013-06-05 15:08:20 +00005000 EXPECT_EQ("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯\n"
5001 " * 𝕓𝕪𝕥𝕖\n"
5002 " * 𝖀𝕿𝕱-𝟠 */",
5003 format("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯 𝕓𝕪𝕥𝕖 𝖀𝕿𝕱-𝟠 */", getLLVMStyleWithColumns(12)));
Alexander Kornienkoffcc0102013-06-05 14:09:10 +00005004}
5005
NAKAMURA Takumi5238eba2013-06-06 01:14:58 +00005006#endif
5007
Daniel Jasper8d1832e2013-01-07 13:26:07 +00005008} // end namespace tooling
5009} // end namespace clang