even more tests, ready to merge

memory_addr/src/addr.rs

@@ -484,6 +484,30 @@ mod test {
         AnotherAddr = "AA:{}";
     }
 
+    #[test]
+    fn test_addr() {
+        let addr = va!(0x2000);
+        assert!(addr.is_aligned_4k());
+        assert!(!addr.is_aligned(0x10000usize));
+        assert_eq!(addr.align_offset_4k(), 0);
+        assert_eq!(addr.align_down_4k(), va!(0x2000));
+        assert_eq!(addr.align_up_4k(), va!(0x2000));
+
+        let addr = va!(0x2fff);
+        assert!(!addr.is_aligned_4k());
+        assert_eq!(addr.align_offset_4k(), 0xfff);
+        assert_eq!(addr.align_down_4k(), va!(0x2000));
+        assert_eq!(addr.align_up_4k(), va!(0x3000));
+
+        let align = 0x100000;
+        let addr = va!(align * 5) + 0x2000;
+        assert!(addr.is_aligned_4k());
+        assert!(!addr.is_aligned(align));
+        assert_eq!(addr.align_offset(align), 0x2000);
+        assert_eq!(addr.align_down(align), va!(align * 5));
+        assert_eq!(addr.align_up(align), va!(align * 6));
+    }
+
     #[test]
     pub fn test_addr_convert_and_comparison() {
         let example1 = ExampleAddr::from_usize(0x1234);
@@ -573,6 +597,50 @@ mod test {
         assert_eq!(offset_addr.wrapping_sub(offset), addr);
     }
 
+    #[test]
+    pub fn test_addr_checked_arithmetic() {
+        let low_addr = ExampleAddr::from_usize(0x100usize);
+        let high_addr = ExampleAddr::from_usize(usize::MAX - 0x100usize);
+        let small_offset = 0x50usize;
+        let large_offset = 0x200usize;
+
+        assert_eq!(
+            low_addr.checked_sub(small_offset),
+            Some(low_addr.wrapping_sub(small_offset))
+        );
+        assert_eq!(low_addr.checked_sub(large_offset), None);
+        assert_eq!(
+            high_addr.checked_add(small_offset),
+            Some(high_addr.wrapping_add(small_offset))
+        );
+        assert_eq!(high_addr.checked_add(large_offset), None);
+    }
+
+    #[test]
+    pub fn test_addr_overflowing_arithmetic() {
+        let low_addr = ExampleAddr::from_usize(0x100usize);
+        let high_addr = ExampleAddr::from_usize(usize::MAX - 0x100usize);
+        let small_offset = 0x50usize;
+        let large_offset = 0x200usize;
+
+        assert_eq!(
+            low_addr.overflowing_sub(small_offset),
+            (low_addr.wrapping_sub(small_offset), false)
+        );
+        assert_eq!(
+            low_addr.overflowing_sub(large_offset),
+            (low_addr.wrapping_sub(large_offset), true)
+        );
+        assert_eq!(
+            high_addr.overflowing_add(small_offset),
+            (high_addr.wrapping_add(small_offset), false)
+        );
+        assert_eq!(
+            high_addr.overflowing_add(large_offset),
+            (high_addr.wrapping_add(large_offset), true)
+        );
+    }
+
     #[test]
     #[should_panic]
     pub fn test_addr_offset_overflow() {

memory_addr/src/iter.rs

@@ -16,6 +16,8 @@ use crate::MemoryAddr;
 /// assert_eq!(iter.next(), Some(0x1000));
 /// assert_eq!(iter.next(), Some(0x2000));
 /// assert_eq!(iter.next(), None);
+///
+/// assert!(PageIter::<0x1000, usize>::new(0x1000, 0x3001).is_none());
 /// ```
 pub struct PageIter<const PAGE_SIZE: usize, A>
 where

memory_addr/src/lib.rs

@@ -77,72 +77,20 @@ pub const fn is_aligned_4k(addr: usize) -> bool {
 
 #[cfg(test)]
 mod tests {
-    use crate::{va, va_range, MemoryAddr, VirtAddrRange};
+    use super::*;
 
     #[test]
-    fn test_addr() {
-        let addr = va!(0x2000);
-        assert!(addr.is_aligned_4k());
-        assert!(!addr.is_aligned(0x10000usize));
-        assert_eq!(addr.align_offset_4k(), 0);
-        assert_eq!(addr.align_down_4k(), va!(0x2000));
-        assert_eq!(addr.align_up_4k(), va!(0x2000));
-
-        let addr = va!(0x2fff);
-        assert!(!addr.is_aligned_4k());
-        assert_eq!(addr.align_offset_4k(), 0xfff);
-        assert_eq!(addr.align_down_4k(), va!(0x2000));
-        assert_eq!(addr.align_up_4k(), va!(0x3000));
-
-        let align = 0x100000;
-        let addr = va!(align * 5) + 0x2000;
-        assert!(addr.is_aligned_4k());
-        assert!(!addr.is_aligned(align));
-        assert_eq!(addr.align_offset(align), 0x2000);
-        assert_eq!(addr.align_down(align), va!(align * 5));
-        assert_eq!(addr.align_up(align), va!(align * 6));
-    }
-
-    #[test]
-    fn test_range() {
-        let start = va!(0x1000);
-        let end = va!(0x2000);
-        let range = va_range!(start..end);
-        println!("range: {:?}", range);
-
-        assert!((0x1000..0x1000).is_empty());
-        assert!((0x1000..0xfff).is_empty());
-        assert!(!range.is_empty());
-
-        assert_eq!(range.start, start);
-        assert_eq!(range.end, end);
-        assert_eq!(range.size(), 0x1000);
-
-        assert!(range.contains(va!(0x1000)));
-        assert!(range.contains(va!(0x1080)));
-        assert!(!range.contains(va!(0x2000)));
-
-        assert!(!range.contains_range((0xfff..0x1fff).into()));
-        assert!(!range.contains_range((0xfff..0x2000).into()));
-        assert!(!range.contains_range((0xfff..0x2001).into()));
-        assert!(range.contains_range((0x1000..0x1fff).into()));
-        assert!(range.contains_range((0x1000..0x2000).into()));
-        assert!(!range.contains_range((0x1000..0x2001).into()));
-        assert!(range.contains_range((0x1001..0x1fff).into()));
-        assert!(range.contains_range((0x1001..0x2000).into()));
-        assert!(!range.contains_range((0x1001..0x2001).into()));
-        assert!(!range.contains_range(VirtAddrRange::from_start_size(0xfff.into(), 0x1)));
-        assert!(!range.contains_range(VirtAddrRange::from_start_size(0x2000.into(), 0x1)));
-
-        assert!(range.contained_in((0xfff..0x2000).into()));
-        assert!(range.contained_in((0x1000..0x2000).into()));
-        assert!(range.contained_in((0x1000..0x2001).into()));
-
-        assert!(!range.overlaps((0x800..0x1000).into()));
-        assert!(range.overlaps((0x800..0x1001).into()));
-        assert!(range.overlaps((0x1800..0x2000).into()));
-        assert!(range.overlaps((0x1800..0x2001).into()));
-        assert!(!range.overlaps((0x2000..0x2800).into()));
-        assert!(range.overlaps((0xfff..0x2001).into()));
+    fn test_align() {
+        assert_eq!(align_down(0x12345678, 0x1000), 0x12345000);
+        assert_eq!(align_up(0x12345678, 0x1000), 0x12346000);
+        assert_eq!(align_offset(0x12345678, 0x1000), 0x678);
+        assert!(is_aligned(0x12345000, 0x1000));
+        assert!(!is_aligned(0x12345678, 0x1000));
+
+        assert_eq!(align_down_4k(0x12345678), 0x12345000);
+        assert_eq!(align_up_4k(0x12345678), 0x12346000);
+        assert_eq!(align_offset_4k(0x12345678), 0x678);
+        assert!(is_aligned_4k(0x12345000));
+        assert!(!is_aligned_4k(0x12345678));
     }
 }

memory_addr/src/range.rs

@@ -314,3 +314,67 @@ macro_rules! pa_range {
         $crate::PhysAddrRange::from($range)
     };
 }
+
+#[cfg(test)]
+mod test {
+    use crate::{va, va_range, VirtAddrRange};
+
+    #[test]
+    fn test_range_format() {
+        let range = va_range!(0xfec000usize..0xfff000usize);
+
+        assert_eq!(format!("{:?}", range), "VA:0xfec000..VA:0xfff000");
+        assert_eq!(format!("{:x}", range), "VA:0xfec000..VA:0xfff000");
+        assert_eq!(format!("{:X}", range), "VA:0xFEC000..VA:0xFFF000");
+    }
+
+    #[test]
+    fn test_range() {
+        let start = va!(0x1000);
+        let end = va!(0x2000);
+        let range = va_range!(start..end);
+
+        println!("range: {:?}", range);
+
+        assert!((0x1000..0x1000).is_empty());
+        assert!((0x1000..0xfff).is_empty());
+        assert!(!range.is_empty());
+
+        assert_eq!(range.start, start);
+        assert_eq!(range.end, end);
+        assert_eq!(range.size(), 0x1000);
+
+        assert!(range.contains(va!(0x1000)));
+        assert!(range.contains(va!(0x1080)));
+        assert!(!range.contains(va!(0x2000)));
+
+        assert!(!range.contains_range((0xfff..0x1fff).into()));
+        assert!(!range.contains_range((0xfff..0x2000).into()));
+        assert!(!range.contains_range((0xfff..0x2001).into()));
+        assert!(range.contains_range((0x1000..0x1fff).into()));
+        assert!(range.contains_range((0x1000..0x2000).into()));
+        assert!(!range.contains_range((0x1000..0x2001).into()));
+        assert!(range.contains_range((0x1001..0x1fff).into()));
+        assert!(range.contains_range((0x1001..0x2000).into()));
+        assert!(!range.contains_range((0x1001..0x2001).into()));
+        assert!(!range.contains_range(VirtAddrRange::from_start_size(0xfff.into(), 0x1)));
+        assert!(!range.contains_range(VirtAddrRange::from_start_size(0x2000.into(), 0x1)));
+
+        assert!(range.contained_in((0xfff..0x2000).into()));
+        assert!(range.contained_in((0x1000..0x2000).into()));
+        assert!(range.contained_in((0x1000..0x2001).into()));
+
+        assert!(!range.overlaps((0x800..0x1000).into()));
+        assert!(range.overlaps((0x800..0x1001).into()));
+        assert!(range.overlaps((0x1800..0x2000).into()));
+        assert!(range.overlaps((0x1800..0x2001).into()));
+        assert!(!range.overlaps((0x2000..0x2800).into()));
+        assert!(range.overlaps((0xfff..0x2001).into()));
+
+        let default_range: VirtAddrRange = Default::default();
+        assert!(default_range.is_empty());
+        assert_eq!(default_range.size(), 0);
+        assert_eq!(default_range.start, va!(0));
+        assert_eq!(default_range.end, va!(0));
+    }
+}

memory_set/src/backend.rs

@@ -5,8 +5,8 @@ use memory_addr::MemoryAddr;
 ///
 /// The backend can be different for different memory areas. e.g., for linear
 /// mappings, the target physical address is known when it is added to the page
-/// table. For lazy mappings, an empty mapping needs to be added to the page table
-/// to trigger a page fault.
+/// table. For lazy mappings, an empty mapping needs to be added to the page
+/// table to trigger a page fault.
 pub trait MappingBackend: Clone {
     /// The address type used in the memory area.
     type Addr: MemoryAddr;

memory_set/src/set.rs

@@ -192,8 +192,8 @@ impl<B: MappingBackend> MemorySet<B> {
     /// It returns [`None`] if there is no bit to change.
     ///
     /// Memory areas will be skipped according to `update_flags`. Memory areas
-    /// that are fully contained in the range or contains the range or intersects
-    /// with the boundary will be handled similarly to `munmap`.
+    /// that are fully contained in the range or contains the range or
+    /// intersects with the boundary will be handled similarly to `munmap`.
     pub fn protect(
         &mut self,
         start: B::Addr,