unittests/Format/UsingDeclarationsSorterTest.cpp

   1 //===- UsingDeclarationsSorterTest.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 "llvm/Support/Debug.h"
  13 #include "gtest/gtest.h"
  14
  15 #define DEBUG_TYPE "using-declarations-sorter-test"
  16
  17 namespace clang {
  18 namespace format {
  19 namespace {
  20
  21 class UsingDeclarationsSorterTest : public ::testing::Test {
  22 protected:
  23   std::string sortUsingDeclarations(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::sortUsingDeclarations(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 sortUsingDeclarations(llvm::StringRef Code,
  37                                     const FormatStyle &Style = getLLVMStyle()) {
  38     return sortUsingDeclarations(Code,
  39                                  /*Ranges=*/{1, tooling::Range(0, Code.size())},
  40                                  Style);
  41   }
  42 };
  43
  44 TEST_F(UsingDeclarationsSorterTest, SwapsTwoConsecutiveUsingDeclarations) {
  45   EXPECT_EQ("using a;\n"
  46             "using b;",
  47             sortUsingDeclarations("using a;\n"
  48                                   "using b;"));
  49   EXPECT_EQ("using a;\n"
  50             "using aa;",
  51             sortUsingDeclarations("using aa;\n"
  52                                   "using a;"));
  53   EXPECT_EQ("using a;\n"
  54             "using ::a;",
  55             sortUsingDeclarations("using a;\n"
  56                                   "using ::a;"));
  57
  58   EXPECT_EQ("using a::bcd;\n"
  59             "using a::cd;",
  60             sortUsingDeclarations("using a::cd;\n"
  61                                   "using a::bcd;"));
  62
  63   EXPECT_EQ("using a;\n"
  64             "using a::a;",
  65             sortUsingDeclarations("using a::a;\n"
  66                                   "using a;"));
  67
  68   EXPECT_EQ("using a::ba::aa;\n"
  69             "using a::bb::ccc;",
  70             sortUsingDeclarations("using a::bb::ccc;\n"
  71                                   "using a::ba::aa;"));
  72
  73   EXPECT_EQ("using a;\n"
  74             "using typename a;",
  75             sortUsingDeclarations("using typename a;\n"
  76                                   "using a;"));
  77
  78   EXPECT_EQ("using typename z;\n"
  79             "using typenamea;",
  80             sortUsingDeclarations("using typenamea;\n"
  81                                   "using typename z;"));
  82
  83   EXPECT_EQ("using a, b;\n"
  84             "using aa;",
  85             sortUsingDeclarations("using aa;\n"
  86                                   "using a, b;"));
  87 }
  88
  89 TEST_F(UsingDeclarationsSorterTest, UsingDeclarationOrder) {
  90   EXPECT_EQ("using A;\n"
  91             "using a;",
  92             sortUsingDeclarations("using A;\n"
  93                                   "using a;"));
  94   EXPECT_EQ("using a;\n"
  95             "using A;",
  96             sortUsingDeclarations("using a;\n"
  97                                   "using A;"));
  98   EXPECT_EQ("using a;\n"
  99             "using B;",
 100             sortUsingDeclarations("using B;\n"
 101                                   "using a;"));
 102
 103   // Ignores leading '::'.
 104   EXPECT_EQ("using ::a;\n"
 105             "using A;",
 106             sortUsingDeclarations("using ::a;\n"
 107                                   "using A;"));
 108
 109   EXPECT_EQ("using ::A;\n"
 110             "using a;",
 111             sortUsingDeclarations("using ::A;\n"
 112                                   "using a;"));
 113
 114   // Sorts '_' before 'a' and 'A'.
 115   EXPECT_EQ("using _;\n"
 116             "using A;",
 117             sortUsingDeclarations("using A;\n"
 118                                   "using _;"));
 119   EXPECT_EQ("using _;\n"
 120             "using a;",
 121             sortUsingDeclarations("using a;\n"
 122                                   "using _;"));
 123   EXPECT_EQ("using a::_;\n"
 124             "using a::a;",
 125             sortUsingDeclarations("using a::a;\n"
 126                                   "using a::_;"));
 127
 128   // Sorts non-namespace names before namespace names at the same level.
 129   EXPECT_EQ("using ::testing::_;\n"
 130             "using ::testing::Aardvark;\n"
 131             "using ::testing::kMax;\n"
 132             "using ::testing::Xylophone;\n"
 133             "using ::testing::apple::Honeycrisp;\n"
 134             "using ::testing::zebra::Stripes;",
 135             sortUsingDeclarations("using ::testing::Aardvark;\n"
 136                                   "using ::testing::Xylophone;\n"
 137                                   "using ::testing::kMax;\n"
 138                                   "using ::testing::_;\n"
 139                                   "using ::testing::apple::Honeycrisp;\n"
 140                                   "using ::testing::zebra::Stripes;"));
 141 }
 142
 143 TEST_F(UsingDeclarationsSorterTest, SortsStably) {
 144   EXPECT_EQ("using a;\n"
 145             "using A;\n"
 146             "using a;\n"
 147             "using A;\n"
 148             "using a;\n"
 149             "using A;\n"
 150             "using a;\n"
 151             "using B;\n"
 152             "using b;\n"
 153             "using B;\n"
 154             "using b;\n"
 155             "using B;\n"
 156             "using b;",
 157             sortUsingDeclarations("using a;\n"
 158                                   "using B;\n"
 159                                   "using a;\n"
 160                                   "using b;\n"
 161                                   "using A;\n"
 162                                   "using a;\n"
 163                                   "using b;\n"
 164                                   "using B;\n"
 165                                   "using b;\n"
 166                                   "using A;\n"
 167                                   "using a;\n"
 168                                   "using b;\n"
 169                                   "using b;\n"
 170                                   "using B;\n"
 171                                   "using b;\n"
 172                                   "using A;\n"
 173                                   "using a;"));
 174 }
 175
 176 TEST_F(UsingDeclarationsSorterTest, SortsMultipleTopLevelDeclarations) {
 177   EXPECT_EQ("using a;\n"
 178             "using b;\n"
 179             "using c;\n"
 180             "using d;\n"
 181             "using e;",
 182             sortUsingDeclarations("using d;\n"
 183                                   "using b;\n"
 184                                   "using e;\n"
 185                                   "using a;\n"
 186                                   "using c;"));
 187
 188   EXPECT_EQ("#include <iostream>\n"
 189             "using std::cin;\n"
 190             "using std::cout;\n"
 191             "using ::std::endl;\n"
 192             "int main();",
 193             sortUsingDeclarations("#include <iostream>\n"
 194                                   "using std::cout;\n"
 195                                   "using ::std::endl;\n"
 196                                   "using std::cin;\n"
 197                                   "int main();"));
 198 }
 199
 200 TEST_F(UsingDeclarationsSorterTest, BreaksOnEmptyLines) {
 201   EXPECT_EQ("using b;\n"
 202             "using c;\n"
 203             "\n"
 204             "using a;\n"
 205             "using d;",
 206             sortUsingDeclarations("using c;\n"
 207                                   "using b;\n"
 208                                   "\n"
 209                                   "using d;\n"
 210                                   "using a;"));
 211 }
 212
 213 TEST_F(UsingDeclarationsSorterTest, BreaksOnUsingNamespace) {
 214   EXPECT_EQ("using b;\n"
 215             "using namespace std;\n"
 216             "using a;",
 217             sortUsingDeclarations("using b;\n"
 218                                   "using namespace std;\n"
 219                                   "using a;"));
 220 }
 221
 222 TEST_F(UsingDeclarationsSorterTest, KeepsUsingDeclarationsInPPDirectives) {
 223   EXPECT_EQ("#define A \\\n"
 224             "using b;\\\n"
 225             "using a;",
 226             sortUsingDeclarations("#define A \\\n"
 227                                   "using b;\\\n"
 228                                   "using a;"));
 229 }
 230
 231 TEST_F(UsingDeclarationsSorterTest, KeepsTypeAliases) {
 232   auto Code = "struct C { struct B { struct A; }; };\n"
 233               "using B = C::B;\n"
 234               "using A = B::A;";
 235   EXPECT_EQ(Code, sortUsingDeclarations(Code));
 236 }
 237
 238 TEST_F(UsingDeclarationsSorterTest, MovesTrailingCommentsWithDeclarations) {
 239   EXPECT_EQ("using a; // line a1\n"
 240             "using b; /* line b1\n"
 241             "          * line b2\n"
 242             "          * line b3 */\n"
 243             "using c; // line c1\n"
 244             "         // line c2",
 245             sortUsingDeclarations("using c; // line c1\n"
 246                                   "         // line c2\n"
 247                                   "using b; /* line b1\n"
 248                                   "          * line b2\n"
 249                                   "          * line b3 */\n"
 250                                   "using a; // line a1"));
 251 }
 252
 253 TEST_F(UsingDeclarationsSorterTest, SortsInStructScope) {
 254   EXPECT_EQ("struct pt3 : pt2 {\n"
 255             "  using pt2::x;\n"
 256             "  using pt2::y;\n"
 257             "  float z;\n"
 258             "};",
 259             sortUsingDeclarations("struct pt3 : pt2 {\n"
 260                                   "  using pt2::y;\n"
 261                                   "  using pt2::x;\n"
 262                                   "  float z;\n"
 263                                   "};"));
 264 }
 265
 266 TEST_F(UsingDeclarationsSorterTest, KeepsOperators) {
 267   EXPECT_EQ("using a::operator();\n"
 268             "using a::operator-;\n"
 269             "using a::operator+;",
 270             sortUsingDeclarations("using a::operator();\n"
 271                                   "using a::operator-;\n"
 272                                   "using a::operator+;"));
 273 }
 274
 275 TEST_F(UsingDeclarationsSorterTest, SortsUsingDeclarationsInsideNamespaces) {
 276   EXPECT_EQ("namespace A {\n"
 277             "struct B;\n"
 278             "struct C;\n"
 279             "}\n"
 280             "namespace X {\n"
 281             "using A::B;\n"
 282             "using A::C;\n"
 283             "}",
 284             sortUsingDeclarations("namespace A {\n"
 285                                   "struct B;\n"
 286                                   "struct C;\n"
 287                                   "}\n"
 288                                   "namespace X {\n"
 289                                   "using A::C;\n"
 290                                   "using A::B;\n"
 291                                   "}"));
 292 }
 293
 294 TEST_F(UsingDeclarationsSorterTest, SupportsClangFormatOff) {
 295   EXPECT_EQ("// clang-format off\n"
 296             "using b;\n"
 297             "using a;\n"
 298             "// clang-format on\n"
 299             "using c;\n"
 300             "using d;",
 301             sortUsingDeclarations("// clang-format off\n"
 302                                   "using b;\n"
 303                                   "using a;\n"
 304                                   "// clang-format on\n"
 305                                   "using d;\n"
 306                                   "using c;"));
 307 }
 308
 309 TEST_F(UsingDeclarationsSorterTest, SortsPartialRangeOfUsingDeclarations) {
 310   // Sorts the whole block of using declarations surrounding the range.
 311   EXPECT_EQ("using a;\n"
 312             "using b;\n"
 313             "using c;",
 314             sortUsingDeclarations("using b;\n"
 315                                   "using c;\n" // starts at offset 10
 316                                   "using a;",
 317                                   {tooling::Range(10, 15)}));
 318   EXPECT_EQ("using a;\n"
 319             "using b;\n"
 320             "using c;\n"
 321             "using A = b;",
 322             sortUsingDeclarations("using b;\n"
 323                                   "using c;\n" // starts at offset 10
 324                                   "using a;\n"
 325                                   "using A = b;",
 326                                   {tooling::Range(10, 15)}));
 327
 328   EXPECT_EQ("using d;\n"
 329             "using c;\n"
 330             "\n"
 331             "using a;\n"
 332             "using b;\n"
 333             "\n"
 334             "using f;\n"
 335             "using e;",
 336             sortUsingDeclarations("using d;\n"
 337                                   "using c;\n"
 338                                   "\n"
 339                                   "using b;\n" // starts at offset 19
 340                                   "using a;\n"
 341                                   "\n"
 342                                   "using f;\n"
 343                                   "using e;",
 344                                   {tooling::Range(19, 1)}));
 345 }
 346
 347 TEST_F(UsingDeclarationsSorterTest, SortsUsingDeclarationsWithLeadingkComments) {
 348   EXPECT_EQ("/* comment */ using a;\n"
 349             "/* comment */ using b;",
 350             sortUsingDeclarations("/* comment */ using b;\n"
 351                                   "/* comment */ using a;"));
 352 }
 353
 354 TEST_F(UsingDeclarationsSorterTest, DeduplicatesUsingDeclarations) {
 355   EXPECT_EQ("using a;\n"
 356             "using b;\n"
 357             "using c;\n"
 358             "\n"
 359             "using a;\n"
 360             "using e;",
 361             sortUsingDeclarations("using c;\n"
 362                                   "using a;\n"
 363                                   "using b;\n"
 364                                   "using a;\n"
 365                                   "using b;\n"
 366                                   "\n"
 367                                   "using e;\n"
 368                                   "using a;\n"
 369                                   "using e;"));
 370
 371 }
 372
 373 } // end namespace
 374 } // end namespace format
 375 } // end namespace clang