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