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