test: reflections' equality

Author: KSXGitHub

src/hardlink/hardlink_list.rs

@@ -86,7 +86,7 @@ where
     Size: size::Size,
 {
     /// Add an entry to the record.
-    #[cfg_attr(not(unix), expect(unused))]
+    #[cfg_attr(not(unix), cfg(test))] // this function isn't used on non-POSIX except in tests
     pub(crate) fn add(
         &self,
         ino: InodeNumber,
@@ -115,3 +115,124 @@ where
         size_assertion.map_err(AddError::SizeConflict)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::HardlinkList;
+    use crate::size::Bytes;
+    use pipe_trait::Pipe;
+    use pretty_assertions::{assert_eq, assert_ne};
+
+    const TABLE: &[(u64, u64, u64, &str)] = &[
+        (241, 3652, 1, "a"),
+        (569, 2210, 1, "b"),
+        (110, 2350, 3, "c"),
+        (110, 2350, 3, "c1"),
+        (778, 1110, 1, "d"),
+        (274, 6060, 2, "e"),
+        (274, 6060, 2, "e1"),
+        (883, 4530, 1, "f"),
+    ];
+
+    fn add<const ROW: usize>(list: HardlinkList<Bytes>) -> HardlinkList<Bytes> {
+        let values = TABLE[ROW];
+        let (ino, size, links, path) = values;
+        if let Err(error) = list.add(ino.into(), size.into(), links, path.as_ref()) {
+            panic!("Failed to add {values:?} (index: {ROW}) to the list: {error}");
+        }
+        list
+    }
+
+    #[test]
+    fn insertion_order_is_irrelevant_to_equality() {
+        let a = HardlinkList::new()
+            .pipe(add::<3>)
+            .pipe(add::<1>)
+            .pipe(add::<4>)
+            .pipe(add::<6>)
+            .pipe(add::<5>)
+            .pipe(add::<0>)
+            .pipe(add::<7>)
+            .pipe(add::<2>)
+            .into_reflection();
+
+        let b = HardlinkList::new()
+            .pipe(add::<5>)
+            .pipe(add::<6>)
+            .pipe(add::<2>)
+            .pipe(add::<0>)
+            .pipe(add::<1>)
+            .pipe(add::<3>)
+            .pipe(add::<7>)
+            .pipe(add::<4>)
+            .into_reflection();
+
+        let c = HardlinkList::new()
+            .pipe(add::<0>)
+            .pipe(add::<1>)
+            .pipe(add::<2>)
+            .pipe(add::<3>)
+            .pipe(add::<4>)
+            .pipe(add::<5>)
+            .pipe(add::<6>)
+            .pipe(add::<7>)
+            .into_reflection();
+
+        assert_eq!(a, b);
+        assert_eq!(b, c);
+        assert_eq!(a, c);
+    }
+
+    #[test]
+    fn omitting_insertion_cause_inequality() {
+        let a = HardlinkList::new()
+            .pipe(add::<0>)
+            .pipe(add::<1>)
+            .pipe(add::<2>)
+            .pipe(add::<3>)
+            .pipe(add::<4>)
+            .pipe(add::<5>)
+            .pipe(add::<6>)
+            .pipe(add::<7>)
+            .into_reflection();
+
+        let b = HardlinkList::new()
+            .pipe(add::<0>)
+            .pipe(add::<1>)
+            .pipe(add::<2>)
+            .pipe(add::<3>)
+            .pipe(add::<4>)
+            .pipe(add::<5>)
+            .pipe(add::<7>)
+            .into_reflection();
+
+        assert_ne!(a, b);
+        assert_ne!(b, a);
+    }
+
+    #[test]
+    fn insertion_difference_cause_inequality() {
+        let a = HardlinkList::new()
+            .pipe(add::<0>)
+            .pipe(add::<1>)
+            .pipe(add::<2>)
+            .pipe(add::<3>)
+            .pipe(add::<4>)
+            .pipe(add::<5>)
+            .pipe(add::<6>)
+            .into_reflection();
+
+        let b = HardlinkList::new()
+            .pipe(add::<0>)
+            .pipe(add::<1>)
+            .pipe(add::<2>)
+            .pipe(add::<3>)
+            .pipe(add::<4>)
+            .pipe(add::<5>)
+            .pipe(add::<7>)
+            .into_reflection();
+
+        assert_ne!(a, b);
+        assert_ne!(b, a);
+    }
+}

src/hardlink/link_path_list.rs

@@ -23,6 +23,14 @@ impl LinkPathList {
         LinkPathList(vec![path])
     }
 
+    /// Create a list of many paths.
+    #[cfg(test)]
+    pub(crate) fn many(paths: impl IntoIterator<Item: Into<PathBuf>>) -> Self {
+        let paths: Vec<_> = paths.into_iter().map(Into::into).collect();
+        assert!(!paths.is_empty(), "paths must not be empty");
+        LinkPathList(paths)
+    }
+
     /// Add a path to the list.
     pub(crate) fn add(&mut self, path: PathBuf) {
         self.0.push(path)
@@ -43,3 +51,50 @@ impl LinkPathList {
         self.into()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::LinkPathList;
+    use pipe_trait::Pipe;
+    use pretty_assertions::{assert_eq, assert_ne};
+
+    #[test]
+    fn item_order_is_irrelevant_to_equality() {
+        let a = ["3", "4", "0", "2", "1"]
+            .pipe(LinkPathList::many)
+            .into_reflection();
+        let b = ["4", "0", "3", "2", "1"]
+            .pipe(LinkPathList::many)
+            .into_reflection();
+        let c = ["0", "1", "2", "3", "4"]
+            .pipe(LinkPathList::many)
+            .into_reflection();
+        assert_eq!(a, b);
+        assert_eq!(b, c);
+        assert_eq!(a, c);
+    }
+
+    #[test]
+    fn item_absent_cause_inequality() {
+        let a = ["0", "1", "2", "3"]
+            .pipe(LinkPathList::many)
+            .into_reflection();
+        let b = ["0", "1", "2", "3", "4"]
+            .pipe(LinkPathList::many)
+            .into_reflection();
+        assert_ne!(a, b);
+        assert_ne!(b, a);
+    }
+
+    #[test]
+    fn item_difference_cause_inequality() {
+        let a = ["0", "1", "2", "3", "5"]
+            .pipe(LinkPathList::many)
+            .into_reflection();
+        let b = ["0", "1", "2", "3", "4"]
+            .pipe(LinkPathList::many)
+            .into_reflection();
+        assert_ne!(a, b);
+        assert_ne!(b, a);
+    }
+}