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 DEBUG(llvm::errs() << "---\n"); 27 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 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 376