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                                     "}",
473                                     ObjCppStyle));
474 }
475 
476 TEST_F(NamespaceEndCommentsFixerTest, AddsMacroEndComment) {
477   FormatStyle Style = getLLVMStyle();
478   Style.NamespaceMacros.push_back("TESTSUITE");
479 
480   EXPECT_EQ("TESTSUITE() {\n"
481             "int i;\n"
482             "int j;\n"
483             "}// TESTSUITE()",
484             fixNamespaceEndComments("TESTSUITE() {\n"
485                                     "int i;\n"
486                                     "int j;\n"
487                                     "}",
488                                     Style));
489 
490   EXPECT_EQ("TESTSUITE(A) {\n"
491             "int i;\n"
492             "int j;\n"
493             "}// TESTSUITE(A)",
494             fixNamespaceEndComments("TESTSUITE(A) {\n"
495                                     "int i;\n"
496                                     "int j;\n"
497                                     "}",
498                                     Style));
499   EXPECT_EQ("inline TESTSUITE(A) {\n"
500             "int i;\n"
501             "int j;\n"
502             "}// TESTSUITE(A)",
503             fixNamespaceEndComments("inline TESTSUITE(A) {\n"
504                                     "int i;\n"
505                                     "int j;\n"
506                                     "}",
507                                     Style));
508   EXPECT_EQ("TESTSUITE(::A) {\n"
509             "int i;\n"
510             "int j;\n"
511             "}// TESTSUITE(::A)",
512             fixNamespaceEndComments("TESTSUITE(::A) {\n"
513                                     "int i;\n"
514                                     "int j;\n"
515                                     "}",
516                                     Style));
517   EXPECT_EQ("TESTSUITE(::A::B) {\n"
518             "int i;\n"
519             "int j;\n"
520             "}// TESTSUITE(::A::B)",
521             fixNamespaceEndComments("TESTSUITE(::A::B) {\n"
522                                     "int i;\n"
523                                     "int j;\n"
524                                     "}",
525                                     Style));
526   EXPECT_EQ("TESTSUITE(/**/::/**/A/**/::/**/B/**/) {\n"
527             "int i;\n"
528             "int j;\n"
529             "}// TESTSUITE(::A::B)",
530             fixNamespaceEndComments("TESTSUITE(/**/::/**/A/**/::/**/B/**/) {\n"
531                                     "int i;\n"
532                                     "int j;\n"
533                                     "}",
534                                     Style));
535   EXPECT_EQ("TESTSUITE(A, B) {\n"
536             "int i;\n"
537             "int j;\n"
538             "}// TESTSUITE(A)",
539             fixNamespaceEndComments("TESTSUITE(A, B) {\n"
540                                     "int i;\n"
541                                     "int j;\n"
542                                     "}",
543                                     Style));
544   EXPECT_EQ("TESTSUITE(\"Test1\") {\n"
545             "int i;\n"
546             "int j;\n"
547             "}// TESTSUITE(\"Test1\")",
548             fixNamespaceEndComments("TESTSUITE(\"Test1\") {\n"
549                                     "int i;\n"
550                                     "int j;\n"
551                                     "}",
552                                     Style));
553 }
554 
555 TEST_F(NamespaceEndCommentsFixerTest, AddsNewlineIfNeeded) {
556   EXPECT_EQ("namespace A {\n"
557             "int i;\n"
558             "int j;\n"
559             "}// namespace A\n"
560             " int k;",
561             fixNamespaceEndComments("namespace A {\n"
562                                     "int i;\n"
563                                     "int j;\n"
564                                     "} int k;"));
565   EXPECT_EQ("namespace {\n"
566             "int i;\n"
567             "int j;\n"
568             "}// namespace\n"
569             " int k;",
570             fixNamespaceEndComments("namespace {\n"
571                                     "int i;\n"
572                                     "int j;\n"
573                                     "} int k;"));
574   EXPECT_EQ("namespace A {\n"
575             "int i;\n"
576             "int j;\n"
577             "}// namespace A\n"
578             " namespace B {\n"
579             "int j;\n"
580             "int k;\n"
581             "}// namespace B",
582             fixNamespaceEndComments("namespace A {\n"
583                                     "int i;\n"
584                                     "int j;\n"
585                                     "} namespace B {\n"
586                                     "int j;\n"
587                                     "int k;\n"
588                                     "}"));
589   EXPECT_EQ("namespace {\n"
590             "int i;\n"
591             "int j;\n"
592             "};// namespace\n"
593             "int k;",
594             fixNamespaceEndComments("namespace {\n"
595                                     "int i;\n"
596                                     "int j;\n"
597                                     "};int k;"));
598   EXPECT_EQ("namespace {\n"
599             "int i;\n"
600             "int j;\n"
601             "};// namespace\n"
602             ";",
603             fixNamespaceEndComments("namespace {\n"
604                                     "int i;\n"
605                                     "int j;\n"
606                                     "};;"));
607 }
608 
609 TEST_F(NamespaceEndCommentsFixerTest, DoesNotAddEndCommentForShortNamespace) {
610   EXPECT_EQ("namespace {}", fixNamespaceEndComments("namespace {}"));
611   EXPECT_EQ("namespace A {}", fixNamespaceEndComments("namespace A {}"));
612   EXPECT_EQ("namespace A { a }", fixNamespaceEndComments("namespace A { a }"));
613   EXPECT_EQ("namespace A { a };",
614             fixNamespaceEndComments("namespace A { a };"));
615 }
616 
617 TEST_F(NamespaceEndCommentsFixerTest, DoesNotAddCommentAfterUnaffectedRBrace) {
618   EXPECT_EQ("namespace A {\n"
619             "int i;\n"
620             "}",
621             fixNamespaceEndComments("namespace A {\n"
622                                     "int i;\n"
623                                     "}",
624                                     // The range (16, 3) spans the 'int' above.
625                                     /*Ranges=*/{1, tooling::Range(16, 3)}));
626   EXPECT_EQ("namespace A {\n"
627             "int i;\n"
628             "};",
629             fixNamespaceEndComments("namespace A {\n"
630                                     "int i;\n"
631                                     "};",
632                                     // The range (16, 3) spans the 'int' above.
633                                     /*Ranges=*/{1, tooling::Range(16, 3)}));
634 }
635 
636 TEST_F(NamespaceEndCommentsFixerTest,
637        DoesNotAddCommentAfterRBraceInPPDirective) {
638   EXPECT_EQ("#define SAD \\\n"
639             "namespace A { \\\n"
640             "int i; \\\n"
641             "}",
642             fixNamespaceEndComments("#define SAD \\\n"
643                                     "namespace A { \\\n"
644                                     "int i; \\\n"
645                                     "}"));
646 }
647 
648 TEST_F(NamespaceEndCommentsFixerTest, KeepsValidEndComment) {
649   EXPECT_EQ("namespace {\n"
650             "int i;\n"
651             "} // end anonymous namespace",
652             fixNamespaceEndComments("namespace {\n"
653                                     "int i;\n"
654                                     "} // end anonymous namespace"));
655   EXPECT_EQ("namespace A {\n"
656             "int i;\n"
657             "} /* end of namespace A */",
658             fixNamespaceEndComments("namespace A {\n"
659                                     "int i;\n"
660                                     "} /* end of namespace A */"));
661   EXPECT_EQ("namespace A {\n"
662             "int i;\n"
663             "}   //   namespace A",
664             fixNamespaceEndComments("namespace A {\n"
665                                     "int i;\n"
666                                     "}   //   namespace A"));
667   EXPECT_EQ("namespace A::B {\n"
668             "int i;\n"
669             "} // end namespace A::B",
670             fixNamespaceEndComments("namespace A::B {\n"
671                                     "int i;\n"
672                                     "} // end namespace A::B"));
673   EXPECT_EQ("namespace A {\n"
674             "int i;\n"
675             "}; // end namespace A",
676             fixNamespaceEndComments("namespace A {\n"
677                                     "int i;\n"
678                                     "}; // end namespace A"));
679   EXPECT_EQ("namespace {\n"
680             "int i;\n"
681             "}; /* unnamed namespace */",
682             fixNamespaceEndComments("namespace {\n"
683                                     "int i;\n"
684                                     "}; /* unnamed namespace */"));
685 }
686 
687 TEST_F(NamespaceEndCommentsFixerTest, KeepsValidMacroEndComment) {
688   FormatStyle Style = getLLVMStyle();
689   Style.NamespaceMacros.push_back("TESTSUITE");
690 
691   EXPECT_EQ("TESTSUITE() {\n"
692             "int i;\n"
693             "} // end anonymous TESTSUITE()",
694             fixNamespaceEndComments("TESTSUITE() {\n"
695                                     "int i;\n"
696                                     "} // end anonymous TESTSUITE()",
697                                     Style));
698   EXPECT_EQ("TESTSUITE(A) {\n"
699             "int i;\n"
700             "} /* end of TESTSUITE(A) */",
701             fixNamespaceEndComments("TESTSUITE(A) {\n"
702                                     "int i;\n"
703                                     "} /* end of TESTSUITE(A) */",
704                                     Style));
705   EXPECT_EQ("TESTSUITE(A) {\n"
706             "int i;\n"
707             "}   //   TESTSUITE(A)",
708             fixNamespaceEndComments("TESTSUITE(A) {\n"
709                                     "int i;\n"
710                                     "}   //   TESTSUITE(A)",
711                                     Style));
712   EXPECT_EQ("TESTSUITE(A::B) {\n"
713             "int i;\n"
714             "} // end TESTSUITE(A::B)",
715             fixNamespaceEndComments("TESTSUITE(A::B) {\n"
716                                     "int i;\n"
717                                     "} // end TESTSUITE(A::B)",
718                                     Style));
719   EXPECT_EQ("TESTSUITE(A) {\n"
720             "int i;\n"
721             "}; // end TESTSUITE(A)",
722             fixNamespaceEndComments("TESTSUITE(A) {\n"
723                                     "int i;\n"
724                                     "}; // end TESTSUITE(A)",
725                                     Style));
726   EXPECT_EQ("TESTSUITE() {\n"
727             "int i;\n"
728             "}; /* unnamed TESTSUITE() */",
729             fixNamespaceEndComments("TESTSUITE() {\n"
730                                     "int i;\n"
731                                     "}; /* unnamed TESTSUITE() */",
732                                     Style));
733 }
734 
735 TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidEndLineComment) {
736   EXPECT_EQ("namespace {\n"
737             "int i;\n"
738             "} // namespace",
739             fixNamespaceEndComments("namespace {\n"
740                                     "int i;\n"
741                                     "} // namespace A"));
742   EXPECT_EQ("namespace A {\n"
743             "int i;\n"
744             "} // namespace A",
745             fixNamespaceEndComments("namespace A {\n"
746                                     "int i;\n"
747                                     "} // namespace"));
748   EXPECT_EQ("namespace A {\n"
749             "int i;\n"
750             "} // namespace A",
751             fixNamespaceEndComments("namespace A {\n"
752                                     "int i;\n"
753                                     "} //"));
754   EXPECT_EQ("namespace A {\n"
755             "int i;\n"
756             "}; // namespace A",
757             fixNamespaceEndComments("namespace A {\n"
758                                     "int i;\n"
759                                     "}; //"));
760 
761   EXPECT_EQ("namespace A {\n"
762             "int i;\n"
763             "} // namespace A",
764             fixNamespaceEndComments("namespace A {\n"
765                                     "int i;\n"
766                                     "} // banamespace A"));
767   EXPECT_EQ("namespace A {\n"
768             "int i;\n"
769             "}; // namespace A",
770             fixNamespaceEndComments("namespace A {\n"
771                                     "int i;\n"
772                                     "}; // banamespace A"));
773   // Updates invalid line comments even for short namespaces.
774   EXPECT_EQ("namespace A {} // namespace A",
775             fixNamespaceEndComments("namespace A {} // namespace"));
776   EXPECT_EQ("namespace A {}; // namespace A",
777             fixNamespaceEndComments("namespace A {}; // namespace"));
778 
779   // Update invalid comments for compacted namespaces.
780   FormatStyle CompactNamespacesStyle = getLLVMStyle();
781   CompactNamespacesStyle.CompactNamespaces = true;
782   EXPECT_EQ("namespace out { namespace in {\n"
783             "}} // namespace out::in",
784             fixNamespaceEndComments("namespace out { namespace in {\n"
785                                     "}} // namespace out",
786                                     CompactNamespacesStyle));
787   EXPECT_EQ("namespace out { namespace in {\n"
788             "}} // namespace out::in",
789             fixNamespaceEndComments("namespace out { namespace in {\n"
790                                     "}} // namespace in",
791                                     CompactNamespacesStyle));
792   EXPECT_EQ("namespace out { namespace in {\n"
793             "}\n"
794             "} // namespace out::in",
795             fixNamespaceEndComments("namespace out { namespace in {\n"
796                                     "}// banamespace in\n"
797                                     "} // namespace out",
798                                     CompactNamespacesStyle));
799   EXPECT_EQ("namespace out { namespace {\n"
800             "}} // namespace out",
801             fixNamespaceEndComments("namespace out { namespace {\n"
802                                     "}} // namespace out::",
803                                     CompactNamespacesStyle));
804 }
805 
806 TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidMacroEndLineComment) {
807   FormatStyle Style = getLLVMStyle();
808   Style.NamespaceMacros.push_back("TESTSUITE");
809 
810   EXPECT_EQ("TESTSUITE() {\n"
811             "int i;\n"
812             "} // TESTSUITE()",
813             fixNamespaceEndComments("TESTSUITE() {\n"
814                                     "int i;\n"
815                                     "} // TESTSUITE(A)",
816                                     Style));
817   EXPECT_EQ("TESTSUITE(A) {\n"
818             "int i;\n"
819             "} // TESTSUITE(A)",
820             fixNamespaceEndComments("TESTSUITE(A) {\n"
821                                     "int i;\n"
822                                     "} // TESTSUITE()",
823                                     Style));
824   EXPECT_EQ("TESTSUITE(A) {\n"
825             "int i;\n"
826             "} // TESTSUITE(A)",
827             fixNamespaceEndComments("TESTSUITE(A) {\n"
828                                     "int i;\n"
829                                     "} //",
830                                     Style));
831   EXPECT_EQ("TESTSUITE(A) {\n"
832             "int i;\n"
833             "}; // TESTSUITE(A)",
834             fixNamespaceEndComments("TESTSUITE(A) {\n"
835                                     "int i;\n"
836                                     "}; //",
837                                     Style));
838   EXPECT_EQ("TESTSUITE(A) {\n"
839             "int i;\n"
840             "} // TESTSUITE(A)",
841             fixNamespaceEndComments("TESTSUITE(A) {\n"
842                                     "int i;\n"
843                                     "} // TESTSUITE A",
844                                     Style));
845   EXPECT_EQ("TESTSUITE() {\n"
846             "int i;\n"
847             "} // TESTSUITE()",
848             fixNamespaceEndComments("TESTSUITE() {\n"
849                                     "int i;\n"
850                                     "} // TESTSUITE",
851                                     Style));
852   EXPECT_EQ("TESTSUITE(A) {\n"
853             "int i;\n"
854             "} // TESTSUITE(A)",
855             fixNamespaceEndComments("TESTSUITE(A) {\n"
856                                     "int i;\n"
857                                     "} // TOASTSUITE(A)",
858                                     Style));
859   EXPECT_EQ("TESTSUITE(A) {\n"
860             "int i;\n"
861             "}; // TESTSUITE(A)",
862             fixNamespaceEndComments("TESTSUITE(A) {\n"
863                                     "int i;\n"
864                                     "}; // TOASTSUITE(A)",
865                                     Style));
866   // Updates invalid line comments even for short namespaces.
867   EXPECT_EQ("TESTSUITE(A) {} // TESTSUITE(A)",
868             fixNamespaceEndComments("TESTSUITE(A) {} // TESTSUITE()", Style));
869   EXPECT_EQ("TESTSUITE(A) {}; // TESTSUITE(A)",
870             fixNamespaceEndComments("TESTSUITE(A) {}; // TESTSUITE()", Style));
871 
872   // Update invalid comments for compacted namespaces.
873   FormatStyle CompactNamespacesStyle = getLLVMStyle();
874   CompactNamespacesStyle.CompactNamespaces = true;
875   CompactNamespacesStyle.NamespaceMacros.push_back("TESTSUITE");
876 
877   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
878             "}} // TESTSUITE(out::in)",
879             fixNamespaceEndComments("TESTSUITE(out) { TESTSUITE(in) {\n"
880                                     "}} // TESTSUITE(out)",
881                                     CompactNamespacesStyle));
882   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
883             "}} // TESTSUITE(out::in)",
884             fixNamespaceEndComments("TESTSUITE(out) { TESTSUITE(in) {\n"
885                                     "}} // TESTSUITE(in)",
886                                     CompactNamespacesStyle));
887   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
888             "}\n"
889             "} // TESTSUITE(out::in)",
890             fixNamespaceEndComments("TESTSUITE(out) { TESTSUITE(in) {\n"
891                                     "}// TAOSTSUITE(in)\n"
892                                     "} // TESTSUITE(out)",
893                                     CompactNamespacesStyle));
894 }
895 
896 TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidEndBlockComment) {
897   EXPECT_EQ("namespace {\n"
898             "int i;\n"
899             "} // namespace",
900             fixNamespaceEndComments("namespace {\n"
901                                     "int i;\n"
902                                     "} /* namespace A */"));
903   EXPECT_EQ("namespace A {\n"
904             "int i;\n"
905             "}  // namespace A",
906             fixNamespaceEndComments("namespace A {\n"
907                                     "int i;\n"
908                                     "}  /* end namespace */"));
909   EXPECT_EQ("namespace A {\n"
910             "int i;\n"
911             "} // namespace A",
912             fixNamespaceEndComments("namespace A {\n"
913                                     "int i;\n"
914                                     "} /**/"));
915   EXPECT_EQ("namespace A {\n"
916             "int i;\n"
917             "} // namespace A",
918             fixNamespaceEndComments("namespace A {\n"
919                                     "int i;\n"
920                                     "} /* end unnamed namespace */"));
921   EXPECT_EQ("namespace A {\n"
922             "int i;\n"
923             "} // namespace A",
924             fixNamespaceEndComments("namespace A {\n"
925                                     "int i;\n"
926                                     "} /* banamespace A */"));
927   EXPECT_EQ("namespace A {\n"
928             "int i;\n"
929             "}; // namespace A",
930             fixNamespaceEndComments("namespace A {\n"
931                                     "int i;\n"
932                                     "}; /* banamespace A */"));
933   EXPECT_EQ("namespace A {} // namespace A",
934             fixNamespaceEndComments("namespace A {} /**/"));
935   EXPECT_EQ("namespace A {}; // namespace A",
936             fixNamespaceEndComments("namespace A {}; /**/"));
937 }
938 
939 TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidMacroEndBlockComment) {
940   FormatStyle Style = getLLVMStyle();
941   Style.NamespaceMacros.push_back("TESTSUITE");
942 
943   EXPECT_EQ("TESTSUITE() {\n"
944             "int i;\n"
945             "} // TESTSUITE()",
946             fixNamespaceEndComments("TESTSUITE() {\n"
947                                     "int i;\n"
948                                     "} /* TESTSUITE(A) */",
949                                     Style));
950   EXPECT_EQ("TESTSUITE(A) {\n"
951             "int i;\n"
952             "}  // TESTSUITE(A)",
953             fixNamespaceEndComments("TESTSUITE(A) {\n"
954                                     "int i;\n"
955                                     "}  /* end TESTSUITE() */",
956                                     Style));
957   EXPECT_EQ("TESTSUITE(A) {\n"
958             "int i;\n"
959             "} // TESTSUITE(A)",
960             fixNamespaceEndComments("TESTSUITE(A) {\n"
961                                     "int i;\n"
962                                     "} /**/",
963                                     Style));
964   EXPECT_EQ("TESTSUITE(A) {\n"
965             "int i;\n"
966             "} // TESTSUITE(A)",
967             fixNamespaceEndComments("TESTSUITE(A) {\n"
968                                     "int i;\n"
969                                     "} /* end unnamed TESTSUITE() */",
970                                     Style));
971   EXPECT_EQ("TESTSUITE(A) {\n"
972             "int i;\n"
973             "} // TESTSUITE(A)",
974             fixNamespaceEndComments("TESTSUITE(A) {\n"
975                                     "int i;\n"
976                                     "} /* TOASTSUITE(A) */",
977                                     Style));
978   EXPECT_EQ("TESTSUITE(A) {\n"
979             "int i;\n"
980             "}; // TESTSUITE(A)",
981             fixNamespaceEndComments("TESTSUITE(A) {\n"
982                                     "int i;\n"
983                                     "}; /* TAOSTSUITE(A) */",
984                                     Style));
985   EXPECT_EQ("TESTSUITE(A) {} // TESTSUITE(A)",
986             fixNamespaceEndComments("TESTSUITE(A) {} /**/", Style));
987   EXPECT_EQ("TESTSUITE(A) {}; // TESTSUITE(A)",
988             fixNamespaceEndComments("TESTSUITE(A) {}; /**/", Style));
989 }
990 
991 TEST_F(NamespaceEndCommentsFixerTest,
992        DoesNotAddEndCommentForNamespacesControlledByMacros) {
993   EXPECT_EQ("#ifdef 1\n"
994             "namespace A {\n"
995             "#elseif\n"
996             "namespace B {\n"
997             "#endif\n"
998             "int i;\n"
999             "}\n"
1000             "}\n",
1001             fixNamespaceEndComments("#ifdef 1\n"
1002                                     "namespace A {\n"
1003                                     "#elseif\n"
1004                                     "namespace B {\n"
1005                                     "#endif\n"
1006                                     "int i;\n"
1007                                     "}\n"
1008                                     "}\n"));
1009 }
1010 
1011 TEST_F(NamespaceEndCommentsFixerTest, AddsEndCommentForNamespacesAroundMacros) {
1012   // Conditional blocks around are fine
1013   EXPECT_EQ("namespace A {\n"
1014             "#if 1\n"
1015             "int i;\n"
1016             "#endif\n"
1017             "}// namespace A",
1018             fixNamespaceEndComments("namespace A {\n"
1019                                     "#if 1\n"
1020                                     "int i;\n"
1021                                     "#endif\n"
1022                                     "}"));
1023   EXPECT_EQ("#if 1\n"
1024             "#endif\n"
1025             "namespace A {\n"
1026             "int i;\n"
1027             "int j;\n"
1028             "}// namespace A",
1029             fixNamespaceEndComments("#if 1\n"
1030                                     "#endif\n"
1031                                     "namespace A {\n"
1032                                     "int i;\n"
1033                                     "int j;\n"
1034                                     "}"));
1035   EXPECT_EQ("namespace A {\n"
1036             "int i;\n"
1037             "int j;\n"
1038             "}// namespace A\n"
1039             "#if 1\n"
1040             "#endif",
1041             fixNamespaceEndComments("namespace A {\n"
1042                                     "int i;\n"
1043                                     "int j;\n"
1044                                     "}\n"
1045                                     "#if 1\n"
1046                                     "#endif"));
1047   EXPECT_EQ("#if 1\n"
1048             "namespace A {\n"
1049             "int i;\n"
1050             "int j;\n"
1051             "}// namespace A\n"
1052             "#endif",
1053             fixNamespaceEndComments("#if 1\n"
1054                                     "namespace A {\n"
1055                                     "int i;\n"
1056                                     "int j;\n"
1057                                     "}\n"
1058                                     "#endif"));
1059 
1060   // Macro definition has no impact
1061   EXPECT_EQ("namespace A {\n"
1062             "#define FOO\n"
1063             "int i;\n"
1064             "}// namespace A",
1065             fixNamespaceEndComments("namespace A {\n"
1066                                     "#define FOO\n"
1067                                     "int i;\n"
1068                                     "}"));
1069   EXPECT_EQ("#define FOO\n"
1070             "namespace A {\n"
1071             "int i;\n"
1072             "int j;\n"
1073             "}// namespace A",
1074             fixNamespaceEndComments("#define FOO\n"
1075                                     "namespace A {\n"
1076                                     "int i;\n"
1077                                     "int j;\n"
1078                                     "}"));
1079   EXPECT_EQ("namespace A {\n"
1080             "int i;\n"
1081             "int j;\n"
1082             "}// namespace A\n"
1083             "#define FOO\n",
1084             fixNamespaceEndComments("namespace A {\n"
1085                                     "int i;\n"
1086                                     "int j;\n"
1087                                     "}\n"
1088                                     "#define FOO\n"));
1089 
1090   // No replacement if open & close in different conditional blocks
1091   EXPECT_EQ("#if 1\n"
1092             "namespace A {\n"
1093             "#endif\n"
1094             "int i;\n"
1095             "int j;\n"
1096             "#if 1\n"
1097             "}\n"
1098             "#endif",
1099             fixNamespaceEndComments("#if 1\n"
1100                                     "namespace A {\n"
1101                                     "#endif\n"
1102                                     "int i;\n"
1103                                     "int j;\n"
1104                                     "#if 1\n"
1105                                     "}\n"
1106                                     "#endif"));
1107   EXPECT_EQ("#ifdef A\n"
1108             "namespace A {\n"
1109             "#endif\n"
1110             "int i;\n"
1111             "int j;\n"
1112             "#ifdef B\n"
1113             "}\n"
1114             "#endif",
1115             fixNamespaceEndComments("#ifdef A\n"
1116                                     "namespace A {\n"
1117                                     "#endif\n"
1118                                     "int i;\n"
1119                                     "int j;\n"
1120                                     "#ifdef B\n"
1121                                     "}\n"
1122                                     "#endif"));
1123 
1124   // No replacement inside unreachable conditional block
1125   EXPECT_EQ("#if 0\n"
1126             "namespace A {\n"
1127             "int i;\n"
1128             "int j;\n"
1129             "}\n"
1130             "#endif",
1131             fixNamespaceEndComments("#if 0\n"
1132                                     "namespace A {\n"
1133                                     "int i;\n"
1134                                     "int j;\n"
1135                                     "}\n"
1136                                     "#endif"));
1137 }
1138 
1139 TEST_F(NamespaceEndCommentsFixerTest,
1140        DoesNotAddEndCommentForNamespacesInMacroDeclarations) {
1141   EXPECT_EQ("#ifdef 1\n"
1142             "namespace A {\n"
1143             "#elseif\n"
1144             "namespace B {\n"
1145             "#endif\n"
1146             "int i;\n"
1147             "}\n"
1148             "}\n",
1149             fixNamespaceEndComments("#ifdef 1\n"
1150                                     "namespace A {\n"
1151                                     "#elseif\n"
1152                                     "namespace B {\n"
1153                                     "#endif\n"
1154                                     "int i;\n"
1155                                     "}\n"
1156                                     "}\n"));
1157   EXPECT_EQ("namespace {\n"
1158             "int i;\n"
1159             "int j;\n"
1160             "}// namespace\n"
1161             "#if A\n"
1162             "int i;\n"
1163             "#else\n"
1164             "int j;\n"
1165             "#endif",
1166             fixNamespaceEndComments("namespace {\n"
1167                                     "int i;\n"
1168                                     "int j;\n"
1169                                     "}\n"
1170                                     "#if A\n"
1171                                     "int i;\n"
1172                                     "#else\n"
1173                                     "int j;\n"
1174                                     "#endif"));
1175   EXPECT_EQ("#if A\n"
1176             "namespace A {\n"
1177             "#else\n"
1178             "namespace B {\n"
1179             "#endif\n"
1180             "int i;\n"
1181             "int j;\n"
1182             "}",
1183             fixNamespaceEndComments("#if A\n"
1184                                     "namespace A {\n"
1185                                     "#else\n"
1186                                     "namespace B {\n"
1187                                     "#endif\n"
1188                                     "int i;\n"
1189                                     "int j;\n"
1190                                     "}"));
1191   EXPECT_EQ("#if A\n"
1192             "namespace A {\n"
1193             "#else\n"
1194             "namespace B {\n"
1195             "#endif\n"
1196             "int i;\n"
1197             "int j;\n"
1198             "} // namespace A",
1199             fixNamespaceEndComments("#if A\n"
1200                                     "namespace A {\n"
1201                                     "#else\n"
1202                                     "namespace B {\n"
1203                                     "#endif\n"
1204                                     "int i;\n"
1205                                     "int j;\n"
1206                                     "} // namespace A"));
1207   EXPECT_EQ("#if A\n"
1208             "namespace A {\n"
1209             "#else\n"
1210             "namespace B {\n"
1211             "#endif\n"
1212             "int i;\n"
1213             "int j;\n"
1214             "} // namespace B",
1215             fixNamespaceEndComments("#if A\n"
1216                                     "namespace A {\n"
1217                                     "#else\n"
1218                                     "namespace B {\n"
1219                                     "#endif\n"
1220                                     "int i;\n"
1221                                     "int j;\n"
1222                                     "} // namespace B"));
1223   EXPECT_EQ("namespace A\n"
1224             "int i;\n"
1225             "int j;\n"
1226             "#if A\n"
1227             "}\n"
1228             "#else\n"
1229             "}\n"
1230             "#endif",
1231             fixNamespaceEndComments("namespace A\n"
1232                                     "int i;\n"
1233                                     "int j;\n"
1234                                     "#if A\n"
1235                                     "}\n"
1236                                     "#else\n"
1237                                     "}\n"
1238                                     "#endif"));
1239   EXPECT_EQ("namespace A\n"
1240             "int i;\n"
1241             "int j;\n"
1242             "#if A\n"
1243             "} // namespace A\n"
1244             "#else\n"
1245             "} // namespace A\n"
1246             "#endif",
1247             fixNamespaceEndComments("namespace A\n"
1248                                     "int i;\n"
1249                                     "int j;\n"
1250                                     "#if A\n"
1251                                     "} // namespace A\n"
1252                                     "#else\n"
1253                                     "} // namespace A\n"
1254                                     "#endif"));
1255 }
1256 
1257 TEST_F(NamespaceEndCommentsFixerTest,
1258        DoesNotAddEndCommentForUnbalancedRBracesAfterNamespaceEnd) {
1259   EXPECT_EQ("namespace {\n"
1260             "int i;\n"
1261             "} // namespace\n"
1262             "}",
1263             fixNamespaceEndComments("namespace {\n"
1264                                     "int i;\n"
1265                                     "} // namespace\n"
1266                                     "}"));
1267 }
1268 
1269 TEST_F(NamespaceEndCommentsFixerTest, HandlesInlineAtEndOfLine_PR32438) {
1270   EXPECT_EQ("template <int> struct a {};\n"
1271             "struct a<bool{}> b() {\n"
1272             "}\n"
1273             "#define c inline\n"
1274             "void d() {\n"
1275             "}\n",
1276             fixNamespaceEndComments("template <int> struct a {};\n"
1277                                     "struct a<bool{}> b() {\n"
1278                                     "}\n"
1279                                     "#define c inline\n"
1280                                     "void d() {\n"
1281                                     "}\n"));
1282 }
1283 
1284 TEST_F(NamespaceEndCommentsFixerTest, IgnoreUnbalanced) {
1285   EXPECT_EQ("namespace A {\n"
1286             "class Foo {\n"
1287             "}\n"
1288             "}// namespace A\n",
1289             fixNamespaceEndComments("namespace A {\n"
1290                                     "class Foo {\n"
1291                                     "}\n"
1292                                     "}\n"));
1293   EXPECT_EQ("namespace A {\n"
1294             "class Foo {\n"
1295             "}\n",
1296             fixNamespaceEndComments("namespace A {\n"
1297                                     "class Foo {\n"
1298                                     "}\n"));
1299 
1300   EXPECT_EQ("namespace A {\n"
1301             "class Foo {\n"
1302             "}\n"
1303             "}\n"
1304             "}\n",
1305             fixNamespaceEndComments("namespace A {\n"
1306                                     "class Foo {\n"
1307                                     "}\n"
1308                                     "}\n"
1309                                     "}\n"));
1310 }
1311 
1312 using ShortNamespaceLinesTest = NamespaceEndCommentsFixerTest;
1313 
1314 TEST_F(ShortNamespaceLinesTest, ZeroUnwrappedLines) {
1315   auto Style = getLLVMStyle();
1316   Style.ShortNamespaceLines = 0u;
1317 
1318   EXPECT_EQ("namespace OneLinerNamespace {}\n",
1319             fixNamespaceEndComments("namespace OneLinerNamespace {}\n", Style));
1320   EXPECT_EQ("namespace ShortNamespace {\n"
1321             "}\n",
1322             fixNamespaceEndComments("namespace ShortNamespace {\n"
1323                                     "}\n",
1324                                     Style));
1325   EXPECT_EQ("namespace LongNamespace {\n"
1326             "int i;\n"
1327             "}// namespace LongNamespace\n",
1328             fixNamespaceEndComments("namespace LongNamespace {\n"
1329                                     "int i;\n"
1330                                     "}\n",
1331                                     Style));
1332 }
1333 
1334 TEST_F(ShortNamespaceLinesTest, OneUnwrappedLine) {
1335   constexpr auto DefaultUnwrappedLines = 1u;
1336   auto const Style = getLLVMStyle();
1337 
1338   EXPECT_EQ(DefaultUnwrappedLines, Style.ShortNamespaceLines);
1339   EXPECT_EQ("namespace ShortNamespace {\n"
1340             "int i;\n"
1341             "}\n",
1342             fixNamespaceEndComments("namespace ShortNamespace {\n"
1343                                     "int i;\n"
1344                                     "}\n"));
1345   EXPECT_EQ("namespace LongNamespace {\n"
1346             "int i;\n"
1347             "int j;\n"
1348             "}// namespace LongNamespace\n",
1349             fixNamespaceEndComments("namespace LongNamespace {\n"
1350                                     "int i;\n"
1351                                     "int j;\n"
1352                                     "}\n"));
1353 }
1354 
1355 TEST_F(ShortNamespaceLinesTest, MultipleUnwrappedLine) {
1356   auto Style = getLLVMStyle();
1357   Style.ShortNamespaceLines = 2u;
1358 
1359   EXPECT_EQ("namespace ShortNamespace {\n"
1360             "int i;\n"
1361             "int j;\n"
1362             "}\n",
1363             fixNamespaceEndComments("namespace ShortNamespace {\n"
1364                                     "int i;\n"
1365                                     "int j;\n"
1366                                     "}\n",
1367                                     Style));
1368   EXPECT_EQ("namespace LongNamespace {\n"
1369             "int i;\n"
1370             "int j;\n"
1371             "int k;\n"
1372             "}// namespace LongNamespace\n",
1373             fixNamespaceEndComments("namespace LongNamespace {\n"
1374                                     "int i;\n"
1375                                     "int j;\n"
1376                                     "int k;\n"
1377                                     "}\n",
1378                                     Style));
1379 }
1380 
1381 TEST_F(ShortNamespaceLinesTest, NamespaceAlias) {
1382   auto Style = getLLVMStyle();
1383 
1384   EXPECT_EQ("namespace n = nn;\n"
1385             "{\n"
1386             "  int i;\n"
1387             "  int j;\n"
1388             "}\n",
1389             fixNamespaceEndComments("namespace n = nn;\n"
1390                                     "{\n"
1391                                     "  int i;\n"
1392                                     "  int j;\n"
1393                                     "}\n",
1394                                     Style));
1395 
1396   EXPECT_EQ("namespace n = nn; // comment\n"
1397             "{\n"
1398             "  int i;\n"
1399             "  int j;\n"
1400             "}\n",
1401             fixNamespaceEndComments("namespace n = nn; // comment\n"
1402                                     "{\n"
1403                                     "  int i;\n"
1404                                     "  int j;\n"
1405                                     "}\n",
1406                                     Style));
1407 
1408   EXPECT_EQ("namespace n = nn; /* comment */\n"
1409             "{\n"
1410             "  int i;\n"
1411             "  int j;\n"
1412             "}\n",
1413             fixNamespaceEndComments("namespace n = nn; /* comment */\n"
1414                                     "{\n"
1415                                     "  int i;\n"
1416                                     "  int j;\n"
1417                                     "}\n",
1418                                     Style));
1419 
1420   EXPECT_EQ(
1421       "namespace n = nn; /* comment */ /* comment2 */\n"
1422       "{\n"
1423       "  int i;\n"
1424       "  int j;\n"
1425       "}\n",
1426       fixNamespaceEndComments("namespace n = nn; /* comment */ /* comment2 */\n"
1427                               "{\n"
1428                               "  int i;\n"
1429                               "  int j;\n"
1430                               "}\n",
1431                               Style));
1432 
1433   EXPECT_EQ("namespace n = nn; {\n"
1434             "  int i;\n"
1435             "  int j;\n"
1436             "}\n",
1437             fixNamespaceEndComments("namespace n = nn; {\n"
1438                                     "  int i;\n"
1439                                     "  int j;\n"
1440                                     "}\n",
1441                                     Style));
1442   EXPECT_EQ("int foo;\n"
1443             "namespace n\n"
1444             "{\n"
1445             "  int i;\n"
1446             "  int j;\n"
1447             "}// namespace n\n",
1448             fixNamespaceEndComments("int foo;\n"
1449                                     "namespace n\n"
1450                                     "{\n"
1451                                     "  int i;\n"
1452                                     "  int j;\n"
1453                                     "}\n",
1454                                     Style));
1455 }
1456 } // end namespace
1457 } // end namespace format
1458 } // end namespace clang
1459