Add more unit tests

Signed-off-by: Liu Jiang <gerry@linux.alibaba.com>

Author: jiangliu

src/interval_tree.rs

@@ -664,6 +664,41 @@ mod tests {
         assert_eq!(d.len(), 1);
     }
 
+    #[test]
+    fn test_range_contain() {
+        let a = Range::new(2, 6);
+        assert!(a.contain(&Range::new(2, 3)));
+        assert!(a.contain(&Range::new(3, 4)));
+        assert!(a.contain(&Range::new(5, 5)));
+        assert!(a.contain(&Range::new(5, 6)));
+        assert!(a.contain(&Range::new(6, 6)));
+        assert!(!a.contain(&Range::new(1, 1)));
+        assert!(!a.contain(&Range::new(1, 2)));
+        assert!(!a.contain(&Range::new(1, 3)));
+        assert!(!a.contain(&Range::new(1, 7)));
+        assert!(!a.contain(&Range::new(7, 8)));
+        assert!(!a.contain(&Range::new(6, 7)));
+        assert!(!a.contain(&Range::new(7, 8)));
+    }
+
+    #[test]
+    fn test_range_align_to() {
+        let a = Range::new(2, 6);
+        assert_eq!(a.align_to(0), Some(Range::new(2, 6)));
+        assert_eq!(a.align_to(1), Some(Range::new(2, 6)));
+        assert_eq!(a.align_to(2), Some(Range::new(2, 6)));
+        assert_eq!(a.align_to(4), Some(Range::new(4, 6)));
+        assert_eq!(a.align_to(8), None);
+        assert_eq!(a.align_to(3), None);
+
+        let a = Range::new(0xFFFF_FFFF_FFFF_FFFD, 0xFFFF_FFFF_FFFF_FFFF);
+        assert_eq!(
+            a.align_to(2),
+            Some(Range::new(0xFFFF_FFFF_FFFF_FFFE, 0xFFFF_FFFF_FFFF_FFFF))
+        );
+        assert_eq!(a.align_to(4), None);
+    }
+
     #[test]
     fn test_range_ord() {
         let a = Range::new(1, 4);
@@ -697,4 +732,119 @@ mod tests {
         tree.insert(Range::new(0x100, 0x200), Some(1));
         tree.insert(Range::new(0x200, 0x2ff), None);
     }
+
+    #[test]
+    fn test_tree_get_superset() {
+        let mut tree = IntervalTree::<u64>::new();
+        tree.insert(Range::new(0x100, 0x100), Some(1));
+        tree.insert(Range::new(0x200, 0x2ff), None);
+        assert_eq!(
+            tree.get_superset(&Range::new(0x100, 0x100)),
+            Some((&Range::new(0x100, 0x100), Some(&1)))
+        );
+        assert_eq!(
+            tree.get_superset(&Range::new(0x200, 0x200)),
+            Some((&Range::new(0x200, 0x2ff), None))
+        );
+        assert_eq!(
+            tree.get_superset(&Range::new(0x200, 0x2ff)),
+            Some((&Range::new(0x200, 0x2ff), None))
+        );
+        assert_eq!(
+            tree.get_superset(&Range::new(0x210, 0x210)),
+            Some((&Range::new(0x200, 0x2ff), None))
+        );
+        assert_eq!(
+            tree.get_superset(&Range::new(0x2ff, 0x2ff)),
+            Some((&Range::new(0x200, 0x2ff), None))
+        );
+        assert_eq!(tree.get_superset(&Range::new(0x2ff, 0x300)), None);
+        assert_eq!(tree.get_superset(&Range::new(0x300, 0x300)), None);
+        assert_eq!(tree.get_superset(&Range::new(0x1ff, 0x300)), None);
+    }
+
+    #[test]
+    fn test_tree_update() {
+        let mut tree = IntervalTree::<u64>::new();
+        tree.insert(Range::new(0x100, 0x100), None);
+        tree.insert(Range::new(0x200, 0x2ff), None);
+
+        let constraint = Constraint::new(2);
+        let key = tree.allocate(&constraint);
+        assert_eq!(key, Some(Range::new(0x200, 0x201)));
+        let old = tree.update(&Range::new(0x200, 0x201), 2);
+        assert_eq!(old, None);
+        let old = tree.update(&Range::new(0x200, 0x201), 3);
+        assert_eq!(old, Some(2));
+        let old = tree.update(&Range::new(0x200, 0x200), 4);
+        assert_eq!(old, None);
+        let old = tree.update(&Range::new(0x200, 0x203), 5);
+        assert_eq!(old, None);
+
+        tree.delete(&Range::new(0x200, 0x201));
+        let old = tree.update(&Range::new(0x200, 0x201), 2);
+        assert_eq!(old, None);
+    }
+
+    #[test]
+    fn test_tree_delete() {
+        let mut tree = IntervalTree::<u64>::new();
+        assert_eq!(tree.get(&Range::new(0x101, 0x101)), None);
+        assert!(tree.is_empty());
+        tree.insert(Range::new(0x100, 0x100), Some(1));
+        tree.insert(Range::new(0x200, 0x2ff), None);
+        assert!(!tree.is_empty());
+        assert_eq!(tree.get(&Range::new(0x100, 0x100)), Some(Some(&1)));
+        assert_eq!(tree.get(&Range::new(0x200, 0x2ff)), Some(None));
+        assert_eq!(tree.get(&Range::new(0x101, 0x101)), None);
+
+        let old = tree.delete(&Range::new(0x100, 0x100));
+        assert_eq!(old, Some(1));
+        let old = tree.delete(&Range::new(0x200, 0x2ff));
+        assert_eq!(old, None);
+
+        assert!(tree.is_empty());
+        assert_eq!(tree.get(&Range::new(0x100, 0x100)), None);
+        assert_eq!(tree.get(&Range::new(0x200, 0x2ff)), None);
+    }
+
+    #[test]
+    fn test_allocate_free() {
+        let mut tree = IntervalTree::<u64>::new();
+        let mut constraint = Constraint::new(1);
+
+        assert_eq!(tree.allocate(&constraint), None);
+        tree.insert(Range::new(0x100, 0x100), None);
+        tree.insert(Range::new(0x200, 0x2ff), None);
+
+        let key = tree.allocate(&constraint);
+        assert_eq!(key, Some(Range::new(0x100, 0x100)));
+        let old = tree.update(&Range::new(0x100, 0x100), 2);
+        assert_eq!(old, None);
+        let val = tree.get(&Range::new(0x100, 0x100));
+        assert_eq!(val, Some(Some(&2)));
+
+        constraint.min = 0x100;
+        constraint.max = 0x100;
+        assert_eq!(tree.allocate(&constraint), None);
+
+        constraint.min = 0x201;
+        constraint.max = 0x300;
+        constraint.align = 0x8;
+        constraint.size = 0x10;
+        assert_eq!(tree.allocate(&constraint), Some(Range::new(0x208, 0x217)));
+
+        constraint.size = 0x100;
+        assert_eq!(tree.allocate(&constraint), None);
+
+        tree.update(&Range::new(0x208, 0x217), 0x10);
+        let old = tree.free(&Range::new(0x208, 0x217));
+        assert_eq!(old, Some(0x10));
+
+        constraint.min = 0x200;
+        constraint.max = 0x2ff;
+        constraint.align = 0x8;
+        constraint.size = 0x100;
+        assert_eq!(tree.allocate(&constraint), Some(Range::new(0x200, 0x2ff)));
+    }
 }