Vendor dependencies

notes-service/vendor/relative-path/src/path_ext.rs

@@ -0,0 +1,353 @@
+// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Ported from the pathdiff crate, which adapted the original rustc's
+// path_relative_from
+// https://github.com/Manishearth/pathdiff/blob/master/src/lib.rs
+// https://github.com/rust-lang/rust/blob/e1d0de82cc40b666b88d4a6d2c9dcbc81d7ed27f/src/librustc_back/rpath.rs#L116-L158
+
+use std::error;
+use std::fmt;
+use std::path::{Path, PathBuf};
+
+use crate::{Component, RelativePathBuf};
+
+// Prevent downstream implementations, so methods may be added without backwards
+// breaking changes.
+mod sealed {
+    use std::path::{Path, PathBuf};
+
+    pub trait Sealed {}
+
+    impl Sealed for Path {}
+    impl Sealed for PathBuf {}
+}
+
+/// An error raised when attempting to convert a path using
+/// [`PathExt::relative_to`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RelativeToError {
+    kind: RelativeToErrorKind,
+}
+
+/// Error kind for [`RelativeToError`].
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[non_exhaustive]
+enum RelativeToErrorKind {
+    /// Non-utf8 component in path.
+    NonUtf8,
+    /// Mismatching path prefixes.
+    PrefixMismatch,
+    /// A provided path is ambiguous, in that there is no way to determine which
+    /// components should be added from one path to the other to traverse it.
+    ///
+    /// For example, `.` is ambiguous relative to `../..` because we don't know
+    /// the names of the components being traversed.
+    AmbiguousTraversal,
+    /// This is a catch-all error since we don't control the `std::path` API a
+    /// Components iterator might decide (intentionally or not) to produce
+    /// components which violates its own contract.
+    ///
+    /// In particular we rely on only relative components being produced after
+    /// the absolute prefix has been consumed.
+    IllegalComponent,
+}
+
+impl fmt::Display for RelativeToError {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        match self.kind {
+            RelativeToErrorKind::NonUtf8 => "path contains non-utf8 component".fmt(fmt),
+            RelativeToErrorKind::PrefixMismatch => {
+                "paths contain different absolute prefixes".fmt(fmt)
+            }
+            RelativeToErrorKind::AmbiguousTraversal => {
+                "path traversal cannot be determined".fmt(fmt)
+            }
+            RelativeToErrorKind::IllegalComponent => "path contains illegal components".fmt(fmt),
+        }
+    }
+}
+
+impl error::Error for RelativeToError {}
+
+impl From<RelativeToErrorKind> for RelativeToError {
+    #[inline]
+    fn from(kind: RelativeToErrorKind) -> Self {
+        Self { kind }
+    }
+}
+
+/// Extension methods for [`Path`] and [`PathBuf`] to for building and
+/// interacting with [`RelativePath`].
+///
+/// [`RelativePath`]: crate::RelativePath
+pub trait PathExt: sealed::Sealed {
+    /// Build a relative path from the provided directory to `self`.
+    ///
+    /// Producing a relative path like this is a logical operation and does not
+    /// guarantee that the constructed path corresponds to what the filesystem
+    /// would do. On Linux for example symbolic links could mean that the
+    /// logical path doesn't correspond to the filesystem path.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::path::Path;
+    /// use relative_path::{RelativePath, PathExt};
+    ///
+    /// let baz = Path::new("/foo/bar/baz");
+    /// let bar = Path::new("/foo/bar");
+    /// let qux = Path::new("/foo/bar/qux");
+    ///
+    /// assert_eq!(bar.relative_to(baz)?, RelativePath::new("../"));
+    /// assert_eq!(baz.relative_to(bar)?, RelativePath::new("baz"));
+    /// assert_eq!(qux.relative_to(baz)?, RelativePath::new("../qux"));
+    /// assert_eq!(baz.relative_to(qux)?, RelativePath::new("../baz"));
+    /// assert_eq!(bar.relative_to(qux)?, RelativePath::new("../"));
+    /// # Ok::<_, relative_path::RelativeToError>(())
+    /// ```
+    ///
+    /// # Errors
+    ///
+    /// Errors in case the provided path contains components which cannot be
+    /// converted into a relative path as needed, such as non-utf8 data.
+    fn relative_to<P>(&self, root: P) -> Result<RelativePathBuf, RelativeToError>
+    where
+        P: AsRef<Path>;
+}
+
+impl PathExt for Path {
+    fn relative_to<P>(&self, root: P) -> Result<RelativePathBuf, RelativeToError>
+    where
+        P: AsRef<Path>,
+    {
+        use std::path::Component::{CurDir, Normal, ParentDir, Prefix, RootDir};
+
+        // Helper function to convert from a std::path::Component to a
+        // relative_path::Component.
+        fn std_to_c(c: std::path::Component<'_>) -> Result<Component<'_>, RelativeToError> {
+            Ok(match c {
+                CurDir => Component::CurDir,
+                ParentDir => Component::ParentDir,
+                Normal(n) => Component::Normal(n.to_str().ok_or(RelativeToErrorKind::NonUtf8)?),
+                _ => return Err(RelativeToErrorKind::IllegalComponent.into()),
+            })
+        }
+
+        let root = root.as_ref();
+        let mut a_it = self.components();
+        let mut b_it = root.components();
+
+        // Ensure that the two paths are both either relative, or have the same
+        // prefix. Strips any common prefix the two paths do have. Prefixes are
+        // platform dependent, but different prefixes would for example indicate
+        // paths for different drives on Windows.
+        let (a_head, b_head) = loop {
+            match (a_it.next(), b_it.next()) {
+                (Some(RootDir), Some(RootDir)) => (),
+                (Some(Prefix(a)), Some(Prefix(b))) if a == b => (),
+                (Some(Prefix(_) | RootDir), _) | (_, Some(Prefix(_) | RootDir)) => {
+                    return Err(RelativeToErrorKind::PrefixMismatch.into());
+                }
+                (None, None) => break (None, None),
+                (a, b) if a != b => break (a, b),
+                _ => (),
+            }
+        };
+
+        let mut a_it = a_head.into_iter().chain(a_it);
+        let mut b_it = b_head.into_iter().chain(b_it);
+        let mut buf = RelativePathBuf::new();
+
+        loop {
+            let a = if let Some(a) = a_it.next() {
+                a
+            } else {
+                for _ in b_it {
+                    buf.push(Component::ParentDir);
+                }
+
+                break;
+            };
+
+            match b_it.next() {
+                Some(CurDir) => buf.push(std_to_c(a)?),
+                Some(ParentDir) => {
+                    return Err(RelativeToErrorKind::AmbiguousTraversal.into());
+                }
+                root => {
+                    if root.is_some() {
+                        buf.push(Component::ParentDir);
+                    }
+
+                    for comp in b_it {
+                        match comp {
+                            ParentDir => {
+                                if !buf.pop() {
+                                    return Err(RelativeToErrorKind::AmbiguousTraversal.into());
+                                }
+                            }
+                            CurDir => (),
+                            _ => buf.push(Component::ParentDir),
+                        }
+                    }
+
+                    buf.push(std_to_c(a)?);
+
+                    for c in a_it {
+                        buf.push(std_to_c(c)?);
+                    }
+
+                    break;
+                }
+            }
+        }
+
+        Ok(buf)
+    }
+}
+
+impl PathExt for PathBuf {
+    #[inline]
+    fn relative_to<P>(&self, root: P) -> Result<RelativePathBuf, RelativeToError>
+    where
+        P: AsRef<Path>,
+    {
+        self.as_path().relative_to(root)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::path::Path;
+
+    use super::{PathExt, RelativeToErrorKind};
+    use crate::{RelativePathBuf, RelativeToError};
+
+    macro_rules! assert_relative_to {
+        ($path:expr, $base:expr, Ok($expected:expr) $(,)?) => {
+            assert_eq!(
+                Path::new($path).relative_to($base),
+                Ok(RelativePathBuf::from($expected))
+            );
+        };
+
+        ($path:expr, $base:expr, Err($expected:ident) $(,)?) => {
+            assert_eq!(
+                Path::new($path).relative_to($base),
+                Err(RelativeToError::from(RelativeToErrorKind::$expected))
+            );
+        };
+    }
+
+    #[cfg(windows)]
+    macro_rules! abs {
+        ($path:expr) => {
+            Path::new(concat!("C:\\", $path))
+        };
+    }
+
+    #[cfg(not(windows))]
+    macro_rules! abs {
+        ($path:expr) => {
+            Path::new(concat!("/", $path))
+        };
+    }
+
+    #[test]
+    #[cfg(windows)]
+    fn test_different_prefixes() {
+        assert_relative_to!("C:\\repo", "D:\\repo", Err(PrefixMismatch),);
+        assert_relative_to!("C:\\repo", "C:\\repo", Ok(""));
+        assert_relative_to!(
+            "\\\\server\\share\\repo",
+            "\\\\server2\\share\\repo",
+            Err(PrefixMismatch),
+        );
+    }
+
+    #[test]
+    fn test_absolute() {
+        assert_relative_to!(abs!("foo"), abs!("bar"), Ok("../foo"));
+        assert_relative_to!("foo", "bar", Ok("../foo"));
+        assert_relative_to!(abs!("foo"), "bar", Err(PrefixMismatch));
+        assert_relative_to!("foo", abs!("bar"), Err(PrefixMismatch));
+    }
+
+    #[test]
+    fn test_identity() {
+        assert_relative_to!(".", ".", Ok(""));
+        assert_relative_to!("../foo", "../foo", Ok(""));
+        assert_relative_to!("./foo", "./foo", Ok(""));
+        assert_relative_to!("/foo", "/foo", Ok(""));
+        assert_relative_to!("foo", "foo", Ok(""));
+
+        assert_relative_to!("../foo/bar/baz", "../foo/bar/baz", Ok(""));
+        assert_relative_to!("foo/bar/baz", "foo/bar/baz", Ok(""));
+    }
+
+    #[test]
+    fn test_subset() {
+        assert_relative_to!("foo", "fo", Ok("../foo"));
+        assert_relative_to!("fo", "foo", Ok("../fo"));
+    }
+
+    #[test]
+    fn test_empty() {
+        assert_relative_to!("", "", Ok(""));
+        assert_relative_to!("foo", "", Ok("foo"));
+        assert_relative_to!("", "foo", Ok(".."));
+    }
+
+    #[test]
+    fn test_relative() {
+        assert_relative_to!("../foo", "../bar", Ok("../foo"));
+        assert_relative_to!("../foo", "../foo/bar/baz", Ok("../.."));
+        assert_relative_to!("../foo/bar/baz", "../foo", Ok("bar/baz"));
+
+        assert_relative_to!("foo/bar/baz", "foo", Ok("bar/baz"));
+        assert_relative_to!("foo/bar/baz", "foo/bar", Ok("baz"));
+        assert_relative_to!("foo/bar/baz", "foo/bar/baz", Ok(""));
+        assert_relative_to!("foo/bar/baz", "foo/bar/baz/", Ok(""));
+
+        assert_relative_to!("foo/bar/baz/", "foo", Ok("bar/baz"));
+        assert_relative_to!("foo/bar/baz/", "foo/bar", Ok("baz"));
+        assert_relative_to!("foo/bar/baz/", "foo/bar/baz", Ok(""));
+        assert_relative_to!("foo/bar/baz/", "foo/bar/baz/", Ok(""));
+
+        assert_relative_to!("foo/bar/baz", "foo/", Ok("bar/baz"));
+        assert_relative_to!("foo/bar/baz", "foo/bar/", Ok("baz"));
+        assert_relative_to!("foo/bar/baz", "foo/bar/baz", Ok(""));
+    }
+
+    #[test]
+    fn test_current_directory() {
+        assert_relative_to!(".", "foo", Ok("../."));
+        assert_relative_to!("foo", ".", Ok("foo"));
+        assert_relative_to!("/foo", "/.", Ok("foo"));
+    }
+
+    #[test]
+    fn assert_does_not_skip_parents() {
+        assert_relative_to!("some/path", "some/foo/baz/path", Ok("../../../path"));
+        assert_relative_to!("some/path", "some/foo/bar/../baz/path", Ok("../../../path"));
+    }
+
+    #[test]
+    fn test_ambiguous_paths() {
+        // Parent directory name is unknown, so trying to make current directory
+        // relative to it is impossible.
+        assert_relative_to!(".", "../..", Err(AmbiguousTraversal));
+        assert_relative_to!(".", "a/../..", Err(AmbiguousTraversal));
+        // Common prefixes are ok.
+        assert_relative_to!("../a/..", "../a/../b", Ok(".."));
+        assert_relative_to!("../a/../b", "../a/..", Ok("b"));
+    }
+}

notes-service/vendor/relative-path/src/tests.rs

@@ -0,0 +1,790 @@
+#![allow(clippy::too_many_lines)]
+
+use super::*;
+
+use std::path::Path;
+use std::rc::Rc;
+use std::sync::Arc;
+
+macro_rules! t(
+    ($path:expr, iter: $iter:expr) => (
+        {
+            let path = RelativePath::new($path);
+
+            // Forward iteration
+            let comps = path.iter().map(str::to_string).collect::<Vec<String>>();
+            let exp: &[&str] = &$iter;
+            let exps = exp.iter().map(|s| s.to_string()).collect::<Vec<String>>();
+            assert!(comps == exps, "iter: Expected {:?}, found {:?}",
+                    exps, comps);
+
+            // Reverse iteration
+            let comps = RelativePath::new($path).iter().rev().map(str::to_string)
+                .collect::<Vec<String>>();
+            let exps = exps.into_iter().rev().collect::<Vec<String>>();
+            assert!(comps == exps, "iter().rev(): Expected {:?}, found {:?}",
+                    exps, comps);
+        }
+    );
+
+    ($path:expr, parent: $parent:expr, file_name: $file:expr) => (
+        {
+            let path = RelativePath::new($path);
+
+            let parent = path.parent().map(|p| p.as_str());
+            let exp_parent: Option<&str> = $parent;
+            assert!(parent == exp_parent, "parent: Expected {:?}, found {:?}",
+                    exp_parent, parent);
+
+            let file = path.file_name();
+            let exp_file: Option<&str> = $file;
+            assert!(file == exp_file, "file_name: Expected {:?}, found {:?}",
+                    exp_file, file);
+        }
+    );
+
+    ($path:expr, file_stem: $file_stem:expr, extension: $extension:expr) => (
+        {
+            let path = RelativePath::new($path);
+
+            let stem = path.file_stem();
+            let exp_stem: Option<&str> = $file_stem;
+            assert!(stem == exp_stem, "file_stem: Expected {:?}, found {:?}",
+                    exp_stem, stem);
+
+            let ext = path.extension();
+            let exp_ext: Option<&str> = $extension;
+            assert!(ext == exp_ext, "extension: Expected {:?}, found {:?}",
+                    exp_ext, ext);
+        }
+    );
+
+    ($path:expr, iter: $iter:expr,
+                    parent: $parent:expr, file_name: $file:expr,
+                    file_stem: $file_stem:expr, extension: $extension:expr) => (
+        {
+            t!($path, iter: $iter);
+            t!($path, parent: $parent, file_name: $file);
+            t!($path, file_stem: $file_stem, extension: $extension);
+        }
+    );
+);
+
+fn assert_components(components: &[&str], path: &RelativePath) {
+    let components = components
+        .iter()
+        .copied()
+        .map(Component::Normal)
+        .collect::<Vec<_>>();
+    let result: Vec<_> = path.components().collect();
+    assert_eq!(&components[..], &result[..]);
+}
+
+fn rp(input: &str) -> &RelativePath {
+    RelativePath::new(input)
+}
+
+#[test]
+#[allow(clippy::cognitive_complexity)]
+pub fn test_decompositions() {
+    t!("",
+    iter: [],
+    parent: None,
+    file_name: None,
+    file_stem: None,
+    extension: None
+    );
+
+    t!("foo",
+    iter: ["foo"],
+    parent: Some(""),
+    file_name: Some("foo"),
+    file_stem: Some("foo"),
+    extension: None
+    );
+
+    t!("/",
+    iter: [],
+    parent: Some(""),
+    file_name: None,
+    file_stem: None,
+    extension: None
+    );
+
+    t!("/foo",
+    iter: ["foo"],
+    parent: Some(""),
+    file_name: Some("foo"),
+    file_stem: Some("foo"),
+    extension: None
+    );
+
+    t!("foo/",
+    iter: ["foo"],
+    parent: Some(""),
+    file_name: Some("foo"),
+    file_stem: Some("foo"),
+    extension: None
+    );
+
+    t!("/foo/",
+    iter: ["foo"],
+    parent: Some(""),
+    file_name: Some("foo"),
+    file_stem: Some("foo"),
+    extension: None
+    );
+
+    t!("foo/bar",
+    iter: ["foo", "bar"],
+    parent: Some("foo"),
+    file_name: Some("bar"),
+    file_stem: Some("bar"),
+    extension: None
+    );
+
+    t!("/foo/bar",
+    iter: ["foo", "bar"],
+    parent: Some("/foo"),
+    file_name: Some("bar"),
+    file_stem: Some("bar"),
+    extension: None
+    );
+
+    t!("///foo///",
+    iter: ["foo"],
+    parent: Some(""),
+    file_name: Some("foo"),
+    file_stem: Some("foo"),
+    extension: None
+    );
+
+    t!("///foo///bar",
+    iter: ["foo", "bar"],
+    parent: Some("///foo"),
+    file_name: Some("bar"),
+    file_stem: Some("bar"),
+    extension: None
+    );
+
+    t!("./.",
+    iter: [".", "."],
+    parent: Some(""),
+    file_name: None,
+    file_stem: None,
+    extension: None
+    );
+
+    t!("/..",
+    iter: [".."],
+    parent: Some(""),
+    file_name: None,
+    file_stem: None,
+    extension: None
+    );
+
+    t!("../",
+    iter: [".."],
+    parent: Some(""),
+    file_name: None,
+    file_stem: None,
+    extension: None
+    );
+
+    t!("foo/.",
+    iter: ["foo", "."],
+    parent: Some(""),
+    file_name: Some("foo"),
+    file_stem: Some("foo"),
+    extension: None
+    );
+
+    t!("foo/..",
+    iter: ["foo", ".."],
+    parent: Some("foo"),
+    file_name: None,
+    file_stem: None,
+    extension: None
+    );
+
+    t!("foo/./",
+    iter: ["foo", "."],
+    parent: Some(""),
+    file_name: Some("foo"),
+    file_stem: Some("foo"),
+    extension: None
+    );
+
+    t!("foo/./bar",
+    iter: ["foo", ".", "bar"],
+    parent: Some("foo/."),
+    file_name: Some("bar"),
+    file_stem: Some("bar"),
+    extension: None
+    );
+
+    t!("foo/../",
+    iter: ["foo", ".."],
+    parent: Some("foo"),
+    file_name: None,
+    file_stem: None,
+    extension: None
+    );
+
+    t!("foo/../bar",
+    iter: ["foo", "..", "bar"],
+    parent: Some("foo/.."),
+    file_name: Some("bar"),
+    file_stem: Some("bar"),
+    extension: None
+    );
+
+    t!("./a",
+    iter: [".", "a"],
+    parent: Some("."),
+    file_name: Some("a"),
+    file_stem: Some("a"),
+    extension: None
+    );
+
+    t!(".",
+    iter: ["."],
+    parent: Some(""),
+    file_name: None,
+    file_stem: None,
+    extension: None
+    );
+
+    t!("./",
+    iter: ["."],
+    parent: Some(""),
+    file_name: None,
+    file_stem: None,
+    extension: None
+    );
+
+    t!("a/b",
+    iter: ["a", "b"],
+    parent: Some("a"),
+    file_name: Some("b"),
+    file_stem: Some("b"),
+    extension: None
+    );
+
+    t!("a//b",
+    iter: ["a", "b"],
+    parent: Some("a"),
+    file_name: Some("b"),
+    file_stem: Some("b"),
+    extension: None
+    );
+
+    t!("a/./b",
+    iter: ["a", ".", "b"],
+    parent: Some("a/."),
+    file_name: Some("b"),
+    file_stem: Some("b"),
+    extension: None
+    );
+
+    t!("a/b/c",
+    iter: ["a", "b", "c"],
+    parent: Some("a/b"),
+    file_name: Some("c"),
+    file_stem: Some("c"),
+    extension: None
+    );
+
+    t!(".foo",
+    iter: [".foo"],
+    parent: Some(""),
+    file_name: Some(".foo"),
+    file_stem: Some(".foo"),
+    extension: None
+    );
+}
+
+#[test]
+pub fn test_stem_ext() {
+    t!("foo",
+    file_stem: Some("foo"),
+    extension: None
+    );
+
+    t!("foo.",
+    file_stem: Some("foo"),
+    extension: Some("")
+    );
+
+    t!(".foo",
+    file_stem: Some(".foo"),
+    extension: None
+    );
+
+    t!("foo.txt",
+    file_stem: Some("foo"),
+    extension: Some("txt")
+    );
+
+    t!("foo.bar.txt",
+    file_stem: Some("foo.bar"),
+    extension: Some("txt")
+    );
+
+    t!("foo.bar.",
+    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);
+}
+
+#[test]
+pub fn test_set_file_name() {
+    macro_rules! tfn(
+            ($path:expr, $file:expr, $expected:expr) => ( {
+            let mut p = RelativePathBuf::from($path);
+            p.set_file_name($file);
+            assert!(p.as_str() == $expected,
+                    "setting file name of {:?} to {:?}: Expected {:?}, got {:?}",
+                    $path, $file, $expected,
+                    p.as_str());
+        });
+    );
+
+    tfn!("foo", "foo", "foo");
+    tfn!("foo", "bar", "bar");
+    tfn!("foo", "", "");
+    tfn!("", "foo", "foo");
+
+    tfn!(".", "foo", "./foo");
+    tfn!("foo/", "bar", "bar");
+    tfn!("foo/.", "bar", "bar");
+    tfn!("..", "foo", "../foo");
+    tfn!("foo/..", "bar", "foo/../bar");
+    tfn!("/", "foo", "/foo");
+}
+
+#[test]
+pub fn test_set_extension() {
+    macro_rules! tse(
+            ($path:expr, $ext:expr, $expected:expr, $output:expr) => ( {
+            let mut p = RelativePathBuf::from($path);
+            let output = p.set_extension($ext);
+            assert!(p.as_str() == $expected && output == $output,
+                    "setting extension of {:?} to {:?}: Expected {:?}/{:?}, got {:?}/{:?}",
+                    $path, $ext, $expected, $output,
+                    p.as_str(), output);
+        });
+    );
+
+    tse!("foo", "txt", "foo.txt", true);
+    tse!("foo.bar", "txt", "foo.txt", true);
+    tse!("foo.bar.baz", "txt", "foo.bar.txt", true);
+    tse!(".test", "txt", ".test.txt", true);
+    tse!("foo.txt", "", "foo", true);
+    tse!("foo", "", "foo", true);
+    tse!("", "foo", "", false);
+    tse!(".", "foo", ".", false);
+    tse!("foo/", "bar", "foo.bar", true);
+    tse!("foo/.", "bar", "foo.bar", true);
+    tse!("..", "foo", "..", false);
+    tse!("foo/..", "bar", "foo/..", false);
+    tse!("/", "foo", "/", false);
+}
+
+#[test]
+fn test_eq_recievers() {
+    use std::borrow::Cow;
+
+    let borrowed: &RelativePath = RelativePath::new("foo/bar");
+    let mut owned: RelativePathBuf = RelativePathBuf::new();
+    owned.push("foo");
+    owned.push("bar");
+    let borrowed_cow: Cow<RelativePath> = borrowed.into();
+    let owned_cow: Cow<RelativePath> = owned.clone().into();
+
+    macro_rules! t {
+        ($($current:expr),+) => {
+            $(
+                assert_eq!($current, borrowed);
+                assert_eq!($current, owned);
+                assert_eq!($current, borrowed_cow);
+                assert_eq!($current, owned_cow);
+            )+
+        }
+    }
+
+    t!(borrowed, owned, borrowed_cow, owned_cow);
+}
+
+#[test]
+#[allow(clippy::cognitive_complexity)]
+pub fn test_compare() {
+    use std::collections::hash_map::DefaultHasher;
+    use std::hash::{Hash, Hasher};
+
+    fn hash<T: Hash>(t: T) -> u64 {
+        let mut s = DefaultHasher::new();
+        t.hash(&mut s);
+        s.finish()
+    }
+
+    macro_rules! tc(
+        ($path1:expr, $path2:expr, eq: $eq:expr,
+            starts_with: $starts_with:expr, ends_with: $ends_with:expr,
+            relative_from: $relative_from:expr) => ({
+                let path1 = RelativePath::new($path1);
+                let path2 = RelativePath::new($path2);
+
+                let eq = path1 == path2;
+                assert!(eq == $eq, "{:?} == {:?}, expected {:?}, got {:?}",
+                        $path1, $path2, $eq, eq);
+                assert!($eq == (hash(path1) == hash(path2)),
+                        "{:?} == {:?}, expected {:?}, got {} and {}",
+                        $path1, $path2, $eq, hash(path1), hash(path2));
+
+                let starts_with = path1.starts_with(path2);
+                assert!(starts_with == $starts_with,
+                        "{:?}.starts_with({:?}), expected {:?}, got {:?}", $path1, $path2,
+                        $starts_with, starts_with);
+
+                let ends_with = path1.ends_with(path2);
+                assert!(ends_with == $ends_with,
+                        "{:?}.ends_with({:?}), expected {:?}, got {:?}", $path1, $path2,
+                        $ends_with, ends_with);
+
+                let relative_from = path1.strip_prefix(path2)
+                                        .map(|p| p.as_str())
+                                        .ok();
+                let exp: Option<&str> = $relative_from;
+                assert!(relative_from == exp,
+                        "{:?}.strip_prefix({:?}), expected {:?}, got {:?}",
+                        $path1, $path2, exp, relative_from);
+        });
+    );
+
+    tc!("", "",
+    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")
+    );
+
+    tc!("", "foo",
+    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("")
+    );
+
+    tc!("foo/", "foo",
+    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")
+    );
+
+    tc!("foo/bar/baz", "foo/bar",
+    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
+    );
+}
+
+#[test]
+fn test_join() {
+    assert_components(&["foo", "bar", "baz"], &rp("foo/bar").join("baz///"));
+    assert_components(
+        &["hello", "world", "foo", "bar", "baz"],
+        &rp("hello/world").join("///foo/bar/baz"),
+    );
+    assert_components(&["foo", "bar", "baz"], &rp("").join("foo/bar/baz"));
+}
+
+#[test]
+fn test_components_iterator() {
+    use self::Component::*;
+
+    assert_eq!(
+        vec![Normal("hello"), Normal("world")],
+        rp("/hello///world//").components().collect::<Vec<_>>()
+    );
+}
+
+#[test]
+fn test_to_path_buf() {
+    let path = rp("/hello///world//");
+    let path_buf = path.to_path(".");
+    let expected = Path::new(".").join("hello").join("world");
+    assert_eq!(expected, path_buf);
+}
+
+#[test]
+fn test_eq() {
+    assert_eq!(rp("//foo///bar"), rp("/foo/bar"));
+    assert_eq!(rp("foo///bar"), rp("foo/bar"));
+    assert_eq!(rp("foo"), rp("foo"));
+    assert_eq!(rp("foo"), rp("foo").to_relative_path_buf());
+}
+
+#[test]
+fn test_next_back() {
+    use self::Component::*;
+
+    let mut it = rp("baz/bar///foo").components();
+    assert_eq!(Some(Normal("foo")), it.next_back());
+    assert_eq!(Some(Normal("bar")), it.next_back());
+    assert_eq!(Some(Normal("baz")), it.next_back());
+    assert_eq!(None, it.next_back());
+}
+
+#[test]
+fn test_parent() {
+    let path = rp("baz/./bar/foo//./.");
+
+    assert_eq!(Some(rp("baz/./bar")), path.parent());
+    assert_eq!(
+        Some(rp("baz/.")),
+        path.parent().and_then(RelativePath::parent)
+    );
+    assert_eq!(
+        Some(rp("")),
+        path.parent()
+            .and_then(RelativePath::parent)
+            .and_then(RelativePath::parent)
+    );
+    assert_eq!(
+        None,
+        path.parent()
+            .and_then(RelativePath::parent)
+            .and_then(RelativePath::parent)
+            .and_then(RelativePath::parent)
+    );
+}
+
+#[test]
+fn test_relative_path_buf() {
+    assert_eq!(
+        rp("hello/world/."),
+        rp("/hello///world//").to_owned().join(".")
+    );
+}
+
+#[test]
+fn test_normalize() {
+    assert_eq!(rp("c/d"), rp("a/.././b/../c/d").normalize());
+}
+
+#[test]
+fn test_relative_to() {
+    assert_eq!(
+        rp("foo/foo/bar"),
+        rp("foo/bar").join_normalized("../foo/bar")
+    );
+
+    assert_eq!(
+        rp("../c/e"),
+        rp("x/y").join_normalized("../../a/b/../../../c/d/../e")
+    );
+}
+
+#[test]
+fn test_from() {
+    assert_eq!(
+        rp("foo/bar").to_owned(),
+        RelativePathBuf::from(String::from("foo/bar")),
+    );
+
+    assert_eq!(
+        RelativePathBuf::from(rp("foo/bar")),
+        RelativePathBuf::from("foo/bar"),
+    );
+
+    assert_eq!(rp("foo/bar").to_owned(), RelativePathBuf::from("foo/bar"),);
+
+    assert_eq!(&*Box::<RelativePath>::from(rp("foo/bar")), rp("foo/bar"));
+    assert_eq!(
+        &*Box::<RelativePath>::from(RelativePathBuf::from("foo/bar")),
+        rp("foo/bar")
+    );
+
+    assert_eq!(&*Arc::<RelativePath>::from(rp("foo/bar")), rp("foo/bar"));
+    assert_eq!(
+        &*Arc::<RelativePath>::from(RelativePathBuf::from("foo/bar")),
+        rp("foo/bar")
+    );
+
+    assert_eq!(&*Rc::<RelativePath>::from(rp("foo/bar")), rp("foo/bar"));
+    assert_eq!(
+        &*Rc::<RelativePath>::from(RelativePathBuf::from("foo/bar")),
+        rp("foo/bar")
+    );
+}
+
+#[test]
+fn test_relative_path_asref_str() {
+    assert_eq!(
+        <RelativePath as AsRef<str>>::as_ref(rp("foo/bar")),
+        "foo/bar"
+    );
+}
+
+#[test]
+fn test_default() {
+    assert_eq!(RelativePathBuf::new(), RelativePathBuf::default(),);
+}
+
+#[test]
+pub fn test_push() {
+    macro_rules! tp(
+        ($path:expr, $push:expr, $expected:expr) => ( {
+            let mut actual = RelativePathBuf::from($path);
+            actual.push($push);
+            assert!(actual.as_str() == $expected,
+                    "pushing {:?} onto {:?}: Expected {:?}, got {:?}",
+                    $push, $path, $expected, actual.as_str());
+        });
+    );
+
+    tp!("", "foo", "foo");
+    tp!("foo", "bar", "foo/bar");
+    tp!("foo/", "bar", "foo/bar");
+    tp!("foo//", "bar", "foo//bar");
+    tp!("foo/.", "bar", "foo/./bar");
+    tp!("foo./.", "bar", "foo././bar");
+    tp!("foo", "", "foo/");
+    tp!("foo", ".", "foo/.");
+    tp!("foo", "..", "foo/..");
+}
+
+#[test]
+pub fn test_pop() {
+    macro_rules! tp(
+        ($path:expr, $expected:expr, $output:expr) => ( {
+            let mut actual = RelativePathBuf::from($path);
+            let output = actual.pop();
+            assert!(actual.as_str() == $expected && output == $output,
+                    "popping from {:?}: Expected {:?}/{:?}, got {:?}/{:?}",
+                    $path, $expected, $output,
+                    actual.as_str(), output);
+        });
+    );
+
+    tp!("", "", false);
+    tp!("/", "", true);
+    tp!("foo", "", true);
+    tp!(".", "", true);
+    tp!("/foo", "", true);
+    tp!("/foo/bar", "/foo", true);
+    tp!("/foo/bar/.", "/foo", true);
+    tp!("foo/bar", "foo", true);
+    tp!("foo/.", "", true);
+    tp!("foo//bar", "foo", true);
+}
+
+#[test]
+pub fn test_display() {
+    // NB: display delegated to the underlying string.
+    assert_eq!(RelativePathBuf::from("foo/bar").to_string(), "foo/bar");
+    assert_eq!(RelativePath::new("foo/bar").to_string(), "foo/bar");
+
+    assert_eq!(format!("{}", RelativePathBuf::from("foo/bar")), "foo/bar");
+    assert_eq!(format!("{}", RelativePath::new("foo/bar")), "foo/bar");
+}
+
+#[cfg(unix)]
+#[test]
+pub fn test_unix_from_path() {
+    use std::ffi::OsStr;
+    use std::os::unix::ffi::OsStrExt;
+
+    assert_eq!(
+        Err(FromPathErrorKind::NonRelative.into()),
+        RelativePath::from_path("/foo/bar")
+    );
+
+    // Continuation byte without continuation.
+    let non_utf8 = OsStr::from_bytes(&[0x80u8]);
+
+    assert_eq!(
+        Err(FromPathErrorKind::NonUtf8.into()),
+        RelativePath::from_path(non_utf8)
+    );
+}
+
+#[cfg(windows)]
+#[test]
+pub fn test_windows_from_path() {
+    assert_eq!(
+        Err(FromPathErrorKind::NonRelative.into()),
+        RelativePath::from_path("c:\\foo\\bar")
+    );
+
+    assert_eq!(
+        Err(FromPathErrorKind::BadSeparator.into()),
+        RelativePath::from_path("foo\\bar")
+    );
+}
+
+#[cfg(unix)]
+#[test]
+pub fn test_unix_owned_from_path() {
+    use std::ffi::OsStr;
+    use std::os::unix::ffi::OsStrExt;
+
+    assert_eq!(
+        Err(FromPathErrorKind::NonRelative.into()),
+        RelativePathBuf::from_path(Path::new("/foo/bar"))
+    );
+
+    // Continuation byte without continuation.
+    let non_utf8 = OsStr::from_bytes(&[0x80u8]);
+
+    assert_eq!(
+        Err(FromPathErrorKind::NonUtf8.into()),
+        RelativePathBuf::from_path(Path::new(non_utf8))
+    );
+}
+
+#[cfg(windows)]
+#[test]
+pub fn test_windows_owned_from_path() {
+    assert_eq!(
+        Err(FromPathErrorKind::NonRelative.into()),
+        RelativePathBuf::from_path(Path::new("c:\\foo\\bar"))
+    );
+}