[clang-format] SortUsingDeclarations support lexicographic order

[Backl1ght]

Summary

fix https://github.com/llvm/llvm-project/issues/59930

[HazardyKnusperkeks]

Looks ok for me.

clang/include/clang/Format/Format.h

3517

You should use the same example lines as for the other options.

clang/lib/Format/UsingDeclarationsSorter.cpp

154–159

Use capital letters for variables and arguments.

[Backl1ght]

1. Update example for SUD_Never
2. Use capital letters for variables and arguments.

[Backl1ght]

ping

clang/docs/ClangFormatStyleOptions.rst

.. code-block:: java
       import org.example.ClassA;
 
       import static org.example.function1;
 
 
 
 .. _SortUsingDeclarations:
 
-**SortUsingDeclarations** (``Boolean``) :versionbadge:`clang-format 5` :ref:`¶ <SortUsingDeclarations>`
-  If ``true``, clang-format will sort using declarations.
+**SortUsingDeclarations** (``SortUsingDeclarationsOptions``) :versionbadge:`clang-format 5` :ref:`¶ <SortUsingDeclarations>`
+  Controls if and how clang-format will sort using declarations.
 
-  The order of using declarations is defined as follows:
-  Split the strings by "::" and discard any initial empty strings. The last
-  element of each list is a non-namespace name; all others are namespace
-  names. Sort the lists of names lexicographically, where the sort order of
-  individual names is that all non-namespace names come before all namespace
-  names, and within those groups, names are in case-insensitive
-  lexicographic order.
+  Possible values:
+
+  * ``SUD_Never`` (in configuration: ``Never``)
+    Using declarations are never sorted.
 
     .. code-block:: c++
 
-     false:                                 true:
-     using std::cout;               vs.     using std::cin;
-     using std::cin;                        using std::cout;
+       using std::chrono::duration_cast;
+       using std::move;
+       using boost::regex;
+       using boost::regex_constants::icase;
+       using std::string;
+
+  * ``SUD_Lexicographic`` (in configuration: ``Lexicographic``)
+    Using declarations are sorted in the order defined as follows:
+    Split the strings by "::" and discard any initial empty strings. Sort
+    the lists of names lexicographically, and within those groups, names are
+    in case-insensitive lexicographic order.
+
+    .. code-block:: c++
+
+       using boost::regex;
+       using boost::regex_constants::icase;
+       using std::chrono::duration_cast;
+       using std::move;
+       using std::string;
+
+  * ``SUD_LexicographicNumeric`` (in configuration: ``LexicographicNumeric``)
+    Using declarations are sorted in the order defined as follows:
+    Split the strings by "::" and discard any initial empty strings. The
+    last element of each list is a non-namespace name; all others are
+    namespace names. Sort the lists of names lexicographically, where the
+    sort order of individual names is that all non-namespace names come
+    before all namespace names, and within those groups, names are in
+    case-insensitive lexicographic order.
+
+    .. code-block:: c++
+
+       using boost::regex;
+       using boost::regex_constants::icase;
+       using std::move;
+       using std::string;
+       using std::chrono::duration_cast;
+
+
 
 .. _SpaceAfterCStyleCast:
 
 **SpaceAfterCStyleCast** (``Boolean``) :versionbadge:`clang-format 3.5` :ref:`¶ <SpaceAfterCStyleCast>`
   If ``true``, a space is inserted after C style casts.
 
   .. code-block:: c++
 

clang/include/clang/Format/Format.h

   };
 
   /// When sorting Java imports, by default static imports are placed before
   /// non-static imports. If ``JavaStaticImportAfterImport`` is ``After``,
   /// static imports are placed after non-static imports.
   /// \version 12
   SortJavaStaticImportOptions SortJavaStaticImport;
 
-  /// If ``true``, clang-format will sort using declarations.
-  ///
-  /// The order of using declarations is defined as follows:
-  /// Split the strings by "::" and discard any initial empty strings. The last
-  /// element of each list is a non-namespace name; all others are namespace
-  /// names. Sort the lists of names lexicographically, where the sort order of
-  /// individual names is that all non-namespace names come before all namespace
-  /// names, and within those groups, names are in case-insensitive
-  /// lexicographic order.
-  /// \code
-  ///    false:                                 true:
-  ///    using std::cout;               vs.     using std::cin;
-  ///    using std::cin;                        using std::cout;
+  /// Using declaration sorting options.
+  enum SortUsingDeclarationsOptions : int8_t {
+    /// Using declarations are never sorted.
+    /// \code
+    ///    using std::chrono::duration_cast;
+    ///    using std::move;
+    ///    using boost::regex;
+    ///    using boost::regex_constants::icase;
+    ///    using std::string;
+    /// \endcode
+    SUD_Never,
+    /// Using declarations are sorted in the order defined as follows:
+    /// Split the strings by "::" and discard any initial empty strings. Sort
+    /// the lists of names lexicographically, and within those groups, names are
+    /// in case-insensitive lexicographic order.
+    /// \code
+    ///    using boost::regex;
+    ///    using boost::regex_constants::icase;
+    ///    using std::chrono::duration_cast;
+    ///    using std::move;
+    ///    using std::string;
+    /// \endcode
+    SUD_Lexicographic,
+    /// Using declarations are sorted in the order defined as follows:
+    /// Split the strings by "::" and discard any initial empty strings. The
+    /// last element of each list is a non-namespace name; all others are
+    /// namespace names. Sort the lists of names lexicographically, where the
+    /// sort order of individual names is that all non-namespace names come
+    /// before all namespace names, and within those groups, names are in
+    /// case-insensitive lexicographic order.
+    /// \code
+    ///    using boost::regex;
+    ///    using boost::regex_constants::icase;
+    ///    using std::move;
+    ///    using std::string;
+    ///    using std::chrono::duration_cast;
     /// \endcode
+    SUD_LexicographicNumeric,
+  };
+
+  /// Controls if and how clang-format will sort using declarations.
   /// \version 5
-  bool SortUsingDeclarations;
+  SortUsingDeclarationsOptions SortUsingDeclarations;
 
   /// If ``true``, a space is inserted after C style casts.
   /// \code
   ///    true:                                  false:
   ///    (int) i;                       vs.     (int)i;
   /// \endcode
   /// \version 3.5
   bool SpaceAfterCStyleCast;

clang/lib/Format/Format.cpp

struct ScalarEnumerationTraits<FormatStyle::SortJavaStaticImportOptions> {
   static void enumeration(IO &IO,
                           FormatStyle::SortJavaStaticImportOptions &Value) {
     IO.enumCase(Value, "Before", FormatStyle::SJSIO_Before);
     IO.enumCase(Value, "After", FormatStyle::SJSIO_After);
   }
 };
 
 template <>
+struct ScalarEnumerationTraits<FormatStyle::SortUsingDeclarationsOptions> {
+  static void enumeration(IO &IO,
+                          FormatStyle::SortUsingDeclarationsOptions &Value) {
+    IO.enumCase(Value, "Never", FormatStyle::SUD_Never);
+    IO.enumCase(Value, "Lexicographic", FormatStyle::SUD_Lexicographic);
+    IO.enumCase(Value, "LexicographicNumeric",
+                FormatStyle::SUD_LexicographicNumeric);
+
+    // For backward compatibility.
+    IO.enumCase(Value, "false", FormatStyle::SUD_Never);
+    IO.enumCase(Value, "true", FormatStyle::SUD_LexicographicNumeric);
+  }
+};
+
+template <>
 struct ScalarEnumerationTraits<FormatStyle::SpaceAroundPointerQualifiersStyle> {
   static void
   enumeration(IO &IO, FormatStyle::SpaceAroundPointerQualifiersStyle &Value) {
     IO.enumCase(Value, "Default", FormatStyle::SAPQ_Default);
     IO.enumCase(Value, "Before", FormatStyle::SAPQ_Before);
     IO.enumCase(Value, "After", FormatStyle::SAPQ_After);
     IO.enumCase(Value, "Both", FormatStyle::SAPQ_Both);
   }
FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
   LLVMStyle.RemoveBracesLLVM = false;
   LLVMStyle.RemoveSemicolon = false;
   LLVMStyle.RequiresClausePosition = FormatStyle::RCPS_OwnLine;
   LLVMStyle.RequiresExpressionIndentation = FormatStyle::REI_OuterScope;
   LLVMStyle.SeparateDefinitionBlocks = FormatStyle::SDS_Leave;
   LLVMStyle.ShortNamespaceLines = 1;
   LLVMStyle.SortIncludes = FormatStyle::SI_CaseSensitive;
   LLVMStyle.SortJavaStaticImport = FormatStyle::SJSIO_Before;
-  LLVMStyle.SortUsingDeclarations = true;
+  LLVMStyle.SortUsingDeclarations = FormatStyle::SUD_LexicographicNumeric;
   LLVMStyle.SpaceAfterCStyleCast = false;
   LLVMStyle.SpaceAfterLogicalNot = false;
   LLVMStyle.SpaceAfterTemplateKeyword = true;
   LLVMStyle.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Default;
   LLVMStyle.SpaceBeforeCaseColon = false;
   LLVMStyle.SpaceBeforeCtorInitializerColon = true;
   LLVMStyle.SpaceBeforeInheritanceColon = true;
   LLVMStyle.SpaceBeforeParens = FormatStyle::SBPO_ControlStatements;
FormatStyle getMicrosoftStyle(FormatStyle::LanguageKind Language) {
   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
   return Style;
 }
 
 FormatStyle getNoStyle() {
   FormatStyle NoStyle = getLLVMStyle();
   NoStyle.DisableFormat = true;
   NoStyle.SortIncludes = FormatStyle::SI_Never;
-  NoStyle.SortUsingDeclarations = false;
+  NoStyle.SortUsingDeclarations = FormatStyle::SUD_Never;
   return NoStyle;
 }
 
 bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language,
                         FormatStyle *Style) {
   if (Name.equals_insensitive("llvm"))
     *Style = getLLVMStyle(Language);
   else if (Name.equals_insensitive("chromium"))
if (Style.isCpp()) {
     }
 
     if (Style.FixNamespaceComments) {
       Passes.emplace_back([&](const Environment &Env) {
         return NamespaceEndCommentsFixer(Env, Expanded).process();
       });
     }
 
-    if (Style.SortUsingDeclarations) {
+    if (Style.SortUsingDeclarations != FormatStyle::SUD_Never) {
       Passes.emplace_back([&](const Environment &Env) {
         return UsingDeclarationsSorter(Env, Expanded).process();
       });
     }
   }
 
   if (Style.SeparateDefinitionBlocks != FormatStyle::SDS_Leave) {
     Passes.emplace_back([&](const Environment &Env) {

clang/lib/Format/UsingDeclarationsSorter.cpp

 //===--- UsingDeclarationsSorter.cpp ----------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file implements UsingDeclarationsSorter, a TokenAnalyzer that
 /// sorts consecutive using declarations.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "UsingDeclarationsSorter.h"
+#include "clang/Format/Format.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Regex.h"
 
 #include <algorithm>
 
 #define DEBUG_TYPE "using-declarations-sorter"
 
 namespace clang {
 namespace format {
 
 namespace {
 
 // The order of using declaration is defined as follows:
 // Split the strings by "::" and discard any initial empty strings. The last
 // element of each list is a non-namespace name; all others are namespace
 // names. Sort the lists of names lexicographically, where the sort order of
 // individual names is that all non-namespace names come before all namespace
 // names, and within those groups, names are in case-insensitive lexicographic
 // order.
-int compareLabels(StringRef A, StringRef B) {
+int compareLabelsLexicographicNumeric(StringRef A, StringRef B) {
   SmallVector<StringRef, 2> NamesA;
   A.split(NamesA, "::", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
   SmallVector<StringRef, 2> NamesB;
   B.split(NamesB, "::", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
   size_t SizeA = NamesA.size();
   size_t SizeB = NamesB.size();
   for (size_t I = 0, E = std::min(SizeA, SizeB); I < E; ++I) {
     if (I + 1 == SizeA) {
for (size_t I = 0, E = std::min(SizeA, SizeB); I < E; ++I) {
     // Two namespaces names within a group compare case-insensitively.
     int C = NamesA[I].compare_insensitive(NamesB[I]);
     if (C != 0)
       return C;
   }
   return 0;
 }
 
+int compareLabelsLexicographic(StringRef A, StringRef B) {
+  SmallVector<StringRef, 2> NamesA;
+  A.split(NamesA, "::", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
+  SmallVector<StringRef, 2> NamesB;
+  B.split(NamesB, "::", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
+  size_t SizeA = NamesA.size();
+  size_t SizeB = NamesB.size();
+  for (size_t I = 0, E = std::min(SizeA, SizeB); I < E; ++I) {
+    // Two namespaces names within a group compare case-insensitively.
+    int C = NamesA[I].compare_insensitive(NamesB[I]);
+    if (C != 0)
+      return C;
+  }
+  if (SizeA < SizeB)
+    return -1;
+  return SizeA == SizeB ? 0 : 1;
+}
+
+int compareLabels(
+    StringRef A, StringRef B,
+    FormatStyle::SortUsingDeclarationsOptions SortUsingDeclarations) {
+  if (SortUsingDeclarations == FormatStyle::SUD_LexicographicNumeric)
+    return compareLabelsLexicographicNumeric(A, B);
+  return compareLabelsLexicographic(A, B);
+}
+
 struct UsingDeclaration {
   const AnnotatedLine *Line;
   std::string Label;
 
   UsingDeclaration(const AnnotatedLine *Line, const std::string &Label)
       : Line(Line), Label(Label) {}
-
-  bool operator<(const UsingDeclaration &Other) const {
-    return compareLabels(Label, Other.Label) < 0;
-  }
 };
 
 /// Computes the label of a using declaration starting at tthe using token
 /// \p UsingTok.
 /// If \p UsingTok doesn't begin a using declaration, returns the empty string.
 /// Note that this detects specifically using declarations, as in:
 /// using A::B::C;
 /// and not type aliases, as in:
std::string computeUsingDeclarationLabel(const FormatToken *UsingTok) {
   }
   if (HasIdentifier && Tok && Tok->isOneOf(tok::semi, tok::comma))
     return Label;
   return "";
 }
 
 void endUsingDeclarationBlock(
     SmallVectorImpl<UsingDeclaration> *UsingDeclarations,
-    const SourceManager &SourceMgr, tooling::Replacements *Fixes) {
+    const SourceManager &SourceMgr, tooling::Replacements *Fixes,
+    FormatStyle::SortUsingDeclarationsOptions SortUsingDeclarations) {
   bool BlockAffected = false;
   for (const UsingDeclaration &Declaration : *UsingDeclarations) {
     if (Declaration.Line->Affected) {
       BlockAffected = true;
       break;
     }
   }
   if (!BlockAffected) {
     UsingDeclarations->clear();
     return;
   }
   SmallVector<UsingDeclaration, 4> SortedUsingDeclarations(
       UsingDeclarations->begin(), UsingDeclarations->end());
-  llvm::stable_sort(SortedUsingDeclarations);
+  auto Comp = [SortUsingDeclarations](const UsingDeclaration &Lhs,
+                                      const UsingDeclaration &Rhs) -> bool {
+    return compareLabels(Lhs.Label, Rhs.Label, SortUsingDeclarations) < 0;
+  };
+  llvm::stable_sort(SortedUsingDeclarations, Comp);
   SortedUsingDeclarations.erase(
       std::unique(SortedUsingDeclarations.begin(),
                   SortedUsingDeclarations.end(),
                   [](const UsingDeclaration &a, const UsingDeclaration &b) {
                     return a.Label == b.Label;
                   }),
       SortedUsingDeclarations.end());
   for (size_t I = 0, E = UsingDeclarations->size(); I < E; ++I) {
     if (I >= SortedUsingDeclarations.size()) {
std::pair<tooling::Replacements, unsigned> UsingDeclarationsSorter::analyze(
   const SourceManager &SourceMgr = Env.getSourceManager();
   AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
   tooling::Replacements Fixes;
   SmallVector<UsingDeclaration, 4> UsingDeclarations;
   for (const AnnotatedLine *Line : AnnotatedLines) {
     const auto *FirstTok = Line->First;
     if (Line->InPPDirective || !Line->startsWith(tok::kw_using) ||
         FirstTok->Finalized) {
-      endUsingDeclarationBlock(&UsingDeclarations, SourceMgr, &Fixes);
+      endUsingDeclarationBlock(&UsingDeclarations, SourceMgr, &Fixes,
+                               Style.SortUsingDeclarations);
       continue;
     }
-    if (FirstTok->NewlinesBefore > 1)
-      endUsingDeclarationBlock(&UsingDeclarations, SourceMgr, &Fixes);
+    if (FirstTok->NewlinesBefore > 1) {
+      endUsingDeclarationBlock(&UsingDeclarations, SourceMgr, &Fixes,
+                               Style.SortUsingDeclarations);
+    }
     const auto *UsingTok =
         FirstTok->is(tok::comment) ? FirstTok->getNextNonComment() : FirstTok;
     std::string Label = computeUsingDeclarationLabel(UsingTok);
     if (Label.empty()) {
-      endUsingDeclarationBlock(&UsingDeclarations, SourceMgr, &Fixes);
+      endUsingDeclarationBlock(&UsingDeclarations, SourceMgr, &Fixes,
+                               Style.SortUsingDeclarations);
       continue;
     }
     UsingDeclarations.push_back(UsingDeclaration(Line, Label));
   }
-  endUsingDeclarationBlock(&UsingDeclarations, SourceMgr, &Fixes);
+  endUsingDeclarationBlock(&UsingDeclarations, SourceMgr, &Fixes,
+                           Style.SortUsingDeclarations);
   return {Fixes, 0};
 }
 
 } // namespace format
 } // namespace clang

clang/unittests/Format/ConfigParseTest.cpp

TEST(ConfigParseTest, ParsesConfigurationBools) {
   CHECK_PARSE_BOOL(InsertNewlineAtEOF);
   CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
   CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
   CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
   CHECK_PARSE_BOOL(Cpp11BracedListStyle);
   CHECK_PARSE_BOOL(ReflowComments);
   CHECK_PARSE_BOOL(RemoveBracesLLVM);
   CHECK_PARSE_BOOL(RemoveSemicolon);
-  CHECK_PARSE_BOOL(SortUsingDeclarations);
   CHECK_PARSE_BOOL(SpacesInParentheses);
   CHECK_PARSE_BOOL(SpacesInSquareBrackets);
   CHECK_PARSE_BOOL(SpacesInConditionalStatement);
   CHECK_PARSE_BOOL(SpaceInEmptyBlock);
   CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
   CHECK_PARSE_BOOL(SpacesInContainerLiterals);
   CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
   CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
CHECK_PARSE("BitFieldColonSpacing: After", BitFieldColonSpacing,
               FormatStyle::BFCS_After);
 
   Style.SortJavaStaticImport = FormatStyle::SJSIO_Before;
   CHECK_PARSE("SortJavaStaticImport: After", SortJavaStaticImport,
               FormatStyle::SJSIO_After);
   CHECK_PARSE("SortJavaStaticImport: Before", SortJavaStaticImport,
               FormatStyle::SJSIO_Before);
 
+  Style.SortUsingDeclarations = FormatStyle::SUD_LexicographicNumeric;
+  CHECK_PARSE("SortUsingDeclarations: Never", SortUsingDeclarations,
+              FormatStyle::SUD_Never);
+  CHECK_PARSE("SortUsingDeclarations: Lexicographic", SortUsingDeclarations,
+              FormatStyle::SUD_Lexicographic);
+  CHECK_PARSE("SortUsingDeclarations: LexicographicNumeric",
+              SortUsingDeclarations, FormatStyle::SUD_LexicographicNumeric);
+  // For backward compatibility:
+  CHECK_PARSE("SortUsingDeclarations: false", SortUsingDeclarations,
+              FormatStyle::SUD_Never);
+  CHECK_PARSE("SortUsingDeclarations: true", SortUsingDeclarations,
+              FormatStyle::SUD_LexicographicNumeric);
+
   // FIXME: This is required because parsing a configuration simply overwrites
   // the first N elements of the list instead of resetting it.
   Style.ForEachMacros.clear();
   std::vector<std::string> BoostForeach;
   BoostForeach.push_back("BOOST_FOREACH");
   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
   std::vector<std::string> BoostAndQForeach;
   BoostAndQForeach.push_back("BOOST_FOREACH");

clang/unittests/Format/UsingDeclarationsSorterTest.cpp

std::string sortUsingDeclarations(llvm::StringRef Code,
                                     const FormatStyle &Style = getLLVMStyle()) {
     return sortUsingDeclarations(Code,
                                  /*Ranges=*/{1, tooling::Range(0, Code.size())},
                                  Style);
   }
 };
 
 TEST_F(UsingDeclarationsSorterTest, SwapsTwoConsecutiveUsingDeclarations) {
+  FormatStyle Style = getLLVMStyle();
+  EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);
   EXPECT_EQ("using a;\n"
             "using b;",
             sortUsingDeclarations("using a;\n"
-                                  "using b;"));
+                                  "using b;",
+                                  Style));
   EXPECT_EQ("using a;\n"
             "using aa;",
             sortUsingDeclarations("using aa;\n"
-                                  "using a;"));
+                                  "using a;",
+                                  Style));
   EXPECT_EQ("using a;\n"
             "using ::a;",
             sortUsingDeclarations("using a;\n"
-                                  "using ::a;"));
+                                  "using ::a;",
+                                  Style));
 
   EXPECT_EQ("using a::bcd;\n"
             "using a::cd;",
             sortUsingDeclarations("using a::cd;\n"
-                                  "using a::bcd;"));
+                                  "using a::bcd;",
+                                  Style));
 
   EXPECT_EQ("using a;\n"
             "using a::a;",
             sortUsingDeclarations("using a::a;\n"
-                                  "using a;"));
+                                  "using a;",
+                                  Style));
 
   EXPECT_EQ("using a::ba::aa;\n"
             "using a::bb::ccc;",
             sortUsingDeclarations("using a::bb::ccc;\n"
-                                  "using a::ba::aa;"));
+                                  "using a::ba::aa;",
+                                  Style));
 
   EXPECT_EQ("using a;\n"
             "using typename a;",
             sortUsingDeclarations("using typename a;\n"
-                                  "using a;"));
+                                  "using a;",
+                                  Style));
 
   EXPECT_EQ("using typename z;\n"
             "using typenamea;",
             sortUsingDeclarations("using typenamea;\n"
-                                  "using typename z;"));
+                                  "using typename z;",
+                                  Style));
 
   EXPECT_EQ("using a, b;\n"
             "using aa;",
             sortUsingDeclarations("using aa;\n"
-                                  "using a, b;"));
+                                  "using a, b;",
+                                  Style));
+
+  Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;
+  EXPECT_EQ("using a;\n"
+            "using b;",
+            sortUsingDeclarations("using a;\n"
+                                  "using b;",
+                                  Style));
+  EXPECT_EQ("using a;\n"
+            "using aa;",
+            sortUsingDeclarations("using aa;\n"
+                                  "using a;",
+                                  Style));
+  EXPECT_EQ("using a;\n"
+            "using ::a;",
+            sortUsingDeclarations("using a;\n"
+                                  "using ::a;",
+                                  Style));
+
+  EXPECT_EQ("using a::bcd;\n"
+            "using a::cd;",
+            sortUsingDeclarations("using a::cd;\n"
+                                  "using a::bcd;",
+                                  Style));
+
+  EXPECT_EQ("using a;\n"
+            "using a::a;",
+            sortUsingDeclarations("using a::a;\n"
+                                  "using a;",
+                                  Style));
+
+  EXPECT_EQ("using a::ba::aa;\n"
+            "using a::bb::ccc;",
+            sortUsingDeclarations("using a::bb::ccc;\n"
+                                  "using a::ba::aa;",
+                                  Style));
+
+  EXPECT_EQ("using a;\n"
+            "using typename a;",
+            sortUsingDeclarations("using typename a;\n"
+                                  "using a;",
+                                  Style));
+
+  EXPECT_EQ("using typename z;\n"
+            "using typenamea;",
+            sortUsingDeclarations("using typenamea;\n"
+                                  "using typename z;",
+                                  Style));
+
+  EXPECT_EQ("using a, b;\n"
+            "using aa;",
+            sortUsingDeclarations("using aa;\n"
+                                  "using a, b;",
+                                  Style));
 }
 
 TEST_F(UsingDeclarationsSorterTest, UsingDeclarationOrder) {
+  FormatStyle Style = getLLVMStyle();
+  EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);
   EXPECT_EQ("using A;\n"
             "using a;",
             sortUsingDeclarations("using A;\n"
-                                  "using a;"));
+                                  "using a;",
+                                  Style));
   EXPECT_EQ("using a;\n"
             "using A;",
             sortUsingDeclarations("using a;\n"
-                                  "using A;"));
+                                  "using A;",
+                                  Style));
   EXPECT_EQ("using a;\n"
             "using B;",
             sortUsingDeclarations("using B;\n"
-                                  "using a;"));
+                                  "using a;",
+                                  Style));
 
   // Ignores leading '::'.
   EXPECT_EQ("using ::a;\n"
             "using A;",
             sortUsingDeclarations("using ::a;\n"
-                                  "using A;"));
+                                  "using A;",
+                                  Style));
 
   EXPECT_EQ("using ::A;\n"
             "using a;",
             sortUsingDeclarations("using ::A;\n"
-                                  "using a;"));
+                                  "using a;",
+                                  Style));
 
   // Sorts '_' before 'a' and 'A'.
   EXPECT_EQ("using _;\n"
             "using A;",
             sortUsingDeclarations("using A;\n"
-                                  "using _;"));
+                                  "using _;",
+                                  Style));
   EXPECT_EQ("using _;\n"
             "using a;",
             sortUsingDeclarations("using a;\n"
-                                  "using _;"));
+                                  "using _;",
+                                  Style));
   EXPECT_EQ("using a::_;\n"
             "using a::a;",
             sortUsingDeclarations("using a::a;\n"
-                                  "using a::_;"));
+                                  "using a::_;",
+                                  Style));
 
   // Sorts non-namespace names before namespace names at the same level.
   EXPECT_EQ("using ::testing::_;\n"
             "using ::testing::Aardvark;\n"
             "using ::testing::kMax;\n"
             "using ::testing::Xylophone;\n"
             "using ::testing::apple::Honeycrisp;\n"
             "using ::testing::zebra::Stripes;",
             sortUsingDeclarations("using ::testing::Aardvark;\n"
                                   "using ::testing::Xylophone;\n"
                                   "using ::testing::kMax;\n"
                                   "using ::testing::_;\n"
                                   "using ::testing::apple::Honeycrisp;\n"
-                                  "using ::testing::zebra::Stripes;"));
+                                  "using ::testing::zebra::Stripes;",
+                                  Style));
+
+  Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;
+  EXPECT_EQ("using A;\n"
+            "using a;",
+            sortUsingDeclarations("using A;\n"
+                                  "using a;",
+                                  Style));
+  EXPECT_EQ("using a;\n"
+            "using A;",
+            sortUsingDeclarations("using a;\n"
+                                  "using A;",
+                                  Style));
+  EXPECT_EQ("using a;\n"
+            "using B;",
+            sortUsingDeclarations("using B;\n"
+                                  "using a;",
+                                  Style));
+
+  // Ignores leading '::'.
+  EXPECT_EQ("using ::a;\n"
+            "using A;",
+            sortUsingDeclarations("using ::a;\n"
+                                  "using A;",
+                                  Style));
+
+  EXPECT_EQ("using ::A;\n"
+            "using a;",
+            sortUsingDeclarations("using ::A;\n"
+                                  "using a;",
+                                  Style));
+
+  // Sorts '_' before 'a' and 'A'.
+  EXPECT_EQ("using _;\n"
+            "using A;",
+            sortUsingDeclarations("using A;\n"
+                                  "using _;",
+                                  Style));
+  EXPECT_EQ("using _;\n"
+            "using a;",
+            sortUsingDeclarations("using a;\n"
+                                  "using _;",
+                                  Style));
+  EXPECT_EQ("using a::_;\n"
+            "using a::a;",
+            sortUsingDeclarations("using a::a;\n"
+                                  "using a::_;",
+                                  Style));
+
+  // Sorts non-namespace names before namespace names at the same level.
+  EXPECT_EQ("using ::testing::_;\n"
+            "using ::testing::Aardvark;\n"
+            "using ::testing::apple::Honeycrisp;\n"
+            "using ::testing::kMax;\n"
+            "using ::testing::Xylophone;\n"
+            "using ::testing::zebra::Stripes;",
+            sortUsingDeclarations("using ::testing::Aardvark;\n"
+                                  "using ::testing::Xylophone;\n"
+                                  "using ::testing::kMax;\n"
+                                  "using ::testing::_;\n"
+                                  "using ::testing::apple::Honeycrisp;\n"
+                                  "using ::testing::zebra::Stripes;",
+                                  Style));
 }
 
 TEST_F(UsingDeclarationsSorterTest, SortsStably) {
+  FormatStyle Style = getLLVMStyle();
+  EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);
+  EXPECT_EQ("using a;\n"
+            "using A;\n"
+            "using a;\n"
+            "using A;\n"
+            "using a;\n"
+            "using A;\n"
+            "using a;\n"
+            "using B;\n"
+            "using b;\n"
+            "using B;\n"
+            "using b;\n"
+            "using B;\n"
+            "using b;",
+            sortUsingDeclarations("using a;\n"
+                                  "using B;\n"
+                                  "using a;\n"
+                                  "using b;\n"
+                                  "using A;\n"
+                                  "using a;\n"
+                                  "using b;\n"
+                                  "using B;\n"
+                                  "using b;\n"
+                                  "using A;\n"
+                                  "using a;\n"
+                                  "using b;\n"
+                                  "using b;\n"
+                                  "using B;\n"
+                                  "using b;\n"
+                                  "using A;\n"
+                                  "using a;",
+                                  Style));
+
+  Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;
   EXPECT_EQ("using a;\n"
             "using A;\n"
             "using a;\n"
             "using A;\n"
             "using a;\n"
             "using A;\n"
             "using a;\n"
             "using B;\n"
EXPECT_EQ("using a;\n"
                                   "using b;\n"
                                   "using A;\n"
                                   "using a;\n"
                                   "using b;\n"
                                   "using b;\n"
                                   "using B;\n"
                                   "using b;\n"
                                   "using A;\n"
-                                  "using a;"));
+                                  "using a;",
+                                  Style));
 }
 
 TEST_F(UsingDeclarationsSorterTest, SortsMultipleTopLevelDeclarations) {
+  FormatStyle Style = getLLVMStyle();
+  EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);
+  EXPECT_EQ("using a;\n"
+            "using b;\n"
+            "using c;\n"
+            "using d;\n"
+            "using e;",
+            sortUsingDeclarations("using d;\n"
+                                  "using b;\n"
+                                  "using e;\n"
+                                  "using a;\n"
+                                  "using c;",
+                                  Style));
+
+  EXPECT_EQ("#include <iostream>\n"
+            "using std::cin;\n"
+            "using std::cout;\n"
+            "using ::std::endl;\n"
+            "int main();",
+            sortUsingDeclarations("#include <iostream>\n"
+                                  "using std::cout;\n"
+                                  "using ::std::endl;\n"
+                                  "using std::cin;\n"
+                                  "int main();",
+                                  Style));
+
+  Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;
   EXPECT_EQ("using a;\n"
             "using b;\n"
             "using c;\n"
             "using d;\n"
             "using e;",
             sortUsingDeclarations("using d;\n"
                                   "using b;\n"
                                   "using e;\n"
                                   "using a;\n"
-                                  "using c;"));
+                                  "using c;",
+                                  Style));
 
   EXPECT_EQ("#include <iostream>\n"
             "using std::cin;\n"
             "using std::cout;\n"
             "using ::std::endl;\n"
             "int main();",
             sortUsingDeclarations("#include <iostream>\n"
                                   "using std::cout;\n"
                                   "using ::std::endl;\n"
                                   "using std::cin;\n"
-                                  "int main();"));
+                                  "int main();",
+                                  Style));
 }
 
 TEST_F(UsingDeclarationsSorterTest, BreaksOnEmptyLines) {
+  FormatStyle Style = getLLVMStyle();
+  EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);
+  EXPECT_EQ("using b;\n"
+            "using c;\n"
+            "\n"
+            "using a;\n"
+            "using d;",
+            sortUsingDeclarations("using c;\n"
+                                  "using b;\n"
+                                  "\n"
+                                  "using d;\n"
+                                  "using a;",
+                                  Style));
+
+  Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;
   EXPECT_EQ("using b;\n"
             "using c;\n"
             "\n"
             "using a;\n"
             "using d;",
             sortUsingDeclarations("using c;\n"
                                   "using b;\n"
                                   "\n"
                                   "using d;\n"
-                                  "using a;"));
+                                  "using a;",
+                                  Style));
 }
 
 TEST_F(UsingDeclarationsSorterTest, BreaksOnUsingNamespace) {
+  FormatStyle Style = getLLVMStyle();
+  EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);
   EXPECT_EQ("using b;\n"
             "using namespace std;\n"
             "using a;",
             sortUsingDeclarations("using b;\n"
                                   "using namespace std;\n"
-                                  "using a;"));
+                                  "using a;",
+                                  Style));
+
+  Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;
+  EXPECT_EQ("using b;\n"
+            "using namespace std;\n"
+            "using a;",
+            sortUsingDeclarations("using b;\n"
+                                  "using namespace std;\n"
+                                  "using a;",
+                                  Style));
 }
 
 TEST_F(UsingDeclarationsSorterTest, KeepsUsingDeclarationsInPPDirectives) {
+  FormatStyle Style = getLLVMStyle();
+  EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);
+  EXPECT_EQ("#define A \\\n"
+            "using b;\\\n"
+            "using a;",
+            sortUsingDeclarations("#define A \\\n"
+                                  "using b;\\\n"
+                                  "using a;",
+                                  Style));
+
+  Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;
   EXPECT_EQ("#define A \\\n"
             "using b;\\\n"
             "using a;",
             sortUsingDeclarations("#define A \\\n"
                                   "using b;\\\n"
-                                  "using a;"));
+                                  "using a;",
+                                  Style));
 }
 
 TEST_F(UsingDeclarationsSorterTest, KeepsTypeAliases) {
   auto Code = "struct C { struct B { struct A; }; };\n"
               "using B = C::B;\n"
               "using A = B::A;";
-  EXPECT_EQ(Code, sortUsingDeclarations(Code));
+
+  FormatStyle Style = getLLVMStyle();
+  EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);
+  EXPECT_EQ(Code, sortUsingDeclarations(Code, Style));
+
+  Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;
+  EXPECT_EQ(Code, sortUsingDeclarations(Code, Style));
 }
 
 TEST_F(UsingDeclarationsSorterTest, MovesTrailingCommentsWithDeclarations) {
+  FormatStyle Style = getLLVMStyle();
+  EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);
   EXPECT_EQ("using a; // line a1\n"
             "using b; /* line b1\n"
             "          * line b2\n"
             "          * line b3 */\n"
             "using c; // line c1\n"
             "         // line c2",
             sortUsingDeclarations("using c; // line c1\n"
                                   "         // line c2\n"
                                   "using b; /* line b1\n"
                                   "          * line b2\n"
                                   "          * line b3 */\n"
-                                  "using a; // line a1"));
+                                  "using a; // line a1",
+                                  Style));
+
+  Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;
+  EXPECT_EQ("using a; // line a1\n"
+            "using b; /* line b1\n"
+            "          * line b2\n"
+            "          * line b3 */\n"
+            "using c; // line c1\n"
+            "         // line c2",
+            sortUsingDeclarations("using c; // line c1\n"
+                                  "         // line c2\n"
+                                  "using b; /* line b1\n"
+                                  "          * line b2\n"
+                                  "          * line b3 */\n"
+                                  "using a; // line a1",
+                                  Style));
 }
 
 TEST_F(UsingDeclarationsSorterTest, SortsInStructScope) {
+  FormatStyle Style = getLLVMStyle();
+  EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);
   EXPECT_EQ("struct pt3 : pt2 {\n"
             "  using pt2::x;\n"
             "  using pt2::y;\n"
             "  float z;\n"
             "};",
             sortUsingDeclarations("struct pt3 : pt2 {\n"
                                   "  using pt2::y;\n"
                                   "  using pt2::x;\n"
                                   "  float z;\n"
-                                  "};"));
+                                  "};",
+                                  Style));
+
+  Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;
+  EXPECT_EQ("struct pt3 : pt2 {\n"
+            "  using pt2::x;\n"
+            "  using pt2::y;\n"
+            "  float z;\n"
+            "};",
+            sortUsingDeclarations("struct pt3 : pt2 {\n"
+                                  "  using pt2::y;\n"
+                                  "  using pt2::x;\n"
+                                  "  float z;\n"
+                                  "};",
+                                  Style));
 }
 
 TEST_F(UsingDeclarationsSorterTest, KeepsOperators) {
+  FormatStyle Style = getLLVMStyle();
+  EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);
+  EXPECT_EQ("using a::operator();\n"
+            "using a::operator-;\n"
+            "using a::operator+;",
+            sortUsingDeclarations("using a::operator();\n"
+                                  "using a::operator-;\n"
+                                  "using a::operator+;",
+                                  Style));
+
+  Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;
   EXPECT_EQ("using a::operator();\n"
             "using a::operator-;\n"
             "using a::operator+;",
             sortUsingDeclarations("using a::operator();\n"
                                   "using a::operator-;\n"
-                                  "using a::operator+;"));
+                                  "using a::operator+;",
+                                  Style));
 }
 
 TEST_F(UsingDeclarationsSorterTest, SortsUsingDeclarationsInsideNamespaces) {
+  FormatStyle Style = getLLVMStyle();
+  EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);
   EXPECT_EQ("namespace A {\n"
             "struct B;\n"
             "struct C;\n"
             "}\n"
             "namespace X {\n"
             "using A::B;\n"
             "using A::C;\n"
             "}",
             sortUsingDeclarations("namespace A {\n"
                                   "struct B;\n"
                                   "struct C;\n"
                                   "}\n"
                                   "namespace X {\n"
                                   "using A::C;\n"
                                   "using A::B;\n"
-                                  "}"));
+                                  "}",
+                                  Style));
+
+  Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;
+  EXPECT_EQ("namespace A {\n"
+            "struct B;\n"
+            "struct C;\n"
+            "}\n"
+            "namespace X {\n"
+            "using A::B;\n"
+            "using A::C;\n"
+            "}",
+            sortUsingDeclarations("namespace A {\n"
+                                  "struct B;\n"
+                                  "struct C;\n"
+                                  "}\n"
+                                  "namespace X {\n"
+                                  "using A::C;\n"
+                                  "using A::B;\n"
+                                  "}",
+                                  Style));
 }
 
 TEST_F(UsingDeclarationsSorterTest, SupportsClangFormatOff) {
+  FormatStyle Style = getLLVMStyle();
+  EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);
   EXPECT_EQ("// clang-format off\n"
             "using b;\n"
             "using a;\n"
             "// clang-format on\n"
             "using c;\n"
             "using d;",
             sortUsingDeclarations("// clang-format off\n"
                                   "using b;\n"
                                   "using a;\n"
                                   "// clang-format on\n"
                                   "using d;\n"
-                                  "using c;"));
+                                  "using c;",
+                                  Style));
+
+  Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;
+  EXPECT_EQ("// clang-format off\n"
+            "using b;\n"
+            "using a;\n"
+            "// clang-format on\n"
+            "using c;\n"
+            "using d;",
+            sortUsingDeclarations("// clang-format off\n"
+                                  "using b;\n"
+                                  "using a;\n"
+                                  "// clang-format on\n"
+                                  "using d;\n"
+                                  "using c;",
+                                  Style));
 }
 
 TEST_F(UsingDeclarationsSorterTest, SortsPartialRangeOfUsingDeclarations) {
+  FormatStyle Style = getLLVMStyle();
+  EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);
+  // Sorts the whole block of using declarations surrounding the range.
+  EXPECT_EQ("using a;\n"
+            "using b;\n"
+            "using c;",
+            sortUsingDeclarations("using b;\n"
+                                  "using c;\n" // starts at offset 10
+                                  "using a;",
+                                  {tooling::Range(10, 15)}, Style));
+  EXPECT_EQ("using a;\n"
+            "using b;\n"
+            "using c;\n"
+            "using A = b;",
+            sortUsingDeclarations("using b;\n"
+                                  "using c;\n" // starts at offset 10
+                                  "using a;\n"
+                                  "using A = b;",
+                                  {tooling::Range(10, 15)}, Style));
+
+  EXPECT_EQ("using d;\n"
+            "using c;\n"
+            "\n"
+            "using a;\n"
+            "using b;\n"
+            "\n"
+            "using f;\n"
+            "using e;",
+            sortUsingDeclarations("using d;\n"
+                                  "using c;\n"
+                                  "\n"
+                                  "using b;\n" // starts at offset 19
+                                  "using a;\n"
+                                  "\n"
+                                  "using f;\n"
+                                  "using e;",
+                                  {tooling::Range(19, 1)}, Style));
+
+  Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;
   // Sorts the whole block of using declarations surrounding the range.
   EXPECT_EQ("using a;\n"
             "using b;\n"
             "using c;",
             sortUsingDeclarations("using b;\n"
                                   "using c;\n" // starts at offset 10
                                   "using a;",
-                                  {tooling::Range(10, 15)}));
+                                  {tooling::Range(10, 15)}, Style));
   EXPECT_EQ("using a;\n"
             "using b;\n"
             "using c;\n"
             "using A = b;",
             sortUsingDeclarations("using b;\n"
                                   "using c;\n" // starts at offset 10
                                   "using a;\n"
                                   "using A = b;",
-                                  {tooling::Range(10, 15)}));
+                                  {tooling::Range(10, 15)}, Style));
 
   EXPECT_EQ("using d;\n"
             "using c;\n"
             "\n"
             "using a;\n"
             "using b;\n"
             "\n"
             "using f;\n"
             "using e;",
             sortUsingDeclarations("using d;\n"
                                   "using c;\n"
                                   "\n"
                                   "using b;\n" // starts at offset 19
                                   "using a;\n"
                                   "\n"
                                   "using f;\n"
                                   "using e;",
-                                  {tooling::Range(19, 1)}));
+                                  {tooling::Range(19, 1)}, Style));
 }
 
 TEST_F(UsingDeclarationsSorterTest,
        SortsUsingDeclarationsWithLeadingkComments) {
+  FormatStyle Style = getLLVMStyle();
+  EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);
   EXPECT_EQ("/* comment */ using a;\n"
             "/* comment */ using b;",
             sortUsingDeclarations("/* comment */ using b;\n"
-                                  "/* comment */ using a;"));
+                                  "/* comment */ using a;",
+                                  Style));
+
+  Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;
+  EXPECT_EQ("/* comment */ using a;\n"
+            "/* comment */ using b;",
+            sortUsingDeclarations("/* comment */ using b;\n"
+                                  "/* comment */ using a;",
+                                  Style));
 }
 
 TEST_F(UsingDeclarationsSorterTest, DeduplicatesUsingDeclarations) {
+  FormatStyle Style = getLLVMStyle();
+  EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);
+  EXPECT_EQ("using a;\n"
+            "using b;\n"
+            "using c;\n"
+            "\n"
+            "using a;\n"
+            "using e;",
+            sortUsingDeclarations("using c;\n"
+                                  "using a;\n"
+                                  "using b;\n"
+                                  "using a;\n"
+                                  "using b;\n"
+                                  "\n"
+                                  "using e;\n"
+                                  "using a;\n"
+                                  "using e;",
+                                  Style));
+
+  Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;
   EXPECT_EQ("using a;\n"
             "using b;\n"
             "using c;\n"
             "\n"
             "using a;\n"
             "using e;",
             sortUsingDeclarations("using c;\n"
                                   "using a;\n"
                                   "using b;\n"
                                   "using a;\n"
                                   "using b;\n"
                                   "\n"
                                   "using e;\n"
                                   "using a;\n"
-                                  "using e;"));
+                                  "using e;",
+                                  Style));
+}
+
+TEST_F(UsingDeclarationsSorterTest,
+       SortsUsingDeclarationsWithDifferentCountsOfScopes) {
+  FormatStyle Style = getLLVMStyle();
+  EXPECT_EQ(FormatStyle::SUD_LexicographicNumeric, Style.SortUsingDeclarations);
+  EXPECT_EQ("using boost::regex;\n"
+            "using boost::regex_constants::icase;\n"
+            "using std::move;\n"
+            "using std::string;\n"
+            "using std::chrono::duration_cast;\n"
+            "using std::chrono::microseconds;\n"
+            "using std::chrono::seconds;\n"
+            "using std::chrono::steady_clock;\n",
+            sortUsingDeclarations("using boost::regex;\n"
+                                  "using boost::regex_constants::icase;\n"
+                                  "using std::chrono::duration_cast;\n"
+                                  "using std::chrono::microseconds;\n"
+                                  "using std::chrono::seconds;\n"
+                                  "using std::chrono::steady_clock;\n"
+                                  "using std::move;\n"
+                                  "using std::string;\n",
+                                  Style));
+
+  Style.SortUsingDeclarations = FormatStyle::SUD_Lexicographic;
+  EXPECT_EQ("using boost::regex;\n"
+            "using boost::regex_constants::icase;\n"
+            "using std::chrono::duration_cast;\n"
+            "using std::chrono::microseconds;\n"
+            "using std::chrono::seconds;\n"
+            "using std::chrono::steady_clock;\n"
+            "using std::move;\n"
+            "using std::string;\n",
+            sortUsingDeclarations("using boost::regex;\n"
+                                  "using boost::regex_constants::icase;\n"
+                                  "using std::move;\n"
+                                  "using std::string;\n"
+                                  "using std::chrono::duration_cast;\n"
+                                  "using std::chrono::microseconds;\n"
+                                  "using std::chrono::seconds;\n"
+                                  "using std::chrono::steady_clock;\n",
+                                  Style));
 }
 
 } // end namespace
 } // end namespace format
 } // end namespace clang