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("#define M(x) x##x\n"
72 "namespace M(x) {\n"
73 "int i;\n"
74 "int j;\n"
75 "}// namespace M(x)",
76 fixNamespaceEndComments("#define M(x) x##x\n"
77 "namespace M(x) {\n"
78 "int i;\n"
79 "int j;\n"
80 "}"));
81 EXPECT_EQ("#define M(x) x##x\n"
82 "namespace A::M(x) {\n"
83 "int i;\n"
84 "int j;\n"
85 "}// namespace A::M(x)",
86 fixNamespaceEndComments("#define M(x) x##x\n"
87 "namespace A::M(x) {\n"
88 "int i;\n"
89 "int j;\n"
90 "}"));
91 EXPECT_EQ("#define M(x) x##x\n"
92 "namespace M(x)::A {\n"
93 "int i;\n"
94 "int j;\n"
95 "}// namespace M(x)::A",
96 fixNamespaceEndComments("#define M(x) x##x\n"
97 "namespace M(x)::A {\n"
98 "int i;\n"
99 "int j;\n"
100 "}"));
101 EXPECT_EQ("#define M(x) x##x\n"
102 "namespace A::inline M(x)::B {\n"
103 "int i;\n"
104 "int j;\n"
105 "}// namespace A::inline M(x)::B",
106 fixNamespaceEndComments("#define M(x) x##x\n"
107 "namespace A::inline M(x)::B {\n"
108 "int i;\n"
109 "int j;\n"
110 "}"));
111 EXPECT_EQ("#define M(x) x##x\n"
112 "namespace [[deprecated(\"foo\")]] A::inline M(x)::A {\n"
113 "int i;\n"
114 "int j;\n"
115 "}// namespace A::inline M(x)::A",
116 fixNamespaceEndComments(
117 "#define M(x) x##x\n"
118 "namespace [[deprecated(\"foo\")]] A::inline M(x)::A {\n"
119 "int i;\n"
120 "int j;\n"
121 "}"));
122 EXPECT_EQ(
123 "namespace /* comment */ [[deprecated(\"foo\")]] /* comment */ A {\n"
124 "int i;\n"
125 "int j;\n"
126 "}// namespace A",
127 fixNamespaceEndComments(
128 "namespace /* comment */ [[deprecated(\"foo\")]] /* comment */ A {\n"
129 "int i;\n"
130 "int j;\n"
131 "}"));
132 EXPECT_EQ("namespace /* comment */ [[deprecated(\"foo\")]] A {\n"
133 "int i;\n"
134 "int j;\n"
135 "}// namespace A",
136 fixNamespaceEndComments(
137 "namespace /* comment */ [[deprecated(\"foo\")]] A {\n"
138 "int i;\n"
139 "int j;\n"
140 "}"));
141 EXPECT_EQ(
142 "#define M(x) x##x\n"
143 "namespace /* comment */ [[deprecated(\"foo\")]] /* comment */ M(x) {\n"
144 "int i;\n"
145 "int j;\n"
146 "}// namespace M(x)",
147 fixNamespaceEndComments("#define M(x) x##x\n"
148 "namespace /* comment */ "
149 "[[deprecated(\"foo\")]] /* comment */ M(x) {\n"
150 "int i;\n"
151 "int j;\n"
152 "}"));
153 EXPECT_EQ("#define M(x) x##x\n"
154 "namespace /* comment */ [[deprecated(\"foo\")]] /* comment */ "
155 "A::M(x) {\n"
156 "int i;\n"
157 "int j;\n"
158 "}// namespace A::M(x)",
159 fixNamespaceEndComments(
160 "#define M(x) x##x\n"
161 "namespace /* comment */ "
162 "[[deprecated(\"foo\")]] /* comment */ A::M(x) {\n"
163 "int i;\n"
164 "int j;\n"
165 "}"));
166 EXPECT_EQ("#define M(x) x##x\n"
167 "namespace /* comment */ [[deprecated(\"foo\")]] /* comment */ "
168 "M(x) /* comment */ {\n"
169 "int i;\n"
170 "int j;\n"
171 "}// namespace M(x)",
172 fixNamespaceEndComments(
173 "#define M(x) x##x\n"
174 "namespace /* comment */ [[deprecated(\"foo\")]] /* comment "
175 "*/ M(x) /* comment */ {\n"
176 "int i;\n"
177 "int j;\n"
178 "}"));
179 EXPECT_EQ("#define M(x) x##x\n"
180 "namespace /* comment */ [[deprecated(\"foo\")]] /* comment */ "
181 "A::M(x) /* comment */ {\n"
182 "int i;\n"
183 "int j;\n"
184 "}// namespace A::M(x)",
185 fixNamespaceEndComments(
186 "#define M(x) x##x\n"
187 "namespace /* comment */ [[deprecated(\"foo\")]] /* comment "
188 "*/ A::M(x) /* comment */ {\n"
189 "int i;\n"
190 "int j;\n"
191 "}"));
192 EXPECT_EQ("#define M(x) x##x\n"
193 "namespace A M(x) {\n"
194 "int i;\n"
195 "int j;\n"
196 "}// namespace A M(x)",
197 fixNamespaceEndComments("#define M(x) x##x\n"
198 "namespace A M(x) {\n"
199 "int i;\n"
200 "int j;\n"
201 "}"));
202 EXPECT_EQ(
203 "#define B __attribute__((availability(macos, introduced=10.15)))\n"
204 "namespace A B {\n"
205 "int i;\n"
206 "int j;\n"
207 "}// namespace A B",
208 fixNamespaceEndComments(
209 "#define B __attribute__((availability(macos, introduced=10.15)))\n"
210 "namespace A B {\n"
211 "int i;\n"
212 "int j;\n"
213 "}"));
214 EXPECT_EQ("#define M(x) x##x\n"
215 "namespace A::B M(x) {\n"
216 "int i;\n"
217 "int j;\n"
218 "}// namespace A::B",
219 fixNamespaceEndComments("#define M(x) x##x\n"
220 "namespace A::B M(x) {\n"
221 "int i;\n"
222 "int j;\n"
223 "}"));
224 EXPECT_EQ(
225 "namespace A __attribute__((availability(macos, introduced=10.15))) {\n"
226 "int i;\n"
227 "int j;\n"
228 "}// namespace A",
229 fixNamespaceEndComments(
230 "namespace A __attribute__((availability(macos, introduced=10.15))) "
231 "{\n"
232 "int i;\n"
233 "int j;\n"
234 "}"));
235 EXPECT_EQ("inline namespace A {\n"
236 "int i;\n"
237 "int j;\n"
238 "}// namespace A",
239 fixNamespaceEndComments("inline namespace A {\n"
240 "int i;\n"
241 "int j;\n"
242 "}"));
243
244 EXPECT_EQ("namespace [[deprecated(\"foo\")]] A::B {\n"
245 "int i;\n"
246 "int j;\n"
247 "}// namespace A::B",
248 fixNamespaceEndComments("namespace [[deprecated(\"foo\")]] A::B {\n"
249 "int i;\n"
250 "int j;\n"
251 "}"));
252
253 EXPECT_EQ("namespace [[deprecated(\"foo\")]] A::inline B::inline C {\n"
254 "int i;\n"
255 "int j;\n"
256 "}// namespace A::inline B::inline C",
257 fixNamespaceEndComments(
258 "namespace [[deprecated(\"foo\")]] A::inline B::inline C {\n"
259 "int i;\n"
260 "int j;\n"
261 "}"));
262
263 EXPECT_EQ("namespace DEPRECATED A::B {\n"
264 "int i;\n"
265 "int j;\n"
266 "}// namespace A::B",
267 fixNamespaceEndComments("namespace DEPRECATED A::B {\n"
268 "int i;\n"
269 "int j;\n"
270 "}"));
271
272 EXPECT_EQ("inline namespace [[deprecated]] A {\n"
273 "int i;\n"
274 "int j;\n"
275 "}// namespace A",
276 fixNamespaceEndComments("inline namespace [[deprecated]] A {\n"
277 "int i;\n"
278 "int j;\n"
279 "}"));
280
281 EXPECT_EQ("namespace ::A {\n"
282 "int i;\n"
283 "int j;\n"
284 "}// namespace ::A",
285 fixNamespaceEndComments("namespace ::A {\n"
286 "int i;\n"
287 "int j;\n"
288 "}"));
289 EXPECT_EQ("namespace ::A::B {\n"
290 "int i;\n"
291 "int j;\n"
292 "}// namespace ::A::B",
293 fixNamespaceEndComments("namespace ::A::B {\n"
294 "int i;\n"
295 "int j;\n"
296 "}"));
297 EXPECT_EQ("namespace /**/::/**/A/**/::/**/B/**/ {\n"
298 "int i;\n"
299 "int j;\n"
300 "}// namespace ::A::B",
301 fixNamespaceEndComments("namespace /**/::/**/A/**/::/**/B/**/ {\n"
302 "int i;\n"
303 "int j;\n"
304 "}"));
305 EXPECT_EQ("namespace A {\n"
306 "namespace B {\n"
307 "int i;\n"
308 "}\n"
309 "}// namespace A",
310 fixNamespaceEndComments("namespace A {\n"
311 "namespace B {\n"
312 "int i;\n"
313 "}\n"
314 "}"));
315 EXPECT_EQ("namespace A {\n"
316 "namespace B {\n"
317 "int i;\n"
318 "int j;\n"
319 "}// namespace B\n"
320 "}// namespace A",
321 fixNamespaceEndComments("namespace A {\n"
322 "namespace B {\n"
323 "int i;\n"
324 "int j;\n"
325 "}\n"
326 "}"));
327 EXPECT_EQ("namespace A {\n"
328 "int a;\n"
329 "int b;\n"
330 "}// namespace A\n"
331 "namespace B {\n"
332 "int b;\n"
333 "int a;\n"
334 "}// namespace B",
335 fixNamespaceEndComments("namespace A {\n"
336 "int a;\n"
337 "int b;\n"
338 "}\n"
339 "namespace B {\n"
340 "int b;\n"
341 "int a;\n"
342 "}"));
343 EXPECT_EQ("namespace A {\n"
344 "int a1;\n"
345 "int a2;\n"
346 "}// namespace A\n"
347 "namespace A {\n"
348 "int a2;\n"
349 "int a1;\n"
350 "}// namespace A",
351 fixNamespaceEndComments("namespace A {\n"
352 "int a1;\n"
353 "int a2;\n"
354 "}\n"
355 "namespace A {\n"
356 "int a2;\n"
357 "int a1;\n"
358 "}"));
359 EXPECT_EQ("namespace A {\n"
360 "int a;\n"
361 "int b;\n"
362 "}// namespace A\n"
363 "// comment about b\n"
364 "int b;",
365 fixNamespaceEndComments("namespace A {\n"
366 "int a;\n"
367 "int b;\n"
368 "}\n"
369 "// comment about b\n"
370 "int b;"));
371
372 EXPECT_EQ("namespace A {\n"
373 "namespace B {\n"
374 "namespace C {\n"
375 "namespace D {\n"
376 "}\n"
377 "}// namespace C\n"
378 "}// namespace B\n"
379 "}// namespace A",
380 fixNamespaceEndComments("namespace A {\n"
381 "namespace B {\n"
382 "namespace C {\n"
383 "namespace D {\n"
384 "}\n"
385 "}\n"
386 "}\n"
387 "}"));
388
389 // Add comment for namespaces which will be 'compacted'
390 FormatStyle CompactNamespacesStyle = getLLVMStyle();
391 CompactNamespacesStyle.CompactNamespaces = true;
392 EXPECT_EQ("namespace out { namespace in {\n"
393 "int i;\n"
394 "int j;\n"
395 "}}// namespace out::in",
396 fixNamespaceEndComments("namespace out { namespace in {\n"
397 "int i;\n"
398 "int j;\n"
399 "}}",
400 CompactNamespacesStyle));
401 EXPECT_EQ("namespace out {\n"
402 "namespace in {\n"
403 "int i;\n"
404 "int j;\n"
405 "}\n"
406 "}// namespace out::in",
407 fixNamespaceEndComments("namespace out {\n"
408 "namespace in {\n"
409 "int i;\n"
410 "int j;\n"
411 "}\n"
412 "}",
413 CompactNamespacesStyle));
414 EXPECT_EQ("namespace out { namespace in {\n"
415 "int i;\n"
416 "int j;\n"
417 "};}// namespace out::in",
418 fixNamespaceEndComments("namespace out { namespace in {\n"
419 "int i;\n"
420 "int j;\n"
421 "};}",
422 CompactNamespacesStyle));
423 EXPECT_EQ("namespace out { namespace {\n"
424 "int i;\n"
425 "int j;\n"
426 "}}// namespace out",
427 fixNamespaceEndComments("namespace out { namespace {\n"
428 "int i;\n"
429 "int j;\n"
430 "}}",
431 CompactNamespacesStyle));
432
433 // Adds an end comment after a semicolon.
434 EXPECT_EQ("namespace {\n"
435 "int i;\n"
436 "int j;\n"
437 "};// namespace",
438 fixNamespaceEndComments("namespace {\n"
439 "int i;\n"
440 "int j;\n"
441 "};"));
442 EXPECT_EQ("namespace A {\n"
443 "int i;\n"
444 "int j;\n"
445 "};// namespace A",
446 fixNamespaceEndComments("namespace A {\n"
447 "int i;\n"
448 "int j;\n"
449 "};"));
450 EXPECT_EQ("namespace A {\n"
451 "int i;\n"
452 "int j;\n"
453 "};// namespace A\n"
454 "// unrelated",
455 fixNamespaceEndComments("namespace A {\n"
456 "int i;\n"
457 "int j;\n"
458 "};\n"
459 "// unrelated"));
460 }
461
TEST_F(NamespaceEndCommentsFixerTest,WorksForObjCpp)462 TEST_F(NamespaceEndCommentsFixerTest, WorksForObjCpp) {
463 FormatStyle ObjCppStyle = getLLVMStyle();
464 ObjCppStyle.Language = FormatStyle::LK_ObjC;
465 EXPECT_EQ("namespace {\n"
466 "int i;\n"
467 "int j;\n"
468 "}// namespace",
469 fixNamespaceEndComments("namespace {\n"
470 "int i;\n"
471 "int j;\n"
472 "}",
473 ObjCppStyle));
474 }
475
TEST_F(NamespaceEndCommentsFixerTest,AddsMacroEndComment)476 TEST_F(NamespaceEndCommentsFixerTest, AddsMacroEndComment) {
477 FormatStyle Style = getLLVMStyle();
478 Style.NamespaceMacros.push_back("TESTSUITE");
479
480 EXPECT_EQ("TESTSUITE() {\n"
481 "int i;\n"
482 "int j;\n"
483 "}// TESTSUITE()",
484 fixNamespaceEndComments("TESTSUITE() {\n"
485 "int i;\n"
486 "int j;\n"
487 "}",
488 Style));
489
490 EXPECT_EQ("TESTSUITE(A) {\n"
491 "int i;\n"
492 "int j;\n"
493 "}// TESTSUITE(A)",
494 fixNamespaceEndComments("TESTSUITE(A) {\n"
495 "int i;\n"
496 "int j;\n"
497 "}",
498 Style));
499 EXPECT_EQ("inline TESTSUITE(A) {\n"
500 "int i;\n"
501 "int j;\n"
502 "}// TESTSUITE(A)",
503 fixNamespaceEndComments("inline TESTSUITE(A) {\n"
504 "int i;\n"
505 "int j;\n"
506 "}",
507 Style));
508 EXPECT_EQ("TESTSUITE(::A) {\n"
509 "int i;\n"
510 "int j;\n"
511 "}// TESTSUITE(::A)",
512 fixNamespaceEndComments("TESTSUITE(::A) {\n"
513 "int i;\n"
514 "int j;\n"
515 "}",
516 Style));
517 EXPECT_EQ("TESTSUITE(::A::B) {\n"
518 "int i;\n"
519 "int j;\n"
520 "}// TESTSUITE(::A::B)",
521 fixNamespaceEndComments("TESTSUITE(::A::B) {\n"
522 "int i;\n"
523 "int j;\n"
524 "}",
525 Style));
526 EXPECT_EQ("TESTSUITE(/**/::/**/A/**/::/**/B/**/) {\n"
527 "int i;\n"
528 "int j;\n"
529 "}// TESTSUITE(::A::B)",
530 fixNamespaceEndComments("TESTSUITE(/**/::/**/A/**/::/**/B/**/) {\n"
531 "int i;\n"
532 "int j;\n"
533 "}",
534 Style));
535 EXPECT_EQ("TESTSUITE(A, B) {\n"
536 "int i;\n"
537 "int j;\n"
538 "}// TESTSUITE(A)",
539 fixNamespaceEndComments("TESTSUITE(A, B) {\n"
540 "int i;\n"
541 "int j;\n"
542 "}",
543 Style));
544 EXPECT_EQ("TESTSUITE(\"Test1\") {\n"
545 "int i;\n"
546 "int j;\n"
547 "}// TESTSUITE(\"Test1\")",
548 fixNamespaceEndComments("TESTSUITE(\"Test1\") {\n"
549 "int i;\n"
550 "int j;\n"
551 "}",
552 Style));
553 }
554
TEST_F(NamespaceEndCommentsFixerTest,AddsNewlineIfNeeded)555 TEST_F(NamespaceEndCommentsFixerTest, AddsNewlineIfNeeded) {
556 EXPECT_EQ("namespace A {\n"
557 "int i;\n"
558 "int j;\n"
559 "}// namespace A\n"
560 " int k;",
561 fixNamespaceEndComments("namespace A {\n"
562 "int i;\n"
563 "int j;\n"
564 "} int k;"));
565 EXPECT_EQ("namespace {\n"
566 "int i;\n"
567 "int j;\n"
568 "}// namespace\n"
569 " int k;",
570 fixNamespaceEndComments("namespace {\n"
571 "int i;\n"
572 "int j;\n"
573 "} int k;"));
574 EXPECT_EQ("namespace A {\n"
575 "int i;\n"
576 "int j;\n"
577 "}// namespace A\n"
578 " namespace B {\n"
579 "int j;\n"
580 "int k;\n"
581 "}// namespace B",
582 fixNamespaceEndComments("namespace A {\n"
583 "int i;\n"
584 "int j;\n"
585 "} namespace B {\n"
586 "int j;\n"
587 "int k;\n"
588 "}"));
589 EXPECT_EQ("namespace {\n"
590 "int i;\n"
591 "int j;\n"
592 "};// namespace\n"
593 "int k;",
594 fixNamespaceEndComments("namespace {\n"
595 "int i;\n"
596 "int j;\n"
597 "};int k;"));
598 EXPECT_EQ("namespace {\n"
599 "int i;\n"
600 "int j;\n"
601 "};// namespace\n"
602 ";",
603 fixNamespaceEndComments("namespace {\n"
604 "int i;\n"
605 "int j;\n"
606 "};;"));
607 }
608
TEST_F(NamespaceEndCommentsFixerTest,DoesNotAddEndCommentForShortNamespace)609 TEST_F(NamespaceEndCommentsFixerTest, DoesNotAddEndCommentForShortNamespace) {
610 EXPECT_EQ("namespace {}", fixNamespaceEndComments("namespace {}"));
611 EXPECT_EQ("namespace A {}", fixNamespaceEndComments("namespace A {}"));
612 EXPECT_EQ("namespace A { a }", fixNamespaceEndComments("namespace A { a }"));
613 EXPECT_EQ("namespace A { a };",
614 fixNamespaceEndComments("namespace A { a };"));
615 }
616
TEST_F(NamespaceEndCommentsFixerTest,DoesNotAddCommentAfterUnaffectedRBrace)617 TEST_F(NamespaceEndCommentsFixerTest, DoesNotAddCommentAfterUnaffectedRBrace) {
618 EXPECT_EQ("namespace A {\n"
619 "int i;\n"
620 "}",
621 fixNamespaceEndComments("namespace A {\n"
622 "int i;\n"
623 "}",
624 // The range (16, 3) spans the 'int' above.
625 /*Ranges=*/{1, tooling::Range(16, 3)}));
626 EXPECT_EQ("namespace A {\n"
627 "int i;\n"
628 "};",
629 fixNamespaceEndComments("namespace A {\n"
630 "int i;\n"
631 "};",
632 // The range (16, 3) spans the 'int' above.
633 /*Ranges=*/{1, tooling::Range(16, 3)}));
634 }
635
TEST_F(NamespaceEndCommentsFixerTest,DoesNotAddCommentAfterRBraceInPPDirective)636 TEST_F(NamespaceEndCommentsFixerTest,
637 DoesNotAddCommentAfterRBraceInPPDirective) {
638 EXPECT_EQ("#define SAD \\\n"
639 "namespace A { \\\n"
640 "int i; \\\n"
641 "}",
642 fixNamespaceEndComments("#define SAD \\\n"
643 "namespace A { \\\n"
644 "int i; \\\n"
645 "}"));
646 }
647
TEST_F(NamespaceEndCommentsFixerTest,KeepsValidEndComment)648 TEST_F(NamespaceEndCommentsFixerTest, KeepsValidEndComment) {
649 EXPECT_EQ("namespace {\n"
650 "int i;\n"
651 "} // end anonymous namespace",
652 fixNamespaceEndComments("namespace {\n"
653 "int i;\n"
654 "} // end anonymous namespace"));
655 EXPECT_EQ("namespace A {\n"
656 "int i;\n"
657 "} /* end of namespace A */",
658 fixNamespaceEndComments("namespace A {\n"
659 "int i;\n"
660 "} /* end of namespace A */"));
661 EXPECT_EQ("namespace A {\n"
662 "int i;\n"
663 "} // namespace A",
664 fixNamespaceEndComments("namespace A {\n"
665 "int i;\n"
666 "} // namespace A"));
667 EXPECT_EQ("namespace A::B {\n"
668 "int i;\n"
669 "} // end namespace A::B",
670 fixNamespaceEndComments("namespace A::B {\n"
671 "int i;\n"
672 "} // end namespace A::B"));
673 EXPECT_EQ("namespace A {\n"
674 "int i;\n"
675 "}; // end namespace A",
676 fixNamespaceEndComments("namespace A {\n"
677 "int i;\n"
678 "}; // end namespace A"));
679 EXPECT_EQ("namespace {\n"
680 "int i;\n"
681 "}; /* unnamed namespace */",
682 fixNamespaceEndComments("namespace {\n"
683 "int i;\n"
684 "}; /* unnamed namespace */"));
685 }
686
TEST_F(NamespaceEndCommentsFixerTest,KeepsValidMacroEndComment)687 TEST_F(NamespaceEndCommentsFixerTest, KeepsValidMacroEndComment) {
688 FormatStyle Style = getLLVMStyle();
689 Style.NamespaceMacros.push_back("TESTSUITE");
690
691 EXPECT_EQ("TESTSUITE() {\n"
692 "int i;\n"
693 "} // end anonymous TESTSUITE()",
694 fixNamespaceEndComments("TESTSUITE() {\n"
695 "int i;\n"
696 "} // end anonymous TESTSUITE()",
697 Style));
698 EXPECT_EQ("TESTSUITE(A) {\n"
699 "int i;\n"
700 "} /* end of TESTSUITE(A) */",
701 fixNamespaceEndComments("TESTSUITE(A) {\n"
702 "int i;\n"
703 "} /* end of TESTSUITE(A) */",
704 Style));
705 EXPECT_EQ("TESTSUITE(A) {\n"
706 "int i;\n"
707 "} // TESTSUITE(A)",
708 fixNamespaceEndComments("TESTSUITE(A) {\n"
709 "int i;\n"
710 "} // TESTSUITE(A)",
711 Style));
712 EXPECT_EQ("TESTSUITE(A::B) {\n"
713 "int i;\n"
714 "} // end TESTSUITE(A::B)",
715 fixNamespaceEndComments("TESTSUITE(A::B) {\n"
716 "int i;\n"
717 "} // end TESTSUITE(A::B)",
718 Style));
719 EXPECT_EQ("TESTSUITE(A) {\n"
720 "int i;\n"
721 "}; // end TESTSUITE(A)",
722 fixNamespaceEndComments("TESTSUITE(A) {\n"
723 "int i;\n"
724 "}; // end TESTSUITE(A)",
725 Style));
726 EXPECT_EQ("TESTSUITE() {\n"
727 "int i;\n"
728 "}; /* unnamed TESTSUITE() */",
729 fixNamespaceEndComments("TESTSUITE() {\n"
730 "int i;\n"
731 "}; /* unnamed TESTSUITE() */",
732 Style));
733 }
734
TEST_F(NamespaceEndCommentsFixerTest,UpdatesInvalidEndLineComment)735 TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidEndLineComment) {
736 EXPECT_EQ("namespace {\n"
737 "int i;\n"
738 "} // namespace",
739 fixNamespaceEndComments("namespace {\n"
740 "int i;\n"
741 "} // namespace A"));
742 EXPECT_EQ("namespace A {\n"
743 "int i;\n"
744 "} // namespace A",
745 fixNamespaceEndComments("namespace A {\n"
746 "int i;\n"
747 "} // namespace"));
748 EXPECT_EQ("namespace A {\n"
749 "int i;\n"
750 "} // namespace A",
751 fixNamespaceEndComments("namespace A {\n"
752 "int i;\n"
753 "} //"));
754 EXPECT_EQ("namespace A {\n"
755 "int i;\n"
756 "}; // namespace A",
757 fixNamespaceEndComments("namespace A {\n"
758 "int i;\n"
759 "}; //"));
760
761 EXPECT_EQ("namespace A {\n"
762 "int i;\n"
763 "} // namespace A",
764 fixNamespaceEndComments("namespace A {\n"
765 "int i;\n"
766 "} // banamespace A"));
767 EXPECT_EQ("namespace A {\n"
768 "int i;\n"
769 "}; // namespace A",
770 fixNamespaceEndComments("namespace A {\n"
771 "int i;\n"
772 "}; // banamespace A"));
773 // Updates invalid line comments even for short namespaces.
774 EXPECT_EQ("namespace A {} // namespace A",
775 fixNamespaceEndComments("namespace A {} // namespace"));
776 EXPECT_EQ("namespace A {}; // namespace A",
777 fixNamespaceEndComments("namespace A {}; // namespace"));
778
779 // Update invalid comments for compacted namespaces.
780 FormatStyle CompactNamespacesStyle = getLLVMStyle();
781 CompactNamespacesStyle.CompactNamespaces = true;
782 EXPECT_EQ("namespace out { namespace in {\n"
783 "}} // namespace out::in",
784 fixNamespaceEndComments("namespace out { namespace in {\n"
785 "}} // namespace out",
786 CompactNamespacesStyle));
787 EXPECT_EQ("namespace out { namespace in {\n"
788 "}} // namespace out::in",
789 fixNamespaceEndComments("namespace out { namespace in {\n"
790 "}} // namespace in",
791 CompactNamespacesStyle));
792 EXPECT_EQ("namespace out { namespace in {\n"
793 "}\n"
794 "} // namespace out::in",
795 fixNamespaceEndComments("namespace out { namespace in {\n"
796 "}// banamespace in\n"
797 "} // namespace out",
798 CompactNamespacesStyle));
799 EXPECT_EQ("namespace out { namespace {\n"
800 "}} // namespace out",
801 fixNamespaceEndComments("namespace out { namespace {\n"
802 "}} // namespace out::",
803 CompactNamespacesStyle));
804 }
805
TEST_F(NamespaceEndCommentsFixerTest,UpdatesInvalidMacroEndLineComment)806 TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidMacroEndLineComment) {
807 FormatStyle Style = getLLVMStyle();
808 Style.NamespaceMacros.push_back("TESTSUITE");
809
810 EXPECT_EQ("TESTSUITE() {\n"
811 "int i;\n"
812 "} // TESTSUITE()",
813 fixNamespaceEndComments("TESTSUITE() {\n"
814 "int i;\n"
815 "} // TESTSUITE(A)",
816 Style));
817 EXPECT_EQ("TESTSUITE(A) {\n"
818 "int i;\n"
819 "} // TESTSUITE(A)",
820 fixNamespaceEndComments("TESTSUITE(A) {\n"
821 "int i;\n"
822 "} // TESTSUITE()",
823 Style));
824 EXPECT_EQ("TESTSUITE(A) {\n"
825 "int i;\n"
826 "} // TESTSUITE(A)",
827 fixNamespaceEndComments("TESTSUITE(A) {\n"
828 "int i;\n"
829 "} //",
830 Style));
831 EXPECT_EQ("TESTSUITE(A) {\n"
832 "int i;\n"
833 "}; // TESTSUITE(A)",
834 fixNamespaceEndComments("TESTSUITE(A) {\n"
835 "int i;\n"
836 "}; //",
837 Style));
838 EXPECT_EQ("TESTSUITE(A) {\n"
839 "int i;\n"
840 "} // TESTSUITE(A)",
841 fixNamespaceEndComments("TESTSUITE(A) {\n"
842 "int i;\n"
843 "} // TESTSUITE A",
844 Style));
845 EXPECT_EQ("TESTSUITE() {\n"
846 "int i;\n"
847 "} // TESTSUITE()",
848 fixNamespaceEndComments("TESTSUITE() {\n"
849 "int i;\n"
850 "} // TESTSUITE",
851 Style));
852 EXPECT_EQ("TESTSUITE(A) {\n"
853 "int i;\n"
854 "} // TESTSUITE(A)",
855 fixNamespaceEndComments("TESTSUITE(A) {\n"
856 "int i;\n"
857 "} // TOASTSUITE(A)",
858 Style));
859 EXPECT_EQ("TESTSUITE(A) {\n"
860 "int i;\n"
861 "}; // TESTSUITE(A)",
862 fixNamespaceEndComments("TESTSUITE(A) {\n"
863 "int i;\n"
864 "}; // TOASTSUITE(A)",
865 Style));
866 // Updates invalid line comments even for short namespaces.
867 EXPECT_EQ("TESTSUITE(A) {} // TESTSUITE(A)",
868 fixNamespaceEndComments("TESTSUITE(A) {} // TESTSUITE()", Style));
869 EXPECT_EQ("TESTSUITE(A) {}; // TESTSUITE(A)",
870 fixNamespaceEndComments("TESTSUITE(A) {}; // TESTSUITE()", Style));
871
872 // Update invalid comments for compacted namespaces.
873 FormatStyle CompactNamespacesStyle = getLLVMStyle();
874 CompactNamespacesStyle.CompactNamespaces = true;
875 CompactNamespacesStyle.NamespaceMacros.push_back("TESTSUITE");
876
877 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
878 "}} // TESTSUITE(out::in)",
879 fixNamespaceEndComments("TESTSUITE(out) { TESTSUITE(in) {\n"
880 "}} // TESTSUITE(out)",
881 CompactNamespacesStyle));
882 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
883 "}} // TESTSUITE(out::in)",
884 fixNamespaceEndComments("TESTSUITE(out) { TESTSUITE(in) {\n"
885 "}} // TESTSUITE(in)",
886 CompactNamespacesStyle));
887 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
888 "}\n"
889 "} // TESTSUITE(out::in)",
890 fixNamespaceEndComments("TESTSUITE(out) { TESTSUITE(in) {\n"
891 "}// TAOSTSUITE(in)\n"
892 "} // TESTSUITE(out)",
893 CompactNamespacesStyle));
894 }
895
TEST_F(NamespaceEndCommentsFixerTest,UpdatesInvalidEndBlockComment)896 TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidEndBlockComment) {
897 EXPECT_EQ("namespace {\n"
898 "int i;\n"
899 "} // namespace",
900 fixNamespaceEndComments("namespace {\n"
901 "int i;\n"
902 "} /* namespace A */"));
903 EXPECT_EQ("namespace A {\n"
904 "int i;\n"
905 "} // namespace A",
906 fixNamespaceEndComments("namespace A {\n"
907 "int i;\n"
908 "} /* end namespace */"));
909 EXPECT_EQ("namespace A {\n"
910 "int i;\n"
911 "} // namespace A",
912 fixNamespaceEndComments("namespace A {\n"
913 "int i;\n"
914 "} /**/"));
915 EXPECT_EQ("namespace A {\n"
916 "int i;\n"
917 "} // namespace A",
918 fixNamespaceEndComments("namespace A {\n"
919 "int i;\n"
920 "} /* end unnamed namespace */"));
921 EXPECT_EQ("namespace A {\n"
922 "int i;\n"
923 "} // namespace A",
924 fixNamespaceEndComments("namespace A {\n"
925 "int i;\n"
926 "} /* banamespace A */"));
927 EXPECT_EQ("namespace A {\n"
928 "int i;\n"
929 "}; // namespace A",
930 fixNamespaceEndComments("namespace A {\n"
931 "int i;\n"
932 "}; /* banamespace A */"));
933 EXPECT_EQ("namespace A {} // namespace A",
934 fixNamespaceEndComments("namespace A {} /**/"));
935 EXPECT_EQ("namespace A {}; // namespace A",
936 fixNamespaceEndComments("namespace A {}; /**/"));
937 }
938
TEST_F(NamespaceEndCommentsFixerTest,UpdatesInvalidMacroEndBlockComment)939 TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidMacroEndBlockComment) {
940 FormatStyle Style = getLLVMStyle();
941 Style.NamespaceMacros.push_back("TESTSUITE");
942
943 EXPECT_EQ("TESTSUITE() {\n"
944 "int i;\n"
945 "} // TESTSUITE()",
946 fixNamespaceEndComments("TESTSUITE() {\n"
947 "int i;\n"
948 "} /* TESTSUITE(A) */",
949 Style));
950 EXPECT_EQ("TESTSUITE(A) {\n"
951 "int i;\n"
952 "} // TESTSUITE(A)",
953 fixNamespaceEndComments("TESTSUITE(A) {\n"
954 "int i;\n"
955 "} /* end TESTSUITE() */",
956 Style));
957 EXPECT_EQ("TESTSUITE(A) {\n"
958 "int i;\n"
959 "} // TESTSUITE(A)",
960 fixNamespaceEndComments("TESTSUITE(A) {\n"
961 "int i;\n"
962 "} /**/",
963 Style));
964 EXPECT_EQ("TESTSUITE(A) {\n"
965 "int i;\n"
966 "} // TESTSUITE(A)",
967 fixNamespaceEndComments("TESTSUITE(A) {\n"
968 "int i;\n"
969 "} /* end unnamed TESTSUITE() */",
970 Style));
971 EXPECT_EQ("TESTSUITE(A) {\n"
972 "int i;\n"
973 "} // TESTSUITE(A)",
974 fixNamespaceEndComments("TESTSUITE(A) {\n"
975 "int i;\n"
976 "} /* TOASTSUITE(A) */",
977 Style));
978 EXPECT_EQ("TESTSUITE(A) {\n"
979 "int i;\n"
980 "}; // TESTSUITE(A)",
981 fixNamespaceEndComments("TESTSUITE(A) {\n"
982 "int i;\n"
983 "}; /* TAOSTSUITE(A) */",
984 Style));
985 EXPECT_EQ("TESTSUITE(A) {} // TESTSUITE(A)",
986 fixNamespaceEndComments("TESTSUITE(A) {} /**/", Style));
987 EXPECT_EQ("TESTSUITE(A) {}; // TESTSUITE(A)",
988 fixNamespaceEndComments("TESTSUITE(A) {}; /**/", Style));
989 }
990
TEST_F(NamespaceEndCommentsFixerTest,DoesNotAddEndCommentForNamespacesControlledByMacros)991 TEST_F(NamespaceEndCommentsFixerTest,
992 DoesNotAddEndCommentForNamespacesControlledByMacros) {
993 EXPECT_EQ("#ifdef 1\n"
994 "namespace A {\n"
995 "#elseif\n"
996 "namespace B {\n"
997 "#endif\n"
998 "int i;\n"
999 "}\n"
1000 "}\n",
1001 fixNamespaceEndComments("#ifdef 1\n"
1002 "namespace A {\n"
1003 "#elseif\n"
1004 "namespace B {\n"
1005 "#endif\n"
1006 "int i;\n"
1007 "}\n"
1008 "}\n"));
1009 }
1010
TEST_F(NamespaceEndCommentsFixerTest,AddsEndCommentForNamespacesAroundMacros)1011 TEST_F(NamespaceEndCommentsFixerTest, AddsEndCommentForNamespacesAroundMacros) {
1012 // Conditional blocks around are fine
1013 EXPECT_EQ("namespace A {\n"
1014 "#if 1\n"
1015 "int i;\n"
1016 "#endif\n"
1017 "}// namespace A",
1018 fixNamespaceEndComments("namespace A {\n"
1019 "#if 1\n"
1020 "int i;\n"
1021 "#endif\n"
1022 "}"));
1023 EXPECT_EQ("#if 1\n"
1024 "#endif\n"
1025 "namespace A {\n"
1026 "int i;\n"
1027 "int j;\n"
1028 "}// namespace A",
1029 fixNamespaceEndComments("#if 1\n"
1030 "#endif\n"
1031 "namespace A {\n"
1032 "int i;\n"
1033 "int j;\n"
1034 "}"));
1035 EXPECT_EQ("namespace A {\n"
1036 "int i;\n"
1037 "int j;\n"
1038 "}// namespace A\n"
1039 "#if 1\n"
1040 "#endif",
1041 fixNamespaceEndComments("namespace A {\n"
1042 "int i;\n"
1043 "int j;\n"
1044 "}\n"
1045 "#if 1\n"
1046 "#endif"));
1047 EXPECT_EQ("#if 1\n"
1048 "namespace A {\n"
1049 "int i;\n"
1050 "int j;\n"
1051 "}// namespace A\n"
1052 "#endif",
1053 fixNamespaceEndComments("#if 1\n"
1054 "namespace A {\n"
1055 "int i;\n"
1056 "int j;\n"
1057 "}\n"
1058 "#endif"));
1059
1060 // Macro definition has no impact
1061 EXPECT_EQ("namespace A {\n"
1062 "#define FOO\n"
1063 "int i;\n"
1064 "}// namespace A",
1065 fixNamespaceEndComments("namespace A {\n"
1066 "#define FOO\n"
1067 "int i;\n"
1068 "}"));
1069 EXPECT_EQ("#define FOO\n"
1070 "namespace A {\n"
1071 "int i;\n"
1072 "int j;\n"
1073 "}// namespace A",
1074 fixNamespaceEndComments("#define FOO\n"
1075 "namespace A {\n"
1076 "int i;\n"
1077 "int j;\n"
1078 "}"));
1079 EXPECT_EQ("namespace A {\n"
1080 "int i;\n"
1081 "int j;\n"
1082 "}// namespace A\n"
1083 "#define FOO\n",
1084 fixNamespaceEndComments("namespace A {\n"
1085 "int i;\n"
1086 "int j;\n"
1087 "}\n"
1088 "#define FOO\n"));
1089
1090 // No replacement if open & close in different conditional blocks
1091 EXPECT_EQ("#if 1\n"
1092 "namespace A {\n"
1093 "#endif\n"
1094 "int i;\n"
1095 "int j;\n"
1096 "#if 1\n"
1097 "}\n"
1098 "#endif",
1099 fixNamespaceEndComments("#if 1\n"
1100 "namespace A {\n"
1101 "#endif\n"
1102 "int i;\n"
1103 "int j;\n"
1104 "#if 1\n"
1105 "}\n"
1106 "#endif"));
1107 EXPECT_EQ("#ifdef A\n"
1108 "namespace A {\n"
1109 "#endif\n"
1110 "int i;\n"
1111 "int j;\n"
1112 "#ifdef B\n"
1113 "}\n"
1114 "#endif",
1115 fixNamespaceEndComments("#ifdef A\n"
1116 "namespace A {\n"
1117 "#endif\n"
1118 "int i;\n"
1119 "int j;\n"
1120 "#ifdef B\n"
1121 "}\n"
1122 "#endif"));
1123
1124 // No replacement inside unreachable conditional block
1125 EXPECT_EQ("#if 0\n"
1126 "namespace A {\n"
1127 "int i;\n"
1128 "int j;\n"
1129 "}\n"
1130 "#endif",
1131 fixNamespaceEndComments("#if 0\n"
1132 "namespace A {\n"
1133 "int i;\n"
1134 "int j;\n"
1135 "}\n"
1136 "#endif"));
1137 }
1138
TEST_F(NamespaceEndCommentsFixerTest,DoesNotAddEndCommentForNamespacesInMacroDeclarations)1139 TEST_F(NamespaceEndCommentsFixerTest,
1140 DoesNotAddEndCommentForNamespacesInMacroDeclarations) {
1141 EXPECT_EQ("#ifdef 1\n"
1142 "namespace A {\n"
1143 "#elseif\n"
1144 "namespace B {\n"
1145 "#endif\n"
1146 "int i;\n"
1147 "}\n"
1148 "}\n",
1149 fixNamespaceEndComments("#ifdef 1\n"
1150 "namespace A {\n"
1151 "#elseif\n"
1152 "namespace B {\n"
1153 "#endif\n"
1154 "int i;\n"
1155 "}\n"
1156 "}\n"));
1157 EXPECT_EQ("namespace {\n"
1158 "int i;\n"
1159 "int j;\n"
1160 "}// namespace\n"
1161 "#if A\n"
1162 "int i;\n"
1163 "#else\n"
1164 "int j;\n"
1165 "#endif",
1166 fixNamespaceEndComments("namespace {\n"
1167 "int i;\n"
1168 "int j;\n"
1169 "}\n"
1170 "#if A\n"
1171 "int i;\n"
1172 "#else\n"
1173 "int j;\n"
1174 "#endif"));
1175 EXPECT_EQ("#if A\n"
1176 "namespace A {\n"
1177 "#else\n"
1178 "namespace B {\n"
1179 "#endif\n"
1180 "int i;\n"
1181 "int j;\n"
1182 "}",
1183 fixNamespaceEndComments("#if A\n"
1184 "namespace A {\n"
1185 "#else\n"
1186 "namespace B {\n"
1187 "#endif\n"
1188 "int i;\n"
1189 "int j;\n"
1190 "}"));
1191 EXPECT_EQ("#if A\n"
1192 "namespace A {\n"
1193 "#else\n"
1194 "namespace B {\n"
1195 "#endif\n"
1196 "int i;\n"
1197 "int j;\n"
1198 "} // namespace A",
1199 fixNamespaceEndComments("#if A\n"
1200 "namespace A {\n"
1201 "#else\n"
1202 "namespace B {\n"
1203 "#endif\n"
1204 "int i;\n"
1205 "int j;\n"
1206 "} // namespace A"));
1207 EXPECT_EQ("#if A\n"
1208 "namespace A {\n"
1209 "#else\n"
1210 "namespace B {\n"
1211 "#endif\n"
1212 "int i;\n"
1213 "int j;\n"
1214 "} // namespace B",
1215 fixNamespaceEndComments("#if A\n"
1216 "namespace A {\n"
1217 "#else\n"
1218 "namespace B {\n"
1219 "#endif\n"
1220 "int i;\n"
1221 "int j;\n"
1222 "} // namespace B"));
1223 EXPECT_EQ("namespace A\n"
1224 "int i;\n"
1225 "int j;\n"
1226 "#if A\n"
1227 "}\n"
1228 "#else\n"
1229 "}\n"
1230 "#endif",
1231 fixNamespaceEndComments("namespace A\n"
1232 "int i;\n"
1233 "int j;\n"
1234 "#if A\n"
1235 "}\n"
1236 "#else\n"
1237 "}\n"
1238 "#endif"));
1239 EXPECT_EQ("namespace A\n"
1240 "int i;\n"
1241 "int j;\n"
1242 "#if A\n"
1243 "} // namespace A\n"
1244 "#else\n"
1245 "} // namespace A\n"
1246 "#endif",
1247 fixNamespaceEndComments("namespace A\n"
1248 "int i;\n"
1249 "int j;\n"
1250 "#if A\n"
1251 "} // namespace A\n"
1252 "#else\n"
1253 "} // namespace A\n"
1254 "#endif"));
1255 }
1256
TEST_F(NamespaceEndCommentsFixerTest,DoesNotAddEndCommentForUnbalancedRBracesAfterNamespaceEnd)1257 TEST_F(NamespaceEndCommentsFixerTest,
1258 DoesNotAddEndCommentForUnbalancedRBracesAfterNamespaceEnd) {
1259 EXPECT_EQ("namespace {\n"
1260 "int i;\n"
1261 "} // namespace\n"
1262 "}",
1263 fixNamespaceEndComments("namespace {\n"
1264 "int i;\n"
1265 "} // namespace\n"
1266 "}"));
1267 }
1268
TEST_F(NamespaceEndCommentsFixerTest,HandlesInlineAtEndOfLine_PR32438)1269 TEST_F(NamespaceEndCommentsFixerTest, HandlesInlineAtEndOfLine_PR32438) {
1270 EXPECT_EQ("template <int> struct a {};\n"
1271 "struct a<bool{}> b() {\n"
1272 "}\n"
1273 "#define c inline\n"
1274 "void d() {\n"
1275 "}\n",
1276 fixNamespaceEndComments("template <int> struct a {};\n"
1277 "struct a<bool{}> b() {\n"
1278 "}\n"
1279 "#define c inline\n"
1280 "void d() {\n"
1281 "}\n"));
1282 }
1283
TEST_F(NamespaceEndCommentsFixerTest,IgnoreUnbalanced)1284 TEST_F(NamespaceEndCommentsFixerTest, IgnoreUnbalanced) {
1285 EXPECT_EQ("namespace A {\n"
1286 "class Foo {\n"
1287 "}\n"
1288 "}// namespace A\n",
1289 fixNamespaceEndComments("namespace A {\n"
1290 "class Foo {\n"
1291 "}\n"
1292 "}\n"));
1293 EXPECT_EQ("namespace A {\n"
1294 "class Foo {\n"
1295 "}\n",
1296 fixNamespaceEndComments("namespace A {\n"
1297 "class Foo {\n"
1298 "}\n"));
1299
1300 EXPECT_EQ("namespace A {\n"
1301 "class Foo {\n"
1302 "}\n"
1303 "}\n"
1304 "}\n",
1305 fixNamespaceEndComments("namespace A {\n"
1306 "class Foo {\n"
1307 "}\n"
1308 "}\n"
1309 "}\n"));
1310 }
1311
1312 using ShortNamespaceLinesTest = NamespaceEndCommentsFixerTest;
1313
TEST_F(ShortNamespaceLinesTest,ZeroUnwrappedLines)1314 TEST_F(ShortNamespaceLinesTest, ZeroUnwrappedLines) {
1315 auto Style = getLLVMStyle();
1316 Style.ShortNamespaceLines = 0u;
1317
1318 EXPECT_EQ("namespace OneLinerNamespace {}\n",
1319 fixNamespaceEndComments("namespace OneLinerNamespace {}\n", Style));
1320 EXPECT_EQ("namespace ShortNamespace {\n"
1321 "}\n",
1322 fixNamespaceEndComments("namespace ShortNamespace {\n"
1323 "}\n",
1324 Style));
1325 EXPECT_EQ("namespace LongNamespace {\n"
1326 "int i;\n"
1327 "}// namespace LongNamespace\n",
1328 fixNamespaceEndComments("namespace LongNamespace {\n"
1329 "int i;\n"
1330 "}\n",
1331 Style));
1332 }
1333
TEST_F(ShortNamespaceLinesTest,OneUnwrappedLine)1334 TEST_F(ShortNamespaceLinesTest, OneUnwrappedLine) {
1335 constexpr auto DefaultUnwrappedLines = 1u;
1336 auto const Style = getLLVMStyle();
1337
1338 EXPECT_EQ(DefaultUnwrappedLines, Style.ShortNamespaceLines);
1339 EXPECT_EQ("namespace ShortNamespace {\n"
1340 "int i;\n"
1341 "}\n",
1342 fixNamespaceEndComments("namespace ShortNamespace {\n"
1343 "int i;\n"
1344 "}\n"));
1345 EXPECT_EQ("namespace LongNamespace {\n"
1346 "int i;\n"
1347 "int j;\n"
1348 "}// namespace LongNamespace\n",
1349 fixNamespaceEndComments("namespace LongNamespace {\n"
1350 "int i;\n"
1351 "int j;\n"
1352 "}\n"));
1353 }
1354
TEST_F(ShortNamespaceLinesTest,MultipleUnwrappedLine)1355 TEST_F(ShortNamespaceLinesTest, MultipleUnwrappedLine) {
1356 auto Style = getLLVMStyle();
1357 Style.ShortNamespaceLines = 2u;
1358
1359 EXPECT_EQ("namespace ShortNamespace {\n"
1360 "int i;\n"
1361 "int j;\n"
1362 "}\n",
1363 fixNamespaceEndComments("namespace ShortNamespace {\n"
1364 "int i;\n"
1365 "int j;\n"
1366 "}\n",
1367 Style));
1368 EXPECT_EQ("namespace LongNamespace {\n"
1369 "int i;\n"
1370 "int j;\n"
1371 "int k;\n"
1372 "}// namespace LongNamespace\n",
1373 fixNamespaceEndComments("namespace LongNamespace {\n"
1374 "int i;\n"
1375 "int j;\n"
1376 "int k;\n"
1377 "}\n",
1378 Style));
1379 }
1380
TEST_F(ShortNamespaceLinesTest,NamespaceAlias)1381 TEST_F(ShortNamespaceLinesTest, NamespaceAlias) {
1382 auto Style = getLLVMStyle();
1383
1384 EXPECT_EQ("namespace n = nn;\n"
1385 "{\n"
1386 " int i;\n"
1387 " int j;\n"
1388 "}\n",
1389 fixNamespaceEndComments("namespace n = nn;\n"
1390 "{\n"
1391 " int i;\n"
1392 " int j;\n"
1393 "}\n",
1394 Style));
1395
1396 EXPECT_EQ("namespace n = nn; // comment\n"
1397 "{\n"
1398 " int i;\n"
1399 " int j;\n"
1400 "}\n",
1401 fixNamespaceEndComments("namespace n = nn; // comment\n"
1402 "{\n"
1403 " int i;\n"
1404 " int j;\n"
1405 "}\n",
1406 Style));
1407
1408 EXPECT_EQ("namespace n = nn; /* comment */\n"
1409 "{\n"
1410 " int i;\n"
1411 " int j;\n"
1412 "}\n",
1413 fixNamespaceEndComments("namespace n = nn; /* comment */\n"
1414 "{\n"
1415 " int i;\n"
1416 " int j;\n"
1417 "}\n",
1418 Style));
1419
1420 EXPECT_EQ(
1421 "namespace n = nn; /* comment */ /* comment2 */\n"
1422 "{\n"
1423 " int i;\n"
1424 " int j;\n"
1425 "}\n",
1426 fixNamespaceEndComments("namespace n = nn; /* comment */ /* comment2 */\n"
1427 "{\n"
1428 " int i;\n"
1429 " int j;\n"
1430 "}\n",
1431 Style));
1432
1433 EXPECT_EQ("namespace n = nn; {\n"
1434 " int i;\n"
1435 " int j;\n"
1436 "}\n",
1437 fixNamespaceEndComments("namespace n = nn; {\n"
1438 " int i;\n"
1439 " int j;\n"
1440 "}\n",
1441 Style));
1442 EXPECT_EQ("int foo;\n"
1443 "namespace n\n"
1444 "{\n"
1445 " int i;\n"
1446 " int j;\n"
1447 "}// namespace n\n",
1448 fixNamespaceEndComments("int foo;\n"
1449 "namespace n\n"
1450 "{\n"
1451 " int i;\n"
1452 " int j;\n"
1453 "}\n",
1454 Style));
1455 }
1456 } // end namespace
1457 } // end namespace format
1458 } // end namespace clang
1459