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