unittests/Format/NamespaceEndCommentsFixerTest.cpp

   1 //===- NamespaceEndCommentsFixerTest.cpp - Formatting unit tests ----------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "clang/Format/Format.h"
  11
  12 #include "clang/Frontend/TextDiagnosticPrinter.h"
  13 #include "llvm/Support/Debug.h"
  14 #include "gtest/gtest.h"
  15
  16 #define DEBUG_TYPE "namespace-end-comments-fixer-test"
  17
  18 namespace clang {
  19 namespace format {
  20 namespace {
  21
  22 class NamespaceEndCommentsFixerTest : public ::testing::Test {
  23 protected:
  24   std::string
  25   fixNamespaceEndComments(llvm::StringRef Code,
  26                           const std::vector<tooling::Range> &Ranges,
  27                           const FormatStyle &Style = getLLVMStyle()) {
  28     LLVM_DEBUG(llvm::errs() << "---\n");
  29     LLVM_DEBUG(llvm::errs() << Code << "\n\n");
  30     tooling::Replacements Replaces =
  31         clang::format::fixNamespaceEndComments(Style, Code, Ranges, "<stdin>");
  32     auto Result = applyAllReplacements(Code, Replaces);
  33     EXPECT_TRUE(static_cast<bool>(Result));
  34     LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
  35     return *Result;
  36   }
  37
  38   std::string
  39   fixNamespaceEndComments(llvm::StringRef Code,
  40                           const FormatStyle &Style = getLLVMStyle()) {
  41     return fixNamespaceEndComments(
  42         Code,
  43         /*Ranges=*/{1, tooling::Range(0, Code.size())}, Style);
  44   }
  45 };
  46
  47 TEST_F(NamespaceEndCommentsFixerTest, AddsEndComment) {
  48   EXPECT_EQ("namespace {\n"
  49             "  int i;\n"
  50             "  int j;\n"
  51             "}// namespace",
  52             fixNamespaceEndComments("namespace {\n"
  53                                     "  int i;\n"
  54                                     "  int j;\n"
  55                                     "}"));
  56   EXPECT_EQ("namespace {\n"
  57             "  int i;\n"
  58             "  int j;\n"
  59             "}// namespace\n",
  60             fixNamespaceEndComments("namespace {\n"
  61                                     "  int i;\n"
  62                                     "  int j;\n"
  63                                     "}\n"));
  64   EXPECT_EQ("namespace A {\n"
  65             "  int i;\n"
  66             "  int j;\n"
  67             "}// namespace A",
  68             fixNamespaceEndComments("namespace A {\n"
  69                                     "  int i;\n"
  70                                     "  int j;\n"
  71                                     "}"));
  72   EXPECT_EQ("inline namespace A {\n"
  73             "  int i;\n"
  74             "  int j;\n"
  75             "}// namespace A",
  76             fixNamespaceEndComments("inline namespace A {\n"
  77                                     "  int i;\n"
  78                                     "  int j;\n"
  79                                     "}"));
  80   EXPECT_EQ("namespace ::A {\n"
  81             "  int i;\n"
  82             "  int j;\n"
  83             "}// namespace ::A",
  84             fixNamespaceEndComments("namespace ::A {\n"
  85                                     "  int i;\n"
  86                                     "  int j;\n"
  87                                     "}"));
  88   EXPECT_EQ("namespace ::A::B {\n"
  89             "  int i;\n"
  90             "  int j;\n"
  91             "}// namespace ::A::B",
  92             fixNamespaceEndComments("namespace ::A::B {\n"
  93                                     "  int i;\n"
  94                                     "  int j;\n"
  95                                     "}"));
  96   EXPECT_EQ("namespace /**/::/**/A/**/::/**/B/**/ {\n"
  97             "  int i;\n"
  98             "  int j;\n"
  99             "}// namespace ::A::B",
 100             fixNamespaceEndComments("namespace /**/::/**/A/**/::/**/B/**/ {\n"
 101                                     "  int i;\n"
 102                                     "  int j;\n"
 103                                     "}"));
 104   EXPECT_EQ("namespace A {\n"
 105             "namespace B {\n"
 106             "  int i;\n"
 107             "}\n"
 108             "}// namespace A",
 109             fixNamespaceEndComments("namespace A {\n"
 110                                     "namespace B {\n"
 111                                     "  int i;\n"
 112                                     "}\n"
 113                                     "}"));
 114   EXPECT_EQ("namespace A {\n"
 115             "namespace B {\n"
 116             "  int i;\n"
 117             "  int j;\n"
 118             "}// namespace B\n"
 119             "}// namespace A",
 120             fixNamespaceEndComments("namespace A {\n"
 121                                     "namespace B {\n"
 122                                     "  int i;\n"
 123                                     "  int j;\n"
 124                                     "}\n"
 125                                     "}"));
 126   EXPECT_EQ("namespace A {\n"
 127             "  int a;\n"
 128             "  int b;\n"
 129             "}// namespace A\n"
 130             "namespace B {\n"
 131             "  int b;\n"
 132             "  int a;\n"
 133             "}// namespace B",
 134             fixNamespaceEndComments("namespace A {\n"
 135                                     "  int a;\n"
 136                                     "  int b;\n"
 137                                     "}\n"
 138                                     "namespace B {\n"
 139                                     "  int b;\n"
 140                                     "  int a;\n"
 141                                     "}"));
 142   EXPECT_EQ("namespace A {\n"
 143             "  int a1;\n"
 144             "  int a2;\n"
 145             "}// namespace A\n"
 146             "namespace A {\n"
 147             "  int a2;\n"
 148             "  int a1;\n"
 149             "}// namespace A",
 150             fixNamespaceEndComments("namespace A {\n"
 151                                     "  int a1;\n"
 152                                     "  int a2;\n"
 153                                     "}\n"
 154                                     "namespace A {\n"
 155                                     "  int a2;\n"
 156                                     "  int a1;\n"
 157                                     "}"));
 158   EXPECT_EQ("namespace A {\n"
 159             "  int a;\n"
 160             "  int b;\n"
 161             "}// namespace A\n"
 162             "// comment about b\n"
 163             "int b;",
 164             fixNamespaceEndComments("namespace A {\n"
 165                                     "  int a;\n"
 166                                     "  int b;\n"
 167                                     "}\n"
 168                                     "// comment about b\n"
 169                                     "int b;"));
 170
 171   EXPECT_EQ("namespace A {\n"
 172             "namespace B {\n"
 173             "namespace C {\n"
 174             "namespace D {\n"
 175             "}\n"
 176             "}// namespace C\n"
 177             "}// namespace B\n"
 178             "}// namespace A",
 179             fixNamespaceEndComments("namespace A {\n"
 180                                     "namespace B {\n"
 181                                     "namespace C {\n"
 182                                     "namespace D {\n"
 183                                     "}\n"
 184                                     "}\n"
 185                                     "}\n"
 186                                     "}"));
 187
 188   // Add comment for namespaces which will be 'compacted'
 189   FormatStyle CompactNamespacesStyle = getLLVMStyle();
 190   CompactNamespacesStyle.CompactNamespaces = true;
 191   EXPECT_EQ("namespace out { namespace in {\n"
 192             "int i;\n"
 193             "int j;\n"
 194             "}}// namespace out::in",
 195             fixNamespaceEndComments("namespace out { namespace in {\n"
 196                                     "int i;\n"
 197                                     "int j;\n"
 198                                     "}}",
 199                                     CompactNamespacesStyle));
 200   EXPECT_EQ("namespace out {\n"
 201             "namespace in {\n"
 202             "int i;\n"
 203             "int j;\n"
 204             "}\n"
 205             "}// namespace out::in",
 206             fixNamespaceEndComments("namespace out {\n"
 207                                     "namespace in {\n"
 208                                     "int i;\n"
 209                                     "int j;\n"
 210                                     "}\n"
 211                                     "}",
 212                                     CompactNamespacesStyle));
 213   EXPECT_EQ("namespace out { namespace in {\n"
 214             "int i;\n"
 215             "int j;\n"
 216             "};}// namespace out::in",
 217             fixNamespaceEndComments("namespace out { namespace in {\n"
 218                                     "int i;\n"
 219                                     "int j;\n"
 220                                     "};}",
 221                                     CompactNamespacesStyle));
 222
 223   // Adds an end comment after a semicolon.
 224   EXPECT_EQ("namespace {\n"
 225             "  int i;\n"
 226             "  int j;\n"
 227             "};// namespace",
 228             fixNamespaceEndComments("namespace {\n"
 229                                     "  int i;\n"
 230                                     "  int j;\n"
 231                                     "};"));
 232   EXPECT_EQ("namespace A {\n"
 233             "  int i;\n"
 234             "  int j;\n"
 235             "};// namespace A",
 236             fixNamespaceEndComments("namespace A {\n"
 237                                     "  int i;\n"
 238                                     "  int j;\n"
 239                                     "};"));
 240   EXPECT_EQ("namespace A {\n"
 241             "  int i;\n"
 242             "  int j;\n"
 243             "};// namespace A\n"
 244             "// unrelated",
 245             fixNamespaceEndComments("namespace A {\n"
 246                                     "  int i;\n"
 247                                     "  int j;\n"
 248                                     "};\n"
 249                                     "// unrelated"));
 250 }
 251
 252 TEST_F(NamespaceEndCommentsFixerTest, AddsNewlineIfNeeded) {
 253   EXPECT_EQ("namespace A {\n"
 254             "  int i;\n"
 255             "  int j;\n"
 256             "}// namespace A\n"
 257             " int k;",
 258             fixNamespaceEndComments("namespace A {\n"
 259                                     "  int i;\n"
 260                                     "  int j;\n"
 261                                     "} int k;"));
 262   EXPECT_EQ("namespace {\n"
 263             "  int i;\n"
 264             "  int j;\n"
 265             "}// namespace\n"
 266             " int k;",
 267             fixNamespaceEndComments("namespace {\n"
 268                                     "  int i;\n"
 269                                     "  int j;\n"
 270                                     "} int k;"));
 271   EXPECT_EQ("namespace A {\n"
 272             "  int i;\n"
 273             "  int j;\n"
 274             "}// namespace A\n"
 275             " namespace B {\n"
 276             "  int j;\n"
 277             "  int k;\n"
 278             "}// namespace B",
 279             fixNamespaceEndComments("namespace A {\n"
 280                                     "  int i;\n"
 281                                     "  int j;\n"
 282                                     "} namespace B {\n"
 283                                     "  int j;\n"
 284                                     "  int k;\n"
 285                                     "}"));
 286   EXPECT_EQ("namespace {\n"
 287             "  int i;\n"
 288             "  int j;\n"
 289             "};// namespace\n"
 290             "int k;",
 291             fixNamespaceEndComments("namespace {\n"
 292                                     "  int i;\n"
 293                                     "  int j;\n"
 294                                     "};int k;"));
 295   EXPECT_EQ("namespace {\n"
 296             "  int i;\n"
 297             "  int j;\n"
 298             "};// namespace\n"
 299             ";",
 300             fixNamespaceEndComments("namespace {\n"
 301                                     "  int i;\n"
 302                                     "  int j;\n"
 303                                     "};;"));
 304 }
 305
 306 TEST_F(NamespaceEndCommentsFixerTest, DoesNotAddEndCommentForShortNamespace) {
 307   EXPECT_EQ("namespace {}", fixNamespaceEndComments("namespace {}"));
 308   EXPECT_EQ("namespace A {}", fixNamespaceEndComments("namespace A {}"));
 309   EXPECT_EQ("namespace A { a }",
 310             fixNamespaceEndComments("namespace A { a }"));
 311   EXPECT_EQ("namespace A { a };",
 312             fixNamespaceEndComments("namespace A { a };"));
 313 }
 314
 315 TEST_F(NamespaceEndCommentsFixerTest, DoesNotAddCommentAfterUnaffectedRBrace) {
 316   EXPECT_EQ("namespace A {\n"
 317             "  int i;\n"
 318             "}",
 319             fixNamespaceEndComments("namespace A {\n"
 320                                     "  int i;\n"
 321                                     "}",
 322                                     // The range (16, 3) spans the 'int' above.
 323                                     /*Ranges=*/{1, tooling::Range(16, 3)}));
 324   EXPECT_EQ("namespace A {\n"
 325             "  int i;\n"
 326             "};",
 327             fixNamespaceEndComments("namespace A {\n"
 328                                     "  int i;\n"
 329                                     "};",
 330                                     // The range (16, 3) spans the 'int' above.
 331                                     /*Ranges=*/{1, tooling::Range(16, 3)}));
 332 }
 333
 334 TEST_F(NamespaceEndCommentsFixerTest, DoesNotAddCommentAfterRBraceInPPDirective) {
 335   EXPECT_EQ("#define SAD \\\n"
 336             "namespace A { \\\n"
 337             "  int i; \\\n"
 338             "}",
 339             fixNamespaceEndComments("#define SAD \\\n"
 340                                     "namespace A { \\\n"
 341                                     "  int i; \\\n"
 342                                     "}"));
 343 }
 344
 345 TEST_F(NamespaceEndCommentsFixerTest, KeepsValidEndComment) {
 346   EXPECT_EQ("namespace {\n"
 347             "  int i;\n"
 348             "} // end anonymous namespace",
 349             fixNamespaceEndComments("namespace {\n"
 350                                     "  int i;\n"
 351                                     "} // end anonymous namespace"));
 352   EXPECT_EQ("namespace A {\n"
 353             "  int i;\n"
 354             "} /* end of namespace A */",
 355             fixNamespaceEndComments("namespace A {\n"
 356                                     "  int i;\n"
 357                                     "} /* end of namespace A */"));
 358   EXPECT_EQ("namespace A {\n"
 359             "  int i;\n"
 360             "}   //   namespace A",
 361             fixNamespaceEndComments("namespace A {\n"
 362                                     "  int i;\n"
 363                                     "}   //   namespace A"));
 364   EXPECT_EQ("namespace A::B {\n"
 365             "  int i;\n"
 366             "} // end namespace A::B",
 367             fixNamespaceEndComments("namespace A::B {\n"
 368                                     "  int i;\n"
 369                                     "} // end namespace A::B"));
 370   EXPECT_EQ("namespace A {\n"
 371             "  int i;\n"
 372             "}; // end namespace A",
 373             fixNamespaceEndComments("namespace A {\n"
 374                                     "  int i;\n"
 375                                     "}; // end namespace A"));
 376   EXPECT_EQ("namespace {\n"
 377             "  int i;\n"
 378             "}; /* unnamed namespace */",
 379             fixNamespaceEndComments("namespace {\n"
 380                                     "  int i;\n"
 381                                     "}; /* unnamed namespace */"));
 382 }
 383
 384 TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidEndLineComment) {
 385   EXPECT_EQ("namespace {\n"
 386             "  int i;\n"
 387             "} // namespace",
 388             fixNamespaceEndComments("namespace {\n"
 389                                     "  int i;\n"
 390                                     "} // namespace A"));
 391   EXPECT_EQ("namespace A {\n"
 392             "  int i;\n"
 393             "} // namespace A",
 394             fixNamespaceEndComments("namespace A {\n"
 395                                     "  int i;\n"
 396                                     "} // namespace"));
 397   EXPECT_EQ("namespace A {\n"
 398             "  int i;\n"
 399             "} // namespace A",
 400             fixNamespaceEndComments("namespace A {\n"
 401                                     "  int i;\n"
 402                                     "} //"));
 403   EXPECT_EQ("namespace A {\n"
 404             "  int i;\n"
 405             "} // namespace A",
 406             fixNamespaceEndComments("namespace A {\n"
 407                                     "  int i;\n"
 408                                     "} //"));
 409   EXPECT_EQ("namespace A {\n"
 410             "  int i;\n"
 411             "} // namespace A",
 412             fixNamespaceEndComments("namespace A {\n"
 413                                     "  int i;\n"
 414                                     "} // banamespace A"));
 415   EXPECT_EQ("namespace A {\n"
 416             "  int i;\n"
 417             "}; // namespace A",
 418             fixNamespaceEndComments("namespace A {\n"
 419                                     "  int i;\n"
 420                                     "}; // banamespace A"));
 421   // Updates invalid line comments even for short namespaces.
 422   EXPECT_EQ("namespace A {} // namespace A",
 423             fixNamespaceEndComments("namespace A {} // namespace"));
 424   EXPECT_EQ("namespace A {}; // namespace A",
 425             fixNamespaceEndComments("namespace A {}; // namespace"));
 426
 427   // Update invalid comments for compacted namespaces.
 428   FormatStyle CompactNamespacesStyle = getLLVMStyle();
 429   CompactNamespacesStyle.CompactNamespaces = true;
 430   EXPECT_EQ("namespace out { namespace in {\n"
 431             "}} // namespace out::in",
 432             fixNamespaceEndComments("namespace out { namespace in {\n"
 433                                     "}} // namespace out",
 434                                     CompactNamespacesStyle));
 435   EXPECT_EQ("namespace out { namespace in {\n"
 436             "}} // namespace out::in",
 437             fixNamespaceEndComments("namespace out { namespace in {\n"
 438                                     "}} // namespace in",
 439                                     CompactNamespacesStyle));
 440   EXPECT_EQ("namespace out { namespace in {\n"
 441             "}\n"
 442             "} // namespace out::in",
 443             fixNamespaceEndComments("namespace out { namespace in {\n"
 444                                     "}// banamespace in\n"
 445                                     "} // namespace out",
 446                                     CompactNamespacesStyle));
 447 }
 448
 449 TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidEndBlockComment) {
 450   EXPECT_EQ("namespace {\n"
 451             "  int i;\n"
 452             "} // namespace",
 453             fixNamespaceEndComments("namespace {\n"
 454                                     "  int i;\n"
 455                                     "} /* namespace A */"));
 456   EXPECT_EQ("namespace A {\n"
 457             "  int i;\n"
 458             "}  // namespace A",
 459             fixNamespaceEndComments("namespace A {\n"
 460                                     "  int i;\n"
 461                                     "}  /* end namespace */"));
 462   EXPECT_EQ("namespace A {\n"
 463             "  int i;\n"
 464             "} // namespace A",
 465             fixNamespaceEndComments("namespace A {\n"
 466                                     "  int i;\n"
 467                                     "} /**/"));
 468   EXPECT_EQ("namespace A {\n"
 469             "  int i;\n"
 470             "} // namespace A",
 471             fixNamespaceEndComments("namespace A {\n"
 472                                     "  int i;\n"
 473                                     "} /* end unnamed namespace */"));
 474   EXPECT_EQ("namespace A {\n"
 475             "  int i;\n"
 476             "} // namespace A",
 477             fixNamespaceEndComments("namespace A {\n"
 478                                     "  int i;\n"
 479                                     "} /* banamespace A */"));
 480   EXPECT_EQ("namespace A {\n"
 481             "  int i;\n"
 482             "}; // namespace A",
 483             fixNamespaceEndComments("namespace A {\n"
 484                                     "  int i;\n"
 485                                     "}; /* banamespace A */"));
 486   EXPECT_EQ("namespace A {} // namespace A",
 487             fixNamespaceEndComments("namespace A {} /**/"));
 488   EXPECT_EQ("namespace A {}; // namespace A",
 489             fixNamespaceEndComments("namespace A {}; /**/"));
 490 }
 491
 492 TEST_F(NamespaceEndCommentsFixerTest,
 493        DoesNotAddEndCommentForNamespacesControlledByMacros) {
 494   EXPECT_EQ("#ifdef 1\n"
 495             "namespace A {\n"
 496             "#elseif\n"
 497             "namespace B {\n"
 498             "#endif\n"
 499             "  int i;\n"
 500             "}\n"
 501             "}\n",
 502             fixNamespaceEndComments("#ifdef 1\n"
 503                                     "namespace A {\n"
 504                                     "#elseif\n"
 505                                     "namespace B {\n"
 506                                     "#endif\n"
 507                                     "  int i;\n"
 508                                     "}\n"
 509                                     "}\n"));
 510 }
 511
 512 TEST_F(NamespaceEndCommentsFixerTest, AddEndCommentForNamespacesAroundMacros) {
 513   // Conditional blocks around are fine
 514   EXPECT_EQ("namespace A {\n"
 515             "#if 1\n"
 516             "int i;\n"
 517             "#endif\n"
 518             "}// namespace A",
 519             fixNamespaceEndComments("namespace A {\n"
 520                                     "#if 1\n"
 521                                     "int i;\n"
 522                                     "#endif\n"
 523                                     "}"));
 524   EXPECT_EQ("#if 1\n"
 525             "#endif\n"
 526             "namespace A {\n"
 527             "int i;\n"
 528             "int j;\n"
 529             "}// namespace A",
 530             fixNamespaceEndComments("#if 1\n"
 531                                     "#endif\n"
 532                                     "namespace A {\n"
 533                                     "int i;\n"
 534                                     "int j;\n"
 535                                     "}"));
 536   EXPECT_EQ("namespace A {\n"
 537             "int i;\n"
 538             "int j;\n"
 539             "}// namespace A\n"
 540             "#if 1\n"
 541             "#endif",
 542             fixNamespaceEndComments("namespace A {\n"
 543                                     "int i;\n"
 544                                     "int j;\n"
 545                                     "}\n"
 546                                     "#if 1\n"
 547                                     "#endif"));
 548   EXPECT_EQ("#if 1\n"
 549             "namespace A {\n"
 550             "int i;\n"
 551             "int j;\n"
 552             "}// namespace A\n"
 553             "#endif",
 554             fixNamespaceEndComments("#if 1\n"
 555                                     "namespace A {\n"
 556                                     "int i;\n"
 557                                     "int j;\n"
 558                                     "}\n"
 559                                     "#endif"));
 560
 561   // Macro definition has no impact
 562   EXPECT_EQ("namespace A {\n"
 563             "#define FOO\n"
 564             "int i;\n"
 565             "}// namespace A",
 566             fixNamespaceEndComments("namespace A {\n"
 567                                     "#define FOO\n"
 568                                     "int i;\n"
 569                                     "}"));
 570   EXPECT_EQ("#define FOO\n"
 571             "namespace A {\n"
 572             "int i;\n"
 573             "int j;\n"
 574             "}// namespace A",
 575             fixNamespaceEndComments("#define FOO\n"
 576                                     "namespace A {\n"
 577                                     "int i;\n"
 578                                     "int j;\n"
 579                                     "}"));
 580   EXPECT_EQ("namespace A {\n"
 581             "int i;\n"
 582             "int j;\n"
 583             "}// namespace A\n"
 584             "#define FOO\n",
 585             fixNamespaceEndComments("namespace A {\n"
 586                                     "int i;\n"
 587                                     "int j;\n"
 588                                     "}\n"
 589                                     "#define FOO\n"));
 590
 591   // No replacement if open & close in different conditional blocks
 592   EXPECT_EQ("#if 1\n"
 593             "namespace A {\n"
 594             "#endif\n"
 595             "int i;\n"
 596             "int j;\n"
 597             "#if 1\n"
 598             "}\n"
 599             "#endif",
 600             fixNamespaceEndComments("#if 1\n"
 601                                     "namespace A {\n"
 602                                     "#endif\n"
 603                                     "int i;\n"
 604                                     "int j;\n"
 605                                     "#if 1\n"
 606                                     "}\n"
 607                                     "#endif"));
 608   EXPECT_EQ("#ifdef A\n"
 609             "namespace A {\n"
 610             "#endif\n"
 611             "int i;\n"
 612             "int j;\n"
 613             "#ifdef B\n"
 614             "}\n"
 615             "#endif",
 616             fixNamespaceEndComments("#ifdef A\n"
 617                                     "namespace A {\n"
 618                                     "#endif\n"
 619                                     "int i;\n"
 620                                     "int j;\n"
 621                                     "#ifdef B\n"
 622                                     "}\n"
 623                                     "#endif"));
 624
 625   // No replacement inside unreachable conditional block
 626   EXPECT_EQ("#if 0\n"
 627             "namespace A {\n"
 628             "int i;\n"
 629             "int j;\n"
 630             "}\n"
 631             "#endif",
 632             fixNamespaceEndComments("#if 0\n"
 633                                     "namespace A {\n"
 634                                     "int i;\n"
 635                                     "int j;\n"
 636                                     "}\n"
 637                                     "#endif"));
 638 }
 639
 640 TEST_F(NamespaceEndCommentsFixerTest,
 641        DoesNotAddEndCommentForNamespacesInMacroDeclarations) {
 642   EXPECT_EQ("#ifdef 1\n"
 643             "namespace A {\n"
 644             "#elseif\n"
 645             "namespace B {\n"
 646             "#endif\n"
 647             "  int i;\n"
 648             "}\n"
 649             "}\n",
 650             fixNamespaceEndComments("#ifdef 1\n"
 651                                     "namespace A {\n"
 652                                     "#elseif\n"
 653                                     "namespace B {\n"
 654                                     "#endif\n"
 655                                     "  int i;\n"
 656                                     "}\n"
 657                                     "}\n"));
 658   EXPECT_EQ("namespace {\n"
 659             "  int i;\n"
 660             "  int j;\n"
 661             "}// namespace\n"
 662             "#if A\n"
 663             "  int i;\n"
 664             "#else\n"
 665             "  int j;\n"
 666             "#endif",
 667             fixNamespaceEndComments("namespace {\n"
 668                                     "  int i;\n"
 669                                     "  int j;\n"
 670                                     "}\n"
 671                                     "#if A\n"
 672                                     "  int i;\n"
 673                                     "#else\n"
 674                                     "  int j;\n"
 675                                     "#endif"));
 676   EXPECT_EQ("#if A\n"
 677             "namespace A {\n"
 678             "#else\n"
 679             "namespace B {\n"
 680             "#endif\n"
 681             "int i;\n"
 682             "int j;\n"
 683             "}",
 684             fixNamespaceEndComments("#if A\n"
 685                                     "namespace A {\n"
 686                                     "#else\n"
 687                                     "namespace B {\n"
 688                                     "#endif\n"
 689                                     "int i;\n"
 690                                     "int j;\n"
 691                                     "}"));
 692   EXPECT_EQ("#if A\n"
 693             "namespace A {\n"
 694             "#else\n"
 695             "namespace B {\n"
 696             "#endif\n"
 697             "int i;\n"
 698             "int j;\n"
 699             "} // namespace A",
 700             fixNamespaceEndComments("#if A\n"
 701                                     "namespace A {\n"
 702                                     "#else\n"
 703                                     "namespace B {\n"
 704                                     "#endif\n"
 705                                     "int i;\n"
 706                                     "int j;\n"
 707                                     "} // namespace A"));
 708   EXPECT_EQ("#if A\n"
 709             "namespace A {\n"
 710             "#else\n"
 711             "namespace B {\n"
 712             "#endif\n"
 713             "int i;\n"
 714             "int j;\n"
 715             "} // namespace B",
 716             fixNamespaceEndComments("#if A\n"
 717                                     "namespace A {\n"
 718                                     "#else\n"
 719                                     "namespace B {\n"
 720                                     "#endif\n"
 721                                     "int i;\n"
 722                                     "int j;\n"
 723                                     "} // namespace B"));
 724   EXPECT_EQ("namespace A\n"
 725             "int i;\n"
 726             "int j;\n"
 727             "#if A\n"
 728             "}\n"
 729             "#else\n"
 730             "}\n"
 731             "#endif",
 732             fixNamespaceEndComments("namespace A\n"
 733                                     "int i;\n"
 734                                     "int j;\n"
 735                                     "#if A\n"
 736                                     "}\n"
 737                                     "#else\n"
 738                                     "}\n"
 739                                     "#endif"));
 740   EXPECT_EQ("namespace A\n"
 741             "int i;\n"
 742             "int j;\n"
 743             "#if A\n"
 744             "} // namespace A\n"
 745             "#else\n"
 746             "} // namespace A\n"
 747             "#endif",
 748             fixNamespaceEndComments("namespace A\n"
 749                                     "int i;\n"
 750                                     "int j;\n"
 751                                     "#if A\n"
 752                                     "} // namespace A\n"
 753                                     "#else\n"
 754                                     "} // namespace A\n"
 755                                     "#endif"));
 756 }
 757
 758 TEST_F(NamespaceEndCommentsFixerTest,
 759        DoesNotAddEndCommentForUnbalancedRBracesAfterNamespaceEnd) {
 760   EXPECT_EQ("namespace {\n"
 761             "  int i;\n"
 762             "} // namespace\n"
 763             "}",
 764             fixNamespaceEndComments("namespace {\n"
 765                                     "  int i;\n"
 766                                     "} // namespace\n"
 767                                     "}"));
 768 }
 769
 770 TEST_F(NamespaceEndCommentsFixerTest, HandlesInlineAtEndOfLine_PR32438) {
 771   EXPECT_EQ("template <int> struct a {};\n"
 772             "struct a<bool{}> b() {\n"
 773             "}\n"
 774             "#define c inline\n"
 775             "void d() {\n"
 776             "}\n",
 777             fixNamespaceEndComments("template <int> struct a {};\n"
 778                                     "struct a<bool{}> b() {\n"
 779                                     "}\n"
 780                                     "#define c inline\n"
 781                                     "void d() {\n"
 782                                     "}\n"));
 783 }
 784 } // end namespace
 785 } // end namespace format
 786 } // end namespace clang