chore: add unit-test

Author: duyquang6

crates/trie/common/src/utils.rs

@@ -58,3 +58,120 @@ where
 
     *target = result;
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_extend_sorted_vec_empty_other() {
+        let mut target = vec![(1, "a"), (2, "b"), (3, "c")];
+        let other: Vec<(i32, &str)> = vec![];
+        extend_sorted_vec(&mut target, &other);
+        assert_eq!(target, vec![(1, "a"), (2, "b"), (3, "c")]);
+    }
+
+    #[test]
+    fn test_extend_sorted_vec_empty_target() {
+        let mut target: Vec<(i32, &str)> = vec![];
+        let other = vec![(1, "a"), (2, "b"), (3, "c")];
+        extend_sorted_vec(&mut target, &other);
+        assert_eq!(target, vec![(1, "a"), (2, "b"), (3, "c")]);
+    }
+
+    #[test]
+    fn test_extend_sorted_vec_no_overlap() {
+        let mut target = vec![(1, "a"), (3, "c"), (5, "e")];
+        let other = vec![(2, "b"), (4, "d"), (6, "f")];
+        extend_sorted_vec(&mut target, &other);
+        assert_eq!(
+            target,
+            vec![(1, "a"), (2, "b"), (3, "c"), (4, "d"), (5, "e"), (6, "f")]
+        );
+    }
+
+    #[test]
+    fn test_extend_sorted_vec_with_duplicates_other_precedence() {
+        let mut target = vec![(1, "a"), (2, "target"), (3, "c")];
+        let other = vec![(2, "other"), (4, "d")];
+        extend_sorted_vec(&mut target, &other);
+        // other's value should take precedence for key 2
+        assert_eq!(target, vec![(1, "a"), (2, "other"), (3, "c"), (4, "d")]);
+    }
+
+    #[test]
+    fn test_extend_sorted_vec_all_other_before_target() {
+        let mut target = vec![(5, "e"), (6, "f")];
+        let other = vec![(1, "a"), (2, "b"), (3, "c")];
+        extend_sorted_vec(&mut target, &other);
+        assert_eq!(
+            target,
+            vec![(1, "a"), (2, "b"), (3, "c"), (5, "e"), (6, "f")]
+        );
+    }
+
+    #[test]
+    fn test_extend_sorted_vec_all_other_after_target() {
+        let mut target = vec![(1, "a"), (2, "b")];
+        let other = vec![(5, "e"), (6, "f"), (7, "g")];
+        extend_sorted_vec(&mut target, &other);
+        assert_eq!(
+            target,
+            vec![(1, "a"), (2, "b"), (5, "e"), (6, "f"), (7, "g")]
+        );
+    }
+
+    #[test]
+    fn test_extend_sorted_vec_interleaved() {
+        let mut target = vec![(1, "a"), (3, "c"), (5, "e"), (7, "g")];
+        let other = vec![(2, "b"), (4, "d"), (6, "f")];
+        extend_sorted_vec(&mut target, &other);
+        assert_eq!(
+            target,
+            vec![(1, "a"), (2, "b"), (3, "c"), (4, "d"), (5, "e"), (6, "f"), (7, "g")]
+        );
+    }
+
+    #[test]
+    fn test_extend_sorted_vec_multiple_duplicates() {
+        let mut target = vec![(1, "target1"), (2, "target2"), (3, "target3")];
+        let other = vec![(1, "other1"), (2, "other2"), (3, "other3")];
+        extend_sorted_vec(&mut target, &other);
+        // All other values should take precedence
+        assert_eq!(target, vec![(1, "other1"), (2, "other2"), (3, "other3")]);
+    }
+
+    #[test]
+    fn test_extend_sorted_vec_single_element_each() {
+        let mut target = vec![(5, "target")];
+        let other = vec![(3, "other")];
+        extend_sorted_vec(&mut target, &other);
+        assert_eq!(target, vec![(3, "other"), (5, "target")]);
+    }
+
+    #[test]
+    fn test_extend_sorted_vec_same_key_different_values() {
+        let mut target = vec![(1, "original")];
+        let other = vec![(1, "override")];
+        extend_sorted_vec(&mut target, &other);
+        assert_eq!(target, vec![(1, "override")]);
+    }
+
+    #[test]
+    fn test_extend_sorted_vec_large_merge() {
+        let mut target: Vec<(i32, i32)> = (0..100).step_by(2).map(|i| (i, i)).collect();
+        let other: Vec<(i32, i32)> = (1..100).step_by(2).map(|i| (i, i * 10)).collect();
+        extend_sorted_vec(&mut target, &other);
+        
+        // Verify sorted order
+        for i in 0..(target.len() - 1) {
+            assert!(target[i].0 < target[i + 1].0);
+        }
+        
+        // Verify all keys are present
+        assert_eq!(target.len(), 100);
+        
+        // Verify other values took precedence for odd numbers
+        assert_eq!(target[1].1, 10); // key 1 should have value 10 from other
+    }
+}