diff --git a/Configurations.md b/Configurations.md
index 8c84614352c..d5ead6e4519 100644
--- a/Configurations.md
+++ b/Configurations.md
@@ -6,7 +6,7 @@ A possible content of `rustfmt.toml` or `.rustfmt.toml` might look like this:
 
 ```toml
 indent_style = "Block"
-reorder_imports = false
+reorder_imports = "Off"
 ```
 
 Each configuration option is either stable or unstable.
@@ -2016,14 +2016,14 @@ impl Iterator for Dummy {
 
 ## `reorder_imports`
 
-Reorder import and extern crate statements alphabetically in groups (a group is
+Reorder import and extern crate statements in groups (a group is
 separated by a newline).
 
-- **Default value**: `true`
-- **Possible values**: `true`, `false`
-- **Stable**: Yes
+- **Default value**: `"Alphabetically"`
+- **Possible values**: `"Alphabetically"`, `"Length"`, `"Off"`
+- **Stable**: No
 
-#### `true` (default):
+#### `"Alphabetically"` (default):
 
 ```rust
 use dolor;
@@ -2032,7 +2032,7 @@ use lorem;
 use sit;
 ```
 
-#### `false`:
+#### `"Off"`:
 
 ```rust
 use lorem;
diff --git a/src/config/mod.rs b/src/config/mod.rs
index a5169528187..ee82e0c2fa4 100644
--- a/src/config/mod.rs
+++ b/src/config/mod.rs
@@ -86,7 +86,8 @@ create_config! {
     merge_imports: bool, false, false, "(deprecated: use imports_granularity instead)";
 
     // Ordering
-    reorder_imports: bool, true, true, "Reorder import and extern crate statements alphabetically";
+    reorder_imports: ReorderImports, ReorderImports::Alphabetically, false,
+        "Reorder import and extern crate statements";
     reorder_modules: bool, true, true, "Reorder module statements alphabetically in group";
     reorder_impl_items: bool, false, false, "Reorder impl items";
 
@@ -547,7 +548,7 @@ imports_indent = "Block"
 imports_layout = "Mixed"
 imports_granularity = "Preserve"
 group_imports = "Preserve"
-reorder_imports = true
+reorder_imports = "Alphabetically"
 reorder_modules = true
 reorder_impl_items = false
 type_punctuation_density = "Wide"
diff --git a/src/config/options.rs b/src/config/options.rs
index 257a17b2703..441041fc4d3 100644
--- a/src/config/options.rs
+++ b/src/config/options.rs
@@ -462,3 +462,13 @@ pub enum MatchArmLeadingPipe {
     /// Preserve any existing leading pipes
     Preserve,
 }
+
+/// Reorder imports
+#[config_type]
+pub enum ReorderImports {
+    Alphabetically,
+
+    Length,
+
+    Off,
+}
diff --git a/src/imports.rs b/src/imports.rs
index 559ed3917db..1370bf98d57 100644
--- a/src/imports.rs
+++ b/src/imports.rs
@@ -14,8 +14,8 @@ use rustc_span::{
 
 use crate::comment::combine_strs_with_missing_comments;
 use crate::config::lists::*;
-use crate::config::ImportGranularity;
 use crate::config::{Edition, IndentStyle};
+use crate::config::{ImportGranularity, ReorderImports};
 use crate::lists::{
     definitive_tactic, itemize_list, write_list, ListFormatting, ListItem, Separator,
 };
@@ -23,7 +23,7 @@ use crate::rewrite::{Rewrite, RewriteContext};
 use crate::shape::Shape;
 use crate::source_map::SpanUtils;
 use crate::spanned::Spanned;
-use crate::utils::{is_same_visibility, mk_sp, rewrite_ident};
+use crate::utils::{compare_sliding_order, is_same_visibility, mk_sp, rewrite_ident};
 use crate::visitor::FmtVisitor;
 
 /// Returns a name imported by a `use` declaration.
@@ -198,6 +198,7 @@ impl UseSegment {
 pub(crate) fn normalize_use_trees_with_granularity(
     use_trees: Vec<UseTree>,
     import_granularity: ImportGranularity,
+    reorder_imports: ReorderImports,
 ) -> Vec<UseTree> {
     let merge_by = match import_granularity {
         ImportGranularity::Item => return flatten_use_trees(use_trees, ImportGranularity::Item),
@@ -219,7 +220,7 @@ pub(crate) fn normalize_use_trees_with_granularity(
                 .iter_mut()
                 .find(|tree| tree.share_prefix(&flattened, merge_by))
             {
-                tree.merge(&flattened, merge_by);
+                tree.merge(&flattened, merge_by, reorder_imports);
             } else {
                 // If this is the first tree with this prefix, handle potential trailing ::self
                 if merge_by == SharedPrefix::Module {
@@ -372,7 +373,7 @@ impl UseTree {
                         Some(item.attrs.clone())
                     },
                 )
-                .normalize(),
+                .normalize(context.config.reorder_imports()),
             ),
             _ => None,
         }
@@ -485,7 +486,7 @@ impl UseTree {
     }
 
     // Do the adjustments that rustfmt does elsewhere to use paths.
-    pub(crate) fn normalize(mut self) -> UseTree {
+    pub(crate) fn normalize(mut self, reorder_imports: ReorderImports) -> UseTree {
         let mut last = self.path.pop().expect("Empty use tree?");
         // Hack around borrow checker.
         let mut normalize_sole_list = false;
@@ -550,7 +551,7 @@ impl UseTree {
                     for seg in &list[0].path {
                         self.path.push(seg.clone());
                     }
-                    return self.normalize();
+                    return self.normalize(reorder_imports);
                 }
                 _ => unreachable!(),
             }
@@ -558,8 +559,16 @@ impl UseTree {
 
         // Recursively normalize elements of a list use (including sorting the list).
         if let UseSegment::List(list) = last {
-            let mut list = list.into_iter().map(UseTree::normalize).collect::<Vec<_>>();
-            list.sort();
+            let mut list = list
+                .into_iter()
+                .map(|member| member.normalize(reorder_imports))
+                .collect::<Vec<_>>();
+
+            if reorder_imports == ReorderImports::Alphabetically {
+                list.sort();
+            } else if reorder_imports == ReorderImports::Length {
+                list.sort_by(|a, b| compare_sliding_order(&a.to_string(), &b.to_string()))
+            }
             last = UseSegment::List(list);
         }
 
@@ -653,7 +662,7 @@ impl UseTree {
         }
     }
 
-    fn merge(&mut self, other: &UseTree, merge_by: SharedPrefix) {
+    fn merge(&mut self, other: &UseTree, merge_by: SharedPrefix, reorder_imports: ReorderImports) {
         let mut prefix = 0;
         for (a, b) in self.path.iter().zip(other.path.iter()) {
             // only discard the alias at the root of the tree
@@ -663,7 +672,9 @@ impl UseTree {
                 break;
             }
         }
-        if let Some(new_path) = merge_rest(&self.path, &other.path, prefix, merge_by) {
+        if let Some(new_path) =
+            merge_rest(&self.path, &other.path, prefix, merge_by, reorder_imports)
+        {
             self.path = new_path;
             self.span = self.span.to(other.span);
         }
@@ -687,6 +698,7 @@ fn merge_rest(
     b: &[UseSegment],
     mut len: usize,
     merge_by: SharedPrefix,
+    reorder_imports: ReorderImports,
 ) -> Option<Vec<UseSegment>> {
     if a.len() == len && b.len() == len {
         return None;
@@ -698,6 +710,7 @@ fn merge_rest(
                 &mut list,
                 UseTree::from_path(b[len..].to_vec(), DUMMY_SP),
                 merge_by,
+                reorder_imports,
             );
             let mut new_path = b[..len].to_vec();
             new_path.push(UseSegment::List(list));
@@ -725,13 +738,22 @@ fn merge_rest(
         UseTree::from_path(a[len..].to_vec(), DUMMY_SP),
         UseTree::from_path(b[len..].to_vec(), DUMMY_SP),
     ];
-    list.sort();
+    if reorder_imports == ReorderImports::Alphabetically {
+        list.sort();
+    } else if reorder_imports == ReorderImports::Length {
+        list.sort_by(|a, b| compare_sliding_order(&a.to_string(), &b.to_string()));
+    }
     let mut new_path = b[..len].to_vec();
     new_path.push(UseSegment::List(list));
     Some(new_path)
 }
 
-fn merge_use_trees_inner(trees: &mut Vec<UseTree>, use_tree: UseTree, merge_by: SharedPrefix) {
+fn merge_use_trees_inner(
+    trees: &mut Vec<UseTree>,
+    use_tree: UseTree,
+    merge_by: SharedPrefix,
+    reorder_imports: ReorderImports,
+) {
     struct SimilarTree<'a> {
         similarity: usize,
         path_len: usize,
@@ -773,18 +795,22 @@ fn merge_use_trees_inner(trees: &mut Vec<UseTree>, use_tree: UseTree, merge_by:
     } else if merge_by == SharedPrefix::One {
         if let Some(sim_tree) = similar_trees.max_by_key(|tree| tree.similarity) {
             if sim_tree.similarity > 0 {
-                sim_tree.tree.merge(&use_tree, merge_by);
+                sim_tree.tree.merge(&use_tree, merge_by, reorder_imports);
                 return;
             }
         }
     } else if let Some(sim_tree) = similar_trees.max_by_key(|tree| tree.path_len) {
         if sim_tree.path_len > 1 {
-            sim_tree.tree.merge(&use_tree, merge_by);
+            sim_tree.tree.merge(&use_tree, merge_by, reorder_imports);
             return;
         }
     }
     trees.push(use_tree);
-    trees.sort();
+    if reorder_imports == ReorderImports::Alphabetically {
+        trees.sort();
+    } else if reorder_imports == ReorderImports::Length {
+        trees.sort_by(|a, b| compare_sliding_order(&a.to_string(), &b.to_string()));
+    }
 }
 
 impl Hash for UseTree {
@@ -1133,7 +1159,6 @@ mod test {
                 }
             }
         }
-
         let mut parser = Parser {
             input: s.chars().peekable(),
         };
@@ -1154,12 +1179,39 @@ mod test {
                 normalize_use_trees_with_granularity(
                     parse_use_trees!($($input,)*),
                     ImportGranularity::$by,
+                    ReorderImports::Alphabetically,
                 ),
                 parse_use_trees!($($output,)*),
             );
         }
     }
 
+    macro_rules! test_normalize_eq {
+        ($first:expr, $second:expr) => {
+            assert_eq!(
+                parse_use_tree($first).normalize(ReorderImports::Alphabetically),
+                parse_use_tree($second)
+            );
+            assert_eq!(
+                parse_use_tree($first).normalize(ReorderImports::Length),
+                parse_use_tree($second)
+            );
+        };
+    }
+
+    macro_rules! test_normalize_smaller {
+        ($first:expr, $second:expr) => {
+            assert!(
+                parse_use_tree($first).normalize(ReorderImports::Alphabetically)
+                    < parse_use_tree($second).normalize(ReorderImports::Alphabetically)
+            );
+            assert!(
+                parse_use_tree($first).normalize(ReorderImports::Length)
+                    < parse_use_tree($second).normalize(ReorderImports::Length)
+            );
+        };
+    }
+
     #[test]
     fn test_use_tree_merge_crate() {
         test_merge!(
@@ -1309,67 +1361,59 @@ mod test {
 
     #[test]
     fn test_use_tree_normalize() {
-        assert_eq!(parse_use_tree("a::self").normalize(), parse_use_tree("a"));
+        test_normalize_eq!("a::self", "a");
+        test_normalize_eq!("a::self as foo", "a as foo");
+        test_normalize_eq!("a::{self}", "a::{self}");
+        test_normalize_eq!("a::{b}", "a::b");
         assert_eq!(
-            parse_use_tree("a::self as foo").normalize(),
-            parse_use_tree("a as foo")
-        );
-        assert_eq!(
-            parse_use_tree("a::{self}").normalize(),
-            parse_use_tree("a::{self}")
-        );
-        assert_eq!(parse_use_tree("a::{b}").normalize(), parse_use_tree("a::b"));
-        assert_eq!(
-            parse_use_tree("a::{b, c::self}").normalize(),
+            parse_use_tree("a::{b, c::self}").normalize(ReorderImports::Alphabetically),
             parse_use_tree("a::{b, c}")
         );
         assert_eq!(
-            parse_use_tree("a::{b as bar, c::self}").normalize(),
+            parse_use_tree("a::{b as bar, c::self}").normalize(ReorderImports::Alphabetically),
             parse_use_tree("a::{b as bar, c}")
         );
     }
 
     #[test]
     fn test_use_tree_ord() {
-        assert!(parse_use_tree("a").normalize() < parse_use_tree("aa").normalize());
-        assert!(parse_use_tree("a").normalize() < parse_use_tree("a::a").normalize());
-        assert!(parse_use_tree("a").normalize() < parse_use_tree("*").normalize());
-        assert!(parse_use_tree("a").normalize() < parse_use_tree("{a, b}").normalize());
-        assert!(parse_use_tree("*").normalize() < parse_use_tree("{a, b}").normalize());
-
-        assert!(
-            parse_use_tree("aaaaaaaaaaaaaaa::{bb, cc, dddddddd}").normalize()
-                < parse_use_tree("aaaaaaaaaaaaaaa::{bb, cc, ddddddddd}").normalize()
-        );
-        assert!(
-            parse_use_tree("serde::de::{Deserialize}").normalize()
-                < parse_use_tree("serde_json").normalize()
-        );
-        assert!(parse_use_tree("a::b::c").normalize() < parse_use_tree("a::b::*").normalize());
-        assert!(
-            parse_use_tree("foo::{Bar, Baz}").normalize()
-                < parse_use_tree("{Bar, Baz}").normalize()
+        test_normalize_smaller!("a", "aa");
+        test_normalize_smaller!("a", "a::a");
+        test_normalize_smaller!("a", "*");
+        test_normalize_smaller!("a", "{a, b}");
+        test_normalize_smaller!("*", "{a, b}");
+
+        test_normalize_smaller!(
+            "aaaaaaaaaaaaaaa::{bb, cc, dddddddd}",
+            "aaaaaaaaaaaaaaa::{bb, cc, ddddddddd}"
         );
+        test_normalize_smaller!("serde::de::{Deserialize}", "serde_json");
+        test_normalize_smaller!("a::b::c", "a::b::*");
+        test_normalize_smaller!("foo::{Bar, Baz}", "{Bar, Baz}");
 
-        assert!(
-            parse_use_tree("foo::{qux as bar}").normalize()
-                < parse_use_tree("foo::{self as bar}").normalize()
-        );
-        assert!(
-            parse_use_tree("foo::{qux as bar}").normalize()
-                < parse_use_tree("foo::{baz, qux as bar}").normalize()
-        );
-        assert!(
-            parse_use_tree("foo::{self as bar, baz}").normalize()
-                < parse_use_tree("foo::{baz, qux as bar}").normalize()
-        );
+        test_normalize_smaller!("foo::{qux as bar}", "foo::{self as bar}");
+        test_normalize_smaller!("foo::{qux as bar}", "foo::{baz, qux as bar}");
+        test_normalize_smaller!("foo::{self as bar, baz}", "foo::{baz, qux as bar}");
 
-        assert!(parse_use_tree("foo").normalize() < parse_use_tree("Foo").normalize());
-        assert!(parse_use_tree("foo").normalize() < parse_use_tree("foo::Bar").normalize());
+        test_normalize_smaller!("foo", "Foo");
+        test_normalize_smaller!("foo", "foo::Bar");
 
-        assert!(
-            parse_use_tree("std::cmp::{d, c, b, a}").normalize()
-                < parse_use_tree("std::cmp::{b, e, g, f}").normalize()
+        test_normalize_smaller!("std::cmp::{d, c, b, a}", "std::cmp::{b, e, g, f}");
+    }
+
+    #[test]
+    fn test_use_tree_length() {
+        assert_eq!(
+            parse_use_tree("aaaaa::{aa, bbbb, cc, d}").normalize(ReorderImports::Length),
+            parse_use_tree("aaaaa::{d, aa, cc, bbbb}")
+        );
+        assert_eq!(
+            parse_use_tree("a::{b, c::self}").normalize(ReorderImports::Length),
+            parse_use_tree("a::{b, c}")
+        );
+        assert_eq!(
+            parse_use_tree("a::{b as bar, c::self}").normalize(ReorderImports::Length),
+            parse_use_tree("a::{c, b as bar}")
         );
     }
 
diff --git a/src/reorder.rs b/src/reorder.rs
index 8ae297de25b..f9bb713a281 100644
--- a/src/reorder.rs
+++ b/src/reorder.rs
@@ -11,7 +11,7 @@ use std::cmp::{Ord, Ordering};
 use rustc_ast::ast;
 use rustc_span::{symbol::sym, Span};
 
-use crate::config::{Config, GroupImportsTactic};
+use crate::config::{Config, GroupImportsTactic, ReorderImports};
 use crate::imports::{normalize_use_trees_with_granularity, UseSegment, UseTree};
 use crate::items::{is_mod_decl, rewrite_extern_crate, rewrite_mod};
 use crate::lists::{itemize_list, write_list, ListFormatting, ListItem};
@@ -19,7 +19,7 @@ use crate::rewrite::RewriteContext;
 use crate::shape::Shape;
 use crate::source_map::LineRangeUtils;
 use crate::spanned::Spanned;
-use crate::utils::{contains_skip, mk_sp};
+use crate::utils::{compare_sliding_order, contains_skip, mk_sp};
 use crate::visitor::FmtVisitor;
 
 /// Choose the ordering between the given two items.
@@ -110,6 +110,7 @@ fn rewrite_reorderable_or_regroupable_items(
             normalized_items = normalize_use_trees_with_granularity(
                 normalized_items,
                 context.config.imports_granularity(),
+                context.config.reorder_imports(),
             );
 
             let mut regrouped_items = match context.config.group_imports() {
@@ -119,8 +120,14 @@ fn rewrite_reorderable_or_regroupable_items(
                 GroupImportsTactic::StdExternalCrate => group_imports(normalized_items),
             };
 
-            if context.config.reorder_imports() {
+            if context.config.reorder_imports() == ReorderImports::Alphabetically {
                 regrouped_items.iter_mut().for_each(|items| items.sort())
+            } else if context.config.reorder_imports() == ReorderImports::Length {
+                regrouped_items.iter_mut().for_each({
+                    |items| {
+                        items.sort_by(|a, b| compare_sliding_order(&a.to_string(), &b.to_string()))
+                    }
+                })
             }
 
             // 4 = "use ", 1 = ";"
@@ -228,9 +235,9 @@ impl ReorderableItemKind {
 
     fn is_reorderable(self, config: &Config) -> bool {
         match self {
-            ReorderableItemKind::ExternCrate => config.reorder_imports(),
+            ReorderableItemKind::ExternCrate => config.reorder_imports() != ReorderImports::Off,
             ReorderableItemKind::Mod => config.reorder_modules(),
-            ReorderableItemKind::Use => config.reorder_imports(),
+            ReorderableItemKind::Use => config.reorder_imports() != ReorderImports::Off,
             ReorderableItemKind::Other => false,
         }
     }
diff --git a/src/utils.rs b/src/utils.rs
index 58fd95c656e..ea13c1acbfe 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -1,4 +1,5 @@
 use std::borrow::Cow;
+use std::cmp::Ordering;
 
 use rustc_ast::ast::{
     self, Attribute, MetaItem, MetaItemKind, NestedMetaItem, NodeId, Path, Visibility,
@@ -685,6 +686,15 @@ pub(crate) fn unicode_str_width(s: &str) -> usize {
     s.width()
 }
 
+pub(crate) fn compare_sliding_order(s1: &str, s2: &str) -> Ordering {
+    let mut is_equal = s1.len().cmp(&s2.len());
+    if Ordering::is_eq(is_equal) {
+        is_equal = s1.cmp(&s2);
+    }
+
+    is_equal
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
diff --git a/tests/config/issue-1111.toml b/tests/config/issue-1111.toml
index 44148a2d3c3..d2fa1201eef 100644
--- a/tests/config/issue-1111.toml
+++ b/tests/config/issue-1111.toml
@@ -1 +1 @@
-reorder_imports = true
+reorder_imports = "Alphabetically"
diff --git a/tests/source/configs/group_imports/One-no_reorder.rs b/tests/source/configs/group_imports/One-no_reorder.rs
index f82f62c7f5b..934ce0ad195 100644
--- a/tests/source/configs/group_imports/One-no_reorder.rs
+++ b/tests/source/configs/group_imports/One-no_reorder.rs
@@ -1,5 +1,5 @@
 // rustfmt-group_imports: One
-// rustfmt-reorder_imports: false
+// rustfmt-reorder_imports: Off
 use chrono::Utc;
 use super::update::convert_publish_payload;
 
diff --git a/tests/source/configs/group_imports/StdExternalCrate-no_reorder.rs b/tests/source/configs/group_imports/StdExternalCrate-no_reorder.rs
index 08c9a72ae61..0ca02d54775 100644
--- a/tests/source/configs/group_imports/StdExternalCrate-no_reorder.rs
+++ b/tests/source/configs/group_imports/StdExternalCrate-no_reorder.rs
@@ -1,5 +1,5 @@
 // rustfmt-group_imports: StdExternalCrate
-// rustfmt-reorder_imports: false
+// rustfmt-reorder_imports: Off
 
 use chrono::Utc;
 use super::update::convert_publish_payload;
diff --git a/tests/source/configs/reorder_imports/false.rs b/tests/source/configs/reorder_imports/false.rs
index 4b85684dc01..37f4287ba27 100644
--- a/tests/source/configs/reorder_imports/false.rs
+++ b/tests/source/configs/reorder_imports/false.rs
@@ -1,4 +1,4 @@
-// rustfmt-reorder_imports: false
+// rustfmt-reorder_imports: Off
 // Reorder imports
 
 use lorem;
diff --git a/tests/source/configs/reorder_imports/true.rs b/tests/source/configs/reorder_imports/true.rs
index 2a40f6d069f..135aee0d848 100644
--- a/tests/source/configs/reorder_imports/true.rs
+++ b/tests/source/configs/reorder_imports/true.rs
@@ -1,4 +1,4 @@
-// rustfmt-reorder_imports: true
+// rustfmt-reorder_imports: Alphabetically
 // Reorder imports
 
 use lorem;
diff --git a/tests/source/issue-1120.rs b/tests/source/issue-1120.rs
index e85c9af99d4..cc068050d72 100644
--- a/tests/source/issue-1120.rs
+++ b/tests/source/issue-1120.rs
@@ -1,4 +1,4 @@
-// rustfmt-reorder_imports: true
+// rustfmt-reorder_imports: Alphabetically
 
 // Ensure that a use at the start of an inline module is correctly formatted.
 mod foo {use bar;}
diff --git a/tests/source/issue-1124.rs b/tests/source/issue-1124.rs
index 35c2197fa34..81529df47f0 100644
--- a/tests/source/issue-1124.rs
+++ b/tests/source/issue-1124.rs
@@ -1,4 +1,4 @@
-// rustfmt-reorder_imports: true
+// rustfmt-reorder_imports: Alphabetically
 
 use d; use c; use b; use a; 
 // The previous line has a space after the `use a;` 
diff --git a/tests/source/issue-3515.rs b/tests/source/issue-3515.rs
index 9f760cb94e8..e34bcf47880 100644
--- a/tests/source/issue-3515.rs
+++ b/tests/source/issue-3515.rs
@@ -1,4 +1,4 @@
-// rustfmt-reorder_imports: false
+// rustfmt-reorder_imports: Off
 
 use std :: fmt :: { self , Display } ;
 use std :: collections :: HashMap ;
diff --git a/tests/source/issue-3585/reorder_imports_disabled.rs b/tests/source/issue-3585/reorder_imports_disabled.rs
index 45b1bb9fdd9..06148871fdd 100644
--- a/tests/source/issue-3585/reorder_imports_disabled.rs
+++ b/tests/source/issue-3585/reorder_imports_disabled.rs
@@ -1,5 +1,5 @@
 // rustfmt-inline_attribute_width: 100
-// rustfmt-reorder_imports: false
+// rustfmt-reorder_imports: Off
 
 #[cfg(unix)]
 extern crate crateb;
diff --git a/tests/source/issue-3585/reorder_imports_enabled.rs b/tests/source/issue-3585/reorder_imports_enabled.rs
index 9f433e5ca21..460a7b95f97 100644
--- a/tests/source/issue-3585/reorder_imports_enabled.rs
+++ b/tests/source/issue-3585/reorder_imports_enabled.rs
@@ -1,5 +1,5 @@
 // rustfmt-inline_attribute_width: 100
-// rustfmt-reorder_imports: true
+// rustfmt-reorder_imports: Alphabetically
 
 #[cfg(unix)]
 extern crate crateb;
diff --git a/tests/source/long-use-statement-issue-3154.rs b/tests/source/long-use-statement-issue-3154.rs
index 339382b5bbf..11411793fa6 100644
--- a/tests/source/long-use-statement-issue-3154.rs
+++ b/tests/source/long-use-statement-issue-3154.rs
@@ -1,3 +1,3 @@
-// rustfmt-reorder_imports: false
+// rustfmt-reorder_imports: Off
 
 pub use self :: super :: super :: super :: root::mozilla::detail::StringClassFlags as nsTStringRepr_ClassFlags ;
diff --git a/tests/target/configs/group_imports/One-no_reorder.rs b/tests/target/configs/group_imports/One-no_reorder.rs
index 015e841d014..bc8a1f25f6d 100644
--- a/tests/target/configs/group_imports/One-no_reorder.rs
+++ b/tests/target/configs/group_imports/One-no_reorder.rs
@@ -1,5 +1,5 @@
 // rustfmt-group_imports: One
-// rustfmt-reorder_imports: false
+// rustfmt-reorder_imports: Off
 use chrono::Utc;
 use super::update::convert_publish_payload;
 use juniper::{FieldError, FieldResult};
diff --git a/tests/target/configs/group_imports/StdExternalCrate-no_reorder.rs b/tests/target/configs/group_imports/StdExternalCrate-no_reorder.rs
index 76d3d6ccb95..d26dd040b66 100644
--- a/tests/target/configs/group_imports/StdExternalCrate-no_reorder.rs
+++ b/tests/target/configs/group_imports/StdExternalCrate-no_reorder.rs
@@ -1,5 +1,5 @@
 // rustfmt-group_imports: StdExternalCrate
-// rustfmt-reorder_imports: false
+// rustfmt-reorder_imports: Off
 
 use alloc::alloc::Layout;
 use std::sync::Arc;
diff --git a/tests/target/configs/reorder_imports/false.rs b/tests/target/configs/reorder_imports/false.rs
index 4b85684dc01..37f4287ba27 100644
--- a/tests/target/configs/reorder_imports/false.rs
+++ b/tests/target/configs/reorder_imports/false.rs
@@ -1,4 +1,4 @@
-// rustfmt-reorder_imports: false
+// rustfmt-reorder_imports: Off
 // Reorder imports
 
 use lorem;
diff --git a/tests/target/configs/reorder_imports/true.rs b/tests/target/configs/reorder_imports/true.rs
index e4ff7295fd0..7e8a961d47c 100644
--- a/tests/target/configs/reorder_imports/true.rs
+++ b/tests/target/configs/reorder_imports/true.rs
@@ -1,4 +1,4 @@
-// rustfmt-reorder_imports: true
+// rustfmt-reorder_imports: Alphabetically
 // Reorder imports
 
 use dolor;
diff --git a/tests/target/issue-1120.rs b/tests/target/issue-1120.rs
index f44597e7d1e..43823fdc268 100644
--- a/tests/target/issue-1120.rs
+++ b/tests/target/issue-1120.rs
@@ -1,4 +1,4 @@
-// rustfmt-reorder_imports: true
+// rustfmt-reorder_imports: Alphabetically
 
 // Ensure that a use at the start of an inline module is correctly formatted.
 mod foo {
diff --git a/tests/target/issue-1124.rs b/tests/target/issue-1124.rs
index f0fc485a3c2..c8985519b93 100644
--- a/tests/target/issue-1124.rs
+++ b/tests/target/issue-1124.rs
@@ -1,4 +1,4 @@
-// rustfmt-reorder_imports: true
+// rustfmt-reorder_imports: Alphabetically
 
 use a;
 use b;
diff --git a/tests/target/issue-3515.rs b/tests/target/issue-3515.rs
index b59d03c6c82..ed4cda36285 100644
--- a/tests/target/issue-3515.rs
+++ b/tests/target/issue-3515.rs
@@ -1,4 +1,4 @@
-// rustfmt-reorder_imports: false
+// rustfmt-reorder_imports: Off
 
 use std::fmt::{self, Display};
 use std::collections::HashMap;
diff --git a/tests/target/issue-3585/reorder_imports_disabled.rs b/tests/target/issue-3585/reorder_imports_disabled.rs
index f9637729b7e..5707f5a71cb 100644
--- a/tests/target/issue-3585/reorder_imports_disabled.rs
+++ b/tests/target/issue-3585/reorder_imports_disabled.rs
@@ -1,5 +1,5 @@
 // rustfmt-inline_attribute_width: 100
-// rustfmt-reorder_imports: false
+// rustfmt-reorder_imports: Off
 
 #[cfg(unix)] extern crate crateb;
 #[cfg(unix)] extern crate cratea;
diff --git a/tests/target/issue-3585/reorder_imports_enabled.rs b/tests/target/issue-3585/reorder_imports_enabled.rs
index d040d0ed341..ba511b4d6ba 100644
--- a/tests/target/issue-3585/reorder_imports_enabled.rs
+++ b/tests/target/issue-3585/reorder_imports_enabled.rs
@@ -1,5 +1,5 @@
 // rustfmt-inline_attribute_width: 100
-// rustfmt-reorder_imports: true
+// rustfmt-reorder_imports: Alphabetically
 
 #[cfg(unix)] extern crate cratea;
 #[cfg(unix)] extern crate crateb;
diff --git a/tests/target/issue-4791/issue_4928.rs b/tests/target/issue-4791/issue_4928.rs
index 588656b535f..d2b58c6822e 100644
--- a/tests/target/issue-4791/issue_4928.rs
+++ b/tests/target/issue-4791/issue_4928.rs
@@ -9,7 +9,7 @@
 // rustfmt-newline_style: Unix
 // rustfmt-normalize_doc_attributes: true
 // rustfmt-overflow_delimited_expr: true
-// rustfmt-reorder_imports: false
+// rustfmt-reorder_imports: Off
 // rustfmt-reorder_modules: true
 // rustfmt-struct_field_align_threshold: 20
 // rustfmt-tab_spaces: 4
diff --git a/tests/target/long-use-statement-issue-3154.rs b/tests/target/long-use-statement-issue-3154.rs
index 877241e3b6f..3ababf161a0 100644
--- a/tests/target/long-use-statement-issue-3154.rs
+++ b/tests/target/long-use-statement-issue-3154.rs
@@ -1,3 +1,3 @@
-// rustfmt-reorder_imports: false
+// rustfmt-reorder_imports: Off
 
 pub use self::super::super::super::root::mozilla::detail::StringClassFlags as nsTStringRepr_ClassFlags;