Format libstd with rustfmt

This commit applies rustfmt with rust-lang/rust's default settings to
files in src/libstd *that are not involved in any currently open PR* to
minimize merge conflicts. THe list of files involved in open PRs was
determined by querying GitHub's GraphQL API with this script:
https://gist.github.com/dtolnay/aa9c34993dc051a4f344d1b10e4487e8

With the list of files from the script in outstanding_files, the
relevant commands were:

    $ find src/libstd -name '*.rs' \
        | xargs rustfmt --edition=2018 --unstable-features --skip-children
    $ rg libstd outstanding_files | xargs git checkout --

Repeating this process several months apart should get us coverage of
most of the rest of libstd.

To confirm no funny business:

    $ git checkout $THIS_COMMIT^
    $ git show --pretty= --name-only $THIS_COMMIT \
        | xargs rustfmt --edition=2018 --unstable-features --skip-children
    $ git diff $THIS_COMMIT  # there should be no difference

1 files changed, 781 insertions, 847 deletions

diff --git a/src/libstd/path.rs b/src/libstd/path.rs
index 6d6bc760649..42bca0a9575 100644
--- a/src/libstd/path.rs
+++ b/src/libstd/path.rs
@@ -84,7 +84,7 @@ use crate::sync::Arc;
 
 use crate::ffi::{OsStr, OsString};
 
-use crate::sys::path::{is_sep_byte, is_verbatim_sep, MAIN_SEP_STR, parse_prefix};
+use crate::sys::path::{is_sep_byte, is_verbatim_sep, parse_prefix, MAIN_SEP_STR};
 
 ////////////////////////////////////////////////////////////////////////////////
 // GENERAL NOTES
@@ -196,26 +196,13 @@ impl<'a> Prefix<'a> {
         match *self {
             Verbatim(x) => 4 + os_str_len(x),
             VerbatimUNC(x, y) => {
-                8 + os_str_len(x) +
-                if os_str_len(y) > 0 {
-                    1 + os_str_len(y)
-                } else {
-                    0
-                }
-            },
+                8 + os_str_len(x) + if os_str_len(y) > 0 { 1 + os_str_len(y) } else { 0 }
+            }
             VerbatimDisk(_) => 6,
-            UNC(x, y) => {
-                2 + os_str_len(x) +
-                if os_str_len(y) > 0 {
-                    1 + os_str_len(y)
-                } else {
-                    0
-                }
-            },
+            UNC(x, y) => 2 + os_str_len(x) + if os_str_len(y) > 0 { 1 + os_str_len(y) } else { 0 },
             DeviceNS(x) => 4 + os_str_len(x),
             Disk(_) => 2,
         }
-
     }
 
     /// Determines if the prefix is verbatim, i.e., begins with `\\?\`.
@@ -291,8 +278,9 @@ pub const MAIN_SEPARATOR: char = crate::sys::path::MAIN_SEP;
 // is not a prefix of `iter`, otherwise return `Some(iter_after_prefix)` giving
 // `iter` after having exhausted `prefix`.
 fn iter_after<'a, 'b, I, J>(mut iter: I, mut prefix: J) -> Option<I>
-    where I: Iterator<Item = Component<'a>> + Clone,
-          J: Iterator<Item = Component<'b>>,
+where
+    I: Iterator<Item = Component<'a>> + Clone,
+    J: Iterator<Item = Component<'b>>,
 {
     loop {
         let mut iter_next = iter.clone();
@@ -326,11 +314,7 @@ fn has_redox_scheme(s: &[u8]) -> bool {
 
 /// Says whether the first byte after the prefix is a separator.
 fn has_physical_root(s: &[u8], prefix: Option<Prefix<'_>>) -> bool {
-    let path = if let Some(p) = prefix {
-        &s[p.len()..]
-    } else {
-        s
-    };
+    let path = if let Some(p) = prefix { &s[p.len()..] } else { s };
     !path.is_empty() && is_sep_byte(path[0])
 }
 
@@ -352,8 +336,7 @@ fn split_file_at_dot(file: &OsStr) -> (Option<&OsStr>, Option<&OsStr>) {
         if before == Some(b"") {
             (Some(file), None)
         } else {
-            (before.map(|s| u8_slice_as_os_str(s)),
-             after.map(|s| u8_slice_as_os_str(s)))
+            (before.map(|s| u8_slice_as_os_str(s)), after.map(|s| u8_slice_as_os_str(s)))
         }
     }
 }
@@ -370,9 +353,9 @@ fn split_file_at_dot(file: &OsStr) -> (Option<&OsStr>, Option<&OsStr>) {
 /// directory component, and a body (of normal components)
 #[derive(Copy, Clone, PartialEq, PartialOrd, Debug)]
 enum State {
-    Prefix = 0,         // c:
-    StartDir = 1,       // / or . or nothing
-    Body = 2,           // foo/bar/baz
+    Prefix = 0,   // c:
+    StartDir = 1, // / or . or nothing
+    Body = 2,     // foo/bar/baz
     Done = 3,
 }
 
@@ -509,9 +492,7 @@ pub enum Component<'a> {
     ///
     /// [`Prefix`]: enum.Prefix.html
     #[stable(feature = "rust1", since = "1.0.0")]
-    Prefix(
-        #[stable(feature = "rust1", since = "1.0.0")] PrefixComponent<'a>
-    ),
+    Prefix(#[stable(feature = "rust1", since = "1.0.0")] PrefixComponent<'a>),
 
     /// The root directory component, appears after any prefix and before anything else.
     ///
@@ -637,15 +618,11 @@ impl fmt::Debug for Components<'_> {
 
         impl fmt::Debug for DebugHelper<'_> {
             fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                f.debug_list()
-                    .entries(self.0.components())
-                    .finish()
+                f.debug_list().entries(self.0.components()).finish()
             }
         }
 
-        f.debug_tuple("Components")
-            .field(&DebugHelper(self.as_path()))
-            .finish()
+        f.debug_tuple("Components").field(&DebugHelper(self.as_path())).finish()
     }
 }
 
@@ -664,26 +641,14 @@ impl<'a> Components<'a> {
     /// how much of the prefix is left from the point of view of iteration?
     #[inline]
     fn prefix_remaining(&self) -> usize {
-        if self.front == State::Prefix {
-            self.prefix_len()
-        } else {
-            0
-        }
+        if self.front == State::Prefix { self.prefix_len() } else { 0 }
     }
 
     // Given the iteration so far, how much of the pre-State::Body path is left?
     #[inline]
     fn len_before_body(&self) -> usize {
-        let root = if self.front <= State::StartDir && self.has_physical_root {
-            1
-        } else {
-            0
-        };
-        let cur_dir = if self.front <= State::StartDir && self.include_cur_dir() {
-            1
-        } else {
-            0
-        };
+        let root = if self.front <= State::StartDir && self.has_physical_root { 1 } else { 0 };
+        let cur_dir = if self.front <= State::StartDir && self.include_cur_dir() { 1 } else { 0 };
         self.prefix_remaining() + root + cur_dir
     }
 
@@ -695,11 +660,7 @@ impl<'a> Components<'a> {
 
     #[inline]
     fn is_sep_byte(&self, b: u8) -> bool {
-        if self.prefix_verbatim() {
-            is_verbatim_sep(b)
-        } else {
-            is_sep_byte(b)
-        }
+        if self.prefix_verbatim() { is_verbatim_sep(b) } else { is_sep_byte(b) }
     }
 
     /// Extracts a slice corresponding to the portion of the path remaining for iteration.
@@ -758,8 +719,8 @@ impl<'a> Components<'a> {
         match comp {
             b"." if self.prefix_verbatim() => Some(Component::CurDir),
             b"." => None, // . components are normalized away, except at
-                          // the beginning of a path, which is treated
-                          // separately via `include_cur_dir`
+            // the beginning of a path, which is treated
+            // separately via `include_cur_dir`
             b".." => Some(Component::ParentDir),
             b"" => None,
             _ => Some(Component::Normal(unsafe { u8_slice_as_os_str(comp) })),
@@ -835,15 +796,11 @@ impl fmt::Debug for Iter<'_> {
 
         impl fmt::Debug for DebugHelper<'_> {
             fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                f.debug_list()
-                    .entries(self.0.iter())
-                    .finish()
+                f.debug_list().entries(self.0.iter()).finish()
             }
         }
 
-        f.debug_tuple("Iter")
-            .field(&DebugHelper(self.as_path()))
-            .finish()
+        f.debug_tuple("Iter").field(&DebugHelper(self.as_path())).finish()
     }
 }
 
@@ -1174,9 +1131,7 @@ impl PathBuf {
     /// [`OsString`]: ../ffi/struct.OsString.html
     #[unstable(feature = "path_buf_capacity", issue = "58234")]
     pub fn with_capacity(capacity: usize) -> PathBuf {
-        PathBuf {
-            inner: OsString::with_capacity(capacity)
-        }
+        PathBuf { inner: OsString::with_capacity(capacity) }
     }
 
     /// Coerces to a [`Path`] slice.
@@ -1239,8 +1194,10 @@ impl PathBuf {
         // in the special case of `C:` on Windows, do *not* add a separator
         {
             let comps = self.components();
-            if comps.prefix_len() > 0 && comps.prefix_len() == comps.path.len() &&
-               comps.prefix.unwrap().is_drive() {
+            if comps.prefix_len() > 0
+                && comps.prefix_len() == comps.path.len()
+                && comps.prefix.unwrap().is_drive()
+            {
                 need_sep = false
             }
         }
@@ -1527,7 +1484,7 @@ impl From<PathBuf> for OsString {
     /// Converts a `PathBuf` into a `OsString`
     ///
     /// This conversion does not allocate or copy memory.
-    fn from(path_buf : PathBuf) -> OsString {
+    fn from(path_buf: PathBuf) -> OsString {
         path_buf.inner
     }
 }
@@ -1992,13 +1949,11 @@ impl Path {
     pub fn parent(&self) -> Option<&Path> {
         let mut comps = self.components();
         let comp = comps.next_back();
-        comp.and_then(|p| {
-            match p {
-                Component::Normal(_) |
-                Component::CurDir |
-                Component::ParentDir => Some(comps.as_path()),
-                _ => None,
+        comp.and_then(|p| match p {
+            Component::Normal(_) | Component::CurDir | Component::ParentDir => {
+                Some(comps.as_path())
             }
+            _ => None,
         })
     }
 
@@ -2026,9 +1981,7 @@ impl Path {
     /// [`parent`]: struct.Path.html#method.parent
     #[stable(feature = "path_ancestors", since = "1.28.0")]
     pub fn ancestors(&self) -> Ancestors<'_> {
-        Ancestors {
-            next: Some(&self),
-        }
+        Ancestors { next: Some(&self) }
     }
 
     /// Returns the final component of the `Path`, if there is one.
@@ -2055,11 +2008,9 @@ impl Path {
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn file_name(&self) -> Option<&OsStr> {
-        self.components().next_back().and_then(|p| {
-            match p {
-                Component::Normal(p) => Some(p.as_ref()),
-                _ => None,
-            }
+        self.components().next_back().and_then(|p| match p {
+            Component::Normal(p) => Some(p.as_ref()),
+            _ => None,
         })
     }
 
@@ -2092,15 +2043,14 @@ impl Path {
     /// assert_eq!(path.strip_prefix(prefix), Ok(Path::new("haha/foo.txt")));
     /// ```
     #[stable(since = "1.7.0", feature = "path_strip_prefix")]
-    pub fn strip_prefix<P>(&self, base: P)
-                           -> Result<&Path, StripPrefixError>
-        where P: AsRef<Path>
+    pub fn strip_prefix<P>(&self, base: P) -> Result<&Path, StripPrefixError>
+    where
+        P: AsRef<Path>,
     {
         self._strip_prefix(base.as_ref())
     }
 
-    fn _strip_prefix(&self, base: &Path)
-                     -> Result<&Path, StripPrefixError> {
+    fn _strip_prefix(&self, base: &Path) -> Result<&Path, StripPrefixError> {
         iter_after(self.components(), base.components())
             .map(|c| c.as_path())
             .ok_or(StripPrefixError(()))
@@ -2329,8 +2279,8 @@ impl Path {
         Components {
             path: self.as_u8_slice(),
             prefix,
-            has_physical_root: has_physical_root(self.as_u8_slice(), prefix) ||
-                               has_redox_scheme(self.as_u8_slice()),
+            has_physical_root: has_physical_root(self.as_u8_slice(), prefix)
+                || has_redox_scheme(self.as_u8_slice()),
             front: State::Prefix,
             back: State::Body,
         }
@@ -2727,14 +2677,18 @@ impl AsRef<Path> for PathBuf {
 impl<'a> IntoIterator for &'a PathBuf {
     type Item = &'a OsStr;
     type IntoIter = Iter<'a>;
-    fn into_iter(self) -> Iter<'a> { self.iter() }
+    fn into_iter(self) -> Iter<'a> {
+        self.iter()
+    }
 }
 
 #[stable(feature = "path_into_iter", since = "1.6.0")]
 impl<'a> IntoIterator for &'a Path {
     type Item = &'a OsStr;
     type IntoIter = Iter<'a>;
-    fn into_iter(self) -> Iter<'a> { self.iter() }
+    fn into_iter(self) -> Iter<'a> {
+        self.iter()
+    }
 }
 
 macro_rules! impl_cmp {
@@ -2742,13 +2696,17 @@ macro_rules! impl_cmp {
         #[stable(feature = "partialeq_path", since = "1.6.0")]
         impl<'a, 'b> PartialEq<$rhs> for $lhs {
             #[inline]
-            fn eq(&self, other: &$rhs) -> bool { <Path as PartialEq>::eq(self, other) }
+            fn eq(&self, other: &$rhs) -> bool {
+                <Path as PartialEq>::eq(self, other)
+            }
         }
 
         #[stable(feature = "partialeq_path", since = "1.6.0")]
         impl<'a, 'b> PartialEq<$lhs> for $rhs {
             #[inline]
-            fn eq(&self, other: &$lhs) -> bool { <Path as PartialEq>::eq(self, other) }
+            fn eq(&self, other: &$lhs) -> bool {
+                <Path as PartialEq>::eq(self, other)
+            }
         }
 
         #[stable(feature = "cmp_path", since = "1.8.0")]
@@ -2766,7 +2724,7 @@ macro_rules! impl_cmp {
                 <Path as PartialOrd>::partial_cmp(self, other)
             }
         }
-    }
+    };
 }
 
 impl_cmp!(PathBuf, Path);
@@ -2780,13 +2738,17 @@ macro_rules! impl_cmp_os_str {
         #[stable(feature = "cmp_path", since = "1.8.0")]
         impl<'a, 'b> PartialEq<$rhs> for $lhs {
             #[inline]
-            fn eq(&self, other: &$rhs) -> bool { <Path as PartialEq>::eq(self, other.as_ref()) }
+            fn eq(&self, other: &$rhs) -> bool {
+                <Path as PartialEq>::eq(self, other.as_ref())
+            }
         }
 
         #[stable(feature = "cmp_path", since = "1.8.0")]
         impl<'a, 'b> PartialEq<$lhs> for $rhs {
             #[inline]
-            fn eq(&self, other: &$lhs) -> bool { <Path as PartialEq>::eq(self.as_ref(), other) }
+            fn eq(&self, other: &$lhs) -> bool {
+                <Path as PartialEq>::eq(self.as_ref(), other)
+            }
         }
 
         #[stable(feature = "cmp_path", since = "1.8.0")]
@@ -2804,7 +2766,7 @@ macro_rules! impl_cmp_os_str {
                 <Path as PartialOrd>::partial_cmp(self.as_ref(), other)
             }
         }
-    }
+    };
 }
 
 impl_cmp_os_str!(PathBuf, OsStr);
@@ -2831,7 +2793,9 @@ impl fmt::Display for StripPrefixError {
 
 #[stable(since = "1.7.0", feature = "strip_prefix")]
 impl Error for StripPrefixError {
-    fn description(&self) -> &str { "prefix not found" }
+    fn description(&self) -> &str {
+        "prefix not found"
+    }
 }
 
 #[cfg(test)]
@@ -2948,568 +2912,568 @@ mod tests {
     #[cfg(unix)]
     pub fn test_decompositions_unix() {
         t!("",
-           iter: [],
-           has_root: false,
-           is_absolute: false,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: [],
+        has_root: false,
+        is_absolute: false,
+        parent: None,
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("foo",
-           iter: ["foo"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
+        iter: ["foo"],
+        has_root: false,
+        is_absolute: false,
+        parent: Some(""),
+        file_name: Some("foo"),
+        file_stem: Some("foo"),
+        extension: None
+        );
 
         t!("/",
-           iter: ["/"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: ["/"],
+        has_root: true,
+        is_absolute: true,
+        parent: None,
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("/foo",
-           iter: ["/", "foo"],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("/"),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
+        iter: ["/", "foo"],
+        has_root: true,
+        is_absolute: true,
+        parent: Some("/"),
+        file_name: Some("foo"),
+        file_stem: Some("foo"),
+        extension: None
+        );
 
         t!("foo/",
-           iter: ["foo"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
+        iter: ["foo"],
+        has_root: false,
+        is_absolute: false,
+        parent: Some(""),
+        file_name: Some("foo"),
+        file_stem: Some("foo"),
+        extension: None
+        );
 
         t!("/foo/",
-           iter: ["/", "foo"],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("/"),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
+        iter: ["/", "foo"],
+        has_root: true,
+        is_absolute: true,
+        parent: Some("/"),
+        file_name: Some("foo"),
+        file_stem: Some("foo"),
+        extension: None
+        );
 
         t!("foo/bar",
-           iter: ["foo", "bar"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("foo"),
-           file_name: Some("bar"),
-           file_stem: Some("bar"),
-           extension: None
-           );
+        iter: ["foo", "bar"],
+        has_root: false,
+        is_absolute: false,
+        parent: Some("foo"),
+        file_name: Some("bar"),
+        file_stem: Some("bar"),
+        extension: None
+        );
 
         t!("/foo/bar",
-           iter: ["/", "foo", "bar"],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("/foo"),
-           file_name: Some("bar"),
-           file_stem: Some("bar"),
-           extension: None
-           );
+        iter: ["/", "foo", "bar"],
+        has_root: true,
+        is_absolute: true,
+        parent: Some("/foo"),
+        file_name: Some("bar"),
+        file_stem: Some("bar"),
+        extension: None
+        );
 
         t!("///foo///",
-           iter: ["/", "foo"],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("/"),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
+        iter: ["/", "foo"],
+        has_root: true,
+        is_absolute: true,
+        parent: Some("/"),
+        file_name: Some("foo"),
+        file_stem: Some("foo"),
+        extension: None
+        );
 
         t!("///foo///bar",
-           iter: ["/", "foo", "bar"],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("///foo"),
-           file_name: Some("bar"),
-           file_stem: Some("bar"),
-           extension: None
-           );
+        iter: ["/", "foo", "bar"],
+        has_root: true,
+        is_absolute: true,
+        parent: Some("///foo"),
+        file_name: Some("bar"),
+        file_stem: Some("bar"),
+        extension: None
+        );
 
         t!("./.",
-           iter: ["."],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: ["."],
+        has_root: false,
+        is_absolute: false,
+        parent: Some(""),
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("/..",
-           iter: ["/", ".."],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("/"),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: ["/", ".."],
+        has_root: true,
+        is_absolute: true,
+        parent: Some("/"),
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("../",
-           iter: [".."],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: [".."],
+        has_root: false,
+        is_absolute: false,
+        parent: Some(""),
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("foo/.",
-           iter: ["foo"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
+        iter: ["foo"],
+        has_root: false,
+        is_absolute: false,
+        parent: Some(""),
+        file_name: Some("foo"),
+        file_stem: Some("foo"),
+        extension: None
+        );
 
         t!("foo/..",
-           iter: ["foo", ".."],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("foo"),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: ["foo", ".."],
+        has_root: false,
+        is_absolute: false,
+        parent: Some("foo"),
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("foo/./",
-           iter: ["foo"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
+        iter: ["foo"],
+        has_root: false,
+        is_absolute: false,
+        parent: Some(""),
+        file_name: Some("foo"),
+        file_stem: Some("foo"),
+        extension: None
+        );
 
         t!("foo/./bar",
-           iter: ["foo", "bar"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("foo"),
-           file_name: Some("bar"),
-           file_stem: Some("bar"),
-           extension: None
-           );
+        iter: ["foo", "bar"],
+        has_root: false,
+        is_absolute: false,
+        parent: Some("foo"),
+        file_name: Some("bar"),
+        file_stem: Some("bar"),
+        extension: None
+        );
 
         t!("foo/../",
-           iter: ["foo", ".."],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("foo"),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: ["foo", ".."],
+        has_root: false,
+        is_absolute: false,
+        parent: Some("foo"),
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("foo/../bar",
-           iter: ["foo", "..", "bar"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("foo/.."),
-           file_name: Some("bar"),
-           file_stem: Some("bar"),
-           extension: None
-           );
+        iter: ["foo", "..", "bar"],
+        has_root: false,
+        is_absolute: false,
+        parent: Some("foo/.."),
+        file_name: Some("bar"),
+        file_stem: Some("bar"),
+        extension: None
+        );
 
         t!("./a",
-           iter: [".", "a"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("."),
-           file_name: Some("a"),
-           file_stem: Some("a"),
-           extension: None
-           );
+        iter: [".", "a"],
+        has_root: false,
+        is_absolute: false,
+        parent: Some("."),
+        file_name: Some("a"),
+        file_stem: Some("a"),
+        extension: None
+        );
 
         t!(".",
-           iter: ["."],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: ["."],
+        has_root: false,
+        is_absolute: false,
+        parent: Some(""),
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("./",
-           iter: ["."],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: ["."],
+        has_root: false,
+        is_absolute: false,
+        parent: Some(""),
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("a/b",
-           iter: ["a", "b"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("a"),
-           file_name: Some("b"),
-           file_stem: Some("b"),
-           extension: None
-           );
+        iter: ["a", "b"],
+        has_root: false,
+        is_absolute: false,
+        parent: Some("a"),
+        file_name: Some("b"),
+        file_stem: Some("b"),
+        extension: None
+        );
 
         t!("a//b",
-           iter: ["a", "b"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("a"),
-           file_name: Some("b"),
-           file_stem: Some("b"),
-           extension: None
-           );
+        iter: ["a", "b"],
+        has_root: false,
+        is_absolute: false,
+        parent: Some("a"),
+        file_name: Some("b"),
+        file_stem: Some("b"),
+        extension: None
+        );
 
         t!("a/./b",
-           iter: ["a", "b"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("a"),
-           file_name: Some("b"),
-           file_stem: Some("b"),
-           extension: None
-           );
+        iter: ["a", "b"],
+        has_root: false,
+        is_absolute: false,
+        parent: Some("a"),
+        file_name: Some("b"),
+        file_stem: Some("b"),
+        extension: None
+        );
 
         t!("a/b/c",
-           iter: ["a", "b", "c"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("a/b"),
-           file_name: Some("c"),
-           file_stem: Some("c"),
-           extension: None
-           );
+        iter: ["a", "b", "c"],
+        has_root: false,
+        is_absolute: false,
+        parent: Some("a/b"),
+        file_name: Some("c"),
+        file_stem: Some("c"),
+        extension: None
+        );
 
         t!(".foo",
-           iter: [".foo"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: Some(".foo"),
-           file_stem: Some(".foo"),
-           extension: None
-           );
+        iter: [".foo"],
+        has_root: false,
+        is_absolute: false,
+        parent: Some(""),
+        file_name: Some(".foo"),
+        file_stem: Some(".foo"),
+        extension: None
+        );
     }
 
     #[test]
     #[cfg(windows)]
     pub fn test_decompositions_windows() {
         t!("",
-           iter: [],
-           has_root: false,
-           is_absolute: false,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: [],
+        has_root: false,
+        is_absolute: false,
+        parent: None,
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("foo",
-           iter: ["foo"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
+        iter: ["foo"],
+        has_root: false,
+        is_absolute: false,
+        parent: Some(""),
+        file_name: Some("foo"),
+        file_stem: Some("foo"),
+        extension: None
+        );
 
         t!("/",
-           iter: ["\\"],
-           has_root: true,
-           is_absolute: false,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: ["\\"],
+        has_root: true,
+        is_absolute: false,
+        parent: None,
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("\\",
-           iter: ["\\"],
-           has_root: true,
-           is_absolute: false,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: ["\\"],
+        has_root: true,
+        is_absolute: false,
+        parent: None,
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("c:",
-           iter: ["c:"],
-           has_root: false,
-           is_absolute: false,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: ["c:"],
+        has_root: false,
+        is_absolute: false,
+        parent: None,
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("c:\\",
-           iter: ["c:", "\\"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: ["c:", "\\"],
+        has_root: true,
+        is_absolute: true,
+        parent: None,
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("c:/",
-           iter: ["c:", "\\"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: ["c:", "\\"],
+        has_root: true,
+        is_absolute: true,
+        parent: None,
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("/foo",
-           iter: ["\\", "foo"],
-           has_root: true,
-           is_absolute: false,
-           parent: Some("/"),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
+        iter: ["\\", "foo"],
+        has_root: true,
+        is_absolute: false,
+        parent: Some("/"),
+        file_name: Some("foo"),
+        file_stem: Some("foo"),
+        extension: None
+        );
 
         t!("foo/",
-           iter: ["foo"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
+        iter: ["foo"],
+        has_root: false,
+        is_absolute: false,
+        parent: Some(""),
+        file_name: Some("foo"),
+        file_stem: Some("foo"),
+        extension: None
+        );
 
         t!("/foo/",
-           iter: ["\\", "foo"],
-           has_root: true,
-           is_absolute: false,
-           parent: Some("/"),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
+        iter: ["\\", "foo"],
+        has_root: true,
+        is_absolute: false,
+        parent: Some("/"),
+        file_name: Some("foo"),
+        file_stem: Some("foo"),
+        extension: None
+        );
 
         t!("foo/bar",
-           iter: ["foo", "bar"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("foo"),
-           file_name: Some("bar"),
-           file_stem: Some("bar"),
-           extension: None
-           );
+        iter: ["foo", "bar"],
+        has_root: false,
+        is_absolute: false,
+        parent: Some("foo"),
+        file_name: Some("bar"),
+        file_stem: Some("bar"),
+        extension: None
+        );
 
         t!("/foo/bar",
-           iter: ["\\", "foo", "bar"],
-           has_root: true,
-           is_absolute: false,
-           parent: Some("/foo"),
-           file_name: Some("bar"),
-           file_stem: Some("bar"),
-           extension: None
-           );
+        iter: ["\\", "foo", "bar"],
+        has_root: true,
+        is_absolute: false,
+        parent: Some("/foo"),
+        file_name: Some("bar"),
+        file_stem: Some("bar"),
+        extension: None
+        );
 
         t!("///foo///",
-           iter: ["\\", "foo"],
-           has_root: true,
-           is_absolute: false,
-           parent: Some("/"),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
+        iter: ["\\", "foo"],
+        has_root: true,
+        is_absolute: false,
+        parent: Some("/"),
+        file_name: Some("foo"),
+        file_stem: Some("foo"),
+        extension: None
+        );
 
         t!("///foo///bar",
-           iter: ["\\", "foo", "bar"],
-           has_root: true,
-           is_absolute: false,
-           parent: Some("///foo"),
-           file_name: Some("bar"),
-           file_stem: Some("bar"),
-           extension: None
-           );
+        iter: ["\\", "foo", "bar"],
+        has_root: true,
+        is_absolute: false,
+        parent: Some("///foo"),
+        file_name: Some("bar"),
+        file_stem: Some("bar"),
+        extension: None
+        );
 
         t!("./.",
-           iter: ["."],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: ["."],
+        has_root: false,
+        is_absolute: false,
+        parent: Some(""),
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("/..",
-           iter: ["\\", ".."],
-           has_root: true,
-           is_absolute: false,
-           parent: Some("/"),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: ["\\", ".."],
+        has_root: true,
+        is_absolute: false,
+        parent: Some("/"),
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("../",
-           iter: [".."],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: [".."],
+        has_root: false,
+        is_absolute: false,
+        parent: Some(""),
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("foo/.",
-           iter: ["foo"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
+        iter: ["foo"],
+        has_root: false,
+        is_absolute: false,
+        parent: Some(""),
+        file_name: Some("foo"),
+        file_stem: Some("foo"),
+        extension: None
+        );
 
         t!("foo/..",
-           iter: ["foo", ".."],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("foo"),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: ["foo", ".."],
+        has_root: false,
+        is_absolute: false,
+        parent: Some("foo"),
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("foo/./",
-           iter: ["foo"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
+        iter: ["foo"],
+        has_root: false,
+        is_absolute: false,
+        parent: Some(""),
+        file_name: Some("foo"),
+        file_stem: Some("foo"),
+        extension: None
+        );
 
         t!("foo/./bar",
-           iter: ["foo", "bar"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("foo"),
-           file_name: Some("bar"),
-           file_stem: Some("bar"),
-           extension: None
-           );
+        iter: ["foo", "bar"],
+        has_root: false,
+        is_absolute: false,
+        parent: Some("foo"),
+        file_name: Some("bar"),
+        file_stem: Some("bar"),
+        extension: None
+        );
 
         t!("foo/../",
-           iter: ["foo", ".."],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("foo"),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: ["foo", ".."],
+        has_root: false,
+        is_absolute: false,
+        parent: Some("foo"),
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("foo/../bar",
-           iter: ["foo", "..", "bar"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("foo/.."),
-           file_name: Some("bar"),
-           file_stem: Some("bar"),
-           extension: None
-           );
+        iter: ["foo", "..", "bar"],
+        has_root: false,
+        is_absolute: false,
+        parent: Some("foo/.."),
+        file_name: Some("bar"),
+        file_stem: Some("bar"),
+        extension: None
+        );
 
         t!("./a",
-           iter: [".", "a"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("."),
-           file_name: Some("a"),
-           file_stem: Some("a"),
-           extension: None
-           );
+        iter: [".", "a"],
+        has_root: false,
+        is_absolute: false,
+        parent: Some("."),
+        file_name: Some("a"),
+        file_stem: Some("a"),
+        extension: None
+        );
 
         t!(".",
-           iter: ["."],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: ["."],
+        has_root: false,
+        is_absolute: false,
+        parent: Some(""),
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("./",
-           iter: ["."],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: ["."],
+        has_root: false,
+        is_absolute: false,
+        parent: Some(""),
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("a/b",
-           iter: ["a", "b"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("a"),
-           file_name: Some("b"),
-           file_stem: Some("b"),
-           extension: None
-           );
+        iter: ["a", "b"],
+        has_root: false,
+        is_absolute: false,
+        parent: Some("a"),
+        file_name: Some("b"),
+        file_stem: Some("b"),
+        extension: None
+        );
 
         t!("a//b",
-           iter: ["a", "b"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("a"),
-           file_name: Some("b"),
-           file_stem: Some("b"),
-           extension: None
-           );
+        iter: ["a", "b"],
+        has_root: false,
+        is_absolute: false,
+        parent: Some("a"),
+        file_name: Some("b"),
+        file_stem: Some("b"),
+        extension: None
+        );
 
         t!("a/./b",
-           iter: ["a", "b"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("a"),
-           file_name: Some("b"),
-           file_stem: Some("b"),
-           extension: None
-           );
+        iter: ["a", "b"],
+        has_root: false,
+        is_absolute: false,
+        parent: Some("a"),
+        file_name: Some("b"),
+        file_stem: Some("b"),
+        extension: None
+        );
 
         t!("a/b/c",
            iter: ["a", "b", "c"],
@@ -3521,291 +3485,273 @@ mod tests {
            extension: None);
 
         t!("a\\b\\c",
-           iter: ["a", "b", "c"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("a\\b"),
-           file_name: Some("c"),
-           file_stem: Some("c"),
-           extension: None
-           );
+        iter: ["a", "b", "c"],
+        has_root: false,
+        is_absolute: false,
+        parent: Some("a\\b"),
+        file_name: Some("c"),
+        file_stem: Some("c"),
+        extension: None
+        );
 
         t!("\\a",
-           iter: ["\\", "a"],
-           has_root: true,
-           is_absolute: false,
-           parent: Some("\\"),
-           file_name: Some("a"),
-           file_stem: Some("a"),
-           extension: None
-           );
+        iter: ["\\", "a"],
+        has_root: true,
+        is_absolute: false,
+        parent: Some("\\"),
+        file_name: Some("a"),
+        file_stem: Some("a"),
+        extension: None
+        );
 
         t!("c:\\foo.txt",
-           iter: ["c:", "\\", "foo.txt"],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("c:\\"),
-           file_name: Some("foo.txt"),
-           file_stem: Some("foo"),
-           extension: Some("txt")
-           );
+        iter: ["c:", "\\", "foo.txt"],
+        has_root: true,
+        is_absolute: true,
+        parent: Some("c:\\"),
+        file_name: Some("foo.txt"),
+        file_stem: Some("foo"),
+        extension: Some("txt")
+        );
 
         t!("\\\\server\\share\\foo.txt",
-           iter: ["\\\\server\\share", "\\", "foo.txt"],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("\\\\server\\share\\"),
-           file_name: Some("foo.txt"),
-           file_stem: Some("foo"),
-           extension: Some("txt")
-           );
+        iter: ["\\\\server\\share", "\\", "foo.txt"],
+        has_root: true,
+        is_absolute: true,
+        parent: Some("\\\\server\\share\\"),
+        file_name: Some("foo.txt"),
+        file_stem: Some("foo"),
+        extension: Some("txt")
+        );
 
         t!("\\\\server\\share",
-           iter: ["\\\\server\\share", "\\"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: ["\\\\server\\share", "\\"],
+        has_root: true,
+        is_absolute: true,
+        parent: None,
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("\\\\server",
-           iter: ["\\", "server"],
-           has_root: true,
-           is_absolute: false,
-           parent: Some("\\"),
-           file_name: Some("server"),
-           file_stem: Some("server"),
-           extension: None
-           );
+        iter: ["\\", "server"],
+        has_root: true,
+        is_absolute: false,
+        parent: Some("\\"),
+        file_name: Some("server"),
+        file_stem: Some("server"),
+        extension: None
+        );
 
         t!("\\\\?\\bar\\foo.txt",
-           iter: ["\\\\?\\bar", "\\", "foo.txt"],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("\\\\?\\bar\\"),
-           file_name: Some("foo.txt"),
-           file_stem: Some("foo"),
-           extension: Some("txt")
-           );
+        iter: ["\\\\?\\bar", "\\", "foo.txt"],
+        has_root: true,
+        is_absolute: true,
+        parent: Some("\\\\?\\bar\\"),
+        file_name: Some("foo.txt"),
+        file_stem: Some("foo"),
+        extension: Some("txt")
+        );
 
         t!("\\\\?\\bar",
-           iter: ["\\\\?\\bar"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: ["\\\\?\\bar"],
+        has_root: true,
+        is_absolute: true,
+        parent: None,
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("\\\\?\\",
-           iter: ["\\\\?\\"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: ["\\\\?\\"],
+        has_root: true,
+        is_absolute: true,
+        parent: None,
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("\\\\?\\UNC\\server\\share\\foo.txt",
-           iter: ["\\\\?\\UNC\\server\\share", "\\", "foo.txt"],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("\\\\?\\UNC\\server\\share\\"),
-           file_name: Some("foo.txt"),
-           file_stem: Some("foo"),
-           extension: Some("txt")
-           );
+        iter: ["\\\\?\\UNC\\server\\share", "\\", "foo.txt"],
+        has_root: true,
+        is_absolute: true,
+        parent: Some("\\\\?\\UNC\\server\\share\\"),
+        file_name: Some("foo.txt"),
+        file_stem: Some("foo"),
+        extension: Some("txt")
+        );
 
         t!("\\\\?\\UNC\\server",
-           iter: ["\\\\?\\UNC\\server"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: ["\\\\?\\UNC\\server"],
+        has_root: true,
+        is_absolute: true,
+        parent: None,
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("\\\\?\\UNC\\",
-           iter: ["\\\\?\\UNC\\"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: ["\\\\?\\UNC\\"],
+        has_root: true,
+        is_absolute: true,
+        parent: None,
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("\\\\?\\C:\\foo.txt",
-           iter: ["\\\\?\\C:", "\\", "foo.txt"],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("\\\\?\\C:\\"),
-           file_name: Some("foo.txt"),
-           file_stem: Some("foo"),
-           extension: Some("txt")
-           );
-
+        iter: ["\\\\?\\C:", "\\", "foo.txt"],
+        has_root: true,
+        is_absolute: true,
+        parent: Some("\\\\?\\C:\\"),
+        file_name: Some("foo.txt"),
+        file_stem: Some("foo"),
+        extension: Some("txt")
+        );
 
         t!("\\\\?\\C:\\",
-           iter: ["\\\\?\\C:", "\\"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
+        iter: ["\\\\?\\C:", "\\"],
+        has_root: true,
+        is_absolute: true,
+        parent: None,
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("\\\\?\\C:",
-           iter: ["\\\\?\\C:"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
+        iter: ["\\\\?\\C:"],
+        has_root: true,
+        is_absolute: true,
+        parent: None,
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("\\\\?\\foo/bar",
-           iter: ["\\\\?\\foo/bar"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
+        iter: ["\\\\?\\foo/bar"],
+        has_root: true,
+        is_absolute: true,
+        parent: None,
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("\\\\?\\C:/foo",
-           iter: ["\\\\?\\C:/foo"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
+        iter: ["\\\\?\\C:/foo"],
+        has_root: true,
+        is_absolute: true,
+        parent: None,
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("\\\\.\\foo\\bar",
-           iter: ["\\\\.\\foo", "\\", "bar"],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("\\\\.\\foo\\"),
-           file_name: Some("bar"),
-           file_stem: Some("bar"),
-           extension: None
-           );
-
+        iter: ["\\\\.\\foo", "\\", "bar"],
+        has_root: true,
+        is_absolute: true,
+        parent: Some("\\\\.\\foo\\"),
+        file_name: Some("bar"),
+        file_stem: Some("bar"),
+        extension: None
+        );
 
         t!("\\\\.\\foo",
-           iter: ["\\\\.\\foo", "\\"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
+        iter: ["\\\\.\\foo", "\\"],
+        has_root: true,
+        is_absolute: true,
+        parent: None,
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("\\\\.\\foo/bar",
-           iter: ["\\\\.\\foo/bar", "\\"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
+        iter: ["\\\\.\\foo/bar", "\\"],
+        has_root: true,
+        is_absolute: true,
+        parent: None,
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("\\\\.\\foo\\bar/baz",
-           iter: ["\\\\.\\foo", "\\", "bar", "baz"],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("\\\\.\\foo\\bar"),
-           file_name: Some("baz"),
-           file_stem: Some("baz"),
-           extension: None
-           );
-
+        iter: ["\\\\.\\foo", "\\", "bar", "baz"],
+        has_root: true,
+        is_absolute: true,
+        parent: Some("\\\\.\\foo\\bar"),
+        file_name: Some("baz"),
+        file_stem: Some("baz"),
+        extension: None
+        );
 
         t!("\\\\.\\",
-           iter: ["\\\\.\\", "\\"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
+        iter: ["\\\\.\\", "\\"],
+        has_root: true,
+        is_absolute: true,
+        parent: None,
+        file_name: None,
+        file_stem: None,
+        extension: None
+        );
 
         t!("\\\\?\\a\\b\\",
-           iter: ["\\\\?\\a", "\\", "b"],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("\\\\?\\a\\"),
-           file_name: Some("b"),
-           file_stem: Some("b"),
-           extension: None
-           );
+        iter: ["\\\\?\\a", "\\", "b"],
+        has_root: true,
+        is_absolute: true,
+        parent: Some("\\\\?\\a\\"),
+        file_name: Some("b"),
+        file_stem: Some("b"),
+        extension: None
+        );
     }
 
     #[test]
     pub fn test_stem_ext() {
         t!("foo",
-           file_stem: Some("foo"),
-           extension: None
-           );
+        file_stem: Some("foo"),
+        extension: None
+        );
 
         t!("foo.",
-           file_stem: Some("foo"),
-           extension: Some("")
-           );
+        file_stem: Some("foo"),
+        extension: Some("")
+        );
 
         t!(".foo",
-           file_stem: Some(".foo"),
-           extension: None
-           );
+        file_stem: Some(".foo"),
+        extension: None
+        );
 
         t!("foo.txt",
-           file_stem: Some("foo"),
-           extension: Some("txt")
-           );
+        file_stem: Some("foo"),
+        extension: Some("txt")
+        );
 
         t!("foo.bar.txt",
-           file_stem: Some("foo.bar"),
-           extension: Some("txt")
-           );
+        file_stem: Some("foo.bar"),
+        extension: Some("txt")
+        );
 
         t!("foo.bar.",
-           file_stem: Some("foo.bar"),
-           extension: Some("")
-           );
+        file_stem: Some("foo.bar"),
+        extension: Some("")
+        );
 
-        t!(".",
-           file_stem: None,
-           extension: None
-           );
+        t!(".", file_stem: None, extension: None);
 
-        t!("..",
-           file_stem: None,
-           extension: None
-           );
+        t!("..", file_stem: None, extension: None);
 
-        t!("",
-           file_stem: None,
-           extension: None
-           );
+        t!("", file_stem: None, extension: None);
     }
 
     #[test]
@@ -3873,26 +3819,20 @@ mod tests {
             tp!("C:a\\b\\c", "C:d", "C:d");
             tp!("C:", r"a\b\c", r"C:a\b\c");
             tp!("C:", r"..\a", r"C:..\a");
-            tp!("\\\\server\\share\\foo",
-                "bar",
-                "\\\\server\\share\\foo\\bar");
+            tp!("\\\\server\\share\\foo", "bar", "\\\\server\\share\\foo\\bar");
             tp!("\\\\server\\share\\foo", "C:baz", "C:baz");
             tp!("\\\\?\\C:\\a\\b", "C:c\\d", "C:c\\d");
             tp!("\\\\?\\C:a\\b", "C:c\\d", "C:c\\d");
             tp!("\\\\?\\C:\\a\\b", "C:\\c\\d", "C:\\c\\d");
             tp!("\\\\?\\foo\\bar", "baz", "\\\\?\\foo\\bar\\baz");
-            tp!("\\\\?\\UNC\\server\\share\\foo",
-                "bar",
-                "\\\\?\\UNC\\server\\share\\foo\\bar");
+            tp!("\\\\?\\UNC\\server\\share\\foo", "bar", "\\\\?\\UNC\\server\\share\\foo\\bar");
             tp!("\\\\?\\UNC\\server\\share", "C:\\a", "C:\\a");
             tp!("\\\\?\\UNC\\server\\share", "C:a", "C:a");
 
             // Note: modified from old path API
             tp!("\\\\?\\UNC\\server", "foo", "\\\\?\\UNC\\server\\foo");
 
-            tp!("C:\\a",
-                "\\\\?\\UNC\\server\\share",
-                "\\\\?\\UNC\\server\\share");
+            tp!("C:\\a", "\\\\?\\UNC\\server\\share", "\\\\?\\UNC\\server\\share");
             tp!("\\\\.\\foo\\bar", "baz", "\\\\.\\foo\\bar\\baz");
             tp!("\\\\.\\foo\\bar", "C:a", "C:a");
             // again, not sure about the following, but I'm assuming \\.\ should be verbatim
@@ -3945,15 +3885,9 @@ mod tests {
             tp!("\\\\?\\C:\\a\\b", "\\\\?\\C:\\a", true);
             tp!("\\\\?\\C:\\a", "\\\\?\\C:\\", true);
             tp!("\\\\?\\C:\\", "\\\\?\\C:\\", false);
-            tp!("\\\\?\\UNC\\server\\share\\a\\b",
-                "\\\\?\\UNC\\server\\share\\a",
-                true);
-            tp!("\\\\?\\UNC\\server\\share\\a",
-                "\\\\?\\UNC\\server\\share\\",
-                true);
-            tp!("\\\\?\\UNC\\server\\share",
-                "\\\\?\\UNC\\server\\share",
-                false);
+            tp!("\\\\?\\UNC\\server\\share\\a\\b", "\\\\?\\UNC\\server\\share\\a", true);
+            tp!("\\\\?\\UNC\\server\\share\\a", "\\\\?\\UNC\\server\\share\\", true);
+            tp!("\\\\?\\UNC\\server\\share", "\\\\?\\UNC\\server\\share", false);
             tp!("\\\\.\\a\\b\\c", "\\\\.\\a\\b", true);
             tp!("\\\\.\\a\\b", "\\\\.\\a\\", true);
             tp!("\\\\.\\a", "\\\\.\\a", false);
@@ -4051,8 +3985,8 @@ mod tests {
 
     #[test]
     pub fn test_compare() {
-        use crate::hash::{Hash, Hasher};
         use crate::collections::hash_map::DefaultHasher;
+        use crate::hash::{Hash, Hasher};
 
         fn hash<T: Hash>(t: T) -> u64 {
             let mut s = DefaultHasher::new();
@@ -4095,83 +4029,83 @@ mod tests {
         );
 
         tc!("", "",
-            eq: true,
-            starts_with: true,
-            ends_with: true,
-            relative_from: Some("")
-            );
+        eq: true,
+        starts_with: true,
+        ends_with: true,
+        relative_from: Some("")
+        );
 
         tc!("foo", "",
-            eq: false,
-            starts_with: true,
-            ends_with: true,
-            relative_from: Some("foo")
-            );
+        eq: false,
+        starts_with: true,
+        ends_with: true,
+        relative_from: Some("foo")
+        );
 
         tc!("", "foo",
-            eq: false,
-            starts_with: false,
-            ends_with: false,
-            relative_from: None
-            );
+        eq: false,
+        starts_with: false,
+        ends_with: false,
+        relative_from: None
+        );
 
         tc!("foo", "foo",
-            eq: true,
-            starts_with: true,
-            ends_with: true,
-            relative_from: Some("")
-            );
+        eq: true,
+        starts_with: true,
+        ends_with: true,
+        relative_from: Some("")
+        );
 
         tc!("foo/", "foo",
-            eq: true,
-            starts_with: true,
-            ends_with: true,
-            relative_from: Some("")
-            );
+        eq: true,
+        starts_with: true,
+        ends_with: true,
+        relative_from: Some("")
+        );
 
         tc!("foo/bar", "foo",
-            eq: false,
-            starts_with: true,
-            ends_with: false,
-            relative_from: Some("bar")
-            );
+        eq: false,
+        starts_with: true,
+        ends_with: false,
+        relative_from: Some("bar")
+        );
 
         tc!("foo/bar/baz", "foo/bar",
-            eq: false,
-            starts_with: true,
-            ends_with: false,
-            relative_from: Some("baz")
-            );
+        eq: false,
+        starts_with: true,
+        ends_with: false,
+        relative_from: Some("baz")
+        );
 
         tc!("foo/bar", "foo/bar/baz",
-            eq: false,
-            starts_with: false,
-            ends_with: false,
-            relative_from: None
-            );
+        eq: false,
+        starts_with: false,
+        ends_with: false,
+        relative_from: None
+        );
 
         tc!("./foo/bar/", ".",
+        eq: false,
+        starts_with: true,
+        ends_with: false,
+        relative_from: Some("foo/bar")
+        );
+
+        if cfg!(windows) {
+            tc!(r"C:\src\rust\cargo-test\test\Cargo.toml",
+            r"c:\src\rust\cargo-test\test",
             eq: false,
             starts_with: true,
             ends_with: false,
-            relative_from: Some("foo/bar")
+            relative_from: Some("Cargo.toml")
             );
 
-        if cfg!(windows) {
-            tc!(r"C:\src\rust\cargo-test\test\Cargo.toml",
-                r"c:\src\rust\cargo-test\test",
-                eq: false,
-                starts_with: true,
-                ends_with: false,
-                relative_from: Some("Cargo.toml")
-                );
-
             tc!(r"c:\foo", r"C:\foo",
-                eq: true,
-                starts_with: true,
-                ends_with: true,
-                relative_from: Some("")
-                );
+            eq: true,
+            starts_with: true,
+            ends_with: true,
+            relative_from: Some("")
+            );
         }
     }