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("#define M(x) x##x\n"
72             "namespace M(x) {\n"
73             "int i;\n"
74             "int j;\n"
75             "}// namespace M(x)",
76             fixNamespaceEndComments("#define M(x) x##x\n"
77                                     "namespace M(x) {\n"
78                                     "int i;\n"
79                                     "int j;\n"
80                                     "}"));
81   EXPECT_EQ("#define M(x) x##x\n"
82             "namespace A::M(x) {\n"
83             "int i;\n"
84             "int j;\n"
85             "}// namespace A::M(x)",
86             fixNamespaceEndComments("#define M(x) x##x\n"
87                                     "namespace A::M(x) {\n"
88                                     "int i;\n"
89                                     "int j;\n"
90                                     "}"));
91   EXPECT_EQ("#define M(x) x##x\n"
92             "namespace M(x)::A {\n"
93             "int i;\n"
94             "int j;\n"
95             "}// namespace M(x)::A",
96             fixNamespaceEndComments("#define M(x) x##x\n"
97                                     "namespace M(x)::A {\n"
98                                     "int i;\n"
99                                     "int j;\n"
100                                     "}"));
101   EXPECT_EQ("#define M(x) x##x\n"
102             "namespace A::inline M(x)::B {\n"
103             "int i;\n"
104             "int j;\n"
105             "}// namespace A::inline M(x)::B",
106             fixNamespaceEndComments("#define M(x) x##x\n"
107                                     "namespace A::inline M(x)::B {\n"
108                                     "int i;\n"
109                                     "int j;\n"
110                                     "}"));
111   EXPECT_EQ("#define M(x) x##x\n"
112             "namespace [[deprecated(\"foo\")]] A::inline M(x)::A {\n"
113             "int i;\n"
114             "int j;\n"
115             "}// namespace A::inline M(x)::A",
116             fixNamespaceEndComments(
117                 "#define M(x) x##x\n"
118                 "namespace [[deprecated(\"foo\")]] A::inline M(x)::A {\n"
119                 "int i;\n"
120                 "int j;\n"
121                 "}"));
122   EXPECT_EQ(
123       "namespace /* comment */ [[deprecated(\"foo\")]] /* comment */ A {\n"
124       "int i;\n"
125       "int j;\n"
126       "}// namespace A",
127       fixNamespaceEndComments(
128           "namespace /* comment */ [[deprecated(\"foo\")]] /* comment */ A {\n"
129           "int i;\n"
130           "int j;\n"
131           "}"));
132   EXPECT_EQ("namespace /* comment */ [[deprecated(\"foo\")]] A {\n"
133             "int i;\n"
134             "int j;\n"
135             "}// namespace A",
136             fixNamespaceEndComments(
137                 "namespace /* comment */ [[deprecated(\"foo\")]] A {\n"
138                 "int i;\n"
139                 "int j;\n"
140                 "}"));
141   EXPECT_EQ(
142       "#define M(x) x##x\n"
143       "namespace /* comment */ [[deprecated(\"foo\")]] /* comment */ M(x) {\n"
144       "int i;\n"
145       "int j;\n"
146       "}// namespace M(x)",
147       fixNamespaceEndComments("#define M(x) x##x\n"
148                               "namespace /* comment */ "
149                               "[[deprecated(\"foo\")]] /* comment */ M(x) {\n"
150                               "int i;\n"
151                               "int j;\n"
152                               "}"));
153   EXPECT_EQ("#define M(x) x##x\n"
154             "namespace /* comment */ [[deprecated(\"foo\")]] /* comment */ "
155             "A::M(x) {\n"
156             "int i;\n"
157             "int j;\n"
158             "}// namespace A::M(x)",
159             fixNamespaceEndComments(
160                 "#define M(x) x##x\n"
161                 "namespace /* comment */ "
162                 "[[deprecated(\"foo\")]] /* comment */ A::M(x) {\n"
163                 "int i;\n"
164                 "int j;\n"
165                 "}"));
166   EXPECT_EQ("#define M(x) x##x\n"
167             "namespace /* comment */ [[deprecated(\"foo\")]] /* comment */ "
168             "M(x) /* comment */ {\n"
169             "int i;\n"
170             "int j;\n"
171             "}// namespace M(x)",
172             fixNamespaceEndComments(
173                 "#define M(x) x##x\n"
174                 "namespace /* comment */ [[deprecated(\"foo\")]] /* comment "
175                 "*/ M(x) /* comment */ {\n"
176                 "int i;\n"
177                 "int j;\n"
178                 "}"));
179   EXPECT_EQ("#define M(x) x##x\n"
180             "namespace /* comment */ [[deprecated(\"foo\")]] /* comment */ "
181             "A::M(x) /* comment */ {\n"
182             "int i;\n"
183             "int j;\n"
184             "}// namespace A::M(x)",
185             fixNamespaceEndComments(
186                 "#define M(x) x##x\n"
187                 "namespace /* comment */ [[deprecated(\"foo\")]] /* comment "
188                 "*/ A::M(x) /* comment */ {\n"
189                 "int i;\n"
190                 "int j;\n"
191                 "}"));
192   EXPECT_EQ("#define M(x) x##x\n"
193             "namespace A M(x) {\n"
194             "int i;\n"
195             "int j;\n"
196             "}// namespace A M(x)",
197             fixNamespaceEndComments("#define M(x) x##x\n"
198                                     "namespace A M(x) {\n"
199                                     "int i;\n"
200                                     "int j;\n"
201                                     "}"));
202   EXPECT_EQ(
203       "#define B __attribute__((availability(macos, introduced=10.15)))\n"
204       "namespace A B {\n"
205       "int i;\n"
206       "int j;\n"
207       "}// namespace A B",
208       fixNamespaceEndComments(
209           "#define B __attribute__((availability(macos, introduced=10.15)))\n"
210           "namespace A B {\n"
211           "int i;\n"
212           "int j;\n"
213           "}"));
214   EXPECT_EQ("#define M(x) x##x\n"
215             "namespace A::B M(x) {\n"
216             "int i;\n"
217             "int j;\n"
218             "}// namespace A::B",
219             fixNamespaceEndComments("#define M(x) x##x\n"
220                                     "namespace A::B M(x) {\n"
221                                     "int i;\n"
222                                     "int j;\n"
223                                     "}"));
224   EXPECT_EQ(
225       "namespace A __attribute__((availability(macos, introduced=10.15))) {\n"
226       "int i;\n"
227       "int j;\n"
228       "}// namespace A",
229       fixNamespaceEndComments(
230           "namespace A __attribute__((availability(macos, introduced=10.15))) "
231           "{\n"
232           "int i;\n"
233           "int j;\n"
234           "}"));
235   EXPECT_EQ("inline namespace A {\n"
236             "int i;\n"
237             "int j;\n"
238             "}// namespace A",
239             fixNamespaceEndComments("inline namespace A {\n"
240                                     "int i;\n"
241                                     "int j;\n"
242                                     "}"));
243 
244   EXPECT_EQ("namespace [[deprecated(\"foo\")]] A::B {\n"
245             "int i;\n"
246             "int j;\n"
247             "}// namespace A::B",
248             fixNamespaceEndComments("namespace [[deprecated(\"foo\")]] A::B {\n"
249                                     "int i;\n"
250                                     "int j;\n"
251                                     "}"));
252 
253   EXPECT_EQ("namespace [[deprecated(\"foo\")]] A::inline B::inline C {\n"
254             "int i;\n"
255             "int j;\n"
256             "}// namespace A::inline B::inline C",
257             fixNamespaceEndComments(
258                 "namespace [[deprecated(\"foo\")]] A::inline B::inline C {\n"
259                 "int i;\n"
260                 "int j;\n"
261                 "}"));
262 
263   EXPECT_EQ("namespace DEPRECATED A::B {\n"
264             "int i;\n"
265             "int j;\n"
266             "}// namespace A::B",
267             fixNamespaceEndComments("namespace DEPRECATED A::B {\n"
268                                     "int i;\n"
269                                     "int j;\n"
270                                     "}"));
271 
272   EXPECT_EQ("inline namespace [[deprecated]] A {\n"
273             "int i;\n"
274             "int j;\n"
275             "}// namespace A",
276             fixNamespaceEndComments("inline namespace [[deprecated]] A {\n"
277                                     "int i;\n"
278                                     "int j;\n"
279                                     "}"));
280 
281   EXPECT_EQ("namespace ::A {\n"
282             "int i;\n"
283             "int j;\n"
284             "}// namespace ::A",
285             fixNamespaceEndComments("namespace ::A {\n"
286                                     "int i;\n"
287                                     "int j;\n"
288                                     "}"));
289   EXPECT_EQ("namespace ::A::B {\n"
290             "int i;\n"
291             "int j;\n"
292             "}// namespace ::A::B",
293             fixNamespaceEndComments("namespace ::A::B {\n"
294                                     "int i;\n"
295                                     "int j;\n"
296                                     "}"));
297   EXPECT_EQ("namespace /**/::/**/A/**/::/**/B/**/ {\n"
298             "int i;\n"
299             "int j;\n"
300             "}// namespace ::A::B",
301             fixNamespaceEndComments("namespace /**/::/**/A/**/::/**/B/**/ {\n"
302                                     "int i;\n"
303                                     "int j;\n"
304                                     "}"));
305   EXPECT_EQ("namespace A {\n"
306             "namespace B {\n"
307             "int i;\n"
308             "}\n"
309             "}// namespace A",
310             fixNamespaceEndComments("namespace A {\n"
311                                     "namespace B {\n"
312                                     "int i;\n"
313                                     "}\n"
314                                     "}"));
315   EXPECT_EQ("namespace A {\n"
316             "namespace B {\n"
317             "int i;\n"
318             "int j;\n"
319             "}// namespace B\n"
320             "}// namespace A",
321             fixNamespaceEndComments("namespace A {\n"
322                                     "namespace B {\n"
323                                     "int i;\n"
324                                     "int j;\n"
325                                     "}\n"
326                                     "}"));
327   EXPECT_EQ("namespace A {\n"
328             "int a;\n"
329             "int b;\n"
330             "}// namespace A\n"
331             "namespace B {\n"
332             "int b;\n"
333             "int a;\n"
334             "}// namespace B",
335             fixNamespaceEndComments("namespace A {\n"
336                                     "int a;\n"
337                                     "int b;\n"
338                                     "}\n"
339                                     "namespace B {\n"
340                                     "int b;\n"
341                                     "int a;\n"
342                                     "}"));
343   EXPECT_EQ("namespace A {\n"
344             "int a1;\n"
345             "int a2;\n"
346             "}// namespace A\n"
347             "namespace A {\n"
348             "int a2;\n"
349             "int a1;\n"
350             "}// namespace A",
351             fixNamespaceEndComments("namespace A {\n"
352                                     "int a1;\n"
353                                     "int a2;\n"
354                                     "}\n"
355                                     "namespace A {\n"
356                                     "int a2;\n"
357                                     "int a1;\n"
358                                     "}"));
359   EXPECT_EQ("namespace A {\n"
360             "int a;\n"
361             "int b;\n"
362             "}// namespace A\n"
363             "// comment about b\n"
364             "int b;",
365             fixNamespaceEndComments("namespace A {\n"
366                                     "int a;\n"
367                                     "int b;\n"
368                                     "}\n"
369                                     "// comment about b\n"
370                                     "int b;"));
371 
372   EXPECT_EQ("namespace A {\n"
373             "namespace B {\n"
374             "namespace C {\n"
375             "namespace D {\n"
376             "}\n"
377             "}// namespace C\n"
378             "}// namespace B\n"
379             "}// namespace A",
380             fixNamespaceEndComments("namespace A {\n"
381                                     "namespace B {\n"
382                                     "namespace C {\n"
383                                     "namespace D {\n"
384                                     "}\n"
385                                     "}\n"
386                                     "}\n"
387                                     "}"));
388 
389   // Add comment for namespaces which will be 'compacted'
390   FormatStyle CompactNamespacesStyle = getLLVMStyle();
391   CompactNamespacesStyle.CompactNamespaces = true;
392   EXPECT_EQ("namespace out { namespace in {\n"
393             "int i;\n"
394             "int j;\n"
395             "}}// namespace out::in",
396             fixNamespaceEndComments("namespace out { namespace in {\n"
397                                     "int i;\n"
398                                     "int j;\n"
399                                     "}}",
400                                     CompactNamespacesStyle));
401   EXPECT_EQ("namespace out {\n"
402             "namespace in {\n"
403             "int i;\n"
404             "int j;\n"
405             "}\n"
406             "}// namespace out::in",
407             fixNamespaceEndComments("namespace out {\n"
408                                     "namespace in {\n"
409                                     "int i;\n"
410                                     "int j;\n"
411                                     "}\n"
412                                     "}",
413                                     CompactNamespacesStyle));
414   EXPECT_EQ("namespace out { namespace in {\n"
415             "int i;\n"
416             "int j;\n"
417             "};}// namespace out::in",
418             fixNamespaceEndComments("namespace out { namespace in {\n"
419                                     "int i;\n"
420                                     "int j;\n"
421                                     "};}",
422                                     CompactNamespacesStyle));
423   EXPECT_EQ("namespace out { namespace {\n"
424             "int i;\n"
425             "int j;\n"
426             "}}// namespace out",
427             fixNamespaceEndComments("namespace out { namespace {\n"
428                                     "int i;\n"
429                                     "int j;\n"
430                                     "}}",
431                                     CompactNamespacesStyle));
432 
433   // Adds an end comment after a semicolon.
434   EXPECT_EQ("namespace {\n"
435             "int i;\n"
436             "int j;\n"
437             "};// namespace",
438             fixNamespaceEndComments("namespace {\n"
439                                     "int i;\n"
440                                     "int j;\n"
441                                     "};"));
442   EXPECT_EQ("namespace A {\n"
443             "int i;\n"
444             "int j;\n"
445             "};// namespace A",
446             fixNamespaceEndComments("namespace A {\n"
447                                     "int i;\n"
448                                     "int j;\n"
449                                     "};"));
450   EXPECT_EQ("namespace A {\n"
451             "int i;\n"
452             "int j;\n"
453             "};// namespace A\n"
454             "// unrelated",
455             fixNamespaceEndComments("namespace A {\n"
456                                     "int i;\n"
457                                     "int j;\n"
458                                     "};\n"
459                                     "// unrelated"));
460 }
461 
462 TEST_F(NamespaceEndCommentsFixerTest, WorksForObjCpp) {
463   FormatStyle ObjCppStyle = getLLVMStyle();
464   ObjCppStyle.Language = FormatStyle::LK_ObjC;
465   EXPECT_EQ("namespace {\n"
466             "int i;\n"
467             "int j;\n"
468             "}// namespace",
469             fixNamespaceEndComments("namespace {\n"
470                                     "int i;\n"
471                                     "int j;\n"
472                                     "}", ObjCppStyle));
473 }
474 
475 TEST_F(NamespaceEndCommentsFixerTest, AddsMacroEndComment) {
476   FormatStyle Style = getLLVMStyle();
477   Style.NamespaceMacros.push_back("TESTSUITE");
478 
479   EXPECT_EQ("TESTSUITE() {\n"
480             "int i;\n"
481             "int j;\n"
482             "}// TESTSUITE()",
483             fixNamespaceEndComments("TESTSUITE() {\n"
484                                     "int i;\n"
485                                     "int j;\n"
486                                     "}",
487                                     Style));
488 
489   EXPECT_EQ("TESTSUITE(A) {\n"
490             "int i;\n"
491             "int j;\n"
492             "}// TESTSUITE(A)",
493             fixNamespaceEndComments("TESTSUITE(A) {\n"
494                                     "int i;\n"
495                                     "int j;\n"
496                                     "}",
497                                     Style));
498   EXPECT_EQ("inline TESTSUITE(A) {\n"
499             "int i;\n"
500             "int j;\n"
501             "}// TESTSUITE(A)",
502             fixNamespaceEndComments("inline TESTSUITE(A) {\n"
503                                     "int i;\n"
504                                     "int j;\n"
505                                     "}",
506                                     Style));
507   EXPECT_EQ("TESTSUITE(::A) {\n"
508             "int i;\n"
509             "int j;\n"
510             "}// TESTSUITE(::A)",
511             fixNamespaceEndComments("TESTSUITE(::A) {\n"
512                                     "int i;\n"
513                                     "int j;\n"
514                                     "}",
515                                     Style));
516   EXPECT_EQ("TESTSUITE(::A::B) {\n"
517             "int i;\n"
518             "int j;\n"
519             "}// TESTSUITE(::A::B)",
520             fixNamespaceEndComments("TESTSUITE(::A::B) {\n"
521                                     "int i;\n"
522                                     "int j;\n"
523                                     "}",
524                                     Style));
525   EXPECT_EQ("TESTSUITE(/**/::/**/A/**/::/**/B/**/) {\n"
526             "int i;\n"
527             "int j;\n"
528             "}// TESTSUITE(::A::B)",
529             fixNamespaceEndComments("TESTSUITE(/**/::/**/A/**/::/**/B/**/) {\n"
530                                     "int i;\n"
531                                     "int j;\n"
532                                     "}",
533                                     Style));
534   EXPECT_EQ("TESTSUITE(A, B) {\n"
535             "int i;\n"
536             "int j;\n"
537             "}// TESTSUITE(A)",
538             fixNamespaceEndComments("TESTSUITE(A, B) {\n"
539                                     "int i;\n"
540                                     "int j;\n"
541                                     "}",
542                                     Style));
543   EXPECT_EQ("TESTSUITE(\"Test1\") {\n"
544             "int i;\n"
545             "int j;\n"
546             "}// TESTSUITE(\"Test1\")",
547             fixNamespaceEndComments("TESTSUITE(\"Test1\") {\n"
548                                     "int i;\n"
549                                     "int j;\n"
550                                     "}",
551                                     Style));
552 }
553 
554 TEST_F(NamespaceEndCommentsFixerTest, AddsNewlineIfNeeded) {
555   EXPECT_EQ("namespace A {\n"
556             "int i;\n"
557             "int j;\n"
558             "}// namespace A\n"
559             " int k;",
560             fixNamespaceEndComments("namespace A {\n"
561                                     "int i;\n"
562                                     "int j;\n"
563                                     "} int k;"));
564   EXPECT_EQ("namespace {\n"
565             "int i;\n"
566             "int j;\n"
567             "}// namespace\n"
568             " int k;",
569             fixNamespaceEndComments("namespace {\n"
570                                     "int i;\n"
571                                     "int j;\n"
572                                     "} int k;"));
573   EXPECT_EQ("namespace A {\n"
574             "int i;\n"
575             "int j;\n"
576             "}// namespace A\n"
577             " namespace B {\n"
578             "int j;\n"
579             "int k;\n"
580             "}// namespace B",
581             fixNamespaceEndComments("namespace A {\n"
582                                     "int i;\n"
583                                     "int j;\n"
584                                     "} namespace B {\n"
585                                     "int j;\n"
586                                     "int k;\n"
587                                     "}"));
588   EXPECT_EQ("namespace {\n"
589             "int i;\n"
590             "int j;\n"
591             "};// namespace\n"
592             "int k;",
593             fixNamespaceEndComments("namespace {\n"
594                                     "int i;\n"
595                                     "int j;\n"
596                                     "};int k;"));
597   EXPECT_EQ("namespace {\n"
598             "int i;\n"
599             "int j;\n"
600             "};// namespace\n"
601             ";",
602             fixNamespaceEndComments("namespace {\n"
603                                     "int i;\n"
604                                     "int j;\n"
605                                     "};;"));
606 }
607 
608 TEST_F(NamespaceEndCommentsFixerTest, DoesNotAddEndCommentForShortNamespace) {
609   EXPECT_EQ("namespace {}", fixNamespaceEndComments("namespace {}"));
610   EXPECT_EQ("namespace A {}", fixNamespaceEndComments("namespace A {}"));
611   EXPECT_EQ("namespace A { a }", fixNamespaceEndComments("namespace A { a }"));
612   EXPECT_EQ("namespace A { a };",
613             fixNamespaceEndComments("namespace A { a };"));
614 }
615 
616 TEST_F(NamespaceEndCommentsFixerTest, DoesNotAddCommentAfterUnaffectedRBrace) {
617   EXPECT_EQ("namespace A {\n"
618             "int i;\n"
619             "}",
620             fixNamespaceEndComments("namespace A {\n"
621                                     "int i;\n"
622                                     "}",
623                                     // The range (16, 3) spans the 'int' above.
624                                     /*Ranges=*/{1, tooling::Range(16, 3)}));
625   EXPECT_EQ("namespace A {\n"
626             "int i;\n"
627             "};",
628             fixNamespaceEndComments("namespace A {\n"
629                                     "int i;\n"
630                                     "};",
631                                     // The range (16, 3) spans the 'int' above.
632                                     /*Ranges=*/{1, tooling::Range(16, 3)}));
633 }
634 
635 TEST_F(NamespaceEndCommentsFixerTest,
636        DoesNotAddCommentAfterRBraceInPPDirective) {
637   EXPECT_EQ("#define SAD \\\n"
638             "namespace A { \\\n"
639             "int i; \\\n"
640             "}",
641             fixNamespaceEndComments("#define SAD \\\n"
642                                     "namespace A { \\\n"
643                                     "int i; \\\n"
644                                     "}"));
645 }
646 
647 TEST_F(NamespaceEndCommentsFixerTest, KeepsValidEndComment) {
648   EXPECT_EQ("namespace {\n"
649             "int i;\n"
650             "} // end anonymous namespace",
651             fixNamespaceEndComments("namespace {\n"
652                                     "int i;\n"
653                                     "} // end anonymous namespace"));
654   EXPECT_EQ("namespace A {\n"
655             "int i;\n"
656             "} /* end of namespace A */",
657             fixNamespaceEndComments("namespace A {\n"
658                                     "int i;\n"
659                                     "} /* end of namespace A */"));
660   EXPECT_EQ("namespace A {\n"
661             "int i;\n"
662             "}   //   namespace A",
663             fixNamespaceEndComments("namespace A {\n"
664                                     "int i;\n"
665                                     "}   //   namespace A"));
666   EXPECT_EQ("namespace A::B {\n"
667             "int i;\n"
668             "} // end namespace A::B",
669             fixNamespaceEndComments("namespace A::B {\n"
670                                     "int i;\n"
671                                     "} // end namespace A::B"));
672   EXPECT_EQ("namespace A {\n"
673             "int i;\n"
674             "}; // end namespace A",
675             fixNamespaceEndComments("namespace A {\n"
676                                     "int i;\n"
677                                     "}; // end namespace A"));
678   EXPECT_EQ("namespace {\n"
679             "int i;\n"
680             "}; /* unnamed namespace */",
681             fixNamespaceEndComments("namespace {\n"
682                                     "int i;\n"
683                                     "}; /* unnamed namespace */"));
684 }
685 
686 TEST_F(NamespaceEndCommentsFixerTest, KeepsValidMacroEndComment) {
687   FormatStyle Style = getLLVMStyle();
688   Style.NamespaceMacros.push_back("TESTSUITE");
689 
690   EXPECT_EQ("TESTSUITE() {\n"
691             "int i;\n"
692             "} // end anonymous TESTSUITE()",
693             fixNamespaceEndComments("TESTSUITE() {\n"
694                                     "int i;\n"
695                                     "} // end anonymous TESTSUITE()",
696                                     Style));
697   EXPECT_EQ("TESTSUITE(A) {\n"
698             "int i;\n"
699             "} /* end of TESTSUITE(A) */",
700             fixNamespaceEndComments("TESTSUITE(A) {\n"
701                                     "int i;\n"
702                                     "} /* end of TESTSUITE(A) */",
703                                     Style));
704   EXPECT_EQ("TESTSUITE(A) {\n"
705             "int i;\n"
706             "}   //   TESTSUITE(A)",
707             fixNamespaceEndComments("TESTSUITE(A) {\n"
708                                     "int i;\n"
709                                     "}   //   TESTSUITE(A)",
710                                     Style));
711   EXPECT_EQ("TESTSUITE(A::B) {\n"
712             "int i;\n"
713             "} // end TESTSUITE(A::B)",
714             fixNamespaceEndComments("TESTSUITE(A::B) {\n"
715                                     "int i;\n"
716                                     "} // end TESTSUITE(A::B)",
717                                     Style));
718   EXPECT_EQ("TESTSUITE(A) {\n"
719             "int i;\n"
720             "}; // end TESTSUITE(A)",
721             fixNamespaceEndComments("TESTSUITE(A) {\n"
722                                     "int i;\n"
723                                     "}; // end TESTSUITE(A)",
724                                     Style));
725   EXPECT_EQ("TESTSUITE() {\n"
726             "int i;\n"
727             "}; /* unnamed TESTSUITE() */",
728             fixNamespaceEndComments("TESTSUITE() {\n"
729                                     "int i;\n"
730                                     "}; /* unnamed TESTSUITE() */",
731                                     Style));
732 }
733 
734 TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidEndLineComment) {
735   EXPECT_EQ("namespace {\n"
736             "int i;\n"
737             "} // namespace",
738             fixNamespaceEndComments("namespace {\n"
739                                     "int i;\n"
740                                     "} // namespace A"));
741   EXPECT_EQ("namespace A {\n"
742             "int i;\n"
743             "} // namespace A",
744             fixNamespaceEndComments("namespace A {\n"
745                                     "int i;\n"
746                                     "} // namespace"));
747   EXPECT_EQ("namespace A {\n"
748             "int i;\n"
749             "} // namespace A",
750             fixNamespaceEndComments("namespace A {\n"
751                                     "int i;\n"
752                                     "} //"));
753   EXPECT_EQ("namespace A {\n"
754             "int i;\n"
755             "}; // namespace A",
756             fixNamespaceEndComments("namespace A {\n"
757                                     "int i;\n"
758                                     "}; //"));
759 
760   EXPECT_EQ("namespace A {\n"
761             "int i;\n"
762             "} // namespace A",
763             fixNamespaceEndComments("namespace A {\n"
764                                     "int i;\n"
765                                     "} // banamespace A"));
766   EXPECT_EQ("namespace A {\n"
767             "int i;\n"
768             "}; // namespace A",
769             fixNamespaceEndComments("namespace A {\n"
770                                     "int i;\n"
771                                     "}; // banamespace A"));
772   // Updates invalid line comments even for short namespaces.
773   EXPECT_EQ("namespace A {} // namespace A",
774             fixNamespaceEndComments("namespace A {} // namespace"));
775   EXPECT_EQ("namespace A {}; // namespace A",
776             fixNamespaceEndComments("namespace A {}; // namespace"));
777 
778   // Update invalid comments for compacted namespaces.
779   FormatStyle CompactNamespacesStyle = getLLVMStyle();
780   CompactNamespacesStyle.CompactNamespaces = true;
781   EXPECT_EQ("namespace out { namespace in {\n"
782             "}} // namespace out::in",
783             fixNamespaceEndComments("namespace out { namespace in {\n"
784                                     "}} // namespace out",
785                                     CompactNamespacesStyle));
786   EXPECT_EQ("namespace out { namespace in {\n"
787             "}} // namespace out::in",
788             fixNamespaceEndComments("namespace out { namespace in {\n"
789                                     "}} // namespace in",
790                                     CompactNamespacesStyle));
791   EXPECT_EQ("namespace out { namespace in {\n"
792             "}\n"
793             "} // namespace out::in",
794             fixNamespaceEndComments("namespace out { namespace in {\n"
795                                     "}// banamespace in\n"
796                                     "} // namespace out",
797                                     CompactNamespacesStyle));
798   EXPECT_EQ("namespace out { namespace {\n"
799             "}} // namespace out",
800             fixNamespaceEndComments("namespace out { namespace {\n"
801                                     "}} // namespace out::",
802                                     CompactNamespacesStyle));
803 }
804 
805 TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidMacroEndLineComment) {
806   FormatStyle Style = getLLVMStyle();
807   Style.NamespaceMacros.push_back("TESTSUITE");
808 
809   EXPECT_EQ("TESTSUITE() {\n"
810             "int i;\n"
811             "} // TESTSUITE()",
812             fixNamespaceEndComments("TESTSUITE() {\n"
813                                     "int i;\n"
814                                     "} // TESTSUITE(A)",
815                                     Style));
816   EXPECT_EQ("TESTSUITE(A) {\n"
817             "int i;\n"
818             "} // TESTSUITE(A)",
819             fixNamespaceEndComments("TESTSUITE(A) {\n"
820                                     "int i;\n"
821                                     "} // TESTSUITE()",
822                                     Style));
823   EXPECT_EQ("TESTSUITE(A) {\n"
824             "int i;\n"
825             "} // TESTSUITE(A)",
826             fixNamespaceEndComments("TESTSUITE(A) {\n"
827                                     "int i;\n"
828                                     "} //",
829                                     Style));
830   EXPECT_EQ("TESTSUITE(A) {\n"
831             "int i;\n"
832             "}; // TESTSUITE(A)",
833             fixNamespaceEndComments("TESTSUITE(A) {\n"
834                                     "int i;\n"
835                                     "}; //",
836                                     Style));
837   EXPECT_EQ("TESTSUITE(A) {\n"
838             "int i;\n"
839             "} // TESTSUITE(A)",
840             fixNamespaceEndComments("TESTSUITE(A) {\n"
841                                     "int i;\n"
842                                     "} // TESTSUITE A",
843                                     Style));
844   EXPECT_EQ("TESTSUITE() {\n"
845             "int i;\n"
846             "} // TESTSUITE()",
847             fixNamespaceEndComments("TESTSUITE() {\n"
848                                     "int i;\n"
849                                     "} // TESTSUITE",
850                                     Style));
851   EXPECT_EQ("TESTSUITE(A) {\n"
852             "int i;\n"
853             "} // TESTSUITE(A)",
854             fixNamespaceEndComments("TESTSUITE(A) {\n"
855                                     "int i;\n"
856                                     "} // TOASTSUITE(A)",
857                                     Style));
858   EXPECT_EQ("TESTSUITE(A) {\n"
859             "int i;\n"
860             "}; // TESTSUITE(A)",
861             fixNamespaceEndComments("TESTSUITE(A) {\n"
862                                     "int i;\n"
863                                     "}; // TOASTSUITE(A)",
864                                     Style));
865   // Updates invalid line comments even for short namespaces.
866   EXPECT_EQ("TESTSUITE(A) {} // TESTSUITE(A)",
867             fixNamespaceEndComments("TESTSUITE(A) {} // TESTSUITE()", Style));
868   EXPECT_EQ("TESTSUITE(A) {}; // TESTSUITE(A)",
869             fixNamespaceEndComments("TESTSUITE(A) {}; // TESTSUITE()", Style));
870 
871   // Update invalid comments for compacted namespaces.
872   FormatStyle CompactNamespacesStyle = getLLVMStyle();
873   CompactNamespacesStyle.CompactNamespaces = true;
874   CompactNamespacesStyle.NamespaceMacros.push_back("TESTSUITE");
875 
876   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
877             "}} // TESTSUITE(out::in)",
878             fixNamespaceEndComments("TESTSUITE(out) { TESTSUITE(in) {\n"
879                                     "}} // TESTSUITE(out)",
880                                     CompactNamespacesStyle));
881   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
882             "}} // TESTSUITE(out::in)",
883             fixNamespaceEndComments("TESTSUITE(out) { TESTSUITE(in) {\n"
884                                     "}} // TESTSUITE(in)",
885                                     CompactNamespacesStyle));
886   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
887             "}\n"
888             "} // TESTSUITE(out::in)",
889             fixNamespaceEndComments("TESTSUITE(out) { TESTSUITE(in) {\n"
890                                     "}// TAOSTSUITE(in)\n"
891                                     "} // TESTSUITE(out)",
892                                     CompactNamespacesStyle));
893 }
894 
895 TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidEndBlockComment) {
896   EXPECT_EQ("namespace {\n"
897             "int i;\n"
898             "} // namespace",
899             fixNamespaceEndComments("namespace {\n"
900                                     "int i;\n"
901                                     "} /* namespace A */"));
902   EXPECT_EQ("namespace A {\n"
903             "int i;\n"
904             "}  // namespace A",
905             fixNamespaceEndComments("namespace A {\n"
906                                     "int i;\n"
907                                     "}  /* end namespace */"));
908   EXPECT_EQ("namespace A {\n"
909             "int i;\n"
910             "} // namespace A",
911             fixNamespaceEndComments("namespace A {\n"
912                                     "int i;\n"
913                                     "} /**/"));
914   EXPECT_EQ("namespace A {\n"
915             "int i;\n"
916             "} // namespace A",
917             fixNamespaceEndComments("namespace A {\n"
918                                     "int i;\n"
919                                     "} /* end unnamed namespace */"));
920   EXPECT_EQ("namespace A {\n"
921             "int i;\n"
922             "} // namespace A",
923             fixNamespaceEndComments("namespace A {\n"
924                                     "int i;\n"
925                                     "} /* banamespace A */"));
926   EXPECT_EQ("namespace A {\n"
927             "int i;\n"
928             "}; // namespace A",
929             fixNamespaceEndComments("namespace A {\n"
930                                     "int i;\n"
931                                     "}; /* banamespace A */"));
932   EXPECT_EQ("namespace A {} // namespace A",
933             fixNamespaceEndComments("namespace A {} /**/"));
934   EXPECT_EQ("namespace A {}; // namespace A",
935             fixNamespaceEndComments("namespace A {}; /**/"));
936 }
937 
938 TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidMacroEndBlockComment) {
939   FormatStyle Style = getLLVMStyle();
940   Style.NamespaceMacros.push_back("TESTSUITE");
941 
942   EXPECT_EQ("TESTSUITE() {\n"
943             "int i;\n"
944             "} // TESTSUITE()",
945             fixNamespaceEndComments("TESTSUITE() {\n"
946                                     "int i;\n"
947                                     "} /* TESTSUITE(A) */",
948                                     Style));
949   EXPECT_EQ("TESTSUITE(A) {\n"
950             "int i;\n"
951             "}  // TESTSUITE(A)",
952             fixNamespaceEndComments("TESTSUITE(A) {\n"
953                                     "int i;\n"
954                                     "}  /* end TESTSUITE() */",
955                                     Style));
956   EXPECT_EQ("TESTSUITE(A) {\n"
957             "int i;\n"
958             "} // TESTSUITE(A)",
959             fixNamespaceEndComments("TESTSUITE(A) {\n"
960                                     "int i;\n"
961                                     "} /**/",
962                                     Style));
963   EXPECT_EQ("TESTSUITE(A) {\n"
964             "int i;\n"
965             "} // TESTSUITE(A)",
966             fixNamespaceEndComments("TESTSUITE(A) {\n"
967                                     "int i;\n"
968                                     "} /* end unnamed TESTSUITE() */",
969                                     Style));
970   EXPECT_EQ("TESTSUITE(A) {\n"
971             "int i;\n"
972             "} // TESTSUITE(A)",
973             fixNamespaceEndComments("TESTSUITE(A) {\n"
974                                     "int i;\n"
975                                     "} /* TOASTSUITE(A) */",
976                                     Style));
977   EXPECT_EQ("TESTSUITE(A) {\n"
978             "int i;\n"
979             "}; // TESTSUITE(A)",
980             fixNamespaceEndComments("TESTSUITE(A) {\n"
981                                     "int i;\n"
982                                     "}; /* TAOSTSUITE(A) */",
983                                     Style));
984   EXPECT_EQ("TESTSUITE(A) {} // TESTSUITE(A)",
985             fixNamespaceEndComments("TESTSUITE(A) {} /**/", Style));
986   EXPECT_EQ("TESTSUITE(A) {}; // TESTSUITE(A)",
987             fixNamespaceEndComments("TESTSUITE(A) {}; /**/", Style));
988 }
989 
990 TEST_F(NamespaceEndCommentsFixerTest,
991        DoesNotAddEndCommentForNamespacesControlledByMacros) {
992   EXPECT_EQ("#ifdef 1\n"
993             "namespace A {\n"
994             "#elseif\n"
995             "namespace B {\n"
996             "#endif\n"
997             "int i;\n"
998             "}\n"
999             "}\n",
1000             fixNamespaceEndComments("#ifdef 1\n"
1001                                     "namespace A {\n"
1002                                     "#elseif\n"
1003                                     "namespace B {\n"
1004                                     "#endif\n"
1005                                     "int i;\n"
1006                                     "}\n"
1007                                     "}\n"));
1008 }
1009 
1010 TEST_F(NamespaceEndCommentsFixerTest, AddsEndCommentForNamespacesAroundMacros) {
1011   // Conditional blocks around are fine
1012   EXPECT_EQ("namespace A {\n"
1013             "#if 1\n"
1014             "int i;\n"
1015             "#endif\n"
1016             "}// namespace A",
1017             fixNamespaceEndComments("namespace A {\n"
1018                                     "#if 1\n"
1019                                     "int i;\n"
1020                                     "#endif\n"
1021                                     "}"));
1022   EXPECT_EQ("#if 1\n"
1023             "#endif\n"
1024             "namespace A {\n"
1025             "int i;\n"
1026             "int j;\n"
1027             "}// namespace A",
1028             fixNamespaceEndComments("#if 1\n"
1029                                     "#endif\n"
1030                                     "namespace A {\n"
1031                                     "int i;\n"
1032                                     "int j;\n"
1033                                     "}"));
1034   EXPECT_EQ("namespace A {\n"
1035             "int i;\n"
1036             "int j;\n"
1037             "}// namespace A\n"
1038             "#if 1\n"
1039             "#endif",
1040             fixNamespaceEndComments("namespace A {\n"
1041                                     "int i;\n"
1042                                     "int j;\n"
1043                                     "}\n"
1044                                     "#if 1\n"
1045                                     "#endif"));
1046   EXPECT_EQ("#if 1\n"
1047             "namespace A {\n"
1048             "int i;\n"
1049             "int j;\n"
1050             "}// namespace A\n"
1051             "#endif",
1052             fixNamespaceEndComments("#if 1\n"
1053                                     "namespace A {\n"
1054                                     "int i;\n"
1055                                     "int j;\n"
1056                                     "}\n"
1057                                     "#endif"));
1058 
1059   // Macro definition has no impact
1060   EXPECT_EQ("namespace A {\n"
1061             "#define FOO\n"
1062             "int i;\n"
1063             "}// namespace A",
1064             fixNamespaceEndComments("namespace A {\n"
1065                                     "#define FOO\n"
1066                                     "int i;\n"
1067                                     "}"));
1068   EXPECT_EQ("#define FOO\n"
1069             "namespace A {\n"
1070             "int i;\n"
1071             "int j;\n"
1072             "}// namespace A",
1073             fixNamespaceEndComments("#define FOO\n"
1074                                     "namespace A {\n"
1075                                     "int i;\n"
1076                                     "int j;\n"
1077                                     "}"));
1078   EXPECT_EQ("namespace A {\n"
1079             "int i;\n"
1080             "int j;\n"
1081             "}// namespace A\n"
1082             "#define FOO\n",
1083             fixNamespaceEndComments("namespace A {\n"
1084                                     "int i;\n"
1085                                     "int j;\n"
1086                                     "}\n"
1087                                     "#define FOO\n"));
1088 
1089   // No replacement if open & close in different conditional blocks
1090   EXPECT_EQ("#if 1\n"
1091             "namespace A {\n"
1092             "#endif\n"
1093             "int i;\n"
1094             "int j;\n"
1095             "#if 1\n"
1096             "}\n"
1097             "#endif",
1098             fixNamespaceEndComments("#if 1\n"
1099                                     "namespace A {\n"
1100                                     "#endif\n"
1101                                     "int i;\n"
1102                                     "int j;\n"
1103                                     "#if 1\n"
1104                                     "}\n"
1105                                     "#endif"));
1106   EXPECT_EQ("#ifdef A\n"
1107             "namespace A {\n"
1108             "#endif\n"
1109             "int i;\n"
1110             "int j;\n"
1111             "#ifdef B\n"
1112             "}\n"
1113             "#endif",
1114             fixNamespaceEndComments("#ifdef A\n"
1115                                     "namespace A {\n"
1116                                     "#endif\n"
1117                                     "int i;\n"
1118                                     "int j;\n"
1119                                     "#ifdef B\n"
1120                                     "}\n"
1121                                     "#endif"));
1122 
1123   // No replacement inside unreachable conditional block
1124   EXPECT_EQ("#if 0\n"
1125             "namespace A {\n"
1126             "int i;\n"
1127             "int j;\n"
1128             "}\n"
1129             "#endif",
1130             fixNamespaceEndComments("#if 0\n"
1131                                     "namespace A {\n"
1132                                     "int i;\n"
1133                                     "int j;\n"
1134                                     "}\n"
1135                                     "#endif"));
1136 }
1137 
1138 TEST_F(NamespaceEndCommentsFixerTest,
1139        DoesNotAddEndCommentForNamespacesInMacroDeclarations) {
1140   EXPECT_EQ("#ifdef 1\n"
1141             "namespace A {\n"
1142             "#elseif\n"
1143             "namespace B {\n"
1144             "#endif\n"
1145             "int i;\n"
1146             "}\n"
1147             "}\n",
1148             fixNamespaceEndComments("#ifdef 1\n"
1149                                     "namespace A {\n"
1150                                     "#elseif\n"
1151                                     "namespace B {\n"
1152                                     "#endif\n"
1153                                     "int i;\n"
1154                                     "}\n"
1155                                     "}\n"));
1156   EXPECT_EQ("namespace {\n"
1157             "int i;\n"
1158             "int j;\n"
1159             "}// namespace\n"
1160             "#if A\n"
1161             "int i;\n"
1162             "#else\n"
1163             "int j;\n"
1164             "#endif",
1165             fixNamespaceEndComments("namespace {\n"
1166                                     "int i;\n"
1167                                     "int j;\n"
1168                                     "}\n"
1169                                     "#if A\n"
1170                                     "int i;\n"
1171                                     "#else\n"
1172                                     "int j;\n"
1173                                     "#endif"));
1174   EXPECT_EQ("#if A\n"
1175             "namespace A {\n"
1176             "#else\n"
1177             "namespace B {\n"
1178             "#endif\n"
1179             "int i;\n"
1180             "int j;\n"
1181             "}",
1182             fixNamespaceEndComments("#if A\n"
1183                                     "namespace A {\n"
1184                                     "#else\n"
1185                                     "namespace B {\n"
1186                                     "#endif\n"
1187                                     "int i;\n"
1188                                     "int j;\n"
1189                                     "}"));
1190   EXPECT_EQ("#if A\n"
1191             "namespace A {\n"
1192             "#else\n"
1193             "namespace B {\n"
1194             "#endif\n"
1195             "int i;\n"
1196             "int j;\n"
1197             "} // namespace A",
1198             fixNamespaceEndComments("#if A\n"
1199                                     "namespace A {\n"
1200                                     "#else\n"
1201                                     "namespace B {\n"
1202                                     "#endif\n"
1203                                     "int i;\n"
1204                                     "int j;\n"
1205                                     "} // namespace A"));
1206   EXPECT_EQ("#if A\n"
1207             "namespace A {\n"
1208             "#else\n"
1209             "namespace B {\n"
1210             "#endif\n"
1211             "int i;\n"
1212             "int j;\n"
1213             "} // namespace B",
1214             fixNamespaceEndComments("#if A\n"
1215                                     "namespace A {\n"
1216                                     "#else\n"
1217                                     "namespace B {\n"
1218                                     "#endif\n"
1219                                     "int i;\n"
1220                                     "int j;\n"
1221                                     "} // namespace B"));
1222   EXPECT_EQ("namespace A\n"
1223             "int i;\n"
1224             "int j;\n"
1225             "#if A\n"
1226             "}\n"
1227             "#else\n"
1228             "}\n"
1229             "#endif",
1230             fixNamespaceEndComments("namespace A\n"
1231                                     "int i;\n"
1232                                     "int j;\n"
1233                                     "#if A\n"
1234                                     "}\n"
1235                                     "#else\n"
1236                                     "}\n"
1237                                     "#endif"));
1238   EXPECT_EQ("namespace A\n"
1239             "int i;\n"
1240             "int j;\n"
1241             "#if A\n"
1242             "} // namespace A\n"
1243             "#else\n"
1244             "} // namespace A\n"
1245             "#endif",
1246             fixNamespaceEndComments("namespace A\n"
1247                                     "int i;\n"
1248                                     "int j;\n"
1249                                     "#if A\n"
1250                                     "} // namespace A\n"
1251                                     "#else\n"
1252                                     "} // namespace A\n"
1253                                     "#endif"));
1254 }
1255 
1256 TEST_F(NamespaceEndCommentsFixerTest,
1257        DoesNotAddEndCommentForUnbalancedRBracesAfterNamespaceEnd) {
1258   EXPECT_EQ("namespace {\n"
1259             "int i;\n"
1260             "} // namespace\n"
1261             "}",
1262             fixNamespaceEndComments("namespace {\n"
1263                                     "int i;\n"
1264                                     "} // namespace\n"
1265                                     "}"));
1266 }
1267 
1268 TEST_F(NamespaceEndCommentsFixerTest, HandlesInlineAtEndOfLine_PR32438) {
1269   EXPECT_EQ("template <int> struct a {};\n"
1270             "struct a<bool{}> b() {\n"
1271             "}\n"
1272             "#define c inline\n"
1273             "void d() {\n"
1274             "}\n",
1275             fixNamespaceEndComments("template <int> struct a {};\n"
1276                                     "struct a<bool{}> b() {\n"
1277                                     "}\n"
1278                                     "#define c inline\n"
1279                                     "void d() {\n"
1280                                     "}\n"));
1281 }
1282 
1283 TEST_F(NamespaceEndCommentsFixerTest, IgnoreUnbalanced) {
1284   EXPECT_EQ("namespace A {\n"
1285             "class Foo {\n"
1286             "}\n"
1287             "}// namespace A\n",
1288             fixNamespaceEndComments("namespace A {\n"
1289                                     "class Foo {\n"
1290                                     "}\n"
1291                                     "}\n"));
1292   EXPECT_EQ("namespace A {\n"
1293             "class Foo {\n"
1294             "}\n",
1295             fixNamespaceEndComments("namespace A {\n"
1296                                     "class Foo {\n"
1297                                     "}\n"));
1298 
1299   EXPECT_EQ("namespace A {\n"
1300             "class Foo {\n"
1301             "}\n"
1302             "}\n"
1303             "}\n",
1304             fixNamespaceEndComments("namespace A {\n"
1305                                     "class Foo {\n"
1306                                     "}\n"
1307                                     "}\n"
1308                                     "}\n"));
1309 }
1310 
1311 using ShortNamespaceLinesTest = NamespaceEndCommentsFixerTest;
1312 
1313 TEST_F(ShortNamespaceLinesTest, ZeroUnwrappedLines) {
1314   auto Style = getLLVMStyle();
1315   Style.ShortNamespaceLines = 0u;
1316 
1317   EXPECT_EQ("namespace OneLinerNamespace {}\n",
1318             fixNamespaceEndComments("namespace OneLinerNamespace {}\n", Style));
1319   EXPECT_EQ("namespace ShortNamespace {\n"
1320             "}\n",
1321             fixNamespaceEndComments("namespace ShortNamespace {\n"
1322                                     "}\n",
1323                                     Style));
1324   EXPECT_EQ("namespace LongNamespace {\n"
1325             "int i;\n"
1326             "}// namespace LongNamespace\n",
1327             fixNamespaceEndComments("namespace LongNamespace {\n"
1328                                     "int i;\n"
1329                                     "}\n",
1330                                     Style));
1331 }
1332 
1333 TEST_F(ShortNamespaceLinesTest, OneUnwrappedLine) {
1334   constexpr auto DefaultUnwrappedLines = 1u;
1335   auto const Style = getLLVMStyle();
1336 
1337   EXPECT_EQ(DefaultUnwrappedLines, Style.ShortNamespaceLines);
1338   EXPECT_EQ("namespace ShortNamespace {\n"
1339             "int i;\n"
1340             "}\n",
1341             fixNamespaceEndComments("namespace ShortNamespace {\n"
1342                                     "int i;\n"
1343                                     "}\n"));
1344   EXPECT_EQ("namespace LongNamespace {\n"
1345             "int i;\n"
1346             "int j;\n"
1347             "}// namespace LongNamespace\n",
1348             fixNamespaceEndComments("namespace LongNamespace {\n"
1349                                     "int i;\n"
1350                                     "int j;\n"
1351                                     "}\n"));
1352 }
1353 
1354 TEST_F(ShortNamespaceLinesTest, MultipleUnwrappedLine) {
1355   auto Style = getLLVMStyle();
1356   Style.ShortNamespaceLines = 2u;
1357 
1358   EXPECT_EQ("namespace ShortNamespace {\n"
1359             "int i;\n"
1360             "int j;\n"
1361             "}\n",
1362             fixNamespaceEndComments("namespace ShortNamespace {\n"
1363                                     "int i;\n"
1364                                     "int j;\n"
1365                                     "}\n",
1366                                     Style));
1367   EXPECT_EQ("namespace LongNamespace {\n"
1368             "int i;\n"
1369             "int j;\n"
1370             "int k;\n"
1371             "}// namespace LongNamespace\n",
1372             fixNamespaceEndComments("namespace LongNamespace {\n"
1373                                     "int i;\n"
1374                                     "int j;\n"
1375                                     "int k;\n"
1376                                     "}\n",
1377                                     Style));
1378 }
1379 
1380 TEST_F(ShortNamespaceLinesTest, NamespaceAlias) {
1381   auto Style = getLLVMStyle();
1382 
1383   EXPECT_EQ("namespace n = nn;\n"
1384             "{\n"
1385             "  int i;\n"
1386             "  int j;\n"
1387             "}\n",
1388             fixNamespaceEndComments("namespace n = nn;\n"
1389                                     "{\n"
1390                                     "  int i;\n"
1391                                     "  int j;\n"
1392                                     "}\n",
1393                                     Style));
1394 
1395   EXPECT_EQ("namespace n = nn; // comment\n"
1396             "{\n"
1397             "  int i;\n"
1398             "  int j;\n"
1399             "}\n",
1400             fixNamespaceEndComments("namespace n = nn; // comment\n"
1401                                     "{\n"
1402                                     "  int i;\n"
1403                                     "  int j;\n"
1404                                     "}\n",
1405                                     Style));
1406 
1407   EXPECT_EQ("namespace n = nn; /* comment */\n"
1408             "{\n"
1409             "  int i;\n"
1410             "  int j;\n"
1411             "}\n",
1412             fixNamespaceEndComments("namespace n = nn; /* comment */\n"
1413                                     "{\n"
1414                                     "  int i;\n"
1415                                     "  int j;\n"
1416                                     "}\n",
1417                                     Style));
1418 
1419   EXPECT_EQ(
1420       "namespace n = nn; /* comment */ /* comment2 */\n"
1421       "{\n"
1422       "  int i;\n"
1423       "  int j;\n"
1424       "}\n",
1425       fixNamespaceEndComments("namespace n = nn; /* comment */ /* comment2 */\n"
1426                               "{\n"
1427                               "  int i;\n"
1428                               "  int j;\n"
1429                               "}\n",
1430                               Style));
1431 
1432   EXPECT_EQ("namespace n = nn; {\n"
1433             "  int i;\n"
1434             "  int j;\n"
1435             "}\n",
1436             fixNamespaceEndComments("namespace n = nn; {\n"
1437                                     "  int i;\n"
1438                                     "  int j;\n"
1439                                     "}\n",
1440                                     Style));
1441   EXPECT_EQ("int foo;\n"
1442             "namespace n\n"
1443             "{\n"
1444             "  int i;\n"
1445             "  int j;\n"
1446             "}// namespace n\n",
1447             fixNamespaceEndComments("int foo;\n"
1448                                     "namespace n\n"
1449                                     "{\n"
1450                                     "  int i;\n"
1451                                     "  int j;\n"
1452                                     "}\n",
1453                                     Style));
1454 }
1455 } // end namespace
1456 } // end namespace format
1457 } // end namespace clang
1458