Gitiles
Code Review Sign In
gerrit-public.fairphone.software / toolchain / llvm-project / bb99a36dc0047a4527a825eb24005bc040a09484 / . / clang / unittests / Format / FormatTestComments.cpp
blob: 049851793c0c45fd5d6e9a2309a1d88ca40875fb [file] [log] [blame]
Krasimir Georgievfd0dda72017-02-08 12:53:18 +0000[diff] [blame]1//===- unittest/Format/FormatTestComments.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
10#include "clang/Format/Format.h"
11
12#include "../Tooling/ReplacementTest.h"
13#include "FormatTestUtils.h"
14
15#include "clang/Frontend/TextDiagnosticPrinter.h"
16#include "llvm/Support/Debug.h"
17#include "llvm/Support/MemoryBuffer.h"
18#include "gtest/gtest.h"
19
20#define DEBUG_TYPE "format-test"
21
22using clang::tooling::ReplacementTest;
Krasimir Georgievfd0dda72017-02-08 12:53:18 +0000[diff] [blame]23
24namespace clang {
25namespace format {
26namespace {
27
28FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); }
29
30class FormatTestComments : public ::testing::Test {
31protected:
32 enum IncompleteCheck {
33 IC_ExpectComplete,
34 IC_ExpectIncomplete,
35 IC_DoNotCheck
36 };
37
38 std::string format(llvm::StringRef Code,
39 const FormatStyle &Style = getLLVMStyle(),
40 IncompleteCheck CheckIncomplete = IC_ExpectComplete) {
41 DEBUG(llvm::errs() << "---\n");
42 DEBUG(llvm::errs() << Code << "\n\n");
43 std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));
44 bool IncompleteFormat = false;
45 tooling::Replacements Replaces =
46 reformat(Style, Code, Ranges, "<stdin>", &IncompleteFormat);
47 if (CheckIncomplete != IC_DoNotCheck) {
48 bool ExpectedIncompleteFormat = CheckIncomplete == IC_ExpectIncomplete;
49 EXPECT_EQ(ExpectedIncompleteFormat, IncompleteFormat) << Code << "\n\n";
50 }
51 ReplacementCount = Replaces.size();
52 auto Result = applyAllReplacements(Code, Replaces);
53 EXPECT_TRUE(static_cast<bool>(Result));
54 DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
55 return *Result;
56 }
57
58 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) {
59 FormatStyle Style = getLLVMStyle();
60 Style.ColumnLimit = ColumnLimit;
61 return Style;
62 }
63
64 void verifyFormat(llvm::StringRef Code,
65 const FormatStyle &Style = getLLVMStyle()) {
66 EXPECT_EQ(Code.str(), format(test::messUp(Code), Style));
67 }
68
Krasimir Georgievfd0dda72017-02-08 12:53:18 +0000[diff] [blame]69 void verifyGoogleFormat(llvm::StringRef Code) {
70 verifyFormat(Code, getGoogleStyle());
71 }
72
73 /// \brief Verify that clang-format does not crash on the given input.
74 void verifyNoCrash(llvm::StringRef Code,
75 const FormatStyle &Style = getLLVMStyle()) {
76 format(Code, Style, IC_DoNotCheck);
77 }
78
79 int ReplacementCount;
80};
81
82//===----------------------------------------------------------------------===//
83// Tests for comments.
84//===----------------------------------------------------------------------===//
85
86TEST_F(FormatTestComments, UnderstandsSingleLineComments) {
87 verifyFormat("//* */");
88 verifyFormat("// line 1\n"
89 "// line 2\n"
90 "void f() {}\n");
91
92 verifyFormat("void f() {\n"
93 " // Doesn't do anything\n"
94 "}");
95 verifyFormat("SomeObject\n"
96 " // Calling someFunction on SomeObject\n"
97 " .someFunction();");
98 verifyFormat("auto result = SomeObject\n"
99 " // Calling someFunction on SomeObject\n"
100 " .someFunction();");
101 verifyFormat("void f(int i, // some comment (probably for i)\n"
102 " int j, // some comment (probably for j)\n"
103 " int k); // some comment (probably for k)");
104 verifyFormat("void f(int i,\n"
105 " // some comment (probably for j)\n"
106 " int j,\n"
107 " // some comment (probably for k)\n"
108 " int k);");
109
110 verifyFormat("int i // This is a fancy variable\n"
111 " = 5; // with nicely aligned comment.");
112
113 verifyFormat("// Leading comment.\n"
114 "int a; // Trailing comment.");
115 verifyFormat("int a; // Trailing comment\n"
116 " // on 2\n"
117 " // or 3 lines.\n"
118 "int b;");
119 verifyFormat("int a; // Trailing comment\n"
120 "\n"
121 "// Leading comment.\n"
122 "int b;");
123 verifyFormat("int a; // Comment.\n"
124 " // More details.\n"
125 "int bbbb; // Another comment.");
126 verifyFormat(
127 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; // comment\n"
128 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; // comment\n"
129 "int cccccccccccccccccccccccccccccc; // comment\n"
130 "int ddd; // looooooooooooooooooooooooong comment\n"
131 "int aaaaaaaaaaaaaaaaaaaaaaa; // comment\n"
132 "int bbbbbbbbbbbbbbbbbbbbb; // comment\n"
133 "int ccccccccccccccccccc; // comment");
134
135 verifyFormat("#include \"a\" // comment\n"
136 "#include \"a/b/c\" // comment");
137 verifyFormat("#include <a> // comment\n"
138 "#include <a/b/c> // comment");
139 EXPECT_EQ("#include \"a\" // comment\n"
140 "#include \"a/b/c\" // comment",
141 format("#include \\\n"
142 " \"a\" // comment\n"
143 "#include \"a/b/c\" // comment"));
144
145 verifyFormat("enum E {\n"
146 " // comment\n"
147 " VAL_A, // comment\n"
148 " VAL_B\n"
149 "};");
150
151 EXPECT_EQ("enum A {\n"
152 " // line a\n"
153 " a,\n"
154 " b, // line b\n"
155 "\n"
156 " // line c\n"
157 " c\n"
158 "};",
159 format("enum A {\n"
160 " // line a\n"
161 " a,\n"
162 " b, // line b\n"
163 "\n"
164 " // line c\n"
165 " c\n"
166 "};",
167 getLLVMStyleWithColumns(20)));
168 EXPECT_EQ("enum A {\n"
169 " a, // line 1\n"
170 " // line 2\n"
171 "};",
172 format("enum A {\n"
173 " a, // line 1\n"
174 " // line 2\n"
175 "};",
176 getLLVMStyleWithColumns(20)));
177 EXPECT_EQ("enum A {\n"
178 " a, // line 1\n"
179 " // line 2\n"
180 "};",
181 format("enum A {\n"
182 " a, // line 1\n"
183 " // line 2\n"
184 "};",
185 getLLVMStyleWithColumns(20)));
186 EXPECT_EQ("enum A {\n"
187 " a, // line 1\n"
188 " // line 2\n"
189 " b\n"
190 "};",
191 format("enum A {\n"
192 " a, // line 1\n"
193 " // line 2\n"
194 " b\n"
195 "};",
196 getLLVMStyleWithColumns(20)));
197 EXPECT_EQ("enum A {\n"
198 " a, // line 1\n"
199 " // line 2\n"
200 " b\n"
201 "};",
202 format("enum A {\n"
203 " a, // line 1\n"
204 " // line 2\n"
205 " b\n"
206 "};",
207 getLLVMStyleWithColumns(20)));
208 verifyFormat(
209 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
210 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; // Trailing comment");
211 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
212 " // Comment inside a statement.\n"
213 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
214 verifyFormat("SomeFunction(a,\n"
215 " // comment\n"
216 " b + x);");
217 verifyFormat("SomeFunction(a, a,\n"
218 " // comment\n"
219 " b + x);");
220 verifyFormat(
221 "bool aaaaaaaaaaaaa = // comment\n"
222 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
223 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
224
225 verifyFormat("int aaaa; // aaaaa\n"
226 "int aa; // aaaaaaa",
227 getLLVMStyleWithColumns(20));
228
229 EXPECT_EQ("void f() { // This does something ..\n"
230 "}\n"
231 "int a; // This is unrelated",
232 format("void f() { // This does something ..\n"
233 " }\n"
234 "int a; // This is unrelated"));
235 EXPECT_EQ("class C {\n"
236 " void f() { // This does something ..\n"
237 " } // awesome..\n"
238 "\n"
239 " int a; // This is unrelated\n"
240 "};",
241 format("class C{void f() { // This does something ..\n"
242 " } // awesome..\n"
243 " \n"
244 "int a; // This is unrelated\n"
245 "};"));
246
247 EXPECT_EQ("int i; // single line trailing comment",
248 format("int i;\\\n// single line trailing comment"));
249
250 verifyGoogleFormat("int a; // Trailing comment.");
251
252 verifyFormat("someFunction(anotherFunction( // Force break.\n"
253 " parameter));");
254
255 verifyGoogleFormat("#endif // HEADER_GUARD");
256
257 verifyFormat("const char *test[] = {\n"
258 " // A\n"
259 " \"aaaa\",\n"
260 " // B\n"
261 " \"aaaaa\"};");
262 verifyGoogleFormat(
263 "aaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
264 " aaaaaaaaaaaaaaaaaaaaaa); // 81_cols_with_this_comment");
265 EXPECT_EQ("D(a, {\n"
266 " // test\n"
267 " int a;\n"
268 "});",
269 format("D(a, {\n"
270 "// test\n"
271 "int a;\n"
272 "});"));
273
274 EXPECT_EQ("lineWith(); // comment\n"
275 "// at start\n"
276 "otherLine();",
277 format("lineWith(); // comment\n"
278 "// at start\n"
279 "otherLine();"));
280 EXPECT_EQ("lineWith(); // comment\n"
281 "/*\n"
282 " * at start */\n"
283 "otherLine();",
284 format("lineWith(); // comment\n"
285 "/*\n"
286 " * at start */\n"
287 "otherLine();"));
288 EXPECT_EQ("lineWith(); // comment\n"
289 " // at start\n"
290 "otherLine();",
291 format("lineWith(); // comment\n"
292 " // at start\n"
293 "otherLine();"));
294
295 EXPECT_EQ("lineWith(); // comment\n"
296 "// at start\n"
297 "otherLine(); // comment",
298 format("lineWith(); // comment\n"
299 "// at start\n"
300 "otherLine(); // comment"));
301 EXPECT_EQ("lineWith();\n"
302 "// at start\n"
303 "otherLine(); // comment",
304 format("lineWith();\n"
305 " // at start\n"
306 "otherLine(); // comment"));
307 EXPECT_EQ("// first\n"
308 "// at start\n"
309 "otherLine(); // comment",
310 format("// first\n"
311 " // at start\n"
312 "otherLine(); // comment"));
313 EXPECT_EQ("f();\n"
314 "// first\n"
315 "// at start\n"
316 "otherLine(); // comment",
317 format("f();\n"
318 "// first\n"
319 " // at start\n"
320 "otherLine(); // comment"));
321 verifyFormat("f(); // comment\n"
322 "// first\n"
323 "// at start\n"
324 "otherLine();");
325 EXPECT_EQ("f(); // comment\n"
326 "// first\n"
327 "// at start\n"
328 "otherLine();",
329 format("f(); // comment\n"
330 "// first\n"
331 " // at start\n"
332 "otherLine();"));
333 EXPECT_EQ("f(); // comment\n"
334 " // first\n"
335 "// at start\n"
336 "otherLine();",
337 format("f(); // comment\n"
338 " // first\n"
339 "// at start\n"
340 "otherLine();"));
341 EXPECT_EQ("void f() {\n"
342 " lineWith(); // comment\n"
343 " // at start\n"
344 "}",
345 format("void f() {\n"
346 " lineWith(); // comment\n"
347 " // at start\n"
348 "}"));
349 EXPECT_EQ("int xy; // a\n"
350 "int z; // b",
351 format("int xy; // a\n"
352 "int z; //b"));
353 EXPECT_EQ("int xy; // a\n"
354 "int z; // bb",
355 format("int xy; // a\n"
356 "int z; //bb",
357 getLLVMStyleWithColumns(12)));
358
359 verifyFormat("#define A \\\n"
360 " int i; /* iiiiiiiiiiiiiiiiiiiii */ \\\n"
361 " int jjjjjjjjjjjjjjjjjjjjjjjj; /* */",
362 getLLVMStyleWithColumns(60));
363 verifyFormat(
364 "#define A \\\n"
365 " int i; /* iiiiiiiiiiiiiiiiiiiii */ \\\n"
366 " int jjjjjjjjjjjjjjjjjjjjjjjj; /* */",
367 getLLVMStyleWithColumns(61));
368
369 verifyFormat("if ( // This is some comment\n"
370 " x + 3) {\n"
371 "}");
372 EXPECT_EQ("if ( // This is some comment\n"
373 " // spanning two lines\n"
374 " x + 3) {\n"
375 "}",
376 format("if( // This is some comment\n"
377 " // spanning two lines\n"
378 " x + 3) {\n"
379 "}"));
380
381 verifyNoCrash("/\\\n/");
382 verifyNoCrash("/\\\n* */");
383 // The 0-character somehow makes the lexer return a proper comment.
384 verifyNoCrash(StringRef("/*\\\0\n/", 6));
385}
386
387TEST_F(FormatTestComments, KeepsParameterWithTrailingCommentsOnTheirOwnLine) {
388 EXPECT_EQ("SomeFunction(a,\n"
389 " b, // comment\n"
390 " c);",
391 format("SomeFunction(a,\n"
392 " b, // comment\n"
393 " c);"));
394 EXPECT_EQ("SomeFunction(a, b,\n"
395 " // comment\n"
396 " c);",
397 format("SomeFunction(a,\n"
398 " b,\n"
399 " // comment\n"
400 " c);"));
401 EXPECT_EQ("SomeFunction(a, b, // comment (unclear relation)\n"
402 " c);",
403 format("SomeFunction(a, b, // comment (unclear relation)\n"
404 " c);"));
405 EXPECT_EQ("SomeFunction(a, // comment\n"
406 " b,\n"
407 " c); // comment",
408 format("SomeFunction(a, // comment\n"
409 " b,\n"
410 " c); // comment"));
411 EXPECT_EQ("aaaaaaaaaa(aaaa(aaaa,\n"
412 " aaaa), //\n"
413 " aaaa, bbbbb);",
414 format("aaaaaaaaaa(aaaa(aaaa,\n"
415 "aaaa), //\n"
416 "aaaa, bbbbb);"));
417}
418
419TEST_F(FormatTestComments, RemovesTrailingWhitespaceOfComments) {
420 EXPECT_EQ("// comment", format("// comment "));
421 EXPECT_EQ("int aaaaaaa, bbbbbbb; // comment",
422 format("int aaaaaaa, bbbbbbb; // comment ",
423 getLLVMStyleWithColumns(33)));
424 EXPECT_EQ("// comment\\\n", format("// comment\\\n \t \v \f "));
425 EXPECT_EQ("// comment \\\n", format("// comment \\\n \t \v \f "));
426}
427
428TEST_F(FormatTestComments, UnderstandsBlockComments) {
429 verifyFormat("f(/*noSpaceAfterParameterNamingComment=*/true);");
430 verifyFormat("void f() { g(/*aaa=*/x, /*bbb=*/!y, /*c=*/::c); }");
431 EXPECT_EQ("f(aaaaaaaaaaaaaaaaaaaaaaaaa, /* Trailing comment for aa... */\n"
432 " bbbbbbbbbbbbbbbbbbbbbbbbb);",
433 format("f(aaaaaaaaaaaaaaaaaaaaaaaaa , \\\n"
434 "/* Trailing comment for aa... */\n"
435 " bbbbbbbbbbbbbbbbbbbbbbbbb);"));
436 EXPECT_EQ(
437 "f(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
438 " /* Leading comment for bb... */ bbbbbbbbbbbbbbbbbbbbbbbbb);",
439 format("f(aaaaaaaaaaaaaaaaaaaaaaaaa , \n"
440 "/* Leading comment for bb... */ bbbbbbbbbbbbbbbbbbbbbbbbb);"));
441 EXPECT_EQ(
442 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
443 " aaaaaaaaaaaaaaaaaa,\n"
444 " aaaaaaaaaaaaaaaaaa) { /*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*/\n"
445 "}",
446 format("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
447 " aaaaaaaaaaaaaaaaaa ,\n"
448 " aaaaaaaaaaaaaaaaaa) { /*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*/\n"
449 "}"));
450 verifyFormat("f(/* aaaaaaaaaaaaaaaaaa = */\n"
451 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
452
453 FormatStyle NoBinPacking = getLLVMStyle();
454 NoBinPacking.BinPackParameters = false;
455 verifyFormat("aaaaaaaa(/* parameter 1 */ aaaaaa,\n"
456 " /* parameter 2 */ aaaaaa,\n"
457 " /* parameter 3 */ aaaaaa,\n"
458 " /* parameter 4 */ aaaaaa);",
459 NoBinPacking);
460
461 // Aligning block comments in macros.
462 verifyGoogleFormat("#define A \\\n"
463 " int i; /*a*/ \\\n"
464 " int jjj; /*b*/");
465}
466
467TEST_F(FormatTestComments, AlignsBlockComments) {
468 EXPECT_EQ("/*\n"
469 " * Really multi-line\n"
470 " * comment.\n"
471 " */\n"
472 "void f() {}",
473 format(" /*\n"
474 " * Really multi-line\n"
475 " * comment.\n"
476 " */\n"
477 " void f() {}"));
478 EXPECT_EQ("class C {\n"
479 " /*\n"
480 " * Another multi-line\n"
481 " * comment.\n"
482 " */\n"
483 " void f() {}\n"
484 "};",
485 format("class C {\n"
486 "/*\n"
487 " * Another multi-line\n"
488 " * comment.\n"
489 " */\n"
490 "void f() {}\n"
491 "};"));
492 EXPECT_EQ("/*\n"
493 " 1. This is a comment with non-trivial formatting.\n"
494 " 1.1. We have to indent/outdent all lines equally\n"
495 " 1.1.1. to keep the formatting.\n"
496 " */",
497 format(" /*\n"
498 " 1. This is a comment with non-trivial formatting.\n"
499 " 1.1. We have to indent/outdent all lines equally\n"
500 " 1.1.1. to keep the formatting.\n"
501 " */"));
502 EXPECT_EQ("/*\n"
503 "Don't try to outdent if there's not enough indentation.\n"
504 "*/",
505 format(" /*\n"
506 " Don't try to outdent if there's not enough indentation.\n"
507 " */"));
508
509 EXPECT_EQ("int i; /* Comment with empty...\n"
510 " *\n"
511 " * line. */",
512 format("int i; /* Comment with empty...\n"
513 " *\n"
514 " * line. */"));
515 EXPECT_EQ("int foobar = 0; /* comment */\n"
516 "int bar = 0; /* multiline\n"
517 " comment 1 */\n"
518 "int baz = 0; /* multiline\n"
519 " comment 2 */\n"
520 "int bzz = 0; /* multiline\n"
521 " comment 3 */",
522 format("int foobar = 0; /* comment */\n"
523 "int bar = 0; /* multiline\n"
524 " comment 1 */\n"
525 "int baz = 0; /* multiline\n"
526 " comment 2 */\n"
527 "int bzz = 0; /* multiline\n"
528 " comment 3 */"));
529 EXPECT_EQ("int foobar = 0; /* comment */\n"
530 "int bar = 0; /* multiline\n"
531 " comment */\n"
532 "int baz = 0; /* multiline\n"
533 "comment */",
534 format("int foobar = 0; /* comment */\n"
535 "int bar = 0; /* multiline\n"
536 "comment */\n"
537 "int baz = 0; /* multiline\n"
538 "comment */"));
539}
540
541TEST_F(FormatTestComments, CommentReflowingCanBeTurnedOff) {
542 FormatStyle Style = getLLVMStyleWithColumns(20);
543 Style.ReflowComments = false;
544 verifyFormat("// aaaaaaaaa aaaaaaaaaa aaaaaaaaaa", Style);
545 verifyFormat("/* aaaaaaaaa aaaaaaaaaa aaaaaaaaaa */", Style);
546}
547
548TEST_F(FormatTestComments, CorrectlyHandlesLengthOfBlockComments) {
549 EXPECT_EQ("double *x; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
550 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */",
551 format("double *x; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
552 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */"));
553 EXPECT_EQ(
554 "void ffffffffffff(\n"
555 " int aaaaaaaa, int bbbbbbbb,\n"
556 " int cccccccccccc) { /*\n"
557 " aaaaaaaaaa\n"
558 " aaaaaaaaaaaaa\n"
559 " bbbbbbbbbbbbbb\n"
560 " bbbbbbbbbb\n"
561 " */\n"
562 "}",
563 format("void ffffffffffff(int aaaaaaaa, int bbbbbbbb, int cccccccccccc)\n"
564 "{ /*\n"
565 " aaaaaaaaaa aaaaaaaaaaaaa\n"
566 " bbbbbbbbbbbbbb bbbbbbbbbb\n"
567 " */\n"
568 "}",
569 getLLVMStyleWithColumns(40)));
570}
571
572TEST_F(FormatTestComments, DontBreakNonTrailingBlockComments) {
573 EXPECT_EQ("void ffffffffff(\n"
574 " int aaaaa /* test */);",
575 format("void ffffffffff(int aaaaa /* test */);",
576 getLLVMStyleWithColumns(35)));
577}
578
579TEST_F(FormatTestComments, SplitsLongCxxComments) {
580 EXPECT_EQ("// A comment that\n"
581 "// doesn't fit on\n"
582 "// one line",
583 format("// A comment that doesn't fit on one line",
584 getLLVMStyleWithColumns(20)));
585 EXPECT_EQ("/// A comment that\n"
586 "/// doesn't fit on\n"
587 "/// one line",
588 format("/// A comment that doesn't fit on one line",
589 getLLVMStyleWithColumns(20)));
590 EXPECT_EQ("//! A comment that\n"
591 "//! doesn't fit on\n"
592 "//! one line",
593 format("//! A comment that doesn't fit on one line",
594 getLLVMStyleWithColumns(20)));
595 EXPECT_EQ("// a b c d\n"
596 "// e f g\n"
597 "// h i j k",
598 format("// a b c d e f g h i j k", getLLVMStyleWithColumns(10)));
599 EXPECT_EQ(
600 "// a b c d\n"
601 "// e f g\n"
602 "// h i j k",
603 format("\\\n// a b c d e f g h i j k", getLLVMStyleWithColumns(10)));
604 EXPECT_EQ("if (true) // A comment that\n"
605 " // doesn't fit on\n"
606 " // one line",
607 format("if (true) // A comment that doesn't fit on one line ",
608 getLLVMStyleWithColumns(30)));
609 EXPECT_EQ("// Don't_touch_leading_whitespace",
610 format("// Don't_touch_leading_whitespace",
611 getLLVMStyleWithColumns(20)));
612 EXPECT_EQ("// Add leading\n"
613 "// whitespace",
614 format("//Add leading whitespace", getLLVMStyleWithColumns(20)));
615 EXPECT_EQ("/// Add leading\n"
616 "/// whitespace",
617 format("///Add leading whitespace", getLLVMStyleWithColumns(20)));
618 EXPECT_EQ("//! Add leading\n"
619 "//! whitespace",
620 format("//!Add leading whitespace", getLLVMStyleWithColumns(20)));
621 EXPECT_EQ("// whitespace", format("//whitespace", getLLVMStyle()));
622 EXPECT_EQ("// Even if it makes the line exceed the column\n"
623 "// limit",
624 format("//Even if it makes the line exceed the column limit",
625 getLLVMStyleWithColumns(51)));
626 EXPECT_EQ("//--But not here", format("//--But not here", getLLVMStyle()));
627 EXPECT_EQ("/// line 1\n"
628 "// add leading whitespace",
629 format("/// line 1\n"
630 "//add leading whitespace",
631 getLLVMStyleWithColumns(30)));
632 EXPECT_EQ("/// line 1\n"
633 "/// line 2\n"
634 "//! line 3\n"
635 "//! line 4\n"
636 "//! line 5\n"
637 "// line 6\n"
638 "// line 7",
639 format("///line 1\n"
640 "///line 2\n"
641 "//! line 3\n"
642 "//!line 4\n"
643 "//!line 5\n"
644 "// line 6\n"
645 "//line 7", getLLVMStyleWithColumns(20)));
646
647 EXPECT_EQ("// aa bb cc dd",
648 format("// aa bb cc dd ",
649 getLLVMStyleWithColumns(15)));
650
651 EXPECT_EQ("// A comment before\n"
652 "// a macro\n"
653 "// definition\n"
654 "#define a b",
655 format("// A comment before a macro definition\n"
656 "#define a b",
657 getLLVMStyleWithColumns(20)));
658 EXPECT_EQ("void ffffff(\n"
659 " int aaaaaaaaa, // wwww\n"
660 " int bbbbbbbbbb, // xxxxxxx\n"
661 " // yyyyyyyyyy\n"
662 " int c, int d, int e) {}",
663 format("void ffffff(\n"
664 " int aaaaaaaaa, // wwww\n"
665 " int bbbbbbbbbb, // xxxxxxx yyyyyyyyyy\n"
666 " int c, int d, int e) {}",
667 getLLVMStyleWithColumns(40)));
668 EXPECT_EQ("//\t aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
669 format("//\t aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
670 getLLVMStyleWithColumns(20)));
671 EXPECT_EQ(
672 "#define XXX // a b c d\n"
673 " // e f g h",
674 format("#define XXX // a b c d e f g h", getLLVMStyleWithColumns(22)));
675 EXPECT_EQ(
676 "#define XXX // q w e r\n"
677 " // t y u i",
678 format("#define XXX //q w e r t y u i", getLLVMStyleWithColumns(22)));
679 EXPECT_EQ("{\n"
680 " //\n"
681 " //\\\n"
682 " // long 1 2 3 4\n"
683 " // 5\n"
684 "}",
685 format("{\n"
686 " //\n"
687 " //\\\n"
688 " // long 1 2 3 4 5\n"
689 "}",
690 getLLVMStyleWithColumns(20)));
691}
692
693TEST_F(FormatTestComments, PreservesHangingIndentInCxxComments) {
694 EXPECT_EQ("// A comment\n"
695 "// that doesn't\n"
696 "// fit on one\n"
697 "// line",
698 format("// A comment that doesn't fit on one line",
699 getLLVMStyleWithColumns(20)));
700 EXPECT_EQ("/// A comment\n"
701 "/// that doesn't\n"
702 "/// fit on one\n"
703 "/// line",
704 format("/// A comment that doesn't fit on one line",
705 getLLVMStyleWithColumns(20)));
706}
707
708TEST_F(FormatTestComments, DontSplitLineCommentsWithEscapedNewlines) {
709 EXPECT_EQ("// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
710 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
711 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
712 format("// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
713 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
714 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
715 EXPECT_EQ("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
716 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
717 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
718 format("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
719 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
720 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
721 getLLVMStyleWithColumns(50)));
722 // FIXME: One day we might want to implement adjustment of leading whitespace
723 // of the consecutive lines in this kind of comment:
724 EXPECT_EQ("double\n"
725 " a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
726 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
727 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
728 format("double a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
729 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
730 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
731 getLLVMStyleWithColumns(49)));
732}
733
734TEST_F(FormatTestComments, DontSplitLineCommentsWithPragmas) {
735 FormatStyle Pragmas = getLLVMStyleWithColumns(30);
736 Pragmas.CommentPragmas = "^ IWYU pragma:";
737 EXPECT_EQ(
738 "// IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb",
739 format("// IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb", Pragmas));
740 EXPECT_EQ(
741 "/* IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb */",
742 format("/* IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb */", Pragmas));
743}
744
745TEST_F(FormatTestComments, PriorityOfCommentBreaking) {
746 EXPECT_EQ("if (xxx ==\n"
747 " yyy && // aaaaaaaaaaaa bbbbbbbbb\n"
748 " zzz)\n"
749 " q();",
750 format("if (xxx == yyy && // aaaaaaaaaaaa bbbbbbbbb\n"
751 " zzz) q();",
752 getLLVMStyleWithColumns(40)));
753 EXPECT_EQ("if (xxxxxxxxxx ==\n"
754 " yyy && // aaaaaa bbbbbbbb cccc\n"
755 " zzz)\n"
756 " q();",
757 format("if (xxxxxxxxxx == yyy && // aaaaaa bbbbbbbb cccc\n"
758 " zzz) q();",
759 getLLVMStyleWithColumns(40)));
760 EXPECT_EQ("if (xxxxxxxxxx &&\n"
761 " yyy || // aaaaaa bbbbbbbb cccc\n"
762 " zzz)\n"
763 " q();",
764 format("if (xxxxxxxxxx && yyy || // aaaaaa bbbbbbbb cccc\n"
765 " zzz) q();",
766 getLLVMStyleWithColumns(40)));
767 EXPECT_EQ("fffffffff(\n"
768 " &xxx, // aaaaaaaaaaaa bbbbbbbbbbb\n"
769 " zzz);",
770 format("fffffffff(&xxx, // aaaaaaaaaaaa bbbbbbbbbbb\n"
771 " zzz);",
772 getLLVMStyleWithColumns(40)));
773}
774
775TEST_F(FormatTestComments, MultiLineCommentsInDefines) {
776 EXPECT_EQ("#define A(x) /* \\\n"
777 " a comment \\\n"
778 " inside */ \\\n"
779 " f();",
780 format("#define A(x) /* \\\n"
781 " a comment \\\n"
782 " inside */ \\\n"
783 " f();",
784 getLLVMStyleWithColumns(17)));
785 EXPECT_EQ("#define A( \\\n"
786 " x) /* \\\n"
787 " a comment \\\n"
788 " inside */ \\\n"
789 " f();",
790 format("#define A( \\\n"
791 " x) /* \\\n"
792 " a comment \\\n"
793 " inside */ \\\n"
794 " f();",
795 getLLVMStyleWithColumns(17)));
796}
797
798TEST_F(FormatTestComments, ParsesCommentsAdjacentToPPDirectives) {
799 EXPECT_EQ("namespace {}\n// Test\n#define A",
800 format("namespace {}\n // Test\n#define A"));
801 EXPECT_EQ("namespace {}\n/* Test */\n#define A",
802 format("namespace {}\n /* Test */\n#define A"));
803 EXPECT_EQ("namespace {}\n/* Test */ #define A",
804 format("namespace {}\n /* Test */ #define A"));
805}
806
807TEST_F(FormatTestComments, SplitsLongLinesInComments) {
808 EXPECT_EQ("/* This is a long\n"
809 " * comment that\n"
810 " * doesn't\n"
811 " * fit on one line.\n"
812 " */",
813 format("/* "
814 "This is a long "
815 "comment that "
816 "doesn't "
817 "fit on one line. */",
818 getLLVMStyleWithColumns(20)));
819 EXPECT_EQ(
820 "/* a b c d\n"
821 " * e f g\n"
822 " * h i j k\n"
823 " */",
824 format("/* a b c d e f g h i j k */", getLLVMStyleWithColumns(10)));
825 EXPECT_EQ(
826 "/* a b c d\n"
827 " * e f g\n"
828 " * h i j k\n"
829 " */",
830 format("\\\n/* a b c d e f g h i j k */", getLLVMStyleWithColumns(10)));
831 EXPECT_EQ("/*\n"
832 "This is a long\n"
833 "comment that doesn't\n"
834 "fit on one line.\n"
835 "*/",
836 format("/*\n"
837 "This is a long "
838 "comment that doesn't "
839 "fit on one line. \n"
840 "*/",
841 getLLVMStyleWithColumns(20)));
842 EXPECT_EQ("/*\n"
843 " * This is a long\n"
844 " * comment that\n"
845 " * doesn't fit on\n"
846 " * one line.\n"
847 " */",
848 format("/* \n"
849 " * This is a long "
850 " comment that "
851 " doesn't fit on "
852 " one line. \n"
853 " */",
854 getLLVMStyleWithColumns(20)));
855 EXPECT_EQ("/*\n"
856 " * This_is_a_comment_with_words_that_dont_fit_on_one_line\n"
857 " * so_it_should_be_broken\n"
858 " * wherever_a_space_occurs\n"
859 " */",
860 format("/*\n"
861 " * This_is_a_comment_with_words_that_dont_fit_on_one_line "
862 " so_it_should_be_broken "
863 " wherever_a_space_occurs \n"
864 " */",
865 getLLVMStyleWithColumns(20)));
866 EXPECT_EQ("/*\n"
867 " * This_comment_can_not_be_broken_into_lines\n"
868 " */",
869 format("/*\n"
870 " * This_comment_can_not_be_broken_into_lines\n"
871 " */",
872 getLLVMStyleWithColumns(20)));
873 EXPECT_EQ("{\n"
874 " /*\n"
875 " This is another\n"
876 " long comment that\n"
877 " doesn't fit on one\n"
878 " line 1234567890\n"
879 " */\n"
880 "}",
881 format("{\n"
882 "/*\n"
883 "This is another "
884 " long comment that "
885 " doesn't fit on one"
886 " line 1234567890\n"
887 "*/\n"
888 "}",
889 getLLVMStyleWithColumns(20)));
890 EXPECT_EQ("{\n"
891 " /*\n"
892 " * This i s\n"
893 " * another comment\n"
894 " * t hat doesn' t\n"
895 " * fit on one l i\n"
896 " * n e\n"
897 " */\n"
898 "}",
899 format("{\n"
900 "/*\n"
901 " * This i s"
902 " another comment"
903 " t hat doesn' t"
904 " fit on one l i"
905 " n e\n"
906 " */\n"
907 "}",
908 getLLVMStyleWithColumns(20)));
909 EXPECT_EQ("/*\n"
910 " * This is a long\n"
911 " * comment that\n"
912 " * doesn't fit on\n"
913 " * one line\n"
914 " */",
915 format(" /*\n"
916 " * This is a long comment that doesn't fit on one line\n"
917 " */",
918 getLLVMStyleWithColumns(20)));
919 EXPECT_EQ("{\n"
920 " if (something) /* This is a\n"
921 " long\n"
922 " comment */\n"
923 " ;\n"
924 "}",
925 format("{\n"
926 " if (something) /* This is a long comment */\n"
927 " ;\n"
928 "}",
929 getLLVMStyleWithColumns(30)));
930
931 EXPECT_EQ("/* A comment before\n"
932 " * a macro\n"
933 " * definition */\n"
934 "#define a b",
935 format("/* A comment before a macro definition */\n"
936 "#define a b",
937 getLLVMStyleWithColumns(20)));
938
939 EXPECT_EQ("/* some comment\n"
Krasimir Georgievbb99a362017-02-16 12:39:31 +0000[diff] [blame^]940 " * a comment that\n"
941 " * we break another\n"
942 " * comment we have\n"
943 " * to break a left\n"
944 " * comment\n"
Krasimir Georgievfd0dda72017-02-08 12:53:18 +0000[diff] [blame]945 " */",
946 format(" /* some comment\n"
947 " * a comment that we break\n"
948 " * another comment we have to break\n"
949 "* a left comment\n"
950 " */",
951 getLLVMStyleWithColumns(20)));
952
953 EXPECT_EQ("/**\n"
954 " * multiline block\n"
955 " * comment\n"
956 " *\n"
957 " */",
958 format("/**\n"
959 " * multiline block comment\n"
960 " *\n"
961 " */",
962 getLLVMStyleWithColumns(20)));
963
964 EXPECT_EQ("/*\n"
965 "\n"
966 "\n"
967 " */\n",
968 format(" /* \n"
969 " \n"
970 " \n"
971 " */\n"));
972
973 EXPECT_EQ("/* a a */",
974 format("/* a a */", getLLVMStyleWithColumns(15)));
975 EXPECT_EQ("/* a a bc */",
976 format("/* a a bc */", getLLVMStyleWithColumns(15)));
977 EXPECT_EQ("/* aaa aaa\n"
978 " * aaaaa */",
979 format("/* aaa aaa aaaaa */", getLLVMStyleWithColumns(15)));
980 EXPECT_EQ("/* aaa aaa\n"
981 " * aaaaa */",
982 format("/* aaa aaa aaaaa */", getLLVMStyleWithColumns(15)));
983}
984
985TEST_F(FormatTestComments, SplitsLongLinesInCommentsInPreprocessor) {
986 EXPECT_EQ("#define X \\\n"
987 " /* \\\n"
988 " Test \\\n"
989 " Macro comment \\\n"
990 " with a long \\\n"
991 " line \\\n"
992 " */ \\\n"
993 " A + B",
994 format("#define X \\\n"
995 " /*\n"
996 " Test\n"
997 " Macro comment with a long line\n"
998 " */ \\\n"
999 " A + B",
1000 getLLVMStyleWithColumns(20)));
1001 EXPECT_EQ("#define X \\\n"
1002 " /* Macro comment \\\n"
1003 " with a long \\\n"
1004 " line */ \\\n"
1005 " A + B",
1006 format("#define X \\\n"
1007 " /* Macro comment with a long\n"
1008 " line */ \\\n"
1009 " A + B",
1010 getLLVMStyleWithColumns(20)));
1011 EXPECT_EQ("#define X \\\n"
1012 " /* Macro comment \\\n"
1013 " * with a long \\\n"
1014 " * line */ \\\n"
1015 " A + B",
1016 format("#define X \\\n"
1017 " /* Macro comment with a long line */ \\\n"
1018 " A + B",
1019 getLLVMStyleWithColumns(20)));
1020}
1021
1022TEST_F(FormatTestComments, CommentsInStaticInitializers) {
1023 EXPECT_EQ(
1024 "static SomeType type = {aaaaaaaaaaaaaaaaaaaa, /* comment */\n"
1025 " aaaaaaaaaaaaaaaaaaaa /* comment */,\n"
1026 " /* comment */ aaaaaaaaaaaaaaaaaaaa,\n"
1027 " aaaaaaaaaaaaaaaaaaaa, // comment\n"
1028 " aaaaaaaaaaaaaaaaaaaa};",
1029 format("static SomeType type = { aaaaaaaaaaaaaaaaaaaa , /* comment */\n"
1030 " aaaaaaaaaaaaaaaaaaaa /* comment */ ,\n"
1031 " /* comment */ aaaaaaaaaaaaaaaaaaaa ,\n"
1032 " aaaaaaaaaaaaaaaaaaaa , // comment\n"
1033 " aaaaaaaaaaaaaaaaaaaa };"));
1034 verifyFormat("static SomeType type = {aaaaaaaaaaa, // comment for aa...\n"
1035 " bbbbbbbbbbb, ccccccccccc};");
1036 verifyFormat("static SomeType type = {aaaaaaaaaaa,\n"
1037 " // comment for bb....\n"
1038 " bbbbbbbbbbb, ccccccccccc};");
1039 verifyGoogleFormat(
1040 "static SomeType type = {aaaaaaaaaaa, // comment for aa...\n"
1041 " bbbbbbbbbbb, ccccccccccc};");
1042 verifyGoogleFormat("static SomeType type = {aaaaaaaaaaa,\n"
1043 " // comment for bb....\n"
1044 " bbbbbbbbbbb, ccccccccccc};");
1045
1046 verifyFormat("S s = {{a, b, c}, // Group #1\n"
1047 " {d, e, f}, // Group #2\n"
1048 " {g, h, i}}; // Group #3");
1049 verifyFormat("S s = {{// Group #1\n"
1050 " a, b, c},\n"
1051 " {// Group #2\n"
1052 " d, e, f},\n"
1053 " {// Group #3\n"
1054 " g, h, i}};");
1055
1056 EXPECT_EQ("S s = {\n"
1057 " // Some comment\n"
1058 " a,\n"
1059 "\n"
1060 " // Comment after empty line\n"
1061 " b}",
1062 format("S s = {\n"
1063 " // Some comment\n"
1064 " a,\n"
1065 " \n"
1066 " // Comment after empty line\n"
1067 " b\n"
1068 "}"));
1069 EXPECT_EQ("S s = {\n"
1070 " /* Some comment */\n"
1071 " a,\n"
1072 "\n"
1073 " /* Comment after empty line */\n"
1074 " b}",
1075 format("S s = {\n"
1076 " /* Some comment */\n"
1077 " a,\n"
1078 " \n"
1079 " /* Comment after empty line */\n"
1080 " b\n"
1081 "}"));
1082 verifyFormat("const uint8_t aaaaaaaaaaaaaaaaaaaaaa[0] = {\n"
1083 " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n"
1084 " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n"
1085 " 0x00, 0x00, 0x00, 0x00}; // comment\n");
1086}
1087
1088TEST_F(FormatTestComments, LineCommentsAfterRightBrace) {
1089 EXPECT_EQ("if (true) { // comment about branch\n"
1090 " // comment about f\n"
1091 " f();\n"
1092 "}",
1093 format("if (true) { // comment about branch\n"
1094 " // comment about f\n"
1095 " f();\n"
1096 "}",
1097 getLLVMStyleWithColumns(80)));
1098 EXPECT_EQ("if (1) { // if line 1\n"
1099 " // if line 2\n"
1100 " // if line 3\n"
1101 " // f line 1\n"
1102 " // f line 2\n"
1103 " f();\n"
1104 "} else { // else line 1\n"
1105 " // else line 2\n"
1106 " // else line 3\n"
1107 " // g line 1\n"
1108 " g();\n"
1109 "}",
1110 format("if (1) { // if line 1\n"
1111 " // if line 2\n"
1112 " // if line 3\n"
1113 " // f line 1\n"
1114 " // f line 2\n"
1115 " f();\n"
1116 "} else { // else line 1\n"
1117 " // else line 2\n"
1118 " // else line 3\n"
1119 " // g line 1\n"
1120 " g();\n"
1121 "}"));
1122 EXPECT_EQ("do { // line 1\n"
1123 " // line 2\n"
1124 " // line 3\n"
1125 " f();\n"
1126 "} while (true);",
1127 format("do { // line 1\n"
1128 " // line 2\n"
1129 " // line 3\n"
1130 " f();\n"
1131 "} while (true);",
1132 getLLVMStyleWithColumns(80)));
1133 EXPECT_EQ("while (a < b) { // line 1\n"
1134 " // line 2\n"
1135 " // line 3\n"
1136 " f();\n"
1137 "}",
1138 format("while (a < b) {// line 1\n"
1139 " // line 2\n"
1140 " // line 3\n"
1141 " f();\n"
1142 "}",
1143 getLLVMStyleWithColumns(80)));
1144}
1145
1146TEST_F(FormatTestComments, ReflowsComments) {
1147 // Break a long line and reflow with the full next line.
1148 EXPECT_EQ("// long long long\n"
1149 "// long long",
1150 format("// long long long long\n"
1151 "// long",
1152 getLLVMStyleWithColumns(20)));
1153
1154 // Keep the trailing newline while reflowing.
1155 EXPECT_EQ("// long long long\n"
1156 "// long long\n",
1157 format("// long long long long\n"
1158 "// long\n",
1159 getLLVMStyleWithColumns(20)));
1160
1161 // Break a long line and reflow with a part of the next line.
1162 EXPECT_EQ("// long long long\n"
1163 "// long long\n"
1164 "// long_long",
1165 format("// long long long long\n"
1166 "// long long_long",
1167 getLLVMStyleWithColumns(20)));
1168
1169 // Break but do not reflow if the first word from the next line is too long.
1170 EXPECT_EQ("// long long long\n"
1171 "// long\n"
1172 "// long_long_long\n",
1173 format("// long long long long\n"
1174 "// long_long_long\n",
1175 getLLVMStyleWithColumns(20)));
1176
1177 // Don't break or reflow short lines.
1178 verifyFormat("// long\n"
1179 "// long long long lo\n"
1180 "// long long long lo\n"
1181 "// long",
1182 getLLVMStyleWithColumns(20));
1183
1184 // Keep prefixes and decorations while reflowing.
1185 EXPECT_EQ("/// long long long\n"
1186 "/// long long\n",
1187 format("/// long long long long\n"
1188 "/// long\n",
1189 getLLVMStyleWithColumns(20)));
1190 EXPECT_EQ("//! long long long\n"
1191 "//! long long\n",
1192 format("//! long long long long\n"
1193 "//! long\n",
1194 getLLVMStyleWithColumns(20)));
1195 EXPECT_EQ("/* long long long\n"
1196 " * long long */",
1197 format("/* long long long long\n"
1198 " * long */",
1199 getLLVMStyleWithColumns(20)));
1200
1201 // Don't bring leading whitespace up while reflowing.
1202 EXPECT_EQ("/* long long long\n"
1203 " * long long long\n"
1204 " */",
1205 format("/* long long long long\n"
1206 " * long long\n"
1207 " */",
1208 getLLVMStyleWithColumns(20)));
1209
1210 // Reflow the last line of a block comment with its trailing '*/'.
1211 EXPECT_EQ("/* long long long\n"
1212 " long long */",
1213 format("/* long long long long\n"
1214 " long */",
1215 getLLVMStyleWithColumns(20)));
1216
1217 // Reflow two short lines; keep the postfix of the last one.
1218 EXPECT_EQ("/* long long long\n"
1219 " * long long long */",
1220 format("/* long long long long\n"
1221 " * long\n"
1222 " * long */",
1223 getLLVMStyleWithColumns(20)));
1224
1225 // Put the postfix of the last short reflow line on a newline if it doesn't
1226 // fit.
1227 EXPECT_EQ("/* long long long\n"
1228 " * long long longg\n"
1229 " */",
1230 format("/* long long long long\n"
1231 " * long\n"
1232 " * longg */",
1233 getLLVMStyleWithColumns(20)));
1234
1235 // Reflow lines with leading whitespace.
1236 EXPECT_EQ("{\n"
1237 " /*\n"
1238 " * long long long\n"
1239 " * long long long\n"
1240 " * long long long\n"
1241 " */\n"
1242 "}",
1243 format("{\n"
1244 "/*\n"
1245 " * long long long long\n"
1246 " * long\n"
1247 " * long long long long\n"
1248 " */\n"
1249 "}",
1250 getLLVMStyleWithColumns(20)));
1251
1252 // Break single line block comments that are first in the line with ' *'
1253 // decoration.
1254 EXPECT_EQ("/* long long long\n"
1255 " * long */",
1256 format("/* long long long long */", getLLVMStyleWithColumns(20)));
1257
1258 // Break single line block comment that are not first in the line with ' '
1259 // decoration.
1260 EXPECT_EQ("int i; /* long long\n"
1261 " long */",
1262 format("int i; /* long long long */", getLLVMStyleWithColumns(20)));
1263
1264 // Reflow a line that goes just over the column limit.
1265 EXPECT_EQ("// long long long\n"
1266 "// lon long",
1267 format("// long long long lon\n"
1268 "// long",
1269 getLLVMStyleWithColumns(20)));
1270
1271 // Stop reflowing if the next line has a different indentation than the
1272 // previous line.
1273 EXPECT_EQ("// long long long\n"
1274 "// long\n"
1275 "// long long\n"
1276 "// long",
1277 format("// long long long long\n"
1278 "// long long\n"
1279 "// long",
1280 getLLVMStyleWithColumns(20)));
1281
1282 // Reflow into the last part of a really long line that has been broken into
1283 // multiple lines.
1284 EXPECT_EQ("// long long long\n"
1285 "// long long long\n"
1286 "// long long long\n",
1287 format("// long long long long long long long long\n"
1288 "// long\n",
1289 getLLVMStyleWithColumns(20)));
1290
1291 // Break the first line, then reflow the beginning of the second and third
1292 // line up.
1293 EXPECT_EQ("// long long long\n"
1294 "// lon1 lon2 lon2\n"
1295 "// lon2 lon3 lon3",
1296 format("// long long long lon1\n"
1297 "// lon2 lon2 lon2\n"
1298 "// lon3 lon3",
1299 getLLVMStyleWithColumns(20)));
1300
1301 // Reflow the beginning of the second line, then break the rest.
1302 EXPECT_EQ("// long long long\n"
1303 "// lon1 lon2 lon2\n"
1304 "// lon2 lon2 lon2\n"
1305 "// lon3",
1306 format("// long long long lon1\n"
1307 "// lon2 lon2 lon2 lon2 lon2 lon3",
1308 getLLVMStyleWithColumns(20)));
1309
1310 // Shrink the first line, then reflow the second line up.
1311 EXPECT_EQ("// long long long", format("// long long\n"
1312 "// long",
1313 getLLVMStyleWithColumns(20)));
1314
1315 // Don't shrink leading whitespace.
1316 EXPECT_EQ("int i; /// a",
1317 format("int i; /// a", getLLVMStyleWithColumns(20)));
1318
1319 // Shrink trailing whitespace if there is no postfix and reflow.
1320 EXPECT_EQ("// long long long\n"
1321 "// long long",
1322 format("// long long long long \n"
1323 "// long",
1324 getLLVMStyleWithColumns(20)));
1325
1326 // Shrink trailing whitespace to a single one if there is postfix.
1327 EXPECT_EQ("/* long long long */",
1328 format("/* long long long */", getLLVMStyleWithColumns(20)));
1329
1330 // Break a block comment postfix if exceeding the line limit.
1331 EXPECT_EQ("/* long\n"
1332 " */",
1333 format("/* long */", getLLVMStyleWithColumns(20)));
1334
1335 // Reflow indented comments.
1336 EXPECT_EQ("{\n"
1337 " // long long long\n"
1338 " // long long\n"
1339 " int i; /* long lon\n"
1340 " g long\n"
1341 " */\n"
1342 "}",
1343 format("{\n"
1344 " // long long long long\n"
1345 " // long\n"
1346 " int i; /* long lon g\n"
1347 " long */\n"
1348 "}",
1349 getLLVMStyleWithColumns(20)));
1350
1351 // Don't realign trailing comments after reflow has happened.
1352 EXPECT_EQ("// long long long\n"
1353 "// long long\n"
1354 "long i; // long",
1355 format("// long long long long\n"
1356 "// long\n"
1357 "long i; // long",
1358 getLLVMStyleWithColumns(20)));
1359 EXPECT_EQ("// long long long\n"
1360 "// longng long long\n"
1361 "// long lo",
1362 format("// long long long longng\n"
1363 "// long long long\n"
1364 "// lo",
1365 getLLVMStyleWithColumns(20)));
1366
1367 // Reflow lines after a broken line.
1368 EXPECT_EQ("int a; // Trailing\n"
1369 " // comment on\n"
1370 " // 2 or 3\n"
1371 " // lines.\n",
1372 format("int a; // Trailing comment\n"
1373 " // on 2\n"
1374 " // or 3\n"
1375 " // lines.\n",
1376 getLLVMStyleWithColumns(20)));
1377 EXPECT_EQ("/// This long line\n"
1378 "/// gets reflown.\n",
1379 format("/// This long line gets\n"
1380 "/// reflown.\n",
1381 getLLVMStyleWithColumns(20)));
1382 EXPECT_EQ("//! This long line\n"
1383 "//! gets reflown.\n",
1384 format(" //! This long line gets\n"
1385 " //! reflown.\n",
1386 getLLVMStyleWithColumns(20)));
1387 EXPECT_EQ("/* This long line\n"
1388 " * gets reflown.\n"
1389 " */\n",
1390 format("/* This long line gets\n"
1391 " * reflown.\n"
1392 " */\n",
1393 getLLVMStyleWithColumns(20)));
1394
1395 // Reflow after indentation makes a line too long.
1396 EXPECT_EQ("{\n"
1397 " // long long long\n"
1398 " // lo long\n"
1399 "}\n",
1400 format("{\n"
1401 "// long long long lo\n"
1402 "// long\n"
1403 "}\n",
1404 getLLVMStyleWithColumns(20)));
1405
1406 // Break and reflow multiple lines.
1407 EXPECT_EQ("/*\n"
1408 " * Reflow the end of\n"
1409 " * line by 11 22 33\n"
1410 " * 4.\n"
1411 " */\n",
1412 format("/*\n"
1413 " * Reflow the end of line\n"
1414 " * by\n"
1415 " * 11\n"
1416 " * 22\n"
1417 " * 33\n"
1418 " * 4.\n"
1419 " */\n",
1420 getLLVMStyleWithColumns(20)));
1421 EXPECT_EQ("/// First line gets\n"
1422 "/// broken. Second\n"
1423 "/// line gets\n"
1424 "/// reflown and\n"
1425 "/// broken. Third\n"
1426 "/// gets reflown.\n",
1427 format("/// First line gets broken.\n"
1428 "/// Second line gets reflown and broken.\n"
1429 "/// Third gets reflown.\n",
1430 getLLVMStyleWithColumns(20)));
1431 EXPECT_EQ("int i; // first long\n"
1432 " // long snd\n"
1433 " // long.\n",
1434 format("int i; // first long long\n"
1435 " // snd long.\n",
1436 getLLVMStyleWithColumns(20)));
1437 EXPECT_EQ("{\n"
1438 " // first long line\n"
1439 " // line second\n"
1440 " // long line line\n"
1441 " // third long line\n"
1442 " // line\n"
1443 "}\n",
1444 format("{\n"
1445 " // first long line line\n"
1446 " // second long line line\n"
1447 " // third long line line\n"
1448 "}\n",
1449 getLLVMStyleWithColumns(20)));
1450 EXPECT_EQ("int i; /* first line\n"
1451 " * second\n"
1452 " * line third\n"
1453 " * line\n"
1454 " */",
1455 format("int i; /* first line\n"
1456 " * second line\n"
1457 " * third line\n"
1458 " */",
1459 getLLVMStyleWithColumns(20)));
1460
1461 // Reflow the last two lines of a section that starts with a line having
1462 // different indentation.
1463 EXPECT_EQ(
1464 "// long\n"
1465 "// long long long\n"
1466 "// long long",
1467 format("// long\n"
1468 "// long long long long\n"
1469 "// long",
1470 getLLVMStyleWithColumns(20)));
1471
1472 // Keep the block comment endling '*/' while reflowing.
1473 EXPECT_EQ("/* Long long long\n"
1474 " * line short */\n",
1475 format("/* Long long long line\n"
1476 " * short */\n",
1477 getLLVMStyleWithColumns(20)));
1478
1479 // Don't reflow between separate blocks of comments.
1480 EXPECT_EQ("/* First comment\n"
1481 " * block will */\n"
1482 "/* Snd\n"
1483 " */\n",
1484 format("/* First comment block\n"
1485 " * will */\n"
1486 "/* Snd\n"
1487 " */\n",
1488 getLLVMStyleWithColumns(20)));
1489
1490 // Don't reflow across blank comment lines.
1491 EXPECT_EQ("int i; // This long\n"
1492 " // line gets\n"
1493 " // broken.\n"
1494 " //\n"
1495 " // keep.\n",
1496 format("int i; // This long line gets broken.\n"
1497 " // \n"
1498 " // keep.\n",
1499 getLLVMStyleWithColumns(20)));
1500 EXPECT_EQ("{\n"
1501 " /// long long long\n"
1502 " /// long long\n"
1503 " ///\n"
1504 " /// long\n"
1505 "}",
1506 format("{\n"
1507 " /// long long long long\n"
1508 " /// long\n"
1509 " ///\n"
1510 " /// long\n"
1511 "}",
1512 getLLVMStyleWithColumns(20)));
1513 EXPECT_EQ("//! long long long\n"
1514 "//! long\n"
1515 "\n"
1516 "//! long",
1517 format("//! long long long long\n"
1518 "\n"
1519 "//! long",
1520 getLLVMStyleWithColumns(20)));
1521 EXPECT_EQ("/* long long long\n"
1522 " long\n"
1523 "\n"
1524 " long */",
1525 format("/* long long long long\n"
1526 "\n"
1527 " long */",
1528 getLLVMStyleWithColumns(20)));
1529 EXPECT_EQ("/* long long long\n"
1530 " * long\n"
1531 " *\n"
1532 " * long */",
1533 format("/* long long long long\n"
1534 " *\n"
1535 " * long */",
1536 getLLVMStyleWithColumns(20)));
1537
1538 // Don't reflow lines having content that is a single character.
1539 EXPECT_EQ("// long long long\n"
1540 "// long\n"
1541 "// l",
1542 format("// long long long long\n"
1543 "// l",
1544 getLLVMStyleWithColumns(20)));
1545
1546 // Don't reflow lines starting with two punctuation characters.
1547 EXPECT_EQ("// long long long\n"
1548 "// long\n"
1549 "// ... --- ...",
1550 format(
1551 "// long long long long\n"
1552 "// ... --- ...",
1553 getLLVMStyleWithColumns(20)));
1554
1555 // Don't reflow lines starting with '@'.
1556 EXPECT_EQ("// long long long\n"
1557 "// long\n"
1558 "// @param arg",
1559 format("// long long long long\n"
1560 "// @param arg",
1561 getLLVMStyleWithColumns(20)));
1562
1563 // Don't reflow lines starting with 'TODO'.
1564 EXPECT_EQ("// long long long\n"
1565 "// long\n"
1566 "// TODO: long",
1567 format("// long long long long\n"
1568 "// TODO: long",
1569 getLLVMStyleWithColumns(20)));
1570
1571 // Don't reflow lines starting with 'FIXME'.
1572 EXPECT_EQ("// long long long\n"
1573 "// long\n"
1574 "// FIXME: long",
1575 format("// long long long long\n"
1576 "// FIXME: long",
1577 getLLVMStyleWithColumns(20)));
1578
1579 // Don't reflow lines starting with 'XXX'.
1580 EXPECT_EQ("// long long long\n"
1581 "// long\n"
1582 "// XXX: long",
1583 format("// long long long long\n"
1584 "// XXX: long",
1585 getLLVMStyleWithColumns(20)));
1586
1587 // Don't reflow comment pragmas.
1588 EXPECT_EQ("// long long long\n"
1589 "// long\n"
1590 "// IWYU pragma:",
1591 format("// long long long long\n"
1592 "// IWYU pragma:",
1593 getLLVMStyleWithColumns(20)));
1594 EXPECT_EQ("/* long long long\n"
1595 " * long\n"
1596 " * IWYU pragma:\n"
1597 " */",
1598 format("/* long long long long\n"
1599 " * IWYU pragma:\n"
1600 " */",
1601 getLLVMStyleWithColumns(20)));
1602
1603 // Reflow lines that have a non-punctuation character among their first 2
1604 // characters.
1605 EXPECT_EQ("// long long long\n"
1606 "// long 'long'",
1607 format(
1608 "// long long long long\n"
1609 "// 'long'",
1610 getLLVMStyleWithColumns(20)));
1611
1612 // Don't reflow between separate blocks of comments.
1613 EXPECT_EQ("/* First comment\n"
1614 " * block will */\n"
1615 "/* Snd\n"
1616 " */\n",
1617 format("/* First comment block\n"
1618 " * will */\n"
1619 "/* Snd\n"
1620 " */\n",
1621 getLLVMStyleWithColumns(20)));
1622
1623 // Don't reflow lines having different indentation.
1624 EXPECT_EQ("// long long long\n"
1625 "// long\n"
1626 "// long",
1627 format("// long long long long\n"
1628 "// long",
1629 getLLVMStyleWithColumns(20)));
1630
1631 // Don't break or reflow after implicit string literals.
1632 verifyFormat("#include <t> // l l l\n"
1633 " // l",
1634 getLLVMStyleWithColumns(20));
1635
1636 // Don't break or reflow comments on import lines.
1637 EXPECT_EQ("#include \"t\" /* l l l\n"
1638 " * l */",
1639 format("#include \"t\" /* l l l\n"
1640 " * l */",
1641 getLLVMStyleWithColumns(20)));
1642
1643 // Don't reflow between different trailing comment sections.
1644 EXPECT_EQ("int i; // long long\n"
1645 " // long\n"
1646 "int j; // long long\n"
1647 " // long\n",
1648 format("int i; // long long long\n"
1649 "int j; // long long long\n",
1650 getLLVMStyleWithColumns(20)));
1651
1652 // Don't reflow if the first word on the next line is longer than the
1653 // available space at current line.
1654 EXPECT_EQ("int i; // trigger\n"
1655 " // reflow\n"
1656 " // longsec\n",
1657 format("int i; // trigger reflow\n"
1658 " // longsec\n",
1659 getLLVMStyleWithColumns(20)));
1660
1661 // Keep empty comment lines.
1662 EXPECT_EQ("/**/", format(" /**/", getLLVMStyleWithColumns(20)));
1663 EXPECT_EQ("/* */", format(" /* */", getLLVMStyleWithColumns(20)));
1664 EXPECT_EQ("/* */", format(" /* */", getLLVMStyleWithColumns(20)));
1665 EXPECT_EQ("//", format(" // ", getLLVMStyleWithColumns(20)));
1666 EXPECT_EQ("///", format(" /// ", getLLVMStyleWithColumns(20)));
1667}
1668
1669TEST_F(FormatTestComments, IgnoresIf0Contents) {
1670 EXPECT_EQ("#if 0\n"
1671 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n"
1672 "#endif\n"
1673 "void f() {}",
1674 format("#if 0\n"
1675 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n"
1676 "#endif\n"
1677 "void f( ) { }"));
1678 EXPECT_EQ("#if false\n"
1679 "void f( ) { }\n"
1680 "#endif\n"
1681 "void g() {}\n",
1682 format("#if false\n"
1683 "void f( ) { }\n"
1684 "#endif\n"
1685 "void g( ) { }\n"));
1686 EXPECT_EQ("enum E {\n"
1687 " One,\n"
1688 " Two,\n"
1689 "#if 0\n"
1690 "Three,\n"
1691 " Four,\n"
1692 "#endif\n"
1693 " Five\n"
1694 "};",
1695 format("enum E {\n"
1696 " One,Two,\n"
1697 "#if 0\n"
1698 "Three,\n"
1699 " Four,\n"
1700 "#endif\n"
1701 " Five};"));
1702 EXPECT_EQ("enum F {\n"
1703 " One,\n"
1704 "#if 1\n"
1705 " Two,\n"
1706 "#if 0\n"
1707 "Three,\n"
1708 " Four,\n"
1709 "#endif\n"
1710 " Five\n"
1711 "#endif\n"
1712 "};",
1713 format("enum F {\n"
1714 "One,\n"
1715 "#if 1\n"
1716 "Two,\n"
1717 "#if 0\n"
1718 "Three,\n"
1719 " Four,\n"
1720 "#endif\n"
1721 "Five\n"
1722 "#endif\n"
1723 "};"));
1724 EXPECT_EQ("enum G {\n"
1725 " One,\n"
1726 "#if 0\n"
1727 "Two,\n"
1728 "#else\n"
1729 " Three,\n"
1730 "#endif\n"
1731 " Four\n"
1732 "};",
1733 format("enum G {\n"
1734 "One,\n"
1735 "#if 0\n"
1736 "Two,\n"
1737 "#else\n"
1738 "Three,\n"
1739 "#endif\n"
1740 "Four\n"
1741 "};"));
1742 EXPECT_EQ("enum H {\n"
1743 " One,\n"
1744 "#if 0\n"
1745 "#ifdef Q\n"
1746 "Two,\n"
1747 "#else\n"
1748 "Three,\n"
1749 "#endif\n"
1750 "#endif\n"
1751 " Four\n"
1752 "};",
1753 format("enum H {\n"
1754 "One,\n"
1755 "#if 0\n"
1756 "#ifdef Q\n"
1757 "Two,\n"
1758 "#else\n"
1759 "Three,\n"
1760 "#endif\n"
1761 "#endif\n"
1762 "Four\n"
1763 "};"));
1764 EXPECT_EQ("enum I {\n"
1765 " One,\n"
1766 "#if /* test */ 0 || 1\n"
1767 "Two,\n"
1768 "Three,\n"
1769 "#endif\n"
1770 " Four\n"
1771 "};",
1772 format("enum I {\n"
1773 "One,\n"
1774 "#if /* test */ 0 || 1\n"
1775 "Two,\n"
1776 "Three,\n"
1777 "#endif\n"
1778 "Four\n"
1779 "};"));
1780 EXPECT_EQ("enum J {\n"
1781 " One,\n"
1782 "#if 0\n"
1783 "#if 0\n"
1784 "Two,\n"
1785 "#else\n"
1786 "Three,\n"
1787 "#endif\n"
1788 "Four,\n"
1789 "#endif\n"
1790 " Five\n"
1791 "};",
1792 format("enum J {\n"
1793 "One,\n"
1794 "#if 0\n"
1795 "#if 0\n"
1796 "Two,\n"
1797 "#else\n"
1798 "Three,\n"
1799 "#endif\n"
1800 "Four,\n"
1801 "#endif\n"
1802 "Five\n"
1803 "};"));
1804}
1805
1806TEST_F(FormatTestComments, DontCrashOnBlockComments) {
1807 EXPECT_EQ(
1808 "int xxxxxxxxx; /* "
1809 "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy\n"
1810 "zzzzzz\n"
1811 "0*/",
1812 format("int xxxxxxxxx; /* "
1813 "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy zzzzzz\n"
1814 "0*/"));
1815}
1816
1817TEST_F(FormatTestComments, BlockCommentsInControlLoops) {
1818 verifyFormat("if (0) /* a comment in a strange place */ {\n"
1819 " f();\n"
1820 "}");
1821 verifyFormat("if (0) /* a comment in a strange place */ {\n"
1822 " f();\n"
1823 "} /* another comment */ else /* comment #3 */ {\n"
1824 " g();\n"
1825 "}");
1826 verifyFormat("while (0) /* a comment in a strange place */ {\n"
1827 " f();\n"
1828 "}");
1829 verifyFormat("for (;;) /* a comment in a strange place */ {\n"
1830 " f();\n"
1831 "}");
1832 verifyFormat("do /* a comment in a strange place */ {\n"
1833 " f();\n"
1834 "} /* another comment */ while (0);");
1835}
1836
1837TEST_F(FormatTestComments, BlockComments) {
1838 EXPECT_EQ("/* */ /* */ /* */\n/* */ /* */ /* */",
1839 format("/* *//* */ /* */\n/* *//* */ /* */"));
1840 EXPECT_EQ("/* */ a /* */ b;", format(" /* */ a/* */ b;"));
1841 EXPECT_EQ("#define A /*123*/ \\\n"
1842 " b\n"
1843 "/* */\n"
1844 "someCall(\n"
1845 " parameter);",
1846 format("#define A /*123*/ b\n"
1847 "/* */\n"
1848 "someCall(parameter);",
1849 getLLVMStyleWithColumns(15)));
1850
1851 EXPECT_EQ("#define A\n"
1852 "/* */ someCall(\n"
1853 " parameter);",
1854 format("#define A\n"
1855 "/* */someCall(parameter);",
1856 getLLVMStyleWithColumns(15)));
1857 EXPECT_EQ("/*\n**\n*/", format("/*\n**\n*/"));
1858 EXPECT_EQ("/*\n"
Krasimir Georgievbb99a362017-02-16 12:39:31 +0000[diff] [blame^]1859 " *\n"
Krasimir Georgievfd0dda72017-02-08 12:53:18 +0000[diff] [blame]1860 " * aaaaaa\n"
1861 " * aaaaaa\n"
Krasimir Georgievbb99a362017-02-16 12:39:31 +0000[diff] [blame^]1862 " */",
Krasimir Georgievfd0dda72017-02-08 12:53:18 +0000[diff] [blame]1863 format("/*\n"
1864 "*\n"
1865 " * aaaaaa aaaaaa\n"
1866 "*/",
1867 getLLVMStyleWithColumns(10)));
1868 EXPECT_EQ("/*\n"
1869 "**\n"
1870 "* aaaaaa\n"
1871 "*aaaaaa\n"
1872 "*/",
1873 format("/*\n"
1874 "**\n"
1875 "* aaaaaa aaaaaa\n"
1876 "*/",
1877 getLLVMStyleWithColumns(10)));
1878 EXPECT_EQ("int aaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
1879 " /* line 1\n"
1880 " bbbbbbbbbbbb */\n"
1881 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
1882 format("int aaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
1883 " /* line 1\n"
1884 " bbbbbbbbbbbb */ bbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
1885 getLLVMStyleWithColumns(50)));
1886
1887 FormatStyle NoBinPacking = getLLVMStyle();
1888 NoBinPacking.BinPackParameters = false;
1889 EXPECT_EQ("someFunction(1, /* comment 1 */\n"
1890 " 2, /* comment 2 */\n"
1891 " 3, /* comment 3 */\n"
1892 " aaaa,\n"
1893 " bbbb);",
1894 format("someFunction (1, /* comment 1 */\n"
1895 " 2, /* comment 2 */ \n"
1896 " 3, /* comment 3 */\n"
1897 "aaaa, bbbb );",
1898 NoBinPacking));
1899 verifyFormat(
1900 "bool aaaaaaaaaaaaa = /* comment: */ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
1901 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
1902 EXPECT_EQ(
1903 "bool aaaaaaaaaaaaa = /* trailing comment */\n"
1904 " aaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
1905 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;",
1906 format(
1907 "bool aaaaaaaaaaaaa = /* trailing comment */\n"
1908 " aaaaaaaaaaaaaaaaaaaaaaaaaaa||aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
1909 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;"));
1910 EXPECT_EQ(
1911 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n"
1912 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n"
1913 "int cccccccccccccccccccccccccccccc; /* comment */\n",
1914 format("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n"
1915 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n"
1916 "int cccccccccccccccccccccccccccccc; /* comment */\n"));
1917
1918 verifyFormat("void f(int * /* unused */) {}");
1919
1920 EXPECT_EQ("/*\n"
1921 " **\n"
1922 " */",
1923 format("/*\n"
1924 " **\n"
1925 " */"));
1926 EXPECT_EQ("/*\n"
1927 " *q\n"
1928 " */",
1929 format("/*\n"
1930 " *q\n"
1931 " */"));
1932 EXPECT_EQ("/*\n"
1933 " * q\n"
1934 " */",
1935 format("/*\n"
1936 " * q\n"
1937 " */"));
1938 EXPECT_EQ("/*\n"
1939 " **/",
1940 format("/*\n"
1941 " **/"));
1942 EXPECT_EQ("/*\n"
1943 " ***/",
1944 format("/*\n"
1945 " ***/"));
1946}
1947
1948TEST_F(FormatTestComments, BlockCommentsInMacros) {
1949 EXPECT_EQ("#define A \\\n"
1950 " { \\\n"
1951 " /* one line */ \\\n"
1952 " someCall();",
1953 format("#define A { \\\n"
1954 " /* one line */ \\\n"
1955 " someCall();",
1956 getLLVMStyleWithColumns(20)));
1957 EXPECT_EQ("#define A \\\n"
1958 " { \\\n"
1959 " /* previous */ \\\n"
1960 " /* one line */ \\\n"
1961 " someCall();",
1962 format("#define A { \\\n"
1963 " /* previous */ \\\n"
1964 " /* one line */ \\\n"
1965 " someCall();",
1966 getLLVMStyleWithColumns(20)));
1967}
1968
1969TEST_F(FormatTestComments, BlockCommentsAtEndOfLine) {
1970 EXPECT_EQ("a = {\n"
1971 " 1111 /* */\n"
1972 "};",
1973 format("a = {1111 /* */\n"
1974 "};",
1975 getLLVMStyleWithColumns(15)));
1976 EXPECT_EQ("a = {\n"
1977 " 1111 /* */\n"
1978 "};",
1979 format("a = {1111 /* */\n"
1980 "};",
1981 getLLVMStyleWithColumns(15)));
1982 EXPECT_EQ("a = {\n"
1983 " 1111 /* a\n"
1984 " */\n"
1985 "};",
1986 format("a = {1111 /* a */\n"
1987 "};",
1988 getLLVMStyleWithColumns(15)));
1989}
1990
1991TEST_F(FormatTestComments, IndentLineCommentsInStartOfBlockAtEndOfFile) {
1992 verifyFormat("{\n"
1993 " // a\n"
1994 " // b");
1995}
1996
1997TEST_F(FormatTestComments, AlignTrailingComments) {
1998 EXPECT_EQ("#define MACRO(V) \\\n"
1999 " V(Rt2) /* one more char */ \\\n"
2000 " V(Rs) /* than here */ \\\n"
2001 "/* comment 3 */\n",
2002 format("#define MACRO(V)\\\n"
2003 "V(Rt2) /* one more char */ \\\n"
2004 "V(Rs) /* than here */ \\\n"
2005 "/* comment 3 */ \\\n",
2006 getLLVMStyleWithColumns(40)));
2007 EXPECT_EQ("int i = f(abc, // line 1\n"
2008 " d, // line 2\n"
2009 " // line 3\n"
2010 " b);",
2011 format("int i = f(abc, // line 1\n"
2012 " d, // line 2\n"
2013 " // line 3\n"
2014 " b);",
2015 getLLVMStyleWithColumns(40)));
2016
2017 // Align newly broken trailing comments.
2018 EXPECT_EQ("int ab; // line\n"
2019 "int a; // long\n"
2020 " // long\n",
2021 format("int ab; // line\n"
2022 "int a; // long long\n",
2023 getLLVMStyleWithColumns(15)));
2024 EXPECT_EQ("int ab; // line\n"
2025 "int a; // long\n"
2026 " // long\n"
2027 " // long",
2028 format("int ab; // line\n"
2029 "int a; // long long\n"
2030 " // long",
2031 getLLVMStyleWithColumns(15)));
2032 EXPECT_EQ("int ab; // line\n"
2033 "int a; // long\n"
2034 " // long\n"
2035 "pt c; // long",
2036 format("int ab; // line\n"
2037 "int a; // long long\n"
2038 "pt c; // long",
2039 getLLVMStyleWithColumns(15)));
2040 EXPECT_EQ("int ab; // line\n"
2041 "int a; // long\n"
2042 " // long\n"
2043 "\n"
2044 "// long",
2045 format("int ab; // line\n"
2046 "int a; // long long\n"
2047 "\n"
2048 "// long",
2049 getLLVMStyleWithColumns(15)));
2050
2051 // Align comment line sections aligned with the next token with the next
2052 // token.
2053 EXPECT_EQ("class A {\n"
2054 "public: // public comment\n"
2055 " // comment about a\n"
2056 " int a;\n"
2057 "};",
2058 format("class A {\n"
2059 "public: // public comment\n"
2060 " // comment about a\n"
2061 " int a;\n"
2062 "};",
2063 getLLVMStyleWithColumns(40)));
2064 EXPECT_EQ("class A {\n"
2065 "public: // public comment 1\n"
2066 " // public comment 2\n"
2067 " // comment 1 about a\n"
2068 " // comment 2 about a\n"
2069 " int a;\n"
2070 "};",
2071 format("class A {\n"
2072 "public: // public comment 1\n"
2073 " // public comment 2\n"
2074 " // comment 1 about a\n"
2075 " // comment 2 about a\n"
2076 " int a;\n"
2077 "};",
2078 getLLVMStyleWithColumns(40)));
2079 EXPECT_EQ("int f(int n) { // comment line 1 on f\n"
2080 " // comment line 2 on f\n"
2081 " // comment line 1 before return\n"
2082 " // comment line 2 before return\n"
2083 " return n; // comment line 1 on return\n"
2084 " // comment line 2 on return\n"
2085 " // comment line 1 after return\n"
2086 "}",
2087 format("int f(int n) { // comment line 1 on f\n"
2088 " // comment line 2 on f\n"
2089 " // comment line 1 before return\n"
2090 " // comment line 2 before return\n"
2091 " return n; // comment line 1 on return\n"
2092 " // comment line 2 on return\n"
2093 " // comment line 1 after return\n"
2094 "}",
2095 getLLVMStyleWithColumns(40)));
2096 EXPECT_EQ("int f(int n) {\n"
2097 " switch (n) { // comment line 1 on switch\n"
2098 " // comment line 2 on switch\n"
2099 " // comment line 1 before case 1\n"
2100 " // comment line 2 before case 1\n"
2101 " case 1: // comment line 1 on case 1\n"
2102 " // comment line 2 on case 1\n"
2103 " // comment line 1 before return 1\n"
2104 " // comment line 2 before return 1\n"
2105 " return 1; // comment line 1 on return 1\n"
2106 " // comment line 2 on return 1\n"
2107 " // comment line 1 before default\n"
2108 " // comment line 2 before default\n"
2109 " default: // comment line 1 on default\n"
2110 " // comment line 2 on default\n"
2111 " // comment line 1 before return 2\n"
2112 " return 2 * f(n - 1); // comment line 1 on return 2\n"
2113 " // comment line 2 on return 2\n"
2114 " // comment line 1 after return\n"
2115 " // comment line 2 after return\n"
2116 " }\n"
2117 "}",
2118 format("int f(int n) {\n"
2119 " switch (n) { // comment line 1 on switch\n"
2120 " // comment line 2 on switch\n"
2121 " // comment line 1 before case 1\n"
2122 " // comment line 2 before case 1\n"
2123 " case 1: // comment line 1 on case 1\n"
2124 " // comment line 2 on case 1\n"
2125 " // comment line 1 before return 1\n"
2126 " // comment line 2 before return 1\n"
2127 " return 1; // comment line 1 on return 1\n"
2128 " // comment line 2 on return 1\n"
2129 " // comment line 1 before default\n"
2130 " // comment line 2 before default\n"
2131 " default: // comment line 1 on default\n"
2132 " // comment line 2 on default\n"
2133 " // comment line 1 before return 2\n"
2134 " return 2 * f(n - 1); // comment line 1 on return 2\n"
2135 " // comment line 2 on return 2\n"
2136 " // comment line 1 after return\n"
2137 " // comment line 2 after return\n"
2138 " }\n"
2139 "}",
2140 getLLVMStyleWithColumns(80)));
2141
2142 // If all the lines in a sequence of line comments are aligned with the next
2143 // token, the first line belongs to the previous token and the other lines
2144 // belong to the next token.
2145 EXPECT_EQ("int a; // line about a\n"
2146 "long b;",
2147 format("int a; // line about a\n"
2148 " long b;",
2149 getLLVMStyleWithColumns(80)));
2150 EXPECT_EQ("int a; // line about a\n"
2151 "// line about b\n"
2152 "long b;",
2153 format("int a; // line about a\n"
2154 " // line about b\n"
2155 " long b;",
2156 getLLVMStyleWithColumns(80)));
2157 EXPECT_EQ("int a; // line about a\n"
2158 "// line 1 about b\n"
2159 "// line 2 about b\n"
2160 "long b;",
2161 format("int a; // line about a\n"
2162 " // line 1 about b\n"
2163 " // line 2 about b\n"
2164 " long b;",
2165 getLLVMStyleWithColumns(80)));
2166}
Krasimir Georgievbb99a362017-02-16 12:39:31 +0000[diff] [blame^]2167
2168TEST_F(FormatTestComments, AlignsBlockCommentDecorations) {
2169 EXPECT_EQ("/*\n"
2170 " */",
2171 format("/*\n"
2172 "*/", getLLVMStyle()));
2173 EXPECT_EQ("/*\n"
2174 " */",
2175 format("/*\n"
2176 " */", getLLVMStyle()));
2177 EXPECT_EQ("/*\n"
2178 " */",
2179 format("/*\n"
2180 " */", getLLVMStyle()));
2181
2182 // Align a single line.
2183 EXPECT_EQ("/*\n"
2184 " * line */",
2185 format("/*\n"
2186 "* line */",
2187 getLLVMStyle()));
2188 EXPECT_EQ("/*\n"
2189 " * line */",
2190 format("/*\n"
2191 " * line */",
2192 getLLVMStyle()));
2193 EXPECT_EQ("/*\n"
2194 " * line */",
2195 format("/*\n"
2196 " * line */",
2197 getLLVMStyle()));
2198 EXPECT_EQ("/*\n"
2199 " * line */",
2200 format("/*\n"
2201 " * line */",
2202 getLLVMStyle()));
2203 EXPECT_EQ("/**\n"
2204 " * line */",
2205 format("/**\n"
2206 "* line */",
2207 getLLVMStyle()));
2208 EXPECT_EQ("/**\n"
2209 " * line */",
2210 format("/**\n"
2211 " * line */",
2212 getLLVMStyle()));
2213 EXPECT_EQ("/**\n"
2214 " * line */",
2215 format("/**\n"
2216 " * line */",
2217 getLLVMStyle()));
2218 EXPECT_EQ("/**\n"
2219 " * line */",
2220 format("/**\n"
2221 " * line */",
2222 getLLVMStyle()));
2223 EXPECT_EQ("/**\n"
2224 " * line */",
2225 format("/**\n"
2226 " * line */",
2227 getLLVMStyle()));
2228
2229 // Align the end '*/' after a line.
2230 EXPECT_EQ("/*\n"
2231 " * line\n"
2232 " */",
2233 format("/*\n"
2234 "* line\n"
2235 "*/", getLLVMStyle()));
2236 EXPECT_EQ("/*\n"
2237 " * line\n"
2238 " */",
2239 format("/*\n"
2240 " * line\n"
2241 " */", getLLVMStyle()));
2242 EXPECT_EQ("/*\n"
2243 " * line\n"
2244 " */",
2245 format("/*\n"
2246 " * line\n"
2247 " */", getLLVMStyle()));
2248
2249 // Align two lines.
2250 EXPECT_EQ("/* line 1\n"
2251 " * line 2 */",
2252 format("/* line 1\n"
2253 " * line 2 */",
2254 getLLVMStyle()));
2255 EXPECT_EQ("/* line 1\n"
2256 " * line 2 */",
2257 format("/* line 1\n"
2258 "* line 2 */",
2259 getLLVMStyle()));
2260 EXPECT_EQ("/* line 1\n"
2261 " * line 2 */",
2262 format("/* line 1\n"
2263 " * line 2 */",
2264 getLLVMStyle()));
2265 EXPECT_EQ("/* line 1\n"
2266 " * line 2 */",
2267 format("/* line 1\n"
2268 " * line 2 */",
2269 getLLVMStyle()));
2270 EXPECT_EQ("/* line 1\n"
2271 " * line 2 */",
2272 format("/* line 1\n"
2273 " * line 2 */",
2274 getLLVMStyle()));
2275 EXPECT_EQ("int i; /* line 1\n"
2276 " * line 2 */",
2277 format("int i; /* line 1\n"
2278 "* line 2 */",
2279 getLLVMStyle()));
2280 EXPECT_EQ("int i; /* line 1\n"
2281 " * line 2 */",
2282 format("int i; /* line 1\n"
2283 " * line 2 */",
2284 getLLVMStyle()));
2285 EXPECT_EQ("int i; /* line 1\n"
2286 " * line 2 */",
2287 format("int i; /* line 1\n"
2288 " * line 2 */",
2289 getLLVMStyle()));
2290
2291 // Align several lines.
2292 EXPECT_EQ("/* line 1\n"
2293 " * line 2\n"
2294 " * line 3 */",
2295 format("/* line 1\n"
2296 " * line 2\n"
2297 "* line 3 */",
2298 getLLVMStyle()));
2299 EXPECT_EQ("/* line 1\n"
2300 " * line 2\n"
2301 " * line 3 */",
2302 format("/* line 1\n"
2303 " * line 2\n"
2304 "* line 3 */",
2305 getLLVMStyle()));
2306 EXPECT_EQ("/*\n"
2307 "** line 1\n"
2308 "** line 2\n"
2309 "*/",
2310 format("/*\n"
2311 "** line 1\n"
2312 " ** line 2\n"
2313 "*/",
2314 getLLVMStyle()));
2315
2316 // Align with different indent after the decorations.
2317 EXPECT_EQ("/*\n"
2318 " * line 1\n"
2319 " * line 2\n"
2320 " * line 3\n"
2321 " * line 4\n"
2322 " */",
2323 format("/*\n"
2324 "* line 1\n"
2325 " * line 2\n"
2326 " * line 3\n"
2327 "* line 4\n"
2328 "*/", getLLVMStyle()));
2329
2330 // Align empty or blank lines.
2331 EXPECT_EQ("/**\n"
2332 " *\n"
2333 " *\n"
2334 " *\n"
2335 " */",
2336 format("/**\n"
2337 "* \n"
2338 " * \n"
2339 " *\n"
2340 "*/", getLLVMStyle()));
2341
2342 // Align while breaking and reflowing.
2343 EXPECT_EQ("/*\n"
2344 " * long long long\n"
2345 " * long long\n"
2346 " *\n"
2347 " * long */",
2348 format("/*\n"
2349 " * long long long long\n"
2350 " * long\n"
2351 " *\n"
2352 "* long */",
2353 getLLVMStyleWithColumns(20)));
2354}
Krasimir Georgievfd0dda72017-02-08 12:53:18 +0000[diff] [blame]2355} // end namespace
2356} // end namespace format
2357} // end namespace clang