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   EXPECT_EQ("namespace out { namespace {\n"
260             "int i;\n"
261             "int j;\n"
262             "}}// namespace out",
263             fixNamespaceEndComments("namespace out { namespace {\n"
264                                     "int i;\n"
265                                     "int j;\n"
266                                     "}}",
267                                     CompactNamespacesStyle));
268 
269   // Adds an end comment after a semicolon.
270   EXPECT_EQ("namespace {\n"
271             "int i;\n"
272             "int j;\n"
273             "};// namespace",
274             fixNamespaceEndComments("namespace {\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",
282             fixNamespaceEndComments("namespace A {\n"
283                                     "int i;\n"
284                                     "int j;\n"
285                                     "};"));
286   EXPECT_EQ("namespace A {\n"
287             "int i;\n"
288             "int j;\n"
289             "};// namespace A\n"
290             "// unrelated",
291             fixNamespaceEndComments("namespace A {\n"
292                                     "int i;\n"
293                                     "int j;\n"
294                                     "};\n"
295                                     "// unrelated"));
296 }
297 
298 TEST_F(NamespaceEndCommentsFixerTest, AddsMacroEndComment) {
299   FormatStyle Style = getLLVMStyle();
300   Style.NamespaceMacros.push_back("TESTSUITE");
301 
302   EXPECT_EQ("TESTSUITE() {\n"
303             "int i;\n"
304             "int j;\n"
305             "}// TESTSUITE()",
306             fixNamespaceEndComments("TESTSUITE() {\n"
307                                     "int i;\n"
308                                     "int j;\n"
309                                     "}",
310                                     Style));
311 
312   EXPECT_EQ("TESTSUITE(A) {\n"
313             "int i;\n"
314             "int j;\n"
315             "}// TESTSUITE(A)",
316             fixNamespaceEndComments("TESTSUITE(A) {\n"
317                                     "int i;\n"
318                                     "int j;\n"
319                                     "}",
320                                     Style));
321   EXPECT_EQ("inline TESTSUITE(A) {\n"
322             "int i;\n"
323             "int j;\n"
324             "}// TESTSUITE(A)",
325             fixNamespaceEndComments("inline TESTSUITE(A) {\n"
326                                     "int i;\n"
327                                     "int j;\n"
328                                     "}",
329                                     Style));
330   EXPECT_EQ("TESTSUITE(::A) {\n"
331             "int i;\n"
332             "int j;\n"
333             "}// TESTSUITE(::A)",
334             fixNamespaceEndComments("TESTSUITE(::A) {\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::B)",
352             fixNamespaceEndComments("TESTSUITE(/**/::/**/A/**/::/**/B/**/) {\n"
353                                     "int i;\n"
354                                     "int j;\n"
355                                     "}",
356                                     Style));
357   EXPECT_EQ("TESTSUITE(A, B) {\n"
358             "int i;\n"
359             "int j;\n"
360             "}// TESTSUITE(A)",
361             fixNamespaceEndComments("TESTSUITE(A, B) {\n"
362                                     "int i;\n"
363                                     "int j;\n"
364                                     "}",
365                                     Style));
366   EXPECT_EQ("TESTSUITE(\"Test1\") {\n"
367             "int i;\n"
368             "int j;\n"
369             "}// TESTSUITE(\"Test1\")",
370             fixNamespaceEndComments("TESTSUITE(\"Test1\") {\n"
371                                     "int i;\n"
372                                     "int j;\n"
373                                     "}",
374                                     Style));
375 }
376 
377 TEST_F(NamespaceEndCommentsFixerTest, AddsNewlineIfNeeded) {
378   EXPECT_EQ("namespace A {\n"
379             "int i;\n"
380             "int j;\n"
381             "}// namespace A\n"
382             " int k;",
383             fixNamespaceEndComments("namespace A {\n"
384                                     "int i;\n"
385                                     "int j;\n"
386                                     "} int k;"));
387   EXPECT_EQ("namespace {\n"
388             "int i;\n"
389             "int j;\n"
390             "}// namespace\n"
391             " int k;",
392             fixNamespaceEndComments("namespace {\n"
393                                     "int i;\n"
394                                     "int j;\n"
395                                     "} int k;"));
396   EXPECT_EQ("namespace A {\n"
397             "int i;\n"
398             "int j;\n"
399             "}// namespace A\n"
400             " namespace B {\n"
401             "int j;\n"
402             "int k;\n"
403             "}// namespace B",
404             fixNamespaceEndComments("namespace A {\n"
405                                     "int i;\n"
406                                     "int j;\n"
407                                     "} namespace B {\n"
408                                     "int j;\n"
409                                     "int k;\n"
410                                     "}"));
411   EXPECT_EQ("namespace {\n"
412             "int i;\n"
413             "int j;\n"
414             "};// namespace\n"
415             "int k;",
416             fixNamespaceEndComments("namespace {\n"
417                                     "int i;\n"
418                                     "int j;\n"
419                                     "};int k;"));
420   EXPECT_EQ("namespace {\n"
421             "int i;\n"
422             "int j;\n"
423             "};// namespace\n"
424             ";",
425             fixNamespaceEndComments("namespace {\n"
426                                     "int i;\n"
427                                     "int j;\n"
428                                     "};;"));
429 }
430 
431 TEST_F(NamespaceEndCommentsFixerTest, DoesNotAddEndCommentForShortNamespace) {
432   EXPECT_EQ("namespace {}", fixNamespaceEndComments("namespace {}"));
433   EXPECT_EQ("namespace A {}", fixNamespaceEndComments("namespace A {}"));
434   EXPECT_EQ("namespace A { a }", fixNamespaceEndComments("namespace A { a }"));
435   EXPECT_EQ("namespace A { a };",
436             fixNamespaceEndComments("namespace A { a };"));
437 }
438 
439 TEST_F(NamespaceEndCommentsFixerTest, DoesNotAddCommentAfterUnaffectedRBrace) {
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   EXPECT_EQ("namespace A {\n"
449             "int i;\n"
450             "};",
451             fixNamespaceEndComments("namespace A {\n"
452                                     "int i;\n"
453                                     "};",
454                                     // The range (16, 3) spans the 'int' above.
455                                     /*Ranges=*/{1, tooling::Range(16, 3)}));
456 }
457 
458 TEST_F(NamespaceEndCommentsFixerTest,
459        DoesNotAddCommentAfterRBraceInPPDirective) {
460   EXPECT_EQ("#define SAD \\\n"
461             "namespace A { \\\n"
462             "int i; \\\n"
463             "}",
464             fixNamespaceEndComments("#define SAD \\\n"
465                                     "namespace A { \\\n"
466                                     "int i; \\\n"
467                                     "}"));
468 }
469 
470 TEST_F(NamespaceEndCommentsFixerTest, KeepsValidEndComment) {
471   EXPECT_EQ("namespace {\n"
472             "int i;\n"
473             "} // end anonymous namespace",
474             fixNamespaceEndComments("namespace {\n"
475                                     "int i;\n"
476                                     "} // end anonymous namespace"));
477   EXPECT_EQ("namespace A {\n"
478             "int i;\n"
479             "} /* end of namespace A */",
480             fixNamespaceEndComments("namespace A {\n"
481                                     "int i;\n"
482                                     "} /* end of namespace A */"));
483   EXPECT_EQ("namespace A {\n"
484             "int i;\n"
485             "}   //   namespace A",
486             fixNamespaceEndComments("namespace A {\n"
487                                     "int i;\n"
488                                     "}   //   namespace A"));
489   EXPECT_EQ("namespace A::B {\n"
490             "int i;\n"
491             "} // end namespace A::B",
492             fixNamespaceEndComments("namespace A::B {\n"
493                                     "int i;\n"
494                                     "} // end namespace A::B"));
495   EXPECT_EQ("namespace A {\n"
496             "int i;\n"
497             "}; // end namespace A",
498             fixNamespaceEndComments("namespace A {\n"
499                                     "int i;\n"
500                                     "}; // end namespace A"));
501   EXPECT_EQ("namespace {\n"
502             "int i;\n"
503             "}; /* unnamed namespace */",
504             fixNamespaceEndComments("namespace {\n"
505                                     "int i;\n"
506                                     "}; /* unnamed namespace */"));
507 }
508 
509 TEST_F(NamespaceEndCommentsFixerTest, KeepsValidMacroEndComment) {
510   FormatStyle Style = getLLVMStyle();
511   Style.NamespaceMacros.push_back("TESTSUITE");
512 
513   EXPECT_EQ("TESTSUITE() {\n"
514             "int i;\n"
515             "} // end anonymous TESTSUITE()",
516             fixNamespaceEndComments("TESTSUITE() {\n"
517                                     "int i;\n"
518                                     "} // end anonymous TESTSUITE()",
519                                     Style));
520   EXPECT_EQ("TESTSUITE(A) {\n"
521             "int i;\n"
522             "} /* end of TESTSUITE(A) */",
523             fixNamespaceEndComments("TESTSUITE(A) {\n"
524                                     "int i;\n"
525                                     "} /* end of TESTSUITE(A) */",
526                                     Style));
527   EXPECT_EQ("TESTSUITE(A) {\n"
528             "int i;\n"
529             "}   //   TESTSUITE(A)",
530             fixNamespaceEndComments("TESTSUITE(A) {\n"
531                                     "int i;\n"
532                                     "}   //   TESTSUITE(A)",
533                                     Style));
534   EXPECT_EQ("TESTSUITE(A::B) {\n"
535             "int i;\n"
536             "} // end TESTSUITE(A::B)",
537             fixNamespaceEndComments("TESTSUITE(A::B) {\n"
538                                     "int i;\n"
539                                     "} // end TESTSUITE(A::B)",
540                                     Style));
541   EXPECT_EQ("TESTSUITE(A) {\n"
542             "int i;\n"
543             "}; // end TESTSUITE(A)",
544             fixNamespaceEndComments("TESTSUITE(A) {\n"
545                                     "int i;\n"
546                                     "}; // end TESTSUITE(A)",
547                                     Style));
548   EXPECT_EQ("TESTSUITE() {\n"
549             "int i;\n"
550             "}; /* unnamed TESTSUITE() */",
551             fixNamespaceEndComments("TESTSUITE() {\n"
552                                     "int i;\n"
553                                     "}; /* unnamed TESTSUITE() */",
554                                     Style));
555 }
556 
557 TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidEndLineComment) {
558   EXPECT_EQ("namespace {\n"
559             "int i;\n"
560             "} // namespace",
561             fixNamespaceEndComments("namespace {\n"
562                                     "int i;\n"
563                                     "} // namespace A"));
564   EXPECT_EQ("namespace A {\n"
565             "int i;\n"
566             "} // namespace A",
567             fixNamespaceEndComments("namespace A {\n"
568                                     "int i;\n"
569                                     "} // namespace"));
570   EXPECT_EQ("namespace A {\n"
571             "int i;\n"
572             "} // namespace A",
573             fixNamespaceEndComments("namespace A {\n"
574                                     "int i;\n"
575                                     "} //"));
576   EXPECT_EQ("namespace A {\n"
577             "int i;\n"
578             "}; // namespace A",
579             fixNamespaceEndComments("namespace A {\n"
580                                     "int i;\n"
581                                     "}; //"));
582 
583   EXPECT_EQ("namespace A {\n"
584             "int i;\n"
585             "} // namespace A",
586             fixNamespaceEndComments("namespace A {\n"
587                                     "int i;\n"
588                                     "} // banamespace A"));
589   EXPECT_EQ("namespace A {\n"
590             "int i;\n"
591             "}; // namespace A",
592             fixNamespaceEndComments("namespace A {\n"
593                                     "int i;\n"
594                                     "}; // banamespace A"));
595   // Updates invalid line comments even for short namespaces.
596   EXPECT_EQ("namespace A {} // namespace A",
597             fixNamespaceEndComments("namespace A {} // namespace"));
598   EXPECT_EQ("namespace A {}; // namespace A",
599             fixNamespaceEndComments("namespace A {}; // namespace"));
600 
601   // Update invalid comments for compacted namespaces.
602   FormatStyle CompactNamespacesStyle = getLLVMStyle();
603   CompactNamespacesStyle.CompactNamespaces = true;
604   EXPECT_EQ("namespace out { namespace in {\n"
605             "}} // namespace out::in",
606             fixNamespaceEndComments("namespace out { namespace in {\n"
607                                     "}} // namespace out",
608                                     CompactNamespacesStyle));
609   EXPECT_EQ("namespace out { namespace in {\n"
610             "}} // namespace out::in",
611             fixNamespaceEndComments("namespace out { namespace in {\n"
612                                     "}} // namespace in",
613                                     CompactNamespacesStyle));
614   EXPECT_EQ("namespace out { namespace in {\n"
615             "}\n"
616             "} // namespace out::in",
617             fixNamespaceEndComments("namespace out { namespace in {\n"
618                                     "}// banamespace in\n"
619                                     "} // namespace out",
620                                     CompactNamespacesStyle));
621   EXPECT_EQ("namespace out { namespace {\n"
622             "}} // namespace out",
623             fixNamespaceEndComments("namespace out { namespace {\n"
624                                     "}} // namespace out::",
625                                     CompactNamespacesStyle));
626 }
627 
628 TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidMacroEndLineComment) {
629   FormatStyle Style = getLLVMStyle();
630   Style.NamespaceMacros.push_back("TESTSUITE");
631 
632   EXPECT_EQ("TESTSUITE() {\n"
633             "int i;\n"
634             "} // TESTSUITE()",
635             fixNamespaceEndComments("TESTSUITE() {\n"
636                                     "int i;\n"
637                                     "} // TESTSUITE(A)",
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                                     "} // TESTSUITE()",
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                                     "} //",
652                                     Style));
653   EXPECT_EQ("TESTSUITE(A) {\n"
654             "int i;\n"
655             "}; // TESTSUITE(A)",
656             fixNamespaceEndComments("TESTSUITE(A) {\n"
657                                     "int i;\n"
658                                     "}; //",
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                                     "} // TESTSUITE A",
666                                     Style));
667   EXPECT_EQ("TESTSUITE() {\n"
668             "int i;\n"
669             "} // TESTSUITE()",
670             fixNamespaceEndComments("TESTSUITE() {\n"
671                                     "int i;\n"
672                                     "} // TESTSUITE",
673                                     Style));
674   EXPECT_EQ("TESTSUITE(A) {\n"
675             "int i;\n"
676             "} // TESTSUITE(A)",
677             fixNamespaceEndComments("TESTSUITE(A) {\n"
678                                     "int i;\n"
679                                     "} // TOASTSUITE(A)",
680                                     Style));
681   EXPECT_EQ("TESTSUITE(A) {\n"
682             "int i;\n"
683             "}; // TESTSUITE(A)",
684             fixNamespaceEndComments("TESTSUITE(A) {\n"
685                                     "int i;\n"
686                                     "}; // TOASTSUITE(A)",
687                                     Style));
688   // Updates invalid line comments even for short namespaces.
689   EXPECT_EQ("TESTSUITE(A) {} // TESTSUITE(A)",
690             fixNamespaceEndComments("TESTSUITE(A) {} // TESTSUITE()", Style));
691   EXPECT_EQ("TESTSUITE(A) {}; // TESTSUITE(A)",
692             fixNamespaceEndComments("TESTSUITE(A) {}; // TESTSUITE()", Style));
693 
694   // Update invalid comments for compacted namespaces.
695   FormatStyle CompactNamespacesStyle = getLLVMStyle();
696   CompactNamespacesStyle.CompactNamespaces = true;
697   CompactNamespacesStyle.NamespaceMacros.push_back("TESTSUITE");
698 
699   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
700             "}} // TESTSUITE(out::in)",
701             fixNamespaceEndComments("TESTSUITE(out) { TESTSUITE(in) {\n"
702                                     "}} // TESTSUITE(out)",
703                                     CompactNamespacesStyle));
704   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
705             "}} // TESTSUITE(out::in)",
706             fixNamespaceEndComments("TESTSUITE(out) { TESTSUITE(in) {\n"
707                                     "}} // TESTSUITE(in)",
708                                     CompactNamespacesStyle));
709   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
710             "}\n"
711             "} // TESTSUITE(out::in)",
712             fixNamespaceEndComments("TESTSUITE(out) { TESTSUITE(in) {\n"
713                                     "}// TAOSTSUITE(in)\n"
714                                     "} // TESTSUITE(out)",
715                                     CompactNamespacesStyle));
716 }
717 
718 TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidEndBlockComment) {
719   EXPECT_EQ("namespace {\n"
720             "int i;\n"
721             "} // namespace",
722             fixNamespaceEndComments("namespace {\n"
723                                     "int i;\n"
724                                     "} /* namespace A */"));
725   EXPECT_EQ("namespace A {\n"
726             "int i;\n"
727             "}  // namespace A",
728             fixNamespaceEndComments("namespace A {\n"
729                                     "int i;\n"
730                                     "}  /* end namespace */"));
731   EXPECT_EQ("namespace A {\n"
732             "int i;\n"
733             "} // namespace A",
734             fixNamespaceEndComments("namespace A {\n"
735                                     "int i;\n"
736                                     "} /**/"));
737   EXPECT_EQ("namespace A {\n"
738             "int i;\n"
739             "} // namespace A",
740             fixNamespaceEndComments("namespace A {\n"
741                                     "int i;\n"
742                                     "} /* end unnamed namespace */"));
743   EXPECT_EQ("namespace A {\n"
744             "int i;\n"
745             "} // namespace A",
746             fixNamespaceEndComments("namespace A {\n"
747                                     "int i;\n"
748                                     "} /* banamespace A */"));
749   EXPECT_EQ("namespace A {\n"
750             "int i;\n"
751             "}; // namespace A",
752             fixNamespaceEndComments("namespace A {\n"
753                                     "int i;\n"
754                                     "}; /* banamespace A */"));
755   EXPECT_EQ("namespace A {} // namespace A",
756             fixNamespaceEndComments("namespace A {} /**/"));
757   EXPECT_EQ("namespace A {}; // namespace A",
758             fixNamespaceEndComments("namespace A {}; /**/"));
759 }
760 
761 TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidMacroEndBlockComment) {
762   FormatStyle Style = getLLVMStyle();
763   Style.NamespaceMacros.push_back("TESTSUITE");
764 
765   EXPECT_EQ("TESTSUITE() {\n"
766             "int i;\n"
767             "} // TESTSUITE()",
768             fixNamespaceEndComments("TESTSUITE() {\n"
769                                     "int i;\n"
770                                     "} /* TESTSUITE(A) */",
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 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                                     "} /**/",
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                                     "} /* end unnamed TESTSUITE() */",
792                                     Style));
793   EXPECT_EQ("TESTSUITE(A) {\n"
794             "int i;\n"
795             "} // TESTSUITE(A)",
796             fixNamespaceEndComments("TESTSUITE(A) {\n"
797                                     "int i;\n"
798                                     "} /* TOASTSUITE(A) */",
799                                     Style));
800   EXPECT_EQ("TESTSUITE(A) {\n"
801             "int i;\n"
802             "}; // TESTSUITE(A)",
803             fixNamespaceEndComments("TESTSUITE(A) {\n"
804                                     "int i;\n"
805                                     "}; /* TAOSTSUITE(A) */",
806                                     Style));
807   EXPECT_EQ("TESTSUITE(A) {} // TESTSUITE(A)",
808             fixNamespaceEndComments("TESTSUITE(A) {} /**/", Style));
809   EXPECT_EQ("TESTSUITE(A) {}; // TESTSUITE(A)",
810             fixNamespaceEndComments("TESTSUITE(A) {}; /**/", Style));
811 }
812 
813 TEST_F(NamespaceEndCommentsFixerTest,
814        DoesNotAddEndCommentForNamespacesControlledByMacros) {
815   EXPECT_EQ("#ifdef 1\n"
816             "namespace A {\n"
817             "#elseif\n"
818             "namespace B {\n"
819             "#endif\n"
820             "int i;\n"
821             "}\n"
822             "}\n",
823             fixNamespaceEndComments("#ifdef 1\n"
824                                     "namespace A {\n"
825                                     "#elseif\n"
826                                     "namespace B {\n"
827                                     "#endif\n"
828                                     "int i;\n"
829                                     "}\n"
830                                     "}\n"));
831 }
832 
833 TEST_F(NamespaceEndCommentsFixerTest, AddsEndCommentForNamespacesAroundMacros) {
834   // Conditional blocks around are fine
835   EXPECT_EQ("namespace A {\n"
836             "#if 1\n"
837             "int i;\n"
838             "#endif\n"
839             "}// namespace A",
840             fixNamespaceEndComments("namespace A {\n"
841                                     "#if 1\n"
842                                     "int i;\n"
843                                     "#endif\n"
844                                     "}"));
845   EXPECT_EQ("#if 1\n"
846             "#endif\n"
847             "namespace A {\n"
848             "int i;\n"
849             "int j;\n"
850             "}// namespace A",
851             fixNamespaceEndComments("#if 1\n"
852                                     "#endif\n"
853                                     "namespace A {\n"
854                                     "int i;\n"
855                                     "int j;\n"
856                                     "}"));
857   EXPECT_EQ("namespace A {\n"
858             "int i;\n"
859             "int j;\n"
860             "}// namespace A\n"
861             "#if 1\n"
862             "#endif",
863             fixNamespaceEndComments("namespace A {\n"
864                                     "int i;\n"
865                                     "int j;\n"
866                                     "}\n"
867                                     "#if 1\n"
868                                     "#endif"));
869   EXPECT_EQ("#if 1\n"
870             "namespace A {\n"
871             "int i;\n"
872             "int j;\n"
873             "}// namespace A\n"
874             "#endif",
875             fixNamespaceEndComments("#if 1\n"
876                                     "namespace A {\n"
877                                     "int i;\n"
878                                     "int j;\n"
879                                     "}\n"
880                                     "#endif"));
881 
882   // Macro definition has no impact
883   EXPECT_EQ("namespace A {\n"
884             "#define FOO\n"
885             "int i;\n"
886             "}// namespace A",
887             fixNamespaceEndComments("namespace A {\n"
888                                     "#define FOO\n"
889                                     "int i;\n"
890                                     "}"));
891   EXPECT_EQ("#define FOO\n"
892             "namespace A {\n"
893             "int i;\n"
894             "int j;\n"
895             "}// namespace A",
896             fixNamespaceEndComments("#define FOO\n"
897                                     "namespace A {\n"
898                                     "int i;\n"
899                                     "int j;\n"
900                                     "}"));
901   EXPECT_EQ("namespace A {\n"
902             "int i;\n"
903             "int j;\n"
904             "}// namespace A\n"
905             "#define FOO\n",
906             fixNamespaceEndComments("namespace A {\n"
907                                     "int i;\n"
908                                     "int j;\n"
909                                     "}\n"
910                                     "#define FOO\n"));
911 
912   // No replacement if open & close in different conditional blocks
913   EXPECT_EQ("#if 1\n"
914             "namespace A {\n"
915             "#endif\n"
916             "int i;\n"
917             "int j;\n"
918             "#if 1\n"
919             "}\n"
920             "#endif",
921             fixNamespaceEndComments("#if 1\n"
922                                     "namespace A {\n"
923                                     "#endif\n"
924                                     "int i;\n"
925                                     "int j;\n"
926                                     "#if 1\n"
927                                     "}\n"
928                                     "#endif"));
929   EXPECT_EQ("#ifdef A\n"
930             "namespace A {\n"
931             "#endif\n"
932             "int i;\n"
933             "int j;\n"
934             "#ifdef B\n"
935             "}\n"
936             "#endif",
937             fixNamespaceEndComments("#ifdef A\n"
938                                     "namespace A {\n"
939                                     "#endif\n"
940                                     "int i;\n"
941                                     "int j;\n"
942                                     "#ifdef B\n"
943                                     "}\n"
944                                     "#endif"));
945 
946   // No replacement inside unreachable conditional block
947   EXPECT_EQ("#if 0\n"
948             "namespace A {\n"
949             "int i;\n"
950             "int j;\n"
951             "}\n"
952             "#endif",
953             fixNamespaceEndComments("#if 0\n"
954                                     "namespace A {\n"
955                                     "int i;\n"
956                                     "int j;\n"
957                                     "}\n"
958                                     "#endif"));
959 }
960 
961 TEST_F(NamespaceEndCommentsFixerTest,
962        DoesNotAddEndCommentForNamespacesInMacroDeclarations) {
963   EXPECT_EQ("#ifdef 1\n"
964             "namespace A {\n"
965             "#elseif\n"
966             "namespace B {\n"
967             "#endif\n"
968             "int i;\n"
969             "}\n"
970             "}\n",
971             fixNamespaceEndComments("#ifdef 1\n"
972                                     "namespace A {\n"
973                                     "#elseif\n"
974                                     "namespace B {\n"
975                                     "#endif\n"
976                                     "int i;\n"
977                                     "}\n"
978                                     "}\n"));
979   EXPECT_EQ("namespace {\n"
980             "int i;\n"
981             "int j;\n"
982             "}// namespace\n"
983             "#if A\n"
984             "int i;\n"
985             "#else\n"
986             "int j;\n"
987             "#endif",
988             fixNamespaceEndComments("namespace {\n"
989                                     "int i;\n"
990                                     "int j;\n"
991                                     "}\n"
992                                     "#if A\n"
993                                     "int i;\n"
994                                     "#else\n"
995                                     "int j;\n"
996                                     "#endif"));
997   EXPECT_EQ("#if A\n"
998             "namespace A {\n"
999             "#else\n"
1000             "namespace B {\n"
1001             "#endif\n"
1002             "int i;\n"
1003             "int j;\n"
1004             "}",
1005             fixNamespaceEndComments("#if A\n"
1006                                     "namespace A {\n"
1007                                     "#else\n"
1008                                     "namespace B {\n"
1009                                     "#endif\n"
1010                                     "int i;\n"
1011                                     "int j;\n"
1012                                     "}"));
1013   EXPECT_EQ("#if A\n"
1014             "namespace A {\n"
1015             "#else\n"
1016             "namespace B {\n"
1017             "#endif\n"
1018             "int i;\n"
1019             "int j;\n"
1020             "} // namespace A",
1021             fixNamespaceEndComments("#if A\n"
1022                                     "namespace A {\n"
1023                                     "#else\n"
1024                                     "namespace B {\n"
1025                                     "#endif\n"
1026                                     "int i;\n"
1027                                     "int j;\n"
1028                                     "} // namespace A"));
1029   EXPECT_EQ("#if A\n"
1030             "namespace A {\n"
1031             "#else\n"
1032             "namespace B {\n"
1033             "#endif\n"
1034             "int i;\n"
1035             "int j;\n"
1036             "} // namespace B",
1037             fixNamespaceEndComments("#if A\n"
1038                                     "namespace A {\n"
1039                                     "#else\n"
1040                                     "namespace B {\n"
1041                                     "#endif\n"
1042                                     "int i;\n"
1043                                     "int j;\n"
1044                                     "} // namespace B"));
1045   EXPECT_EQ("namespace A\n"
1046             "int i;\n"
1047             "int j;\n"
1048             "#if A\n"
1049             "}\n"
1050             "#else\n"
1051             "}\n"
1052             "#endif",
1053             fixNamespaceEndComments("namespace A\n"
1054                                     "int i;\n"
1055                                     "int j;\n"
1056                                     "#if A\n"
1057                                     "}\n"
1058                                     "#else\n"
1059                                     "}\n"
1060                                     "#endif"));
1061   EXPECT_EQ("namespace A\n"
1062             "int i;\n"
1063             "int j;\n"
1064             "#if A\n"
1065             "} // namespace A\n"
1066             "#else\n"
1067             "} // namespace A\n"
1068             "#endif",
1069             fixNamespaceEndComments("namespace A\n"
1070                                     "int i;\n"
1071                                     "int j;\n"
1072                                     "#if A\n"
1073                                     "} // namespace A\n"
1074                                     "#else\n"
1075                                     "} // namespace A\n"
1076                                     "#endif"));
1077 }
1078 
1079 TEST_F(NamespaceEndCommentsFixerTest,
1080        DoesNotAddEndCommentForUnbalancedRBracesAfterNamespaceEnd) {
1081   EXPECT_EQ("namespace {\n"
1082             "int i;\n"
1083             "} // namespace\n"
1084             "}",
1085             fixNamespaceEndComments("namespace {\n"
1086                                     "int i;\n"
1087                                     "} // namespace\n"
1088                                     "}"));
1089 }
1090 
1091 TEST_F(NamespaceEndCommentsFixerTest, HandlesInlineAtEndOfLine_PR32438) {
1092   EXPECT_EQ("template <int> struct a {};\n"
1093             "struct a<bool{}> b() {\n"
1094             "}\n"
1095             "#define c inline\n"
1096             "void d() {\n"
1097             "}\n",
1098             fixNamespaceEndComments("template <int> struct a {};\n"
1099                                     "struct a<bool{}> b() {\n"
1100                                     "}\n"
1101                                     "#define c inline\n"
1102                                     "void d() {\n"
1103                                     "}\n"));
1104 }
1105 
1106 TEST_F(NamespaceEndCommentsFixerTest, IgnoreUnbalanced) {
1107   EXPECT_EQ("namespace A {\n"
1108             "class Foo {\n"
1109             "}\n"
1110             "}// namespace A\n",
1111             fixNamespaceEndComments("namespace A {\n"
1112                                     "class Foo {\n"
1113                                     "}\n"
1114                                     "}\n"));
1115   EXPECT_EQ("namespace A {\n"
1116             "class Foo {\n"
1117             "}\n",
1118             fixNamespaceEndComments("namespace A {\n"
1119                                     "class Foo {\n"
1120                                     "}\n"));
1121 
1122   EXPECT_EQ("namespace A {\n"
1123             "class Foo {\n"
1124             "}\n"
1125             "}\n"
1126             "}\n",
1127             fixNamespaceEndComments("namespace A {\n"
1128                                     "class Foo {\n"
1129                                     "}\n"
1130                                     "}\n"
1131                                     "}\n"));
1132 }
1133 
1134 using ShortNamespaceLinesTest = NamespaceEndCommentsFixerTest;
1135 
1136 TEST_F(ShortNamespaceLinesTest, ZeroUnwrappedLines) {
1137   auto Style = getLLVMStyle();
1138   Style.ShortNamespaceLines = 0u;
1139 
1140   EXPECT_EQ("namespace OneLinerNamespace {}\n",
1141             fixNamespaceEndComments("namespace OneLinerNamespace {}\n", Style));
1142   EXPECT_EQ("namespace ShortNamespace {\n"
1143             "}\n",
1144             fixNamespaceEndComments("namespace ShortNamespace {\n"
1145                                     "}\n",
1146                                     Style));
1147   EXPECT_EQ("namespace LongNamespace {\n"
1148             "int i;\n"
1149             "}// namespace LongNamespace\n",
1150             fixNamespaceEndComments("namespace LongNamespace {\n"
1151                                     "int i;\n"
1152                                     "}\n",
1153                                     Style));
1154 }
1155 
1156 TEST_F(ShortNamespaceLinesTest, OneUnwrappedLine) {
1157   constexpr auto DefaultUnwrappedLines = 1u;
1158   auto const Style = getLLVMStyle();
1159 
1160   EXPECT_EQ(DefaultUnwrappedLines, Style.ShortNamespaceLines);
1161   EXPECT_EQ("namespace ShortNamespace {\n"
1162             "int i;\n"
1163             "}\n",
1164             fixNamespaceEndComments("namespace ShortNamespace {\n"
1165                                     "int i;\n"
1166                                     "}\n"));
1167   EXPECT_EQ("namespace LongNamespace {\n"
1168             "int i;\n"
1169             "int j;\n"
1170             "}// namespace LongNamespace\n",
1171             fixNamespaceEndComments("namespace LongNamespace {\n"
1172                                     "int i;\n"
1173                                     "int j;\n"
1174                                     "}\n"));
1175 }
1176 
1177 TEST_F(ShortNamespaceLinesTest, MultipleUnwrappedLine) {
1178   auto Style = getLLVMStyle();
1179   Style.ShortNamespaceLines = 2u;
1180 
1181   EXPECT_EQ("namespace ShortNamespace {\n"
1182             "int i;\n"
1183             "int j;\n"
1184             "}\n",
1185             fixNamespaceEndComments("namespace ShortNamespace {\n"
1186                                     "int i;\n"
1187                                     "int j;\n"
1188                                     "}\n",
1189                                     Style));
1190   EXPECT_EQ("namespace LongNamespace {\n"
1191             "int i;\n"
1192             "int j;\n"
1193             "int k;\n"
1194             "}// namespace LongNamespace\n",
1195             fixNamespaceEndComments("namespace LongNamespace {\n"
1196                                     "int i;\n"
1197                                     "int j;\n"
1198                                     "int k;\n"
1199                                     "}\n",
1200                                     Style));
1201 }
1202 
1203 TEST_F(ShortNamespaceLinesTest, NamespaceAlias) {
1204   auto Style = getLLVMStyle();
1205 
1206   EXPECT_EQ("namespace n = nn;\n"
1207             "{\n"
1208             "  int i;\n"
1209             "  int j;\n"
1210             "}\n",
1211             fixNamespaceEndComments("namespace n = nn;\n"
1212                                     "{\n"
1213                                     "  int i;\n"
1214                                     "  int j;\n"
1215                                     "}\n",
1216                                     Style));
1217 
1218   EXPECT_EQ("namespace n = nn; // comment\n"
1219             "{\n"
1220             "  int i;\n"
1221             "  int j;\n"
1222             "}\n",
1223             fixNamespaceEndComments("namespace n = nn; // comment\n"
1224                                     "{\n"
1225                                     "  int i;\n"
1226                                     "  int j;\n"
1227                                     "}\n",
1228                                     Style));
1229 
1230   EXPECT_EQ("namespace n = nn; /* comment */\n"
1231             "{\n"
1232             "  int i;\n"
1233             "  int j;\n"
1234             "}\n",
1235             fixNamespaceEndComments("namespace n = nn; /* comment */\n"
1236                                     "{\n"
1237                                     "  int i;\n"
1238                                     "  int j;\n"
1239                                     "}\n",
1240                                     Style));
1241 
1242   EXPECT_EQ(
1243       "namespace n = nn; /* comment */ /* comment2 */\n"
1244       "{\n"
1245       "  int i;\n"
1246       "  int j;\n"
1247       "}\n",
1248       fixNamespaceEndComments("namespace n = nn; /* comment */ /* comment2 */\n"
1249                               "{\n"
1250                               "  int i;\n"
1251                               "  int j;\n"
1252                               "}\n",
1253                               Style));
1254 
1255   EXPECT_EQ("namespace n = nn; {\n"
1256             "  int i;\n"
1257             "  int j;\n"
1258             "}\n",
1259             fixNamespaceEndComments("namespace n = nn; {\n"
1260                                     "  int i;\n"
1261                                     "  int j;\n"
1262                                     "}\n",
1263                                     Style));
1264   EXPECT_EQ("int foo;\n"
1265             "namespace n\n"
1266             "{\n"
1267             "  int i;\n"
1268             "  int j;\n"
1269             "}// namespace n\n",
1270             fixNamespaceEndComments("int foo;\n"
1271                                     "namespace n\n"
1272                                     "{\n"
1273                                     "  int i;\n"
1274                                     "  int j;\n"
1275                                     "}\n",
1276                                     Style));
1277 }
1278 } // end namespace
1279 } // end namespace format
1280 } // end namespace clang
1281