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 }", fixNamespaceEndComments("namespace A { a }"));
427   EXPECT_EQ("namespace A { a };",
428             fixNamespaceEndComments("namespace A { a };"));
429 }
430 
431 TEST_F(NamespaceEndCommentsFixerTest, DoesNotAddCommentAfterUnaffectedRBrace) {
432   EXPECT_EQ("namespace A {\n"
433             "int i;\n"
434             "}",
435             fixNamespaceEndComments("namespace A {\n"
436                                     "int i;\n"
437                                     "}",
438                                     // The range (16, 3) spans the 'int' above.
439                                     /*Ranges=*/{1, tooling::Range(16, 3)}));
440   EXPECT_EQ("namespace A {\n"
441             "int i;\n"
442             "};",
443             fixNamespaceEndComments("namespace A {\n"
444                                     "int i;\n"
445                                     "};",
446                                     // The range (16, 3) spans the 'int' above.
447                                     /*Ranges=*/{1, tooling::Range(16, 3)}));
448 }
449 
450 TEST_F(NamespaceEndCommentsFixerTest,
451        DoesNotAddCommentAfterRBraceInPPDirective) {
452   EXPECT_EQ("#define SAD \\\n"
453             "namespace A { \\\n"
454             "int i; \\\n"
455             "}",
456             fixNamespaceEndComments("#define SAD \\\n"
457                                     "namespace A { \\\n"
458                                     "int i; \\\n"
459                                     "}"));
460 }
461 
462 TEST_F(NamespaceEndCommentsFixerTest, KeepsValidEndComment) {
463   EXPECT_EQ("namespace {\n"
464             "int i;\n"
465             "} // end anonymous namespace",
466             fixNamespaceEndComments("namespace {\n"
467                                     "int i;\n"
468                                     "} // end anonymous namespace"));
469   EXPECT_EQ("namespace A {\n"
470             "int i;\n"
471             "} /* end of namespace A */",
472             fixNamespaceEndComments("namespace A {\n"
473                                     "int i;\n"
474                                     "} /* end of namespace A */"));
475   EXPECT_EQ("namespace A {\n"
476             "int i;\n"
477             "}   //   namespace A",
478             fixNamespaceEndComments("namespace A {\n"
479                                     "int i;\n"
480                                     "}   //   namespace A"));
481   EXPECT_EQ("namespace A::B {\n"
482             "int i;\n"
483             "} // end namespace A::B",
484             fixNamespaceEndComments("namespace A::B {\n"
485                                     "int i;\n"
486                                     "} // end namespace A::B"));
487   EXPECT_EQ("namespace A {\n"
488             "int i;\n"
489             "}; // end namespace A",
490             fixNamespaceEndComments("namespace A {\n"
491                                     "int i;\n"
492                                     "}; // end namespace A"));
493   EXPECT_EQ("namespace {\n"
494             "int i;\n"
495             "}; /* unnamed namespace */",
496             fixNamespaceEndComments("namespace {\n"
497                                     "int i;\n"
498                                     "}; /* unnamed namespace */"));
499 }
500 
501 TEST_F(NamespaceEndCommentsFixerTest, KeepsValidMacroEndComment) {
502   FormatStyle Style = getLLVMStyle();
503   Style.NamespaceMacros.push_back("TESTSUITE");
504 
505   EXPECT_EQ("TESTSUITE() {\n"
506             "int i;\n"
507             "} // end anonymous TESTSUITE()",
508             fixNamespaceEndComments("TESTSUITE() {\n"
509                                     "int i;\n"
510                                     "} // end anonymous TESTSUITE()",
511                                     Style));
512   EXPECT_EQ("TESTSUITE(A) {\n"
513             "int i;\n"
514             "} /* end of TESTSUITE(A) */",
515             fixNamespaceEndComments("TESTSUITE(A) {\n"
516                                     "int i;\n"
517                                     "} /* end of TESTSUITE(A) */",
518                                     Style));
519   EXPECT_EQ("TESTSUITE(A) {\n"
520             "int i;\n"
521             "}   //   TESTSUITE(A)",
522             fixNamespaceEndComments("TESTSUITE(A) {\n"
523                                     "int i;\n"
524                                     "}   //   TESTSUITE(A)",
525                                     Style));
526   EXPECT_EQ("TESTSUITE(A::B) {\n"
527             "int i;\n"
528             "} // end TESTSUITE(A::B)",
529             fixNamespaceEndComments("TESTSUITE(A::B) {\n"
530                                     "int i;\n"
531                                     "} // end TESTSUITE(A::B)",
532                                     Style));
533   EXPECT_EQ("TESTSUITE(A) {\n"
534             "int i;\n"
535             "}; // end TESTSUITE(A)",
536             fixNamespaceEndComments("TESTSUITE(A) {\n"
537                                     "int i;\n"
538                                     "}; // end TESTSUITE(A)",
539                                     Style));
540   EXPECT_EQ("TESTSUITE() {\n"
541             "int i;\n"
542             "}; /* unnamed TESTSUITE() */",
543             fixNamespaceEndComments("TESTSUITE() {\n"
544                                     "int i;\n"
545                                     "}; /* unnamed TESTSUITE() */",
546                                     Style));
547 }
548 
549 TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidEndLineComment) {
550   EXPECT_EQ("namespace {\n"
551             "int i;\n"
552             "} // namespace",
553             fixNamespaceEndComments("namespace {\n"
554                                     "int i;\n"
555                                     "} // namespace A"));
556   EXPECT_EQ("namespace A {\n"
557             "int i;\n"
558             "} // namespace A",
559             fixNamespaceEndComments("namespace A {\n"
560                                     "int i;\n"
561                                     "} // namespace"));
562   EXPECT_EQ("namespace A {\n"
563             "int i;\n"
564             "} // namespace A",
565             fixNamespaceEndComments("namespace A {\n"
566                                     "int i;\n"
567                                     "} //"));
568   EXPECT_EQ("namespace A {\n"
569             "int i;\n"
570             "}; // namespace A",
571             fixNamespaceEndComments("namespace A {\n"
572                                     "int i;\n"
573                                     "}; //"));
574 
575   EXPECT_EQ("namespace A {\n"
576             "int i;\n"
577             "} // namespace A",
578             fixNamespaceEndComments("namespace A {\n"
579                                     "int i;\n"
580                                     "} // banamespace A"));
581   EXPECT_EQ("namespace A {\n"
582             "int i;\n"
583             "}; // namespace A",
584             fixNamespaceEndComments("namespace A {\n"
585                                     "int i;\n"
586                                     "}; // banamespace A"));
587   // Updates invalid line comments even for short namespaces.
588   EXPECT_EQ("namespace A {} // namespace A",
589             fixNamespaceEndComments("namespace A {} // namespace"));
590   EXPECT_EQ("namespace A {}; // namespace A",
591             fixNamespaceEndComments("namespace A {}; // namespace"));
592 
593   // Update invalid comments for compacted namespaces.
594   FormatStyle CompactNamespacesStyle = getLLVMStyle();
595   CompactNamespacesStyle.CompactNamespaces = true;
596   EXPECT_EQ("namespace out { namespace in {\n"
597             "}} // namespace out::in",
598             fixNamespaceEndComments("namespace out { namespace in {\n"
599                                     "}} // namespace out",
600                                     CompactNamespacesStyle));
601   EXPECT_EQ("namespace out { namespace in {\n"
602             "}} // namespace out::in",
603             fixNamespaceEndComments("namespace out { namespace in {\n"
604                                     "}} // namespace in",
605                                     CompactNamespacesStyle));
606   EXPECT_EQ("namespace out { namespace in {\n"
607             "}\n"
608             "} // namespace out::in",
609             fixNamespaceEndComments("namespace out { namespace in {\n"
610                                     "}// banamespace in\n"
611                                     "} // namespace out",
612                                     CompactNamespacesStyle));
613 }
614 
615 TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidMacroEndLineComment) {
616   FormatStyle Style = getLLVMStyle();
617   Style.NamespaceMacros.push_back("TESTSUITE");
618 
619   EXPECT_EQ("TESTSUITE() {\n"
620             "int i;\n"
621             "} // TESTSUITE()",
622             fixNamespaceEndComments("TESTSUITE() {\n"
623                                     "int i;\n"
624                                     "} // TESTSUITE(A)",
625                                     Style));
626   EXPECT_EQ("TESTSUITE(A) {\n"
627             "int i;\n"
628             "} // TESTSUITE(A)",
629             fixNamespaceEndComments("TESTSUITE(A) {\n"
630                                     "int i;\n"
631                                     "} // TESTSUITE()",
632                                     Style));
633   EXPECT_EQ("TESTSUITE(A) {\n"
634             "int i;\n"
635             "} // TESTSUITE(A)",
636             fixNamespaceEndComments("TESTSUITE(A) {\n"
637                                     "int i;\n"
638                                     "} //",
639                                     Style));
640   EXPECT_EQ("TESTSUITE(A) {\n"
641             "int i;\n"
642             "}; // TESTSUITE(A)",
643             fixNamespaceEndComments("TESTSUITE(A) {\n"
644                                     "int i;\n"
645                                     "}; //",
646                                     Style));
647   EXPECT_EQ("TESTSUITE(A) {\n"
648             "int i;\n"
649             "} // TESTSUITE(A)",
650             fixNamespaceEndComments("TESTSUITE(A) {\n"
651                                     "int i;\n"
652                                     "} // TESTSUITE A",
653                                     Style));
654   EXPECT_EQ("TESTSUITE() {\n"
655             "int i;\n"
656             "} // TESTSUITE()",
657             fixNamespaceEndComments("TESTSUITE() {\n"
658                                     "int i;\n"
659                                     "} // TESTSUITE",
660                                     Style));
661   EXPECT_EQ("TESTSUITE(A) {\n"
662             "int i;\n"
663             "} // TESTSUITE(A)",
664             fixNamespaceEndComments("TESTSUITE(A) {\n"
665                                     "int i;\n"
666                                     "} // TOASTSUITE(A)",
667                                     Style));
668   EXPECT_EQ("TESTSUITE(A) {\n"
669             "int i;\n"
670             "}; // TESTSUITE(A)",
671             fixNamespaceEndComments("TESTSUITE(A) {\n"
672                                     "int i;\n"
673                                     "}; // TOASTSUITE(A)",
674                                     Style));
675   // Updates invalid line comments even for short namespaces.
676   EXPECT_EQ("TESTSUITE(A) {} // TESTSUITE(A)",
677             fixNamespaceEndComments("TESTSUITE(A) {} // TESTSUITE()", Style));
678   EXPECT_EQ("TESTSUITE(A) {}; // TESTSUITE(A)",
679             fixNamespaceEndComments("TESTSUITE(A) {}; // TESTSUITE()", Style));
680 
681   // Update invalid comments for compacted namespaces.
682   FormatStyle CompactNamespacesStyle = getLLVMStyle();
683   CompactNamespacesStyle.CompactNamespaces = true;
684   CompactNamespacesStyle.NamespaceMacros.push_back("TESTSUITE");
685 
686   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
687             "}} // TESTSUITE(out::in)",
688             fixNamespaceEndComments("TESTSUITE(out) { TESTSUITE(in) {\n"
689                                     "}} // TESTSUITE(out)",
690                                     CompactNamespacesStyle));
691   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
692             "}} // TESTSUITE(out::in)",
693             fixNamespaceEndComments("TESTSUITE(out) { TESTSUITE(in) {\n"
694                                     "}} // TESTSUITE(in)",
695                                     CompactNamespacesStyle));
696   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
697             "}\n"
698             "} // TESTSUITE(out::in)",
699             fixNamespaceEndComments("TESTSUITE(out) { TESTSUITE(in) {\n"
700                                     "}// TAOSTSUITE(in)\n"
701                                     "} // TESTSUITE(out)",
702                                     CompactNamespacesStyle));
703 }
704 
705 TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidEndBlockComment) {
706   EXPECT_EQ("namespace {\n"
707             "int i;\n"
708             "} // namespace",
709             fixNamespaceEndComments("namespace {\n"
710                                     "int i;\n"
711                                     "} /* namespace A */"));
712   EXPECT_EQ("namespace A {\n"
713             "int i;\n"
714             "}  // namespace A",
715             fixNamespaceEndComments("namespace A {\n"
716                                     "int i;\n"
717                                     "}  /* end namespace */"));
718   EXPECT_EQ("namespace A {\n"
719             "int i;\n"
720             "} // namespace A",
721             fixNamespaceEndComments("namespace A {\n"
722                                     "int i;\n"
723                                     "} /**/"));
724   EXPECT_EQ("namespace A {\n"
725             "int i;\n"
726             "} // namespace A",
727             fixNamespaceEndComments("namespace A {\n"
728                                     "int i;\n"
729                                     "} /* end unnamed namespace */"));
730   EXPECT_EQ("namespace A {\n"
731             "int i;\n"
732             "} // namespace A",
733             fixNamespaceEndComments("namespace A {\n"
734                                     "int i;\n"
735                                     "} /* banamespace A */"));
736   EXPECT_EQ("namespace A {\n"
737             "int i;\n"
738             "}; // namespace A",
739             fixNamespaceEndComments("namespace A {\n"
740                                     "int i;\n"
741                                     "}; /* banamespace A */"));
742   EXPECT_EQ("namespace A {} // namespace A",
743             fixNamespaceEndComments("namespace A {} /**/"));
744   EXPECT_EQ("namespace A {}; // namespace A",
745             fixNamespaceEndComments("namespace A {}; /**/"));
746 }
747 
748 TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidMacroEndBlockComment) {
749   FormatStyle Style = getLLVMStyle();
750   Style.NamespaceMacros.push_back("TESTSUITE");
751 
752   EXPECT_EQ("TESTSUITE() {\n"
753             "int i;\n"
754             "} // TESTSUITE()",
755             fixNamespaceEndComments("TESTSUITE() {\n"
756                                     "int i;\n"
757                                     "} /* TESTSUITE(A) */",
758                                     Style));
759   EXPECT_EQ("TESTSUITE(A) {\n"
760             "int i;\n"
761             "}  // TESTSUITE(A)",
762             fixNamespaceEndComments("TESTSUITE(A) {\n"
763                                     "int i;\n"
764                                     "}  /* end TESTSUITE() */",
765                                     Style));
766   EXPECT_EQ("TESTSUITE(A) {\n"
767             "int i;\n"
768             "} // TESTSUITE(A)",
769             fixNamespaceEndComments("TESTSUITE(A) {\n"
770                                     "int i;\n"
771                                     "} /**/",
772                                     Style));
773   EXPECT_EQ("TESTSUITE(A) {\n"
774             "int i;\n"
775             "} // TESTSUITE(A)",
776             fixNamespaceEndComments("TESTSUITE(A) {\n"
777                                     "int i;\n"
778                                     "} /* end unnamed TESTSUITE() */",
779                                     Style));
780   EXPECT_EQ("TESTSUITE(A) {\n"
781             "int i;\n"
782             "} // TESTSUITE(A)",
783             fixNamespaceEndComments("TESTSUITE(A) {\n"
784                                     "int i;\n"
785                                     "} /* TOASTSUITE(A) */",
786                                     Style));
787   EXPECT_EQ("TESTSUITE(A) {\n"
788             "int i;\n"
789             "}; // TESTSUITE(A)",
790             fixNamespaceEndComments("TESTSUITE(A) {\n"
791                                     "int i;\n"
792                                     "}; /* TAOSTSUITE(A) */",
793                                     Style));
794   EXPECT_EQ("TESTSUITE(A) {} // TESTSUITE(A)",
795             fixNamespaceEndComments("TESTSUITE(A) {} /**/", Style));
796   EXPECT_EQ("TESTSUITE(A) {}; // TESTSUITE(A)",
797             fixNamespaceEndComments("TESTSUITE(A) {}; /**/", Style));
798 }
799 
800 TEST_F(NamespaceEndCommentsFixerTest,
801        DoesNotAddEndCommentForNamespacesControlledByMacros) {
802   EXPECT_EQ("#ifdef 1\n"
803             "namespace A {\n"
804             "#elseif\n"
805             "namespace B {\n"
806             "#endif\n"
807             "int i;\n"
808             "}\n"
809             "}\n",
810             fixNamespaceEndComments("#ifdef 1\n"
811                                     "namespace A {\n"
812                                     "#elseif\n"
813                                     "namespace B {\n"
814                                     "#endif\n"
815                                     "int i;\n"
816                                     "}\n"
817                                     "}\n"));
818 }
819 
820 TEST_F(NamespaceEndCommentsFixerTest, AddEndCommentForNamespacesAroundMacros) {
821   // Conditional blocks around are fine
822   EXPECT_EQ("namespace A {\n"
823             "#if 1\n"
824             "int i;\n"
825             "#endif\n"
826             "}// namespace A",
827             fixNamespaceEndComments("namespace A {\n"
828                                     "#if 1\n"
829                                     "int i;\n"
830                                     "#endif\n"
831                                     "}"));
832   EXPECT_EQ("#if 1\n"
833             "#endif\n"
834             "namespace A {\n"
835             "int i;\n"
836             "int j;\n"
837             "}// namespace A",
838             fixNamespaceEndComments("#if 1\n"
839                                     "#endif\n"
840                                     "namespace A {\n"
841                                     "int i;\n"
842                                     "int j;\n"
843                                     "}"));
844   EXPECT_EQ("namespace A {\n"
845             "int i;\n"
846             "int j;\n"
847             "}// namespace A\n"
848             "#if 1\n"
849             "#endif",
850             fixNamespaceEndComments("namespace A {\n"
851                                     "int i;\n"
852                                     "int j;\n"
853                                     "}\n"
854                                     "#if 1\n"
855                                     "#endif"));
856   EXPECT_EQ("#if 1\n"
857             "namespace A {\n"
858             "int i;\n"
859             "int j;\n"
860             "}// namespace A\n"
861             "#endif",
862             fixNamespaceEndComments("#if 1\n"
863                                     "namespace A {\n"
864                                     "int i;\n"
865                                     "int j;\n"
866                                     "}\n"
867                                     "#endif"));
868 
869   // Macro definition has no impact
870   EXPECT_EQ("namespace A {\n"
871             "#define FOO\n"
872             "int i;\n"
873             "}// namespace A",
874             fixNamespaceEndComments("namespace A {\n"
875                                     "#define FOO\n"
876                                     "int i;\n"
877                                     "}"));
878   EXPECT_EQ("#define FOO\n"
879             "namespace A {\n"
880             "int i;\n"
881             "int j;\n"
882             "}// namespace A",
883             fixNamespaceEndComments("#define FOO\n"
884                                     "namespace A {\n"
885                                     "int i;\n"
886                                     "int j;\n"
887                                     "}"));
888   EXPECT_EQ("namespace A {\n"
889             "int i;\n"
890             "int j;\n"
891             "}// namespace A\n"
892             "#define FOO\n",
893             fixNamespaceEndComments("namespace A {\n"
894                                     "int i;\n"
895                                     "int j;\n"
896                                     "}\n"
897                                     "#define FOO\n"));
898 
899   // No replacement if open & close in different conditional blocks
900   EXPECT_EQ("#if 1\n"
901             "namespace A {\n"
902             "#endif\n"
903             "int i;\n"
904             "int j;\n"
905             "#if 1\n"
906             "}\n"
907             "#endif",
908             fixNamespaceEndComments("#if 1\n"
909                                     "namespace A {\n"
910                                     "#endif\n"
911                                     "int i;\n"
912                                     "int j;\n"
913                                     "#if 1\n"
914                                     "}\n"
915                                     "#endif"));
916   EXPECT_EQ("#ifdef A\n"
917             "namespace A {\n"
918             "#endif\n"
919             "int i;\n"
920             "int j;\n"
921             "#ifdef B\n"
922             "}\n"
923             "#endif",
924             fixNamespaceEndComments("#ifdef A\n"
925                                     "namespace A {\n"
926                                     "#endif\n"
927                                     "int i;\n"
928                                     "int j;\n"
929                                     "#ifdef B\n"
930                                     "}\n"
931                                     "#endif"));
932 
933   // No replacement inside unreachable conditional block
934   EXPECT_EQ("#if 0\n"
935             "namespace A {\n"
936             "int i;\n"
937             "int j;\n"
938             "}\n"
939             "#endif",
940             fixNamespaceEndComments("#if 0\n"
941                                     "namespace A {\n"
942                                     "int i;\n"
943                                     "int j;\n"
944                                     "}\n"
945                                     "#endif"));
946 }
947 
948 TEST_F(NamespaceEndCommentsFixerTest,
949        DoesNotAddEndCommentForNamespacesInMacroDeclarations) {
950   EXPECT_EQ("#ifdef 1\n"
951             "namespace A {\n"
952             "#elseif\n"
953             "namespace B {\n"
954             "#endif\n"
955             "int i;\n"
956             "}\n"
957             "}\n",
958             fixNamespaceEndComments("#ifdef 1\n"
959                                     "namespace A {\n"
960                                     "#elseif\n"
961                                     "namespace B {\n"
962                                     "#endif\n"
963                                     "int i;\n"
964                                     "}\n"
965                                     "}\n"));
966   EXPECT_EQ("namespace {\n"
967             "int i;\n"
968             "int j;\n"
969             "}// namespace\n"
970             "#if A\n"
971             "int i;\n"
972             "#else\n"
973             "int j;\n"
974             "#endif",
975             fixNamespaceEndComments("namespace {\n"
976                                     "int i;\n"
977                                     "int j;\n"
978                                     "}\n"
979                                     "#if A\n"
980                                     "int i;\n"
981                                     "#else\n"
982                                     "int j;\n"
983                                     "#endif"));
984   EXPECT_EQ("#if A\n"
985             "namespace A {\n"
986             "#else\n"
987             "namespace B {\n"
988             "#endif\n"
989             "int i;\n"
990             "int j;\n"
991             "}",
992             fixNamespaceEndComments("#if A\n"
993                                     "namespace A {\n"
994                                     "#else\n"
995                                     "namespace B {\n"
996                                     "#endif\n"
997                                     "int i;\n"
998                                     "int j;\n"
999                                     "}"));
1000   EXPECT_EQ("#if A\n"
1001             "namespace A {\n"
1002             "#else\n"
1003             "namespace B {\n"
1004             "#endif\n"
1005             "int i;\n"
1006             "int j;\n"
1007             "} // namespace A",
1008             fixNamespaceEndComments("#if A\n"
1009                                     "namespace A {\n"
1010                                     "#else\n"
1011                                     "namespace B {\n"
1012                                     "#endif\n"
1013                                     "int i;\n"
1014                                     "int j;\n"
1015                                     "} // namespace A"));
1016   EXPECT_EQ("#if A\n"
1017             "namespace A {\n"
1018             "#else\n"
1019             "namespace B {\n"
1020             "#endif\n"
1021             "int i;\n"
1022             "int j;\n"
1023             "} // namespace B",
1024             fixNamespaceEndComments("#if A\n"
1025                                     "namespace A {\n"
1026                                     "#else\n"
1027                                     "namespace B {\n"
1028                                     "#endif\n"
1029                                     "int i;\n"
1030                                     "int j;\n"
1031                                     "} // namespace B"));
1032   EXPECT_EQ("namespace A\n"
1033             "int i;\n"
1034             "int j;\n"
1035             "#if A\n"
1036             "}\n"
1037             "#else\n"
1038             "}\n"
1039             "#endif",
1040             fixNamespaceEndComments("namespace A\n"
1041                                     "int i;\n"
1042                                     "int j;\n"
1043                                     "#if A\n"
1044                                     "}\n"
1045                                     "#else\n"
1046                                     "}\n"
1047                                     "#endif"));
1048   EXPECT_EQ("namespace A\n"
1049             "int i;\n"
1050             "int j;\n"
1051             "#if A\n"
1052             "} // namespace A\n"
1053             "#else\n"
1054             "} // namespace A\n"
1055             "#endif",
1056             fixNamespaceEndComments("namespace A\n"
1057                                     "int i;\n"
1058                                     "int j;\n"
1059                                     "#if A\n"
1060                                     "} // namespace A\n"
1061                                     "#else\n"
1062                                     "} // namespace A\n"
1063                                     "#endif"));
1064 }
1065 
1066 TEST_F(NamespaceEndCommentsFixerTest,
1067        DoesNotAddEndCommentForUnbalancedRBracesAfterNamespaceEnd) {
1068   EXPECT_EQ("namespace {\n"
1069             "int i;\n"
1070             "} // namespace\n"
1071             "}",
1072             fixNamespaceEndComments("namespace {\n"
1073                                     "int i;\n"
1074                                     "} // namespace\n"
1075                                     "}"));
1076 }
1077 
1078 TEST_F(NamespaceEndCommentsFixerTest, HandlesInlineAtEndOfLine_PR32438) {
1079   EXPECT_EQ("template <int> struct a {};\n"
1080             "struct a<bool{}> b() {\n"
1081             "}\n"
1082             "#define c inline\n"
1083             "void d() {\n"
1084             "}\n",
1085             fixNamespaceEndComments("template <int> struct a {};\n"
1086                                     "struct a<bool{}> b() {\n"
1087                                     "}\n"
1088                                     "#define c inline\n"
1089                                     "void d() {\n"
1090                                     "}\n"));
1091 }
1092 
1093 TEST_F(NamespaceEndCommentsFixerTest, IgnoreUnbalanced) {
1094   EXPECT_EQ("namespace A {\n"
1095             "class Foo {\n"
1096             "}\n"
1097             "}// namespace A\n",
1098             fixNamespaceEndComments("namespace A {\n"
1099                                     "class Foo {\n"
1100                                     "}\n"
1101                                     "}\n"));
1102   EXPECT_EQ("namespace A {\n"
1103             "class Foo {\n"
1104             "}\n",
1105             fixNamespaceEndComments("namespace A {\n"
1106                                     "class Foo {\n"
1107                                     "}\n"));
1108 
1109   EXPECT_EQ("namespace A {\n"
1110             "class Foo {\n"
1111             "}\n"
1112             "}\n"
1113             "}\n",
1114             fixNamespaceEndComments("namespace A {\n"
1115                                     "class Foo {\n"
1116                                     "}\n"
1117                                     "}\n"
1118                                     "}\n"));
1119 }
1120 } // end namespace
1121 } // end namespace format
1122 } // end namespace clang
1123