chore: add more tests for comparisons

polazarus · Jan 7, 2025 · 6abc025 · 6abc025
1 parent 7b11ce6
commit 6abc025
Show file tree

Hide file tree

Showing 3 changed files with 202 additions and 33 deletions.
diff --git a/src/os_string/cmp.rs b/src/os_string/cmp.rs
@@ -121,11 +121,10 @@ symmetric_ord! {
 mod tests {
     use alloc::borrow::Cow;
     use alloc::boxed::Box;
-    use core::cmp::Ordering;
     use std::ffi::OsStr;
     use std::path::Path;
 
-    use crate::HipOsStr;
+    use crate::{HipOsStr, HipPath};
 
     #[test]
     fn test_eq() {
@@ -176,26 +175,70 @@ mod tests {
 
     #[test]
     fn test_ord() {
-        let h1 = HipOsStr::borrowed("abc");
-        let h2 = HipOsStr::from("abd");
-
-        assert_eq!(h1.partial_cmp(&h1), Some(Ordering::Equal));
-        assert_eq!(h1.cmp(&h1), Ordering::Equal);
-
-        assert!(h1 < h2);
-        assert_eq!(h1.cmp(&h2), Ordering::Less);
-        assert_eq!(h1.partial_cmp(&h2), Some(Ordering::Less));
-        assert_eq!(h2.cmp(&h1), Ordering::Greater);
-        assert_eq!(h2.partial_cmp(&h1), Some(Ordering::Greater));
-
-        assert_eq!(
-            OsStr::partial_cmp(h1.as_os_str(), &h2),
-            Some(Ordering::Less)
-        );
-        assert_eq!(
-            OsStr::partial_cmp(h2.as_os_str(), &h1),
-            Some(Ordering::Greater)
-        );
-        assert!(h1 < h2.as_os_str());
+        for (a, b) in [("abc", "abd"), ("abc", "abc"), ("ab", "abc")] {
+            let a_os_str = OsStr::new(a);
+            let a_cow_os_str = Cow::Borrowed(a_os_str);
+            let a_box_os_str: Box<OsStr> = Box::from(a_os_str);
+            let a_os_string = a_os_str.to_os_string();
+
+            let b_os_str = OsStr::new(b);
+            let b_cow_os_str = Cow::Borrowed(b_os_str);
+            let b_box_os_str: Box<OsStr> = Box::from(b_os_str);
+            let b_os_string = b_os_str.to_os_string();
+
+            let a_hip_os_str = HipOsStr::from(a_os_str);
+            let a_hip_os_str_borrow = HipOsStr::borrowed(a_os_str);
+            let b_hip_os_str = HipOsStr::from(b_os_str);
+            let a_hip_path = HipPath::from(a_os_str);
+            let b_hip_path = HipPath::from(b_os_str);
+
+            let a_path = Path::new(a);
+            let a_box_path: Box<Path> = Box::from(a_path);
+            let a_cow_path = Cow::Borrowed(a_path);
+            let a_path_buf = a_path.to_path_buf();
+
+            let b_path = Path::new(b);
+            let b_box_path: Box<Path> = Box::from(b_path);
+            let b_cow_path = Cow::Borrowed(b_path);
+            let b_path_buf = b_path.to_path_buf();
+
+            let expected = a_os_str.cmp(b_os_str);
+
+            assert_eq!(a_hip_os_str.cmp(&b_hip_os_str), expected);
+
+            assert_eq!(a_hip_os_str.partial_cmp(&b_hip_os_str), Some(expected));
+
+            assert_eq!(a_hip_os_str_borrow.cmp(&b_hip_os_str), expected);
+
+            assert_eq!(a_hip_path.partial_cmp(&b_hip_os_str), Some(expected));
+            assert_eq!(a_hip_os_str.partial_cmp(&b_hip_path), Some(expected));
+
+            assert_eq!(a_os_str.partial_cmp(&b_hip_os_str), Some(expected));
+            assert_eq!(a_hip_os_str.partial_cmp(&b_os_str), Some(expected));
+
+            assert_eq!(a_box_os_str.partial_cmp(&b_hip_os_str), Some(expected));
+            assert_eq!(a_hip_os_str.partial_cmp(&b_box_os_str), Some(expected));
+
+            assert_eq!(a_cow_os_str.partial_cmp(&b_hip_os_str), Some(expected));
+            assert_eq!(a_hip_os_str.partial_cmp(&b_cow_os_str), Some(expected));
+
+            assert_eq!(a_os_string.partial_cmp(&b_hip_os_str), Some(expected));
+            assert_eq!(a_hip_os_str.partial_cmp(&b_os_string), Some(expected));
+
+            assert_eq!(a_path.partial_cmp(&b_hip_os_str), Some(expected));
+            assert_eq!(a_hip_os_str.partial_cmp(b_path), Some(expected));
+
+            assert_eq!((&a_path).partial_cmp(&b_hip_os_str), Some(expected));
+            assert_eq!(a_hip_os_str.partial_cmp(&b_path), Some(expected));
+
+            assert_eq!(a_box_path.partial_cmp(&b_hip_os_str), Some(expected));
+            assert_eq!(a_hip_os_str.partial_cmp(&b_box_path), Some(expected));
+
+            assert_eq!(a_cow_path.partial_cmp(&b_hip_os_str), Some(expected));
+            assert_eq!(a_hip_os_str.partial_cmp(&b_cow_path), Some(expected));
+
+            assert_eq!(a_path_buf.partial_cmp(&b_hip_os_str), Some(expected));
+            assert_eq!(a_hip_os_str.partial_cmp(&b_path_buf), Some(expected));
+        }
     }
 }
diff --git a/src/path/cmp.rs b/src/path/cmp.rs
@@ -111,7 +111,6 @@ symmetric_ord! {
 mod tests {
     use alloc::borrow::Cow;
     use alloc::boxed::Box;
-    use core::cmp::Ordering;
     use std::ffi::{OsStr, OsString};
     use std::path::{Path, PathBuf};
 
@@ -170,16 +169,85 @@ mod tests {
 
     #[test]
     fn test_ord() {
-        let h1 = HipPath::borrowed("abc");
-        let h2 = HipPath::from("abd");
+        for (a, b) in [
+            ("abc", "abd"),
+            ("abc", "abc"),
+            ("ab", "abc"),
+            ("a//", "a/"),
+            ("/a//b/", "/a/b/c"),
+        ] {
+            let a_os_str = OsStr::new(a);
+            let a_cow_os_str = Cow::Borrowed(a_os_str);
+            let a_box_os_str: Box<OsStr> = Box::from(a_os_str);
+            let a_os_string = a_os_str.to_os_string();
 
-        assert_eq!(h1.partial_cmp(&h1), Some(Ordering::Equal));
-        assert_eq!(h1.cmp(&h1), Ordering::Equal);
+            let b_os_str = OsStr::new(b);
+            let b_cow_os_str = Cow::Borrowed(b_os_str);
+            let b_box_os_str: Box<OsStr> = Box::from(b_os_str);
+            let b_os_string = b_os_str.to_os_string();
 
-        assert!(h1 < h2);
-        assert_eq!(h1.cmp(&h2), Ordering::Less);
-        assert_eq!(h1.partial_cmp(&h2), Some(Ordering::Less));
-        assert_eq!(h2.cmp(&h1), Ordering::Greater);
-        assert_eq!(h2.partial_cmp(&h1), Some(Ordering::Greater));
+            let a_hip_path = HipPath::from(a_os_str);
+            let a_hip_path_borrow = HipPath::borrowed(a_os_str);
+            let b_hip_path = HipPath::from(b_os_str);
+
+            let a_path = Path::new(a);
+            let a_box_path: Box<Path> = Box::from(a_path);
+            let a_cow_path = Cow::Borrowed(a_path);
+            let a_path_buf = a_path.to_path_buf();
+
+            let b_path = Path::new(b);
+            let b_box_path: Box<Path> = Box::from(b_path);
+            let b_cow_path = Cow::Borrowed(b_path);
+            let b_path_buf = b_path.to_path_buf();
+
+            let expected = a_path.cmp(b_path);
+            assert_eq!(Some(expected), a_path.partial_cmp(b_os_str));
+            let expected_os_str = expected;
+
+            if expected == core::cmp::Ordering::Equal {
+                assert_eq!(a_hip_path, b_hip_path);
+            } else {
+                assert_ne!(a_hip_path, b_hip_path);
+            }
+
+            assert_eq!(a_hip_path.cmp(&b_hip_path), expected);
+
+            assert_eq!(a_hip_path.partial_cmp(&b_hip_path), Some(expected));
+
+            assert_eq!(a_hip_path_borrow.cmp(&b_hip_path), expected);
+
+            assert_eq!(a_hip_path.partial_cmp(&b_hip_path), Some(expected));
+            assert_eq!(a_hip_path.partial_cmp(&b_hip_path), Some(expected));
+
+            assert_eq!(a_os_str.partial_cmp(&b_hip_path), Some(expected_os_str));
+            assert_eq!(a_hip_path.partial_cmp(b_os_str), Some(expected_os_str));
+
+            assert_eq!((&a_os_str).partial_cmp(&b_hip_path), Some(expected_os_str));
+            assert_eq!(a_hip_path.partial_cmp(&b_os_str), Some(expected_os_str));
+
+            assert_eq!(a_box_os_str.partial_cmp(&b_hip_path), Some(expected_os_str));
+            assert_eq!(a_hip_path.partial_cmp(&b_box_os_str), Some(expected_os_str));
+
+            assert_eq!(a_cow_os_str.partial_cmp(&b_hip_path), Some(expected_os_str));
+            assert_eq!(a_hip_path.partial_cmp(&b_cow_os_str), Some(expected_os_str));
+
+            assert_eq!(a_os_string.partial_cmp(&b_hip_path), Some(expected_os_str));
+            assert_eq!(a_hip_path.partial_cmp(&b_os_string), Some(expected_os_str));
+
+            assert_eq!(a_path.partial_cmp(&b_hip_path), Some(expected));
+            assert_eq!(a_hip_path.partial_cmp(b_path), Some(expected));
+
+            assert_eq!((&a_path).partial_cmp(&b_hip_path), Some(expected));
+            assert_eq!(a_hip_path.partial_cmp(&b_path), Some(expected));
+
+            assert_eq!(a_box_path.partial_cmp(&b_hip_path), Some(expected));
+            assert_eq!(a_hip_path.partial_cmp(&b_box_path), Some(expected));
+
+            assert_eq!(a_cow_path.partial_cmp(&b_hip_path), Some(expected));
+            assert_eq!(a_hip_path.partial_cmp(&b_cow_path), Some(expected));
+
+            assert_eq!(a_path_buf.partial_cmp(&b_hip_path), Some(expected));
+            assert_eq!(a_hip_path.partial_cmp(&b_path_buf), Some(expected));
+        }
     }
 }
diff --git a/src/string/cmp.rs b/src/string/cmp.rs
@@ -159,6 +159,28 @@ mod tests {
         assert_eq!(oss, h);
     }
 
+    #[cfg(feature = "bstr")]
+    #[test]
+    fn test_eq_bstr() {
+        let s = "abc";
+        let b: &bstr::BStr = s.as_ref();
+        let h = HipStr::from(s);
+        assert_eq!(h, b);
+        assert_eq!(b, h);
+        assert_eq!(&h, b);
+        assert_eq!(b, &h);
+    }
+
+    #[cfg(feature = "bstr")]
+    #[test]
+    fn test_eq_bstring() {
+        let s = "abc";
+        let bs = bstr::BString::from(s);
+        let h = HipStr::from(s);
+        assert_eq!(h, bs);
+        assert_eq!(bs, h);
+    }
+
     static BB_H: HipStr = HipStr::borrowed("bb");
     static BC_H: HipStr = HipStr::borrowed("bc");
 
@@ -241,4 +263,40 @@ mod tests {
         assert!(BB_H > OsString::from("ba"));
         assert!(BB_H >= OsString::from("bb"));
     }
+
+    #[cfg(feature = "bstr")]
+    #[test]
+    fn test_cmp_bstr() {
+        use bstr::BStr;
+
+        assert!(BStr::new("bc") > &BB_H);
+        assert!(BStr::new("ba") < &BB_H);
+        assert!(BStr::new("bb") <= &BB_H);
+
+        assert!(&BB_H < BStr::new("bc"));
+        assert!(&BB_H > BStr::new("ba"));
+        assert!(&BB_H >= BStr::new("bb"));
+
+        assert!(BStr::new("bc") > BB_H);
+        assert!(BStr::new("ba") < BB_H);
+        assert!(BStr::new("bb") <= BB_H);
+
+        assert!(BB_H < BStr::new("bc"));
+        assert!(BB_H > BStr::new("ba"));
+        assert!(BB_H >= BStr::new("bb"));
+    }
+
+    #[cfg(feature = "bstr")]
+    #[test]
+    fn test_cmp_bstring() {
+        use bstr::BString;
+
+        assert!(BString::from("bc") > BB_H);
+        assert!(BString::from("ba") < BB_H);
+        assert!(BString::from("bb") <= BB_H);
+
+        assert!(BB_H < BString::from("bc"));
+        assert!(BB_H > BString::from("ba"));
+        assert!(BB_H >= BString::from("bb"));
+    }
 }