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