1 //===- NamespaceEndCommentsFixerTest.cpp - Formatting unit tests ----------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "clang/Format/Format.h"
10
11 #include "llvm/Support/Debug.h"
12 #include "gtest/gtest.h"
13
14 #define DEBUG_TYPE "namespace-end-comments-fixer-test"
15
16 namespace clang {
17 namespace format {
18 namespace {
19
20 class NamespaceEndCommentsFixerTest : public ::testing::Test {
21 protected:
22 std::string
fixNamespaceEndComments(llvm::StringRef Code,const std::vector<tooling::Range> & Ranges,const FormatStyle & Style=getLLVMStyle ())23 fixNamespaceEndComments(llvm::StringRef Code,
24 const std::vector<tooling::Range> &Ranges,
25 const FormatStyle &Style = getLLVMStyle()) {
26 LLVM_DEBUG(llvm::errs() << "---\n");
27 LLVM_DEBUG(llvm::errs() << Code << "\n\n");
28 tooling::Replacements Replaces =
29 clang::format::fixNamespaceEndComments(Style, Code, Ranges, "<stdin>");
30 auto Result = applyAllReplacements(Code, Replaces);
31 EXPECT_TRUE(static_cast<bool>(Result));
32 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
33 return *Result;
34 }
35
36 std::string
fixNamespaceEndComments(llvm::StringRef Code,const FormatStyle & Style=getLLVMStyle ())37 fixNamespaceEndComments(llvm::StringRef Code,
38 const FormatStyle &Style = getLLVMStyle()) {
39 return fixNamespaceEndComments(
40 Code,
41 /*Ranges=*/{1, tooling::Range(0, Code.size())}, Style);
42 }
43 };
44
TEST_F(NamespaceEndCommentsFixerTest,AddsEndComment)45 TEST_F(NamespaceEndCommentsFixerTest, AddsEndComment) {
46 EXPECT_EQ("namespace {\n"
47 "int i;\n"
48 "int j;\n"
49 "}// namespace",
50 fixNamespaceEndComments("namespace {\n"
51 "int i;\n"
52 "int j;\n"
53 "}"));
54
55 EXPECT_EQ("namespace {\n"
56 "int i;\n"
57 "int j;\n"
58 "}// namespace\n",
59 fixNamespaceEndComments("namespace {\n"
60 "int i;\n"
61 "int j;\n"
62 "}\n"));
63 EXPECT_EQ("namespace A {\n"
64 "int i;\n"
65 "int j;\n"
66 "}// namespace A",
67 fixNamespaceEndComments("namespace A {\n"
68 "int i;\n"
69 "int j;\n"
70 "}"));
71 EXPECT_EQ("inline namespace A {\n"
72 "int i;\n"
73 "int j;\n"
74 "}// namespace A",
75 fixNamespaceEndComments("inline namespace A {\n"
76 "int i;\n"
77 "int j;\n"
78 "}"));
79
80 EXPECT_EQ("namespace [[deprecated(\"foo\")]] A::B {\n"
81 "int i;\n"
82 "int j;\n"
83 "}// namespace A::B",
84 fixNamespaceEndComments("namespace [[deprecated(\"foo\")]] A::B {\n"
85 "int i;\n"
86 "int j;\n"
87 "}"));
88
89 EXPECT_EQ("namespace [[deprecated(\"foo\")]] A::inline B::inline C {\n"
90 "int i;\n"
91 "int j;\n"
92 "}// namespace A::inline B::inline C",
93 fixNamespaceEndComments(
94 "namespace [[deprecated(\"foo\")]] A::inline B::inline C {\n"
95 "int i;\n"
96 "int j;\n"
97 "}"));
98
99 EXPECT_EQ("namespace DEPRECATED A::B {\n"
100 "int i;\n"
101 "int j;\n"
102 "}// namespace A::B",
103 fixNamespaceEndComments("namespace DEPRECATED A::B {\n"
104 "int i;\n"
105 "int j;\n"
106 "}"));
107
108 EXPECT_EQ("inline namespace [[deprecated]] A {\n"
109 "int i;\n"
110 "int j;\n"
111 "}// namespace A",
112 fixNamespaceEndComments("inline namespace [[deprecated]] A {\n"
113 "int i;\n"
114 "int j;\n"
115 "}"));
116
117 EXPECT_EQ("namespace ::A {\n"
118 "int i;\n"
119 "int j;\n"
120 "}// namespace ::A",
121 fixNamespaceEndComments("namespace ::A {\n"
122 "int i;\n"
123 "int j;\n"
124 "}"));
125 EXPECT_EQ("namespace ::A::B {\n"
126 "int i;\n"
127 "int j;\n"
128 "}// namespace ::A::B",
129 fixNamespaceEndComments("namespace ::A::B {\n"
130 "int i;\n"
131 "int j;\n"
132 "}"));
133 EXPECT_EQ("namespace /**/::/**/A/**/::/**/B/**/ {\n"
134 "int i;\n"
135 "int j;\n"
136 "}// namespace ::A::B",
137 fixNamespaceEndComments("namespace /**/::/**/A/**/::/**/B/**/ {\n"
138 "int i;\n"
139 "int j;\n"
140 "}"));
141 EXPECT_EQ("namespace A {\n"
142 "namespace B {\n"
143 "int i;\n"
144 "}\n"
145 "}// namespace A",
146 fixNamespaceEndComments("namespace A {\n"
147 "namespace B {\n"
148 "int i;\n"
149 "}\n"
150 "}"));
151 EXPECT_EQ("namespace A {\n"
152 "namespace B {\n"
153 "int i;\n"
154 "int j;\n"
155 "}// namespace B\n"
156 "}// namespace A",
157 fixNamespaceEndComments("namespace A {\n"
158 "namespace B {\n"
159 "int i;\n"
160 "int j;\n"
161 "}\n"
162 "}"));
163 EXPECT_EQ("namespace A {\n"
164 "int a;\n"
165 "int b;\n"
166 "}// namespace A\n"
167 "namespace B {\n"
168 "int b;\n"
169 "int a;\n"
170 "}// namespace B",
171 fixNamespaceEndComments("namespace A {\n"
172 "int a;\n"
173 "int b;\n"
174 "}\n"
175 "namespace B {\n"
176 "int b;\n"
177 "int a;\n"
178 "}"));
179 EXPECT_EQ("namespace A {\n"
180 "int a1;\n"
181 "int a2;\n"
182 "}// namespace A\n"
183 "namespace A {\n"
184 "int a2;\n"
185 "int a1;\n"
186 "}// namespace A",
187 fixNamespaceEndComments("namespace A {\n"
188 "int a1;\n"
189 "int a2;\n"
190 "}\n"
191 "namespace A {\n"
192 "int a2;\n"
193 "int a1;\n"
194 "}"));
195 EXPECT_EQ("namespace A {\n"
196 "int a;\n"
197 "int b;\n"
198 "}// namespace A\n"
199 "// comment about b\n"
200 "int b;",
201 fixNamespaceEndComments("namespace A {\n"
202 "int a;\n"
203 "int b;\n"
204 "}\n"
205 "// comment about b\n"
206 "int b;"));
207
208 EXPECT_EQ("namespace A {\n"
209 "namespace B {\n"
210 "namespace C {\n"
211 "namespace D {\n"
212 "}\n"
213 "}// namespace C\n"
214 "}// namespace B\n"
215 "}// namespace A",
216 fixNamespaceEndComments("namespace A {\n"
217 "namespace B {\n"
218 "namespace C {\n"
219 "namespace D {\n"
220 "}\n"
221 "}\n"
222 "}\n"
223 "}"));
224
225 // Add comment for namespaces which will be 'compacted'
226 FormatStyle CompactNamespacesStyle = getLLVMStyle();
227 CompactNamespacesStyle.CompactNamespaces = true;
228 EXPECT_EQ("namespace out { namespace in {\n"
229 "int i;\n"
230 "int j;\n"
231 "}}// namespace out::in",
232 fixNamespaceEndComments("namespace out { namespace in {\n"
233 "int i;\n"
234 "int j;\n"
235 "}}",
236 CompactNamespacesStyle));
237 EXPECT_EQ("namespace out {\n"
238 "namespace in {\n"
239 "int i;\n"
240 "int j;\n"
241 "}\n"
242 "}// namespace out::in",
243 fixNamespaceEndComments("namespace out {\n"
244 "namespace in {\n"
245 "int i;\n"
246 "int j;\n"
247 "}\n"
248 "}",
249 CompactNamespacesStyle));
250 EXPECT_EQ("namespace out { namespace in {\n"
251 "int i;\n"
252 "int j;\n"
253 "};}// namespace out::in",
254 fixNamespaceEndComments("namespace out { namespace in {\n"
255 "int i;\n"
256 "int j;\n"
257 "};}",
258 CompactNamespacesStyle));
259
260 // Adds an end comment after a semicolon.
261 EXPECT_EQ("namespace {\n"
262 "int i;\n"
263 "int j;\n"
264 "};// namespace",
265 fixNamespaceEndComments("namespace {\n"
266 "int i;\n"
267 "int j;\n"
268 "};"));
269 EXPECT_EQ("namespace A {\n"
270 "int i;\n"
271 "int j;\n"
272 "};// namespace A",
273 fixNamespaceEndComments("namespace A {\n"
274 "int i;\n"
275 "int j;\n"
276 "};"));
277 EXPECT_EQ("namespace A {\n"
278 "int i;\n"
279 "int j;\n"
280 "};// namespace A\n"
281 "// unrelated",
282 fixNamespaceEndComments("namespace A {\n"
283 "int i;\n"
284 "int j;\n"
285 "};\n"
286 "// unrelated"));
287 }
288
TEST_F(NamespaceEndCommentsFixerTest,AddsMacroEndComment)289 TEST_F(NamespaceEndCommentsFixerTest, AddsMacroEndComment) {
290 FormatStyle Style = getLLVMStyle();
291 Style.NamespaceMacros.push_back("TESTSUITE");
292
293 EXPECT_EQ("TESTSUITE() {\n"
294 "int i;\n"
295 "int j;\n"
296 "}// TESTSUITE()",
297 fixNamespaceEndComments("TESTSUITE() {\n"
298 "int i;\n"
299 "int j;\n"
300 "}",
301 Style));
302
303 EXPECT_EQ("TESTSUITE(A) {\n"
304 "int i;\n"
305 "int j;\n"
306 "}// TESTSUITE(A)",
307 fixNamespaceEndComments("TESTSUITE(A) {\n"
308 "int i;\n"
309 "int j;\n"
310 "}",
311 Style));
312 EXPECT_EQ("inline TESTSUITE(A) {\n"
313 "int i;\n"
314 "int j;\n"
315 "}// TESTSUITE(A)",
316 fixNamespaceEndComments("inline TESTSUITE(A) {\n"
317 "int i;\n"
318 "int j;\n"
319 "}",
320 Style));
321 EXPECT_EQ("TESTSUITE(::A) {\n"
322 "int i;\n"
323 "int j;\n"
324 "}// TESTSUITE(::A)",
325 fixNamespaceEndComments("TESTSUITE(::A) {\n"
326 "int i;\n"
327 "int j;\n"
328 "}",
329 Style));
330 EXPECT_EQ("TESTSUITE(::A::B) {\n"
331 "int i;\n"
332 "int j;\n"
333 "}// TESTSUITE(::A::B)",
334 fixNamespaceEndComments("TESTSUITE(::A::B) {\n"
335 "int i;\n"
336 "int j;\n"
337 "}",
338 Style));
339 EXPECT_EQ("TESTSUITE(/**/::/**/A/**/::/**/B/**/) {\n"
340 "int i;\n"
341 "int j;\n"
342 "}// TESTSUITE(::A::B)",
343 fixNamespaceEndComments("TESTSUITE(/**/::/**/A/**/::/**/B/**/) {\n"
344 "int i;\n"
345 "int j;\n"
346 "}",
347 Style));
348 EXPECT_EQ("TESTSUITE(A, B) {\n"
349 "int i;\n"
350 "int j;\n"
351 "}// TESTSUITE(A)",
352 fixNamespaceEndComments("TESTSUITE(A, B) {\n"
353 "int i;\n"
354 "int j;\n"
355 "}",
356 Style));
357 EXPECT_EQ("TESTSUITE(\"Test1\") {\n"
358 "int i;\n"
359 "int j;\n"
360 "}// TESTSUITE(\"Test1\")",
361 fixNamespaceEndComments("TESTSUITE(\"Test1\") {\n"
362 "int i;\n"
363 "int j;\n"
364 "}",
365 Style));
366 }
367
TEST_F(NamespaceEndCommentsFixerTest,AddsNewlineIfNeeded)368 TEST_F(NamespaceEndCommentsFixerTest, AddsNewlineIfNeeded) {
369 EXPECT_EQ("namespace A {\n"
370 "int i;\n"
371 "int j;\n"
372 "}// namespace A\n"
373 " int k;",
374 fixNamespaceEndComments("namespace A {\n"
375 "int i;\n"
376 "int j;\n"
377 "} int k;"));
378 EXPECT_EQ("namespace {\n"
379 "int i;\n"
380 "int j;\n"
381 "}// namespace\n"
382 " int k;",
383 fixNamespaceEndComments("namespace {\n"
384 "int i;\n"
385 "int j;\n"
386 "} int k;"));
387 EXPECT_EQ("namespace A {\n"
388 "int i;\n"
389 "int j;\n"
390 "}// namespace A\n"
391 " namespace B {\n"
392 "int j;\n"
393 "int k;\n"
394 "}// namespace B",
395 fixNamespaceEndComments("namespace A {\n"
396 "int i;\n"
397 "int j;\n"
398 "} namespace B {\n"
399 "int j;\n"
400 "int k;\n"
401 "}"));
402 EXPECT_EQ("namespace {\n"
403 "int i;\n"
404 "int j;\n"
405 "};// namespace\n"
406 "int k;",
407 fixNamespaceEndComments("namespace {\n"
408 "int i;\n"
409 "int j;\n"
410 "};int k;"));
411 EXPECT_EQ("namespace {\n"
412 "int i;\n"
413 "int j;\n"
414 "};// namespace\n"
415 ";",
416 fixNamespaceEndComments("namespace {\n"
417 "int i;\n"
418 "int j;\n"
419 "};;"));
420 }
421
TEST_F(NamespaceEndCommentsFixerTest,DoesNotAddEndCommentForShortNamespace)422 TEST_F(NamespaceEndCommentsFixerTest, DoesNotAddEndCommentForShortNamespace) {
423 EXPECT_EQ("namespace {}", fixNamespaceEndComments("namespace {}"));
424 EXPECT_EQ("namespace A {}", fixNamespaceEndComments("namespace A {}"));
425 EXPECT_EQ("namespace A { a }", fixNamespaceEndComments("namespace A { a }"));
426 EXPECT_EQ("namespace A { a };",
427 fixNamespaceEndComments("namespace A { a };"));
428 }
429
TEST_F(NamespaceEndCommentsFixerTest,DoesNotAddCommentAfterUnaffectedRBrace)430 TEST_F(NamespaceEndCommentsFixerTest, DoesNotAddCommentAfterUnaffectedRBrace) {
431 EXPECT_EQ("namespace A {\n"
432 "int i;\n"
433 "}",
434 fixNamespaceEndComments("namespace A {\n"
435 "int i;\n"
436 "}",
437 // The range (16, 3) spans the 'int' above.
438 /*Ranges=*/{1, tooling::Range(16, 3)}));
439 EXPECT_EQ("namespace A {\n"
440 "int i;\n"
441 "};",
442 fixNamespaceEndComments("namespace A {\n"
443 "int i;\n"
444 "};",
445 // The range (16, 3) spans the 'int' above.
446 /*Ranges=*/{1, tooling::Range(16, 3)}));
447 }
448
TEST_F(NamespaceEndCommentsFixerTest,DoesNotAddCommentAfterRBraceInPPDirective)449 TEST_F(NamespaceEndCommentsFixerTest,
450 DoesNotAddCommentAfterRBraceInPPDirective) {
451 EXPECT_EQ("#define SAD \\\n"
452 "namespace A { \\\n"
453 "int i; \\\n"
454 "}",
455 fixNamespaceEndComments("#define SAD \\\n"
456 "namespace A { \\\n"
457 "int i; \\\n"
458 "}"));
459 }
460
TEST_F(NamespaceEndCommentsFixerTest,KeepsValidEndComment)461 TEST_F(NamespaceEndCommentsFixerTest, KeepsValidEndComment) {
462 EXPECT_EQ("namespace {\n"
463 "int i;\n"
464 "} // end anonymous namespace",
465 fixNamespaceEndComments("namespace {\n"
466 "int i;\n"
467 "} // end anonymous namespace"));
468 EXPECT_EQ("namespace A {\n"
469 "int i;\n"
470 "} /* end of namespace A */",
471 fixNamespaceEndComments("namespace A {\n"
472 "int i;\n"
473 "} /* end of namespace A */"));
474 EXPECT_EQ("namespace A {\n"
475 "int i;\n"
476 "} // namespace A",
477 fixNamespaceEndComments("namespace A {\n"
478 "int i;\n"
479 "} // namespace A"));
480 EXPECT_EQ("namespace A::B {\n"
481 "int i;\n"
482 "} // end namespace A::B",
483 fixNamespaceEndComments("namespace A::B {\n"
484 "int i;\n"
485 "} // end namespace A::B"));
486 EXPECT_EQ("namespace A {\n"
487 "int i;\n"
488 "}; // end namespace A",
489 fixNamespaceEndComments("namespace A {\n"
490 "int i;\n"
491 "}; // end namespace A"));
492 EXPECT_EQ("namespace {\n"
493 "int i;\n"
494 "}; /* unnamed namespace */",
495 fixNamespaceEndComments("namespace {\n"
496 "int i;\n"
497 "}; /* unnamed namespace */"));
498 }
499
TEST_F(NamespaceEndCommentsFixerTest,KeepsValidMacroEndComment)500 TEST_F(NamespaceEndCommentsFixerTest, KeepsValidMacroEndComment) {
501 FormatStyle Style = getLLVMStyle();
502 Style.NamespaceMacros.push_back("TESTSUITE");
503
504 EXPECT_EQ("TESTSUITE() {\n"
505 "int i;\n"
506 "} // end anonymous TESTSUITE()",
507 fixNamespaceEndComments("TESTSUITE() {\n"
508 "int i;\n"
509 "} // end anonymous TESTSUITE()",
510 Style));
511 EXPECT_EQ("TESTSUITE(A) {\n"
512 "int i;\n"
513 "} /* end of TESTSUITE(A) */",
514 fixNamespaceEndComments("TESTSUITE(A) {\n"
515 "int i;\n"
516 "} /* end of TESTSUITE(A) */",
517 Style));
518 EXPECT_EQ("TESTSUITE(A) {\n"
519 "int i;\n"
520 "} // TESTSUITE(A)",
521 fixNamespaceEndComments("TESTSUITE(A) {\n"
522 "int i;\n"
523 "} // TESTSUITE(A)",
524 Style));
525 EXPECT_EQ("TESTSUITE(A::B) {\n"
526 "int i;\n"
527 "} // end TESTSUITE(A::B)",
528 fixNamespaceEndComments("TESTSUITE(A::B) {\n"
529 "int i;\n"
530 "} // end TESTSUITE(A::B)",
531 Style));
532 EXPECT_EQ("TESTSUITE(A) {\n"
533 "int i;\n"
534 "}; // end TESTSUITE(A)",
535 fixNamespaceEndComments("TESTSUITE(A) {\n"
536 "int i;\n"
537 "}; // end TESTSUITE(A)",
538 Style));
539 EXPECT_EQ("TESTSUITE() {\n"
540 "int i;\n"
541 "}; /* unnamed TESTSUITE() */",
542 fixNamespaceEndComments("TESTSUITE() {\n"
543 "int i;\n"
544 "}; /* unnamed TESTSUITE() */",
545 Style));
546 }
547
TEST_F(NamespaceEndCommentsFixerTest,UpdatesInvalidEndLineComment)548 TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidEndLineComment) {
549 EXPECT_EQ("namespace {\n"
550 "int i;\n"
551 "} // namespace",
552 fixNamespaceEndComments("namespace {\n"
553 "int i;\n"
554 "} // namespace A"));
555 EXPECT_EQ("namespace A {\n"
556 "int i;\n"
557 "} // namespace A",
558 fixNamespaceEndComments("namespace A {\n"
559 "int i;\n"
560 "} // namespace"));
561 EXPECT_EQ("namespace A {\n"
562 "int i;\n"
563 "} // namespace A",
564 fixNamespaceEndComments("namespace A {\n"
565 "int i;\n"
566 "} //"));
567 EXPECT_EQ("namespace A {\n"
568 "int i;\n"
569 "}; // namespace A",
570 fixNamespaceEndComments("namespace A {\n"
571 "int i;\n"
572 "}; //"));
573
574 EXPECT_EQ("namespace A {\n"
575 "int i;\n"
576 "} // namespace A",
577 fixNamespaceEndComments("namespace A {\n"
578 "int i;\n"
579 "} // banamespace A"));
580 EXPECT_EQ("namespace A {\n"
581 "int i;\n"
582 "}; // namespace A",
583 fixNamespaceEndComments("namespace A {\n"
584 "int i;\n"
585 "}; // banamespace A"));
586 // Updates invalid line comments even for short namespaces.
587 EXPECT_EQ("namespace A {} // namespace A",
588 fixNamespaceEndComments("namespace A {} // namespace"));
589 EXPECT_EQ("namespace A {}; // namespace A",
590 fixNamespaceEndComments("namespace A {}; // namespace"));
591
592 // Update invalid comments for compacted namespaces.
593 FormatStyle CompactNamespacesStyle = getLLVMStyle();
594 CompactNamespacesStyle.CompactNamespaces = true;
595 EXPECT_EQ("namespace out { namespace in {\n"
596 "}} // namespace out::in",
597 fixNamespaceEndComments("namespace out { namespace in {\n"
598 "}} // namespace out",
599 CompactNamespacesStyle));
600 EXPECT_EQ("namespace out { namespace in {\n"
601 "}} // namespace out::in",
602 fixNamespaceEndComments("namespace out { namespace in {\n"
603 "}} // namespace in",
604 CompactNamespacesStyle));
605 EXPECT_EQ("namespace out { namespace in {\n"
606 "}\n"
607 "} // namespace out::in",
608 fixNamespaceEndComments("namespace out { namespace in {\n"
609 "}// banamespace in\n"
610 "} // namespace out",
611 CompactNamespacesStyle));
612 }
613
TEST_F(NamespaceEndCommentsFixerTest,UpdatesInvalidMacroEndLineComment)614 TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidMacroEndLineComment) {
615 FormatStyle Style = getLLVMStyle();
616 Style.NamespaceMacros.push_back("TESTSUITE");
617
618 EXPECT_EQ("TESTSUITE() {\n"
619 "int i;\n"
620 "} // TESTSUITE()",
621 fixNamespaceEndComments("TESTSUITE() {\n"
622 "int i;\n"
623 "} // TESTSUITE(A)",
624 Style));
625 EXPECT_EQ("TESTSUITE(A) {\n"
626 "int i;\n"
627 "} // TESTSUITE(A)",
628 fixNamespaceEndComments("TESTSUITE(A) {\n"
629 "int i;\n"
630 "} // TESTSUITE()",
631 Style));
632 EXPECT_EQ("TESTSUITE(A) {\n"
633 "int i;\n"
634 "} // TESTSUITE(A)",
635 fixNamespaceEndComments("TESTSUITE(A) {\n"
636 "int i;\n"
637 "} //",
638 Style));
639 EXPECT_EQ("TESTSUITE(A) {\n"
640 "int i;\n"
641 "}; // TESTSUITE(A)",
642 fixNamespaceEndComments("TESTSUITE(A) {\n"
643 "int i;\n"
644 "}; //",
645 Style));
646 EXPECT_EQ("TESTSUITE(A) {\n"
647 "int i;\n"
648 "} // TESTSUITE(A)",
649 fixNamespaceEndComments("TESTSUITE(A) {\n"
650 "int i;\n"
651 "} // TESTSUITE A",
652 Style));
653 EXPECT_EQ("TESTSUITE() {\n"
654 "int i;\n"
655 "} // TESTSUITE()",
656 fixNamespaceEndComments("TESTSUITE() {\n"
657 "int i;\n"
658 "} // TESTSUITE",
659 Style));
660 EXPECT_EQ("TESTSUITE(A) {\n"
661 "int i;\n"
662 "} // TESTSUITE(A)",
663 fixNamespaceEndComments("TESTSUITE(A) {\n"
664 "int i;\n"
665 "} // TOASTSUITE(A)",
666 Style));
667 EXPECT_EQ("TESTSUITE(A) {\n"
668 "int i;\n"
669 "}; // TESTSUITE(A)",
670 fixNamespaceEndComments("TESTSUITE(A) {\n"
671 "int i;\n"
672 "}; // TOASTSUITE(A)",
673 Style));
674 // Updates invalid line comments even for short namespaces.
675 EXPECT_EQ("TESTSUITE(A) {} // TESTSUITE(A)",
676 fixNamespaceEndComments("TESTSUITE(A) {} // TESTSUITE()", Style));
677 EXPECT_EQ("TESTSUITE(A) {}; // TESTSUITE(A)",
678 fixNamespaceEndComments("TESTSUITE(A) {}; // TESTSUITE()", Style));
679
680 // Update invalid comments for compacted namespaces.
681 FormatStyle CompactNamespacesStyle = getLLVMStyle();
682 CompactNamespacesStyle.CompactNamespaces = true;
683 CompactNamespacesStyle.NamespaceMacros.push_back("TESTSUITE");
684
685 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
686 "}} // TESTSUITE(out::in)",
687 fixNamespaceEndComments("TESTSUITE(out) { TESTSUITE(in) {\n"
688 "}} // TESTSUITE(out)",
689 CompactNamespacesStyle));
690 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
691 "}} // TESTSUITE(out::in)",
692 fixNamespaceEndComments("TESTSUITE(out) { TESTSUITE(in) {\n"
693 "}} // TESTSUITE(in)",
694 CompactNamespacesStyle));
695 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
696 "}\n"
697 "} // TESTSUITE(out::in)",
698 fixNamespaceEndComments("TESTSUITE(out) { TESTSUITE(in) {\n"
699 "}// TAOSTSUITE(in)\n"
700 "} // TESTSUITE(out)",
701 CompactNamespacesStyle));
702 }
703
TEST_F(NamespaceEndCommentsFixerTest,UpdatesInvalidEndBlockComment)704 TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidEndBlockComment) {
705 EXPECT_EQ("namespace {\n"
706 "int i;\n"
707 "} // namespace",
708 fixNamespaceEndComments("namespace {\n"
709 "int i;\n"
710 "} /* namespace A */"));
711 EXPECT_EQ("namespace A {\n"
712 "int i;\n"
713 "} // namespace A",
714 fixNamespaceEndComments("namespace A {\n"
715 "int i;\n"
716 "} /* end namespace */"));
717 EXPECT_EQ("namespace A {\n"
718 "int i;\n"
719 "} // namespace A",
720 fixNamespaceEndComments("namespace A {\n"
721 "int i;\n"
722 "} /**/"));
723 EXPECT_EQ("namespace A {\n"
724 "int i;\n"
725 "} // namespace A",
726 fixNamespaceEndComments("namespace A {\n"
727 "int i;\n"
728 "} /* end unnamed namespace */"));
729 EXPECT_EQ("namespace A {\n"
730 "int i;\n"
731 "} // namespace A",
732 fixNamespaceEndComments("namespace A {\n"
733 "int i;\n"
734 "} /* banamespace A */"));
735 EXPECT_EQ("namespace A {\n"
736 "int i;\n"
737 "}; // namespace A",
738 fixNamespaceEndComments("namespace A {\n"
739 "int i;\n"
740 "}; /* banamespace A */"));
741 EXPECT_EQ("namespace A {} // namespace A",
742 fixNamespaceEndComments("namespace A {} /**/"));
743 EXPECT_EQ("namespace A {}; // namespace A",
744 fixNamespaceEndComments("namespace A {}; /**/"));
745 }
746
TEST_F(NamespaceEndCommentsFixerTest,UpdatesInvalidMacroEndBlockComment)747 TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidMacroEndBlockComment) {
748 FormatStyle Style = getLLVMStyle();
749 Style.NamespaceMacros.push_back("TESTSUITE");
750
751 EXPECT_EQ("TESTSUITE() {\n"
752 "int i;\n"
753 "} // TESTSUITE()",
754 fixNamespaceEndComments("TESTSUITE() {\n"
755 "int i;\n"
756 "} /* TESTSUITE(A) */",
757 Style));
758 EXPECT_EQ("TESTSUITE(A) {\n"
759 "int i;\n"
760 "} // TESTSUITE(A)",
761 fixNamespaceEndComments("TESTSUITE(A) {\n"
762 "int i;\n"
763 "} /* end TESTSUITE() */",
764 Style));
765 EXPECT_EQ("TESTSUITE(A) {\n"
766 "int i;\n"
767 "} // TESTSUITE(A)",
768 fixNamespaceEndComments("TESTSUITE(A) {\n"
769 "int i;\n"
770 "} /**/",
771 Style));
772 EXPECT_EQ("TESTSUITE(A) {\n"
773 "int i;\n"
774 "} // TESTSUITE(A)",
775 fixNamespaceEndComments("TESTSUITE(A) {\n"
776 "int i;\n"
777 "} /* end unnamed TESTSUITE() */",
778 Style));
779 EXPECT_EQ("TESTSUITE(A) {\n"
780 "int i;\n"
781 "} // TESTSUITE(A)",
782 fixNamespaceEndComments("TESTSUITE(A) {\n"
783 "int i;\n"
784 "} /* TOASTSUITE(A) */",
785 Style));
786 EXPECT_EQ("TESTSUITE(A) {\n"
787 "int i;\n"
788 "}; // TESTSUITE(A)",
789 fixNamespaceEndComments("TESTSUITE(A) {\n"
790 "int i;\n"
791 "}; /* TAOSTSUITE(A) */",
792 Style));
793 EXPECT_EQ("TESTSUITE(A) {} // TESTSUITE(A)",
794 fixNamespaceEndComments("TESTSUITE(A) {} /**/", Style));
795 EXPECT_EQ("TESTSUITE(A) {}; // TESTSUITE(A)",
796 fixNamespaceEndComments("TESTSUITE(A) {}; /**/", Style));
797 }
798
TEST_F(NamespaceEndCommentsFixerTest,DoesNotAddEndCommentForNamespacesControlledByMacros)799 TEST_F(NamespaceEndCommentsFixerTest,
800 DoesNotAddEndCommentForNamespacesControlledByMacros) {
801 EXPECT_EQ("#ifdef 1\n"
802 "namespace A {\n"
803 "#elseif\n"
804 "namespace B {\n"
805 "#endif\n"
806 "int i;\n"
807 "}\n"
808 "}\n",
809 fixNamespaceEndComments("#ifdef 1\n"
810 "namespace A {\n"
811 "#elseif\n"
812 "namespace B {\n"
813 "#endif\n"
814 "int i;\n"
815 "}\n"
816 "}\n"));
817 }
818
TEST_F(NamespaceEndCommentsFixerTest,AddsEndCommentForNamespacesAroundMacros)819 TEST_F(NamespaceEndCommentsFixerTest, AddsEndCommentForNamespacesAroundMacros) {
820 // Conditional blocks around are fine
821 EXPECT_EQ("namespace A {\n"
822 "#if 1\n"
823 "int i;\n"
824 "#endif\n"
825 "}// namespace A",
826 fixNamespaceEndComments("namespace A {\n"
827 "#if 1\n"
828 "int i;\n"
829 "#endif\n"
830 "}"));
831 EXPECT_EQ("#if 1\n"
832 "#endif\n"
833 "namespace A {\n"
834 "int i;\n"
835 "int j;\n"
836 "}// namespace A",
837 fixNamespaceEndComments("#if 1\n"
838 "#endif\n"
839 "namespace A {\n"
840 "int i;\n"
841 "int j;\n"
842 "}"));
843 EXPECT_EQ("namespace A {\n"
844 "int i;\n"
845 "int j;\n"
846 "}// namespace A\n"
847 "#if 1\n"
848 "#endif",
849 fixNamespaceEndComments("namespace A {\n"
850 "int i;\n"
851 "int j;\n"
852 "}\n"
853 "#if 1\n"
854 "#endif"));
855 EXPECT_EQ("#if 1\n"
856 "namespace A {\n"
857 "int i;\n"
858 "int j;\n"
859 "}// namespace A\n"
860 "#endif",
861 fixNamespaceEndComments("#if 1\n"
862 "namespace A {\n"
863 "int i;\n"
864 "int j;\n"
865 "}\n"
866 "#endif"));
867
868 // Macro definition has no impact
869 EXPECT_EQ("namespace A {\n"
870 "#define FOO\n"
871 "int i;\n"
872 "}// namespace A",
873 fixNamespaceEndComments("namespace A {\n"
874 "#define FOO\n"
875 "int i;\n"
876 "}"));
877 EXPECT_EQ("#define FOO\n"
878 "namespace A {\n"
879 "int i;\n"
880 "int j;\n"
881 "}// namespace A",
882 fixNamespaceEndComments("#define FOO\n"
883 "namespace A {\n"
884 "int i;\n"
885 "int j;\n"
886 "}"));
887 EXPECT_EQ("namespace A {\n"
888 "int i;\n"
889 "int j;\n"
890 "}// namespace A\n"
891 "#define FOO\n",
892 fixNamespaceEndComments("namespace A {\n"
893 "int i;\n"
894 "int j;\n"
895 "}\n"
896 "#define FOO\n"));
897
898 // No replacement if open & close in different conditional blocks
899 EXPECT_EQ("#if 1\n"
900 "namespace A {\n"
901 "#endif\n"
902 "int i;\n"
903 "int j;\n"
904 "#if 1\n"
905 "}\n"
906 "#endif",
907 fixNamespaceEndComments("#if 1\n"
908 "namespace A {\n"
909 "#endif\n"
910 "int i;\n"
911 "int j;\n"
912 "#if 1\n"
913 "}\n"
914 "#endif"));
915 EXPECT_EQ("#ifdef A\n"
916 "namespace A {\n"
917 "#endif\n"
918 "int i;\n"
919 "int j;\n"
920 "#ifdef B\n"
921 "}\n"
922 "#endif",
923 fixNamespaceEndComments("#ifdef A\n"
924 "namespace A {\n"
925 "#endif\n"
926 "int i;\n"
927 "int j;\n"
928 "#ifdef B\n"
929 "}\n"
930 "#endif"));
931
932 // No replacement inside unreachable conditional block
933 EXPECT_EQ("#if 0\n"
934 "namespace A {\n"
935 "int i;\n"
936 "int j;\n"
937 "}\n"
938 "#endif",
939 fixNamespaceEndComments("#if 0\n"
940 "namespace A {\n"
941 "int i;\n"
942 "int j;\n"
943 "}\n"
944 "#endif"));
945 }
946
TEST_F(NamespaceEndCommentsFixerTest,DoesNotAddEndCommentForNamespacesInMacroDeclarations)947 TEST_F(NamespaceEndCommentsFixerTest,
948 DoesNotAddEndCommentForNamespacesInMacroDeclarations) {
949 EXPECT_EQ("#ifdef 1\n"
950 "namespace A {\n"
951 "#elseif\n"
952 "namespace B {\n"
953 "#endif\n"
954 "int i;\n"
955 "}\n"
956 "}\n",
957 fixNamespaceEndComments("#ifdef 1\n"
958 "namespace A {\n"
959 "#elseif\n"
960 "namespace B {\n"
961 "#endif\n"
962 "int i;\n"
963 "}\n"
964 "}\n"));
965 EXPECT_EQ("namespace {\n"
966 "int i;\n"
967 "int j;\n"
968 "}// namespace\n"
969 "#if A\n"
970 "int i;\n"
971 "#else\n"
972 "int j;\n"
973 "#endif",
974 fixNamespaceEndComments("namespace {\n"
975 "int i;\n"
976 "int j;\n"
977 "}\n"
978 "#if A\n"
979 "int i;\n"
980 "#else\n"
981 "int j;\n"
982 "#endif"));
983 EXPECT_EQ("#if A\n"
984 "namespace A {\n"
985 "#else\n"
986 "namespace B {\n"
987 "#endif\n"
988 "int i;\n"
989 "int j;\n"
990 "}",
991 fixNamespaceEndComments("#if A\n"
992 "namespace A {\n"
993 "#else\n"
994 "namespace B {\n"
995 "#endif\n"
996 "int i;\n"
997 "int j;\n"
998 "}"));
999 EXPECT_EQ("#if A\n"
1000 "namespace A {\n"
1001 "#else\n"
1002 "namespace B {\n"
1003 "#endif\n"
1004 "int i;\n"
1005 "int j;\n"
1006 "} // namespace A",
1007 fixNamespaceEndComments("#if A\n"
1008 "namespace A {\n"
1009 "#else\n"
1010 "namespace B {\n"
1011 "#endif\n"
1012 "int i;\n"
1013 "int j;\n"
1014 "} // namespace A"));
1015 EXPECT_EQ("#if A\n"
1016 "namespace A {\n"
1017 "#else\n"
1018 "namespace B {\n"
1019 "#endif\n"
1020 "int i;\n"
1021 "int j;\n"
1022 "} // namespace B",
1023 fixNamespaceEndComments("#if A\n"
1024 "namespace A {\n"
1025 "#else\n"
1026 "namespace B {\n"
1027 "#endif\n"
1028 "int i;\n"
1029 "int j;\n"
1030 "} // namespace B"));
1031 EXPECT_EQ("namespace A\n"
1032 "int i;\n"
1033 "int j;\n"
1034 "#if A\n"
1035 "}\n"
1036 "#else\n"
1037 "}\n"
1038 "#endif",
1039 fixNamespaceEndComments("namespace A\n"
1040 "int i;\n"
1041 "int j;\n"
1042 "#if A\n"
1043 "}\n"
1044 "#else\n"
1045 "}\n"
1046 "#endif"));
1047 EXPECT_EQ("namespace A\n"
1048 "int i;\n"
1049 "int j;\n"
1050 "#if A\n"
1051 "} // namespace A\n"
1052 "#else\n"
1053 "} // namespace A\n"
1054 "#endif",
1055 fixNamespaceEndComments("namespace A\n"
1056 "int i;\n"
1057 "int j;\n"
1058 "#if A\n"
1059 "} // namespace A\n"
1060 "#else\n"
1061 "} // namespace A\n"
1062 "#endif"));
1063 }
1064
TEST_F(NamespaceEndCommentsFixerTest,DoesNotAddEndCommentForUnbalancedRBracesAfterNamespaceEnd)1065 TEST_F(NamespaceEndCommentsFixerTest,
1066 DoesNotAddEndCommentForUnbalancedRBracesAfterNamespaceEnd) {
1067 EXPECT_EQ("namespace {\n"
1068 "int i;\n"
1069 "} // namespace\n"
1070 "}",
1071 fixNamespaceEndComments("namespace {\n"
1072 "int i;\n"
1073 "} // namespace\n"
1074 "}"));
1075 }
1076
TEST_F(NamespaceEndCommentsFixerTest,HandlesInlineAtEndOfLine_PR32438)1077 TEST_F(NamespaceEndCommentsFixerTest, HandlesInlineAtEndOfLine_PR32438) {
1078 EXPECT_EQ("template <int> struct a {};\n"
1079 "struct a<bool{}> b() {\n"
1080 "}\n"
1081 "#define c inline\n"
1082 "void d() {\n"
1083 "}\n",
1084 fixNamespaceEndComments("template <int> struct a {};\n"
1085 "struct a<bool{}> b() {\n"
1086 "}\n"
1087 "#define c inline\n"
1088 "void d() {\n"
1089 "}\n"));
1090 }
1091
TEST_F(NamespaceEndCommentsFixerTest,IgnoreUnbalanced)1092 TEST_F(NamespaceEndCommentsFixerTest, IgnoreUnbalanced) {
1093 EXPECT_EQ("namespace A {\n"
1094 "class Foo {\n"
1095 "}\n"
1096 "}// namespace A\n",
1097 fixNamespaceEndComments("namespace A {\n"
1098 "class Foo {\n"
1099 "}\n"
1100 "}\n"));
1101 EXPECT_EQ("namespace A {\n"
1102 "class Foo {\n"
1103 "}\n",
1104 fixNamespaceEndComments("namespace A {\n"
1105 "class Foo {\n"
1106 "}\n"));
1107
1108 EXPECT_EQ("namespace A {\n"
1109 "class Foo {\n"
1110 "}\n"
1111 "}\n"
1112 "}\n",
1113 fixNamespaceEndComments("namespace A {\n"
1114 "class Foo {\n"
1115 "}\n"
1116 "}\n"
1117 "}\n"));
1118 }
1119
1120 using ShortNamespaceLinesTest = NamespaceEndCommentsFixerTest;
1121
TEST_F(ShortNamespaceLinesTest,ZeroUnwrappedLines)1122 TEST_F(ShortNamespaceLinesTest, ZeroUnwrappedLines) {
1123 auto Style = getLLVMStyle();
1124 Style.ShortNamespaceLines = 0u;
1125
1126 EXPECT_EQ("namespace OneLinerNamespace {}\n",
1127 fixNamespaceEndComments("namespace OneLinerNamespace {}\n", Style));
1128 EXPECT_EQ("namespace ShortNamespace {\n"
1129 "}\n",
1130 fixNamespaceEndComments("namespace ShortNamespace {\n"
1131 "}\n",
1132 Style));
1133 EXPECT_EQ("namespace LongNamespace {\n"
1134 "int i;\n"
1135 "}// namespace LongNamespace\n",
1136 fixNamespaceEndComments("namespace LongNamespace {\n"
1137 "int i;\n"
1138 "}\n",
1139 Style));
1140 }
1141
TEST_F(ShortNamespaceLinesTest,OneUnwrappedLine)1142 TEST_F(ShortNamespaceLinesTest, OneUnwrappedLine) {
1143 constexpr auto DefaultUnwrappedLines = 1u;
1144 auto const Style = getLLVMStyle();
1145
1146 EXPECT_EQ(DefaultUnwrappedLines, Style.ShortNamespaceLines);
1147 EXPECT_EQ("namespace ShortNamespace {\n"
1148 "int i;\n"
1149 "}\n",
1150 fixNamespaceEndComments("namespace ShortNamespace {\n"
1151 "int i;\n"
1152 "}\n"));
1153 EXPECT_EQ("namespace LongNamespace {\n"
1154 "int i;\n"
1155 "int j;\n"
1156 "}// namespace LongNamespace\n",
1157 fixNamespaceEndComments("namespace LongNamespace {\n"
1158 "int i;\n"
1159 "int j;\n"
1160 "}\n"));
1161 }
1162
TEST_F(ShortNamespaceLinesTest,MultipleUnwrappedLine)1163 TEST_F(ShortNamespaceLinesTest, MultipleUnwrappedLine) {
1164 auto Style = getLLVMStyle();
1165 Style.ShortNamespaceLines = 2u;
1166
1167 EXPECT_EQ("namespace ShortNamespace {\n"
1168 "int i;\n"
1169 "int j;\n"
1170 "}\n",
1171 fixNamespaceEndComments("namespace ShortNamespace {\n"
1172 "int i;\n"
1173 "int j;\n"
1174 "}\n",
1175 Style));
1176 EXPECT_EQ("namespace LongNamespace {\n"
1177 "int i;\n"
1178 "int j;\n"
1179 "int k;\n"
1180 "}// namespace LongNamespace\n",
1181 fixNamespaceEndComments("namespace LongNamespace {\n"
1182 "int i;\n"
1183 "int j;\n"
1184 "int k;\n"
1185 "}\n",
1186 Style));
1187 }
1188 } // end namespace
1189 } // end namespace format
1190 } // end namespace clang
1191