From e7eb205213669c9cf37695885ea300926b7f3363 Mon Sep 17 00:00:00 2001
From: ligt <me@ligt.dev>
Date: Thu, 27 Nov 2025 09:11:52 +0700
Subject: [PATCH] chore: add unit-test

---
 crates/trie/common/src/utils.rs | 108 ++++++++++++++++++++++++++++++++
 1 file changed, 108 insertions(+)

diff --git a/crates/trie/common/src/utils.rs b/crates/trie/common/src/utils.rs
index c495267d23..46677d189c 100644
--- a/crates/trie/common/src/utils.rs
+++ b/crates/trie/common/src/utils.rs
@@ -89,3 +89,111 @@ mod tests {
         assert_eq!(target, vec![(1, "a"), (2, "b"), (3, "c_new")]);
     }
 }
+
+#[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
+    }
+}