821 lines · cpp
1//===- UsingDeclarationsSorterTest.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-exception6//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 "using-declarations-sorter-test"15 16namespace clang {17namespace format {18namespace {19 20class UsingDeclarationsSorterTest : public testing::Test {21protected:22 std::string sortUsingDeclarations(StringRef Code,23 const std::vector<tooling::Range> &Ranges,24 const FormatStyle &Style = getLLVMStyle()) {25 LLVM_DEBUG(llvm::errs() << "---\n");26 LLVM_DEBUG(llvm::errs() << Code << "\n\n");27 tooling::Replacements Replaces =28 format::sortUsingDeclarations(Style, Code, Ranges, "<stdin>");29 auto Result = applyAllReplacements(Code, Replaces);30 EXPECT_TRUE(static_cast<bool>(Result));31 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");32 return *Result;33 }34 35 std::string sortUsingDeclarations(StringRef Code,36 const FormatStyle &Style = getLLVMStyle()) {37 return sortUsingDeclarations(Code,38 /*Ranges=*/{1, tooling::Range(0, Code.size())},39 Style);40 }41};42 43TEST_F(UsingDeclarationsSorterTest, SwapsTwoConsecutiveUsingDeclarations) {44 FormatStyle Style = getLLVMStyle();45 EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);46 EXPECT_EQ("using a;\n"47 "using b;",48 sortUsingDeclarations("using a;\n"49 "using b;",50 Style));51 EXPECT_EQ("using a;\n"52 "using aa;",53 sortUsingDeclarations("using aa;\n"54 "using a;",55 Style));56 EXPECT_EQ("using a;\n"57 "using ::a;",58 sortUsingDeclarations("using a;\n"59 "using ::a;",60 Style));61 62 EXPECT_EQ("using a::bcd;\n"63 "using a::cd;",64 sortUsingDeclarations("using a::cd;\n"65 "using a::bcd;",66 Style));67 68 EXPECT_EQ("using a;\n"69 "using a::a;",70 sortUsingDeclarations("using a::a;\n"71 "using a;",72 Style));73 74 EXPECT_EQ("using a::ba::aa;\n"75 "using a::bb::ccc;",76 sortUsingDeclarations("using a::bb::ccc;\n"77 "using a::ba::aa;",78 Style));79 80 EXPECT_EQ("using a;\n"81 "using typename a;",82 sortUsingDeclarations("using typename a;\n"83 "using a;",84 Style));85 86 EXPECT_EQ("using typename z;\n"87 "using typenamea;",88 sortUsingDeclarations("using typenamea;\n"89 "using typename z;",90 Style));91 92 EXPECT_EQ("using a, b;\n"93 "using aa;",94 sortUsingDeclarations("using aa;\n"95 "using a, b;",96 Style));97 98 Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;99 EXPECT_EQ("using a;\n"100 "using b;",101 sortUsingDeclarations("using a;\n"102 "using b;",103 Style));104 EXPECT_EQ("using a;\n"105 "using aa;",106 sortUsingDeclarations("using aa;\n"107 "using a;",108 Style));109 EXPECT_EQ("using a;\n"110 "using ::a;",111 sortUsingDeclarations("using a;\n"112 "using ::a;",113 Style));114 115 EXPECT_EQ("using a::bcd;\n"116 "using a::cd;",117 sortUsingDeclarations("using a::cd;\n"118 "using a::bcd;",119 Style));120 121 EXPECT_EQ("using a;\n"122 "using a::a;",123 sortUsingDeclarations("using a::a;\n"124 "using a;",125 Style));126 127 EXPECT_EQ("using a::ba::aa;\n"128 "using a::bb::ccc;",129 sortUsingDeclarations("using a::bb::ccc;\n"130 "using a::ba::aa;",131 Style));132 133 EXPECT_EQ("using a;\n"134 "using typename a;",135 sortUsingDeclarations("using typename a;\n"136 "using a;",137 Style));138 139 EXPECT_EQ("using typename z;\n"140 "using typenamea;",141 sortUsingDeclarations("using typenamea;\n"142 "using typename z;",143 Style));144 145 EXPECT_EQ("using a, b;\n"146 "using aa;",147 sortUsingDeclarations("using aa;\n"148 "using a, b;",149 Style));150}151 152TEST_F(UsingDeclarationsSorterTest, UsingDeclarationOrder) {153 FormatStyle Style = getLLVMStyle();154 EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);155 EXPECT_EQ("using A;\n"156 "using a;",157 sortUsingDeclarations("using A;\n"158 "using a;",159 Style));160 EXPECT_EQ("using a;\n"161 "using A;",162 sortUsingDeclarations("using a;\n"163 "using A;",164 Style));165 EXPECT_EQ("using a;\n"166 "using B;",167 sortUsingDeclarations("using B;\n"168 "using a;",169 Style));170 171 // Ignores leading '::'.172 EXPECT_EQ("using ::a;\n"173 "using A;",174 sortUsingDeclarations("using ::a;\n"175 "using A;",176 Style));177 178 EXPECT_EQ("using ::A;\n"179 "using a;",180 sortUsingDeclarations("using ::A;\n"181 "using a;",182 Style));183 184 // Sorts '_' before 'a' and 'A'.185 EXPECT_EQ("using _;\n"186 "using A;",187 sortUsingDeclarations("using A;\n"188 "using _;",189 Style));190 EXPECT_EQ("using _;\n"191 "using a;",192 sortUsingDeclarations("using a;\n"193 "using _;",194 Style));195 EXPECT_EQ("using a::_;\n"196 "using a::a;",197 sortUsingDeclarations("using a::a;\n"198 "using a::_;",199 Style));200 201 // Sorts non-namespace names before namespace names at the same level.202 EXPECT_EQ("using ::testing::_;\n"203 "using ::testing::Aardvark;\n"204 "using ::testing::kMax;\n"205 "using ::testing::Xylophone;\n"206 "using ::testing::apple::Honeycrisp;\n"207 "using ::testing::zebra::Stripes;",208 sortUsingDeclarations("using ::testing::Aardvark;\n"209 "using ::testing::Xylophone;\n"210 "using ::testing::kMax;\n"211 "using ::testing::_;\n"212 "using ::testing::apple::Honeycrisp;\n"213 "using ::testing::zebra::Stripes;",214 Style));215 216 Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;217 EXPECT_EQ("using A;\n"218 "using a;",219 sortUsingDeclarations("using A;\n"220 "using a;",221 Style));222 EXPECT_EQ("using a;\n"223 "using A;",224 sortUsingDeclarations("using a;\n"225 "using A;",226 Style));227 EXPECT_EQ("using a;\n"228 "using B;",229 sortUsingDeclarations("using B;\n"230 "using a;",231 Style));232 233 // Ignores leading '::'.234 EXPECT_EQ("using ::a;\n"235 "using A;",236 sortUsingDeclarations("using ::a;\n"237 "using A;",238 Style));239 240 EXPECT_EQ("using ::A;\n"241 "using a;",242 sortUsingDeclarations("using ::A;\n"243 "using a;",244 Style));245 246 // Sorts '_' before 'a' and 'A'.247 EXPECT_EQ("using _;\n"248 "using A;",249 sortUsingDeclarations("using A;\n"250 "using _;",251 Style));252 EXPECT_EQ("using _;\n"253 "using a;",254 sortUsingDeclarations("using a;\n"255 "using _;",256 Style));257 EXPECT_EQ("using a::_;\n"258 "using a::a;",259 sortUsingDeclarations("using a::a;\n"260 "using a::_;",261 Style));262 263 // Sorts non-namespace names before namespace names at the same level.264 EXPECT_EQ("using ::testing::_;\n"265 "using ::testing::Aardvark;\n"266 "using ::testing::apple::Honeycrisp;\n"267 "using ::testing::kMax;\n"268 "using ::testing::Xylophone;\n"269 "using ::testing::zebra::Stripes;",270 sortUsingDeclarations("using ::testing::Aardvark;\n"271 "using ::testing::Xylophone;\n"272 "using ::testing::kMax;\n"273 "using ::testing::_;\n"274 "using ::testing::apple::Honeycrisp;\n"275 "using ::testing::zebra::Stripes;",276 Style));277}278 279TEST_F(UsingDeclarationsSorterTest, SortsStably) {280 FormatStyle Style = getLLVMStyle();281 EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);282 EXPECT_EQ("using a;\n"283 "using A;\n"284 "using a;\n"285 "using A;\n"286 "using a;\n"287 "using A;\n"288 "using a;\n"289 "using B;\n"290 "using b;\n"291 "using B;\n"292 "using b;\n"293 "using B;\n"294 "using b;",295 sortUsingDeclarations("using a;\n"296 "using B;\n"297 "using a;\n"298 "using b;\n"299 "using A;\n"300 "using a;\n"301 "using b;\n"302 "using B;\n"303 "using b;\n"304 "using A;\n"305 "using a;\n"306 "using b;\n"307 "using b;\n"308 "using B;\n"309 "using b;\n"310 "using A;\n"311 "using a;",312 Style));313 314 Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;315 EXPECT_EQ("using a;\n"316 "using A;\n"317 "using a;\n"318 "using A;\n"319 "using a;\n"320 "using A;\n"321 "using a;\n"322 "using B;\n"323 "using b;\n"324 "using B;\n"325 "using b;\n"326 "using B;\n"327 "using b;",328 sortUsingDeclarations("using a;\n"329 "using B;\n"330 "using a;\n"331 "using b;\n"332 "using A;\n"333 "using a;\n"334 "using b;\n"335 "using B;\n"336 "using b;\n"337 "using A;\n"338 "using a;\n"339 "using b;\n"340 "using b;\n"341 "using B;\n"342 "using b;\n"343 "using A;\n"344 "using a;",345 Style));346}347 348TEST_F(UsingDeclarationsSorterTest, SortsMultipleTopLevelDeclarations) {349 FormatStyle Style = getLLVMStyle();350 EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);351 EXPECT_EQ("using a;\n"352 "using b;\n"353 "using c;\n"354 "using d;\n"355 "using e;",356 sortUsingDeclarations("using d;\n"357 "using b;\n"358 "using e;\n"359 "using a;\n"360 "using c;",361 Style));362 363 EXPECT_EQ("#include <iostream>\n"364 "using std::cin;\n"365 "using std::cout;\n"366 "using ::std::endl;\n"367 "int main();",368 sortUsingDeclarations("#include <iostream>\n"369 "using std::cout;\n"370 "using ::std::endl;\n"371 "using std::cin;\n"372 "int main();",373 Style));374 375 Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;376 EXPECT_EQ("using a;\n"377 "using b;\n"378 "using c;\n"379 "using d;\n"380 "using e;",381 sortUsingDeclarations("using d;\n"382 "using b;\n"383 "using e;\n"384 "using a;\n"385 "using c;",386 Style));387 388 EXPECT_EQ("#include <iostream>\n"389 "using std::cin;\n"390 "using std::cout;\n"391 "using ::std::endl;\n"392 "int main();",393 sortUsingDeclarations("#include <iostream>\n"394 "using std::cout;\n"395 "using ::std::endl;\n"396 "using std::cin;\n"397 "int main();",398 Style));399}400 401TEST_F(UsingDeclarationsSorterTest, BreaksOnEmptyLines) {402 FormatStyle Style = getLLVMStyle();403 EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);404 EXPECT_EQ("using b;\n"405 "using c;\n"406 "\n"407 "using a;\n"408 "using d;",409 sortUsingDeclarations("using c;\n"410 "using b;\n"411 "\n"412 "using d;\n"413 "using a;",414 Style));415 416 Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;417 EXPECT_EQ("using b;\n"418 "using c;\n"419 "\n"420 "using a;\n"421 "using d;",422 sortUsingDeclarations("using c;\n"423 "using b;\n"424 "\n"425 "using d;\n"426 "using a;",427 Style));428}429 430TEST_F(UsingDeclarationsSorterTest, BreaksOnUsingNamespace) {431 FormatStyle Style = getLLVMStyle();432 EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);433 EXPECT_EQ("using b;\n"434 "using namespace std;\n"435 "using a;",436 sortUsingDeclarations("using b;\n"437 "using namespace std;\n"438 "using a;",439 Style));440 441 Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;442 EXPECT_EQ("using b;\n"443 "using namespace std;\n"444 "using a;",445 sortUsingDeclarations("using b;\n"446 "using namespace std;\n"447 "using a;",448 Style));449}450 451TEST_F(UsingDeclarationsSorterTest, KeepsUsingDeclarationsInPPDirectives) {452 FormatStyle Style = getLLVMStyle();453 EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);454 EXPECT_EQ("#define A \\\n"455 "using b;\\\n"456 "using a;",457 sortUsingDeclarations("#define A \\\n"458 "using b;\\\n"459 "using a;",460 Style));461 462 Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;463 EXPECT_EQ("#define A \\\n"464 "using b;\\\n"465 "using a;",466 sortUsingDeclarations("#define A \\\n"467 "using b;\\\n"468 "using a;",469 Style));470}471 472TEST_F(UsingDeclarationsSorterTest, KeepsTypeAliases) {473 auto Code = "struct C { struct B { struct A; }; };\n"474 "using B = C::B;\n"475 "using A = B::A;";476 477 FormatStyle Style = getLLVMStyle();478 EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);479 EXPECT_EQ(Code, sortUsingDeclarations(Code, Style));480 481 Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;482 EXPECT_EQ(Code, sortUsingDeclarations(Code, Style));483}484 485TEST_F(UsingDeclarationsSorterTest, MovesTrailingCommentsWithDeclarations) {486 FormatStyle Style = getLLVMStyle();487 EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);488 EXPECT_EQ("using a; // line a1\n"489 "using b; /* line b1\n"490 " * line b2\n"491 " * line b3 */\n"492 "using c; // line c1\n"493 " // line c2",494 sortUsingDeclarations("using c; // line c1\n"495 " // line c2\n"496 "using b; /* line b1\n"497 " * line b2\n"498 " * line b3 */\n"499 "using a; // line a1",500 Style));501 502 Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;503 EXPECT_EQ("using a; // line a1\n"504 "using b; /* line b1\n"505 " * line b2\n"506 " * line b3 */\n"507 "using c; // line c1\n"508 " // line c2",509 sortUsingDeclarations("using c; // line c1\n"510 " // line c2\n"511 "using b; /* line b1\n"512 " * line b2\n"513 " * line b3 */\n"514 "using a; // line a1",515 Style));516}517 518TEST_F(UsingDeclarationsSorterTest, SortsInStructScope) {519 FormatStyle Style = getLLVMStyle();520 EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);521 EXPECT_EQ("struct pt3 : pt2 {\n"522 " using pt2::x;\n"523 " using pt2::y;\n"524 " float z;\n"525 "};",526 sortUsingDeclarations("struct pt3 : pt2 {\n"527 " using pt2::y;\n"528 " using pt2::x;\n"529 " float z;\n"530 "};",531 Style));532 533 Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;534 EXPECT_EQ("struct pt3 : pt2 {\n"535 " using pt2::x;\n"536 " using pt2::y;\n"537 " float z;\n"538 "};",539 sortUsingDeclarations("struct pt3 : pt2 {\n"540 " using pt2::y;\n"541 " using pt2::x;\n"542 " float z;\n"543 "};",544 Style));545}546 547TEST_F(UsingDeclarationsSorterTest, KeepsOperators) {548 FormatStyle Style = getLLVMStyle();549 EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);550 EXPECT_EQ("using a::operator();\n"551 "using a::operator-;\n"552 "using a::operator+;",553 sortUsingDeclarations("using a::operator();\n"554 "using a::operator-;\n"555 "using a::operator+;",556 Style));557 558 Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;559 EXPECT_EQ("using a::operator();\n"560 "using a::operator-;\n"561 "using a::operator+;",562 sortUsingDeclarations("using a::operator();\n"563 "using a::operator-;\n"564 "using a::operator+;",565 Style));566}567 568TEST_F(UsingDeclarationsSorterTest, SortsUsingDeclarationsInsideNamespaces) {569 FormatStyle Style = getLLVMStyle();570 EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);571 EXPECT_EQ("namespace A {\n"572 "struct B;\n"573 "struct C;\n"574 "}\n"575 "namespace X {\n"576 "using A::B;\n"577 "using A::C;\n"578 "}",579 sortUsingDeclarations("namespace A {\n"580 "struct B;\n"581 "struct C;\n"582 "}\n"583 "namespace X {\n"584 "using A::C;\n"585 "using A::B;\n"586 "}",587 Style));588 589 Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;590 EXPECT_EQ("namespace A {\n"591 "struct B;\n"592 "struct C;\n"593 "}\n"594 "namespace X {\n"595 "using A::B;\n"596 "using A::C;\n"597 "}",598 sortUsingDeclarations("namespace A {\n"599 "struct B;\n"600 "struct C;\n"601 "}\n"602 "namespace X {\n"603 "using A::C;\n"604 "using A::B;\n"605 "}",606 Style));607}608 609TEST_F(UsingDeclarationsSorterTest, SupportsClangFormatOff) {610 FormatStyle Style = getLLVMStyle();611 EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);612 EXPECT_EQ("// clang-format off\n"613 "using b;\n"614 "using a;\n"615 "// clang-format on\n"616 "using c;\n"617 "using d;",618 sortUsingDeclarations("// clang-format off\n"619 "using b;\n"620 "using a;\n"621 "// clang-format on\n"622 "using d;\n"623 "using c;",624 Style));625 626 Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;627 EXPECT_EQ("// clang-format off\n"628 "using b;\n"629 "using a;\n"630 "// clang-format on\n"631 "using c;\n"632 "using d;",633 sortUsingDeclarations("// clang-format off\n"634 "using b;\n"635 "using a;\n"636 "// clang-format on\n"637 "using d;\n"638 "using c;",639 Style));640}641 642TEST_F(UsingDeclarationsSorterTest, SortsPartialRangeOfUsingDeclarations) {643 FormatStyle Style = getLLVMStyle();644 EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);645 // Sorts the whole block of using declarations surrounding the range.646 EXPECT_EQ("using a;\n"647 "using b;\n"648 "using c;",649 sortUsingDeclarations("using b;\n"650 "using c;\n" // starts at offset 10651 "using a;",652 {tooling::Range(10, 15)}, Style));653 EXPECT_EQ("using a;\n"654 "using b;\n"655 "using c;\n"656 "using A = b;",657 sortUsingDeclarations("using b;\n"658 "using c;\n" // starts at offset 10659 "using a;\n"660 "using A = b;",661 {tooling::Range(10, 15)}, Style));662 663 EXPECT_EQ("using d;\n"664 "using c;\n"665 "\n"666 "using a;\n"667 "using b;\n"668 "\n"669 "using f;\n"670 "using e;",671 sortUsingDeclarations("using d;\n"672 "using c;\n"673 "\n"674 "using b;\n" // starts at offset 19675 "using a;\n"676 "\n"677 "using f;\n"678 "using e;",679 {tooling::Range(19, 1)}, Style));680 681 Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;682 // Sorts the whole block of using declarations surrounding the range.683 EXPECT_EQ("using a;\n"684 "using b;\n"685 "using c;",686 sortUsingDeclarations("using b;\n"687 "using c;\n" // starts at offset 10688 "using a;",689 {tooling::Range(10, 15)}, Style));690 EXPECT_EQ("using a;\n"691 "using b;\n"692 "using c;\n"693 "using A = b;",694 sortUsingDeclarations("using b;\n"695 "using c;\n" // starts at offset 10696 "using a;\n"697 "using A = b;",698 {tooling::Range(10, 15)}, Style));699 700 EXPECT_EQ("using d;\n"701 "using c;\n"702 "\n"703 "using a;\n"704 "using b;\n"705 "\n"706 "using f;\n"707 "using e;",708 sortUsingDeclarations("using d;\n"709 "using c;\n"710 "\n"711 "using b;\n" // starts at offset 19712 "using a;\n"713 "\n"714 "using f;\n"715 "using e;",716 {tooling::Range(19, 1)}, Style));717}718 719TEST_F(UsingDeclarationsSorterTest,720 SortsUsingDeclarationsWithLeadingkComments) {721 FormatStyle Style = getLLVMStyle();722 EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);723 EXPECT_EQ("/* comment */ using a;\n"724 "/* comment */ using b;",725 sortUsingDeclarations("/* comment */ using b;\n"726 "/* comment */ using a;",727 Style));728 729 Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;730 EXPECT_EQ("/* comment */ using a;\n"731 "/* comment */ using b;",732 sortUsingDeclarations("/* comment */ using b;\n"733 "/* comment */ using a;",734 Style));735}736 737TEST_F(UsingDeclarationsSorterTest, DeduplicatesUsingDeclarations) {738 FormatStyle Style = getLLVMStyle();739 EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);740 EXPECT_EQ("using a;\n"741 "using b;\n"742 "using c;\n"743 "\n"744 "using a;\n"745 "using e;",746 sortUsingDeclarations("using c;\n"747 "using a;\n"748 "using b;\n"749 "using a;\n"750 "using b;\n"751 "\n"752 "using e;\n"753 "using a;\n"754 "using e;",755 Style));756 757 Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;758 EXPECT_EQ("using a;\n"759 "using b;\n"760 "using c;\n"761 "\n"762 "using a;\n"763 "using e;",764 sortUsingDeclarations("using c;\n"765 "using a;\n"766 "using b;\n"767 "using a;\n"768 "using b;\n"769 "\n"770 "using e;\n"771 "using a;\n"772 "using e;",773 Style));774}775 776TEST_F(UsingDeclarationsSorterTest,777 SortsUsingDeclarationsWithDifferentCountsOfScopes) {778 FormatStyle Style = getLLVMStyle();779 EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);780 EXPECT_EQ("using boost::regex;\n"781 "using boost::regex_constants::icase;\n"782 "using std::move;\n"783 "using std::string;\n"784 "using std::chrono::duration_cast;\n"785 "using std::chrono::microseconds;\n"786 "using std::chrono::seconds;\n"787 "using std::chrono::steady_clock;",788 sortUsingDeclarations("using boost::regex;\n"789 "using boost::regex_constants::icase;\n"790 "using std::chrono::duration_cast;\n"791 "using std::chrono::microseconds;\n"792 "using std::chrono::seconds;\n"793 "using std::chrono::steady_clock;\n"794 "using std::move;\n"795 "using std::string;",796 Style));797 798 Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;799 EXPECT_EQ("using boost::regex;\n"800 "using boost::regex_constants::icase;\n"801 "using std::chrono::duration_cast;\n"802 "using std::chrono::microseconds;\n"803 "using std::chrono::seconds;\n"804 "using std::chrono::steady_clock;\n"805 "using std::move;\n"806 "using std::string;",807 sortUsingDeclarations("using boost::regex;\n"808 "using boost::regex_constants::icase;\n"809 "using std::move;\n"810 "using std::string;\n"811 "using std::chrono::duration_cast;\n"812 "using std::chrono::microseconds;\n"813 "using std::chrono::seconds;\n"814 "using std::chrono::steady_clock;",815 Style));816}817 818} // end namespace819} // end namespace format820} // end namespace clang821