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