Moving tests into their own module in each file
This is a common pattern and it limits the scope of entities made only
for testing purposes.
Signed-off-by: Imre Kis <imre.kis@arm.com>
Change-Id: I4338a5f68471377b87653240fbb0debf3d80e924
diff --git a/src/descriptor.rs b/src/descriptor.rs
index ef78d13..6f370ec 100644
--- a/src/descriptor.rs
+++ b/src/descriptor.rs
@@ -300,408 +300,414 @@
}
}
-#[test]
-fn test_attributes() {
- let attributes = Attributes::default();
- assert_eq!(0u64, attributes.into());
+#[cfg(test)]
+mod tests {
+ use super::*;
- let attributes = Attributes {
- uxn: true,
- ..Default::default()
- };
- assert_eq!(1u64 << 54, attributes.into());
+ #[test]
+ fn test_attributes() {
+ let attributes = Attributes::default();
+ assert_eq!(0u64, attributes.into());
- let attributes = Attributes {
- pxn: true,
- ..Default::default()
- };
- assert_eq!(1u64 << 53, attributes.into());
-
- let attributes = Attributes {
- contiguous: true,
- ..Default::default()
- };
- assert_eq!(1u64 << 52, attributes.into());
-
- let attributes = Attributes {
- not_global: true,
- ..Default::default()
- };
- assert_eq!(1u64 << 11, attributes.into());
-
- let attributes = Attributes {
- access_flag: true,
- ..Default::default()
- };
- assert_eq!(1u64 << 10, attributes.into());
-
- let attributes = Attributes {
- non_secure: true,
- ..Default::default()
- };
- assert_eq!(1u64 << 5, attributes.into());
-
- let attributes = Attributes {
- mem_attr_index: MemoryAttributesIndex::Normal_IWBWA_OWBWA,
- ..Default::default()
- };
- assert_eq!(
- (MemoryAttributesIndex::Normal_IWBWA_OWBWA as u64) << 2,
- attributes.into()
- );
-
- let attributes: Attributes = 0.into();
- assert!(!attributes.uxn);
- assert!(!attributes.pxn);
- assert!(!attributes.contiguous);
- assert!(!attributes.not_global);
- assert!(!attributes.access_flag);
- assert_eq!(Shareability::NonShareable, attributes.shareability);
- assert_eq!(
- DataAccessPermissions::ReadWrite_None,
- attributes.data_access_permissions
- );
- assert!(!attributes.non_secure);
- assert_eq!(
- MemoryAttributesIndex::Device_nGnRnE,
- attributes.mem_attr_index
- );
-}
-
-#[test]
-fn test_next_level_attributes() {
- let next_level_attributes = NextLevelAttributes::default();
- assert_eq!(0u64, next_level_attributes.into());
-
- let next_level_attributes = NextLevelAttributes {
- ns_table: true,
- ..Default::default()
- };
- assert_eq!(1u64 << 63, next_level_attributes.into());
-
- let next_level_attributes = NextLevelAttributes {
- ap_table: 3.into(),
- ..Default::default()
- };
- assert_eq!(3u64 << 61, next_level_attributes.into());
-
- let next_level_attributes = NextLevelAttributes {
- xn_table: true,
- ..Default::default()
- };
- assert_eq!(1u64 << 60, next_level_attributes.into());
-
- let next_level_attributes = NextLevelAttributes {
- pxn_table: true,
- ..Default::default()
- };
- assert_eq!(1u64 << 59, next_level_attributes.into());
-
- let next_level_attributes: NextLevelAttributes = 0.into();
- assert!(!next_level_attributes.ns_table);
- assert_eq!(0u8, next_level_attributes.ap_table.into());
- assert!(!next_level_attributes.xn_table);
- assert!(!next_level_attributes.pxn_table);
-
- let next_level_attributes: NextLevelAttributes = u64::MAX.into();
- assert!(next_level_attributes.ns_table);
- assert_eq!(3u8, next_level_attributes.ap_table.into());
- assert!(next_level_attributes.xn_table);
- assert!(next_level_attributes.pxn_table);
-}
-
-#[test]
-fn test_descriptor_get_type() {
- let descriptor = Descriptor {
- cell: UnsafeCell::new(0),
- };
- assert_eq!(DescriptorType::Invalid, descriptor.get_descriptor_type(1));
-
- let descriptor = Descriptor {
- cell: UnsafeCell::new(1),
- };
- assert_eq!(DescriptorType::Block, descriptor.get_descriptor_type(1));
-
- let descriptor = Descriptor {
- cell: UnsafeCell::new(3),
- };
- assert_eq!(DescriptorType::Table, descriptor.get_descriptor_type(1));
-
- let descriptor = Descriptor {
- cell: UnsafeCell::new(0),
- };
- assert_eq!(DescriptorType::Invalid, descriptor.get_descriptor_type(3));
-
- let descriptor = Descriptor {
- cell: UnsafeCell::new(3),
- };
- assert_eq!(DescriptorType::Block, descriptor.get_descriptor_type(3));
-}
-
-#[test]
-fn test_descriptor_is_valid() {
- let descriptor = Descriptor {
- cell: UnsafeCell::new(0),
- };
- assert!(!descriptor.is_valid());
-
- let descriptor = Descriptor {
- cell: UnsafeCell::new(1),
- };
- assert!(descriptor.is_valid());
-}
-
-#[test]
-fn test_descriptor_set_block_to_block_again() {
- let mut descriptor = Descriptor {
- cell: UnsafeCell::new(1),
- };
-
- descriptor.set_block_descriptor(1, 0, Attributes::default());
- assert_eq!(0x1, descriptor.get());
-}
-
-#[test]
-#[should_panic]
-fn test_descriptor_set_block_invalid_oa() {
- let mut descriptor = Descriptor {
- cell: UnsafeCell::new(0),
- };
-
- descriptor.set_block_descriptor(1, 1 << 63, Attributes::default());
-}
-
-#[test]
-fn test_descriptor_block() {
- let mut descriptor = Descriptor {
- cell: UnsafeCell::new(0),
- };
-
- descriptor.set_block_descriptor(
- 1,
- 0x0000000f_c0000000,
- Attributes {
+ let attributes = Attributes {
uxn: true,
..Default::default()
- },
- );
- assert_eq!(0x0040000f_c0000001, descriptor.get());
+ };
+ assert_eq!(1u64 << 54, attributes.into());
- let mut descriptor = Descriptor {
- cell: UnsafeCell::new(0),
- };
-
- descriptor.set_block_descriptor(
- 3,
- 0x0000000f_fffff000,
- Attributes {
- uxn: true,
- ..Default::default()
- },
- );
- assert_eq!(0x0040000f_fffff003, descriptor.get());
-
- assert_eq!(0x0000000f_fffff000, descriptor.get_block_output_address(3));
- assert_eq!(
- Attributes {
- uxn: true,
- ..Default::default()
- },
- descriptor.get_block_attributes(3)
- );
-
- descriptor.set_block_attributes(
- 3,
- Attributes {
+ let attributes = Attributes {
pxn: true,
..Default::default()
- },
- );
- assert_eq!(
- Attributes {
- pxn: true,
+ };
+ assert_eq!(1u64 << 53, attributes.into());
+
+ let attributes = Attributes {
+ contiguous: true,
..Default::default()
- },
- descriptor.get_block_attributes(3)
- );
-}
+ };
+ assert_eq!(1u64 << 52, attributes.into());
-#[test]
-#[should_panic]
-fn test_descriptor_invalid_block_to_invalid() {
- let mut descriptor = Descriptor {
- cell: UnsafeCell::new(0),
- };
+ let attributes = Attributes {
+ not_global: true,
+ ..Default::default()
+ };
+ assert_eq!(1u64 << 11, attributes.into());
- descriptor.set_block_descriptor_to_invalid(0);
-}
+ let attributes = Attributes {
+ access_flag: true,
+ ..Default::default()
+ };
+ assert_eq!(1u64 << 10, attributes.into());
-#[test]
-fn test_descriptor_block_to_invalid() {
- let mut descriptor = Descriptor {
- cell: UnsafeCell::new(3),
- };
+ let attributes = Attributes {
+ non_secure: true,
+ ..Default::default()
+ };
+ assert_eq!(1u64 << 5, attributes.into());
- descriptor.set_block_descriptor_to_invalid(3);
- assert_eq!(0, descriptor.get());
-}
+ let attributes = Attributes {
+ mem_attr_index: MemoryAttributesIndex::Normal_IWBWA_OWBWA,
+ ..Default::default()
+ };
+ assert_eq!(
+ (MemoryAttributesIndex::Normal_IWBWA_OWBWA as u64) << 2,
+ attributes.into()
+ );
-#[test]
-#[should_panic]
-fn test_descriptor_level3_to_table() {
- let mut next_level_table = [Descriptor {
- cell: UnsafeCell::new(0),
- }];
- let mut descriptor = Descriptor {
- cell: UnsafeCell::new(0),
- };
-
- unsafe {
- descriptor.set_table_descriptor(3, &mut next_level_table, None);
- }
-}
-
-#[test]
-fn test_descriptor_block_to_table() {
- let next_level_table =
- unsafe { core::slice::from_raw_parts_mut(0x1000 as *mut Descriptor, 512) };
- let mut descriptor = Descriptor {
- cell: UnsafeCell::new(1),
- };
-
- unsafe {
- descriptor.set_table_descriptor(0, next_level_table, None);
- }
- assert_eq!(0x1003, descriptor.get());
-}
-
-#[test]
-#[should_panic]
-fn test_descriptor_table_invalid_count() {
- let next_level_table =
- unsafe { core::slice::from_raw_parts_mut(0x800 as *mut Descriptor, 511) };
- let mut descriptor = Descriptor {
- cell: UnsafeCell::new(0),
- };
-
- unsafe {
- descriptor.set_table_descriptor(0, next_level_table, None);
- }
-}
-
-#[test]
-#[should_panic]
-fn test_descriptor_table_non_aligned() {
- let next_level_table =
- unsafe { core::slice::from_raw_parts_mut(0x800 as *mut Descriptor, 512) };
- let mut descriptor = Descriptor {
- cell: UnsafeCell::new(0),
- };
-
- unsafe {
- descriptor.set_table_descriptor(0, next_level_table, None);
- }
-}
-
-#[test]
-fn test_descriptor_table() {
- let next_level_table =
- unsafe { core::slice::from_raw_parts_mut(0x0000_000c_ba98_7000 as *mut Descriptor, 512) };
- let mut descriptor = Descriptor {
- cell: UnsafeCell::new(0),
- };
-
- unsafe {
- descriptor.set_table_descriptor(0, next_level_table, None);
- }
- assert_eq!(0x0000_000c_ba98_7003, descriptor.get());
-}
-
-#[test]
-fn test_descriptor_table_next_level_attr() {
- const NEXT_LEVEL_ADDR: u64 = 0x0000_000c_ba98_7000;
- let next_level_table =
- unsafe { core::slice::from_raw_parts_mut(NEXT_LEVEL_ADDR as *mut Descriptor, 512) };
- let mut descriptor = Descriptor {
- cell: UnsafeCell::new(0),
- };
-
- unsafe {
- descriptor.set_table_descriptor(
- 0,
- next_level_table,
- Some(NextLevelAttributes {
- ns_table: true,
- ..Default::default()
- }),
+ let attributes: Attributes = 0.into();
+ assert!(!attributes.uxn);
+ assert!(!attributes.pxn);
+ assert!(!attributes.contiguous);
+ assert!(!attributes.not_global);
+ assert!(!attributes.access_flag);
+ assert_eq!(Shareability::NonShareable, attributes.shareability);
+ assert_eq!(
+ DataAccessPermissions::ReadWrite_None,
+ attributes.data_access_permissions
+ );
+ assert!(!attributes.non_secure);
+ assert_eq!(
+ MemoryAttributesIndex::Device_nGnRnE,
+ attributes.mem_attr_index
);
}
- assert_eq!(NEXT_LEVEL_ADDR | 0x8000_0000_0000_0003, descriptor.get());
-}
-#[test]
-fn test_descriptor_table_get_next_level_table() {
- const NEXT_LEVEL_ADDR: u64 = 0x0000_000c_ba98_7000;
- let descriptor = Descriptor {
- cell: UnsafeCell::new(NEXT_LEVEL_ADDR | 0x8000_0000_0000_0003),
- };
- assert_eq!(KernelSpace::pa_to_kernel(NEXT_LEVEL_ADDR), unsafe {
- descriptor.get_next_level_table(0).as_ptr() as u64
- });
-}
+ #[test]
+ fn test_next_level_attributes() {
+ let next_level_attributes = NextLevelAttributes::default();
+ assert_eq!(0u64, next_level_attributes.into());
-#[test]
-fn test_descriptor_table_get_next_level_table_mut() {
- const NEXT_LEVEL_ADDR: u64 = 0x0000_000c_ba98_7000;
- let mut descriptor = Descriptor {
- cell: UnsafeCell::new(NEXT_LEVEL_ADDR | 0x8000_0000_0000_0003),
- };
- assert_eq!(KernelSpace::pa_to_kernel(NEXT_LEVEL_ADDR), unsafe {
- descriptor.get_next_level_table_mut(0).as_ptr() as *mut Descriptor as u64
- });
-}
-
-#[test]
-fn test_descriptor_table_get_next_level_attr() {
- const NEXT_LEVEL_ADDR: u64 = 0x0000_000c_ba98_7000;
- let descriptor = Descriptor {
- cell: UnsafeCell::new(NEXT_LEVEL_ADDR | 0x8000_0000_0000_0003),
- };
- assert_eq!(
- NextLevelAttributes {
+ let next_level_attributes = NextLevelAttributes {
ns_table: true,
..Default::default()
- },
- descriptor.get_next_level_attributes(0)
- );
-}
+ };
+ assert_eq!(1u64 << 63, next_level_attributes.into());
-#[test]
-fn test_descriptor_table_set_to_invalid() {
- const NEXT_LEVEL_ADDR: u64 = 0x0000_000c_ba98_7000;
- let mut descriptor = Descriptor {
- cell: UnsafeCell::new(NEXT_LEVEL_ADDR | 0x8000_0000_0000_0003),
- };
- assert_eq!(KernelSpace::pa_to_kernel(NEXT_LEVEL_ADDR), unsafe {
- descriptor.set_table_descriptor_to_invalid(0).as_ptr() as *mut Descriptor as u64
- });
- assert_eq!(0, descriptor.get());
-}
+ let next_level_attributes = NextLevelAttributes {
+ ap_table: 3.into(),
+ ..Default::default()
+ };
+ assert_eq!(3u64 << 61, next_level_attributes.into());
-#[test]
-fn test_descriptor_raw_interface() {
- let cell_value = 0x01234567_89abcdefu64;
- let cell_new_value = 0x12345678_9abcdef0u64;
+ let next_level_attributes = NextLevelAttributes {
+ xn_table: true,
+ ..Default::default()
+ };
+ assert_eq!(1u64 << 60, next_level_attributes.into());
- let mut descriptor = Descriptor {
- cell: UnsafeCell::new(cell_value),
- };
+ let next_level_attributes = NextLevelAttributes {
+ pxn_table: true,
+ ..Default::default()
+ };
+ assert_eq!(1u64 << 59, next_level_attributes.into());
- assert_eq!(cell_value, descriptor.get());
+ let next_level_attributes: NextLevelAttributes = 0.into();
+ assert!(!next_level_attributes.ns_table);
+ assert_eq!(0u8, next_level_attributes.ap_table.into());
+ assert!(!next_level_attributes.xn_table);
+ assert!(!next_level_attributes.pxn_table);
- descriptor.set(cell_new_value);
- assert_eq!(cell_new_value, descriptor.get());
+ let next_level_attributes: NextLevelAttributes = u64::MAX.into();
+ assert!(next_level_attributes.ns_table);
+ assert_eq!(3u8, next_level_attributes.ap_table.into());
+ assert!(next_level_attributes.xn_table);
+ assert!(next_level_attributes.pxn_table);
+ }
- descriptor.modify(|d| d + 1);
- assert_eq!(cell_new_value + 1, descriptor.get());
+ #[test]
+ fn test_descriptor_get_type() {
+ let descriptor = Descriptor {
+ cell: UnsafeCell::new(0),
+ };
+ assert_eq!(DescriptorType::Invalid, descriptor.get_descriptor_type(1));
+
+ let descriptor = Descriptor {
+ cell: UnsafeCell::new(1),
+ };
+ assert_eq!(DescriptorType::Block, descriptor.get_descriptor_type(1));
+
+ let descriptor = Descriptor {
+ cell: UnsafeCell::new(3),
+ };
+ assert_eq!(DescriptorType::Table, descriptor.get_descriptor_type(1));
+
+ let descriptor = Descriptor {
+ cell: UnsafeCell::new(0),
+ };
+ assert_eq!(DescriptorType::Invalid, descriptor.get_descriptor_type(3));
+
+ let descriptor = Descriptor {
+ cell: UnsafeCell::new(3),
+ };
+ assert_eq!(DescriptorType::Block, descriptor.get_descriptor_type(3));
+ }
+
+ #[test]
+ fn test_descriptor_is_valid() {
+ let descriptor = Descriptor {
+ cell: UnsafeCell::new(0),
+ };
+ assert!(!descriptor.is_valid());
+
+ let descriptor = Descriptor {
+ cell: UnsafeCell::new(1),
+ };
+ assert!(descriptor.is_valid());
+ }
+
+ #[test]
+ fn test_descriptor_set_block_to_block_again() {
+ let mut descriptor = Descriptor {
+ cell: UnsafeCell::new(1),
+ };
+
+ descriptor.set_block_descriptor(1, 0, Attributes::default());
+ assert_eq!(0x1, descriptor.get());
+ }
+
+ #[test]
+ #[should_panic]
+ fn test_descriptor_set_block_invalid_oa() {
+ let mut descriptor = Descriptor {
+ cell: UnsafeCell::new(0),
+ };
+
+ descriptor.set_block_descriptor(1, 1 << 63, Attributes::default());
+ }
+
+ #[test]
+ fn test_descriptor_block() {
+ let mut descriptor = Descriptor {
+ cell: UnsafeCell::new(0),
+ };
+
+ descriptor.set_block_descriptor(
+ 1,
+ 0x0000000f_c0000000,
+ Attributes {
+ uxn: true,
+ ..Default::default()
+ },
+ );
+ assert_eq!(0x0040000f_c0000001, descriptor.get());
+
+ let mut descriptor = Descriptor {
+ cell: UnsafeCell::new(0),
+ };
+
+ descriptor.set_block_descriptor(
+ 3,
+ 0x0000000f_fffff000,
+ Attributes {
+ uxn: true,
+ ..Default::default()
+ },
+ );
+ assert_eq!(0x0040000f_fffff003, descriptor.get());
+
+ assert_eq!(0x0000000f_fffff000, descriptor.get_block_output_address(3));
+ assert_eq!(
+ Attributes {
+ uxn: true,
+ ..Default::default()
+ },
+ descriptor.get_block_attributes(3)
+ );
+
+ descriptor.set_block_attributes(
+ 3,
+ Attributes {
+ pxn: true,
+ ..Default::default()
+ },
+ );
+ assert_eq!(
+ Attributes {
+ pxn: true,
+ ..Default::default()
+ },
+ descriptor.get_block_attributes(3)
+ );
+ }
+
+ #[test]
+ #[should_panic]
+ fn test_descriptor_invalid_block_to_invalid() {
+ let mut descriptor = Descriptor {
+ cell: UnsafeCell::new(0),
+ };
+
+ descriptor.set_block_descriptor_to_invalid(0);
+ }
+
+ #[test]
+ fn test_descriptor_block_to_invalid() {
+ let mut descriptor = Descriptor {
+ cell: UnsafeCell::new(3),
+ };
+
+ descriptor.set_block_descriptor_to_invalid(3);
+ assert_eq!(0, descriptor.get());
+ }
+
+ #[test]
+ #[should_panic]
+ fn test_descriptor_level3_to_table() {
+ let mut next_level_table = [Descriptor {
+ cell: UnsafeCell::new(0),
+ }];
+ let mut descriptor = Descriptor {
+ cell: UnsafeCell::new(0),
+ };
+
+ unsafe {
+ descriptor.set_table_descriptor(3, &mut next_level_table, None);
+ }
+ }
+
+ #[test]
+ fn test_descriptor_block_to_table() {
+ let next_level_table =
+ unsafe { core::slice::from_raw_parts_mut(0x1000 as *mut Descriptor, 512) };
+ let mut descriptor = Descriptor {
+ cell: UnsafeCell::new(1),
+ };
+
+ unsafe {
+ descriptor.set_table_descriptor(0, next_level_table, None);
+ }
+ assert_eq!(0x1003, descriptor.get());
+ }
+
+ #[test]
+ #[should_panic]
+ fn test_descriptor_table_invalid_count() {
+ let next_level_table =
+ unsafe { core::slice::from_raw_parts_mut(0x800 as *mut Descriptor, 511) };
+ let mut descriptor = Descriptor {
+ cell: UnsafeCell::new(0),
+ };
+
+ unsafe {
+ descriptor.set_table_descriptor(0, next_level_table, None);
+ }
+ }
+
+ #[test]
+ #[should_panic]
+ fn test_descriptor_table_non_aligned() {
+ let next_level_table =
+ unsafe { core::slice::from_raw_parts_mut(0x800 as *mut Descriptor, 512) };
+ let mut descriptor = Descriptor {
+ cell: UnsafeCell::new(0),
+ };
+
+ unsafe {
+ descriptor.set_table_descriptor(0, next_level_table, None);
+ }
+ }
+
+ #[test]
+ fn test_descriptor_table() {
+ let next_level_table = unsafe {
+ core::slice::from_raw_parts_mut(0x0000_000c_ba98_7000 as *mut Descriptor, 512)
+ };
+ let mut descriptor = Descriptor {
+ cell: UnsafeCell::new(0),
+ };
+
+ unsafe {
+ descriptor.set_table_descriptor(0, next_level_table, None);
+ }
+ assert_eq!(0x0000_000c_ba98_7003, descriptor.get());
+ }
+
+ #[test]
+ fn test_descriptor_table_next_level_attr() {
+ const NEXT_LEVEL_ADDR: u64 = 0x0000_000c_ba98_7000;
+ let next_level_table =
+ unsafe { core::slice::from_raw_parts_mut(NEXT_LEVEL_ADDR as *mut Descriptor, 512) };
+ let mut descriptor = Descriptor {
+ cell: UnsafeCell::new(0),
+ };
+
+ unsafe {
+ descriptor.set_table_descriptor(
+ 0,
+ next_level_table,
+ Some(NextLevelAttributes {
+ ns_table: true,
+ ..Default::default()
+ }),
+ );
+ }
+ assert_eq!(NEXT_LEVEL_ADDR | 0x8000_0000_0000_0003, descriptor.get());
+ }
+
+ #[test]
+ fn test_descriptor_table_get_next_level_table() {
+ const NEXT_LEVEL_ADDR: u64 = 0x0000_000c_ba98_7000;
+ let descriptor = Descriptor {
+ cell: UnsafeCell::new(NEXT_LEVEL_ADDR | 0x8000_0000_0000_0003),
+ };
+ assert_eq!(KernelSpace::pa_to_kernel(NEXT_LEVEL_ADDR), unsafe {
+ descriptor.get_next_level_table(0).as_ptr() as u64
+ });
+ }
+
+ #[test]
+ fn test_descriptor_table_get_next_level_table_mut() {
+ const NEXT_LEVEL_ADDR: u64 = 0x0000_000c_ba98_7000;
+ let mut descriptor = Descriptor {
+ cell: UnsafeCell::new(NEXT_LEVEL_ADDR | 0x8000_0000_0000_0003),
+ };
+ assert_eq!(KernelSpace::pa_to_kernel(NEXT_LEVEL_ADDR), unsafe {
+ descriptor.get_next_level_table_mut(0).as_ptr() as *mut Descriptor as u64
+ });
+ }
+
+ #[test]
+ fn test_descriptor_table_get_next_level_attr() {
+ const NEXT_LEVEL_ADDR: u64 = 0x0000_000c_ba98_7000;
+ let descriptor = Descriptor {
+ cell: UnsafeCell::new(NEXT_LEVEL_ADDR | 0x8000_0000_0000_0003),
+ };
+ assert_eq!(
+ NextLevelAttributes {
+ ns_table: true,
+ ..Default::default()
+ },
+ descriptor.get_next_level_attributes(0)
+ );
+ }
+
+ #[test]
+ fn test_descriptor_table_set_to_invalid() {
+ const NEXT_LEVEL_ADDR: u64 = 0x0000_000c_ba98_7000;
+ let mut descriptor = Descriptor {
+ cell: UnsafeCell::new(NEXT_LEVEL_ADDR | 0x8000_0000_0000_0003),
+ };
+ assert_eq!(KernelSpace::pa_to_kernel(NEXT_LEVEL_ADDR), unsafe {
+ descriptor.set_table_descriptor_to_invalid(0).as_ptr() as *mut Descriptor as u64
+ });
+ assert_eq!(0, descriptor.get());
+ }
+
+ #[test]
+ fn test_descriptor_raw_interface() {
+ let cell_value = 0x01234567_89abcdefu64;
+ let cell_new_value = 0x12345678_9abcdef0u64;
+
+ let mut descriptor = Descriptor {
+ cell: UnsafeCell::new(cell_value),
+ };
+
+ assert_eq!(cell_value, descriptor.get());
+
+ descriptor.set(cell_new_value);
+ assert_eq!(cell_new_value, descriptor.get());
+
+ descriptor.modify(|d| d + 1);
+ assert_eq!(cell_new_value + 1, descriptor.get());
+ }
}
diff --git a/src/lib.rs b/src/lib.rs
index ecaa6b5..7fc5839 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -730,25 +730,30 @@
}
}
-#[test]
-fn test_split_to_pages() {
- let pages = Xlat::split_region_to_blocks(0x3fff_c000, 0x3fff_c000, 0x4020_5000).unwrap();
- assert_eq!(Block::new(0x3fff_c000, 0x3fff_c000, 0x1000), pages[0]);
- assert_eq!(Block::new(0x3fff_d000, 0x3fff_d000, 0x1000), pages[1]);
- assert_eq!(Block::new(0x3fff_e000, 0x3fff_e000, 0x1000), pages[2]);
- assert_eq!(Block::new(0x3fff_f000, 0x3fff_f000, 0x1000), pages[3]);
- assert_eq!(Block::new(0x4000_0000, 0x4000_0000, 0x4000_0000), pages[4]);
- assert_eq!(Block::new(0x8000_0000, 0x8000_0000, 0x0020_0000), pages[5]);
- assert_eq!(Block::new(0x8020_0000, 0x8020_0000, 0x1000), pages[6]);
-}
+#[cfg(test)]
+mod tests {
+ use super::*;
-#[test]
-fn test_split_to_pages_unaligned() {
- let pages = Xlat::split_region_to_blocks(0x3fff_c000, 0x3f20_0000, 0x200000).unwrap();
- for (i, block) in pages.iter().enumerate().take(512) {
- assert_eq!(
- Block::new(0x3fff_c000 + (i << 12), 0x3f20_0000 + (i << 12), 0x1000),
- *block
- );
+ #[test]
+ fn test_split_to_pages() {
+ let pages = Xlat::split_region_to_blocks(0x3fff_c000, 0x3fff_c000, 0x4020_5000).unwrap();
+ assert_eq!(Block::new(0x3fff_c000, 0x3fff_c000, 0x1000), pages[0]);
+ assert_eq!(Block::new(0x3fff_d000, 0x3fff_d000, 0x1000), pages[1]);
+ assert_eq!(Block::new(0x3fff_e000, 0x3fff_e000, 0x1000), pages[2]);
+ assert_eq!(Block::new(0x3fff_f000, 0x3fff_f000, 0x1000), pages[3]);
+ assert_eq!(Block::new(0x4000_0000, 0x4000_0000, 0x4000_0000), pages[4]);
+ assert_eq!(Block::new(0x8000_0000, 0x8000_0000, 0x0020_0000), pages[5]);
+ assert_eq!(Block::new(0x8020_0000, 0x8020_0000, 0x1000), pages[6]);
+ }
+
+ #[test]
+ fn test_split_to_pages_unaligned() {
+ let pages = Xlat::split_region_to_blocks(0x3fff_c000, 0x3f20_0000, 0x200000).unwrap();
+ for (i, block) in pages.iter().enumerate().take(512) {
+ assert_eq!(
+ Block::new(0x3fff_c000 + (i << 12), 0x3f20_0000 + (i << 12), 0x1000),
+ *block
+ );
+ }
}
}
diff --git a/src/page_pool.rs b/src/page_pool.rs
index 66f22c7..cc50b30 100644
--- a/src/page_pool.rs
+++ b/src/page_pool.rs
@@ -196,45 +196,50 @@
}
}
-#[test]
-fn test_pages() {
- let area = [0x5au8; 4096];
- let mut pages = Pages::new(area.as_ptr() as usize, area.len(), true);
+#[cfg(test)]
+mod tests {
+ use super::*;
- assert_eq!(area.as_ptr() as usize, pages.pa);
- assert_eq!(area.len(), pages.length);
- assert!(pages.used);
- assert_eq!(area.as_ptr() as usize, pages.get_pa());
- assert_eq!(area.as_ptr() as usize, pages.base());
- assert_eq!(area.len(), pages.length());
- assert!(pages.used());
+ #[test]
+ fn test_pages() {
+ let area = [0x5au8; 4096];
+ let mut pages = Pages::new(area.as_ptr() as usize, area.len(), true);
- pages.copy_data_to_page(&[0, 1, 2, 3, 4, 5, 6, 7]);
- assert_eq!([0, 1, 2, 3, 4, 5, 6, 7], area[0..8]);
+ assert_eq!(area.as_ptr() as usize, pages.pa);
+ assert_eq!(area.len(), pages.length);
+ assert!(pages.used);
+ assert_eq!(area.as_ptr() as usize, pages.get_pa());
+ assert_eq!(area.as_ptr() as usize, pages.base());
+ assert_eq!(area.len(), pages.length());
+ assert!(pages.used());
- pages.zero_init();
- assert_eq!([0, 0, 0, 0, 0, 0, 0, 0], area[0..8]);
+ pages.copy_data_to_page(&[0, 1, 2, 3, 4, 5, 6, 7]);
+ assert_eq!([0, 1, 2, 3, 4, 5, 6, 7], area[0..8]);
- let s = unsafe { pages.get_as_slice() };
- for (i, e) in s.iter_mut().enumerate().take(8) {
- *e = i as u8;
+ pages.zero_init();
+ assert_eq!([0, 0, 0, 0, 0, 0, 0, 0], area[0..8]);
+
+ let s = unsafe { pages.get_as_slice() };
+ for (i, e) in s.iter_mut().enumerate().take(8) {
+ *e = i as u8;
+ }
+ assert_eq!([0, 1, 2, 3, 4, 5, 6, 7], area[0..8]);
+
+ let from_slice = unsafe { Pages::from_slice(s) };
+ assert_eq!(area.as_ptr() as usize, from_slice.pa);
+ assert_eq!(area.len(), from_slice.length);
+ assert!(from_slice.used);
}
- assert_eq!([0, 1, 2, 3, 4, 5, 6, 7], area[0..8]);
- let from_slice = unsafe { Pages::from_slice(s) };
- assert_eq!(area.as_ptr() as usize, from_slice.pa);
- assert_eq!(area.len(), from_slice.length);
- assert!(from_slice.used);
-}
+ #[test]
+ fn test_pages_contains() {
+ let pages = Pages::new(0x4000_0000, 0x4000, true);
-#[test]
-fn test_pages_contains() {
- let pages = Pages::new(0x4000_0000, 0x4000, true);
+ assert!(!pages.contains(0x3fff_f000, 0x1000));
+ assert!(!pages.contains(0x3fff_f000, 0x1_0000));
+ assert!(!pages.contains(0x4000_4000, 0x1000));
+ assert!(!pages.contains(0x4000_0000, 0x1_0000));
- assert!(!pages.contains(0x3fff_f000, 0x1000));
- assert!(!pages.contains(0x3fff_f000, 0x1_0000));
- assert!(!pages.contains(0x4000_4000, 0x1000));
- assert!(!pages.contains(0x4000_0000, 0x1_0000));
-
- // Overflow tests
+ // Overflow tests
+ }
}
diff --git a/src/region.rs b/src/region.rs
index fb13db9..f5e6ab8 100644
--- a/src/region.rs
+++ b/src/region.rs
@@ -244,389 +244,396 @@
}
#[cfg(test)]
-use super::page_pool::PagePoolArea;
+mod tests {
+ use super::super::page_pool::PagePoolArea;
+ use super::*;
-#[test]
-#[should_panic]
-fn test_physical_region_unused() {
- let region = PhysicalRegion::Unused;
- region.get_pa();
-}
+ #[test]
+ #[should_panic]
+ fn test_physical_region_unused() {
+ let region = PhysicalRegion::Unused;
+ region.get_pa();
+ }
-#[test]
-fn test_physical_region() {
- const PA: usize = 0x0123_4567_89ab_cdef;
- const LENGTH: usize = 0x8000_0000_0000;
+ #[test]
+ fn test_physical_region() {
+ const PA: usize = 0x0123_4567_89ab_cdef;
+ const LENGTH: usize = 0x8000_0000_0000;
- static PAGE_POOL_AREA: PagePoolArea<16> = PagePoolArea::new();
- let region =
- PhysicalRegion::Allocated(PagePool::new(&PAGE_POOL_AREA), Pages::new(PA, LENGTH, true));
- assert_eq!(PA, region.get_pa());
+ static PAGE_POOL_AREA: PagePoolArea<16> = PagePoolArea::new();
+ let region =
+ PhysicalRegion::Allocated(PagePool::new(&PAGE_POOL_AREA), Pages::new(PA, LENGTH, true));
+ assert_eq!(PA, region.get_pa());
- let region = PhysicalRegion::PhysicalAddress(PA);
- assert_eq!(PA, region.get_pa());
-}
+ let region = PhysicalRegion::PhysicalAddress(PA);
+ assert_eq!(PA, region.get_pa());
+ }
-#[test]
-fn test_virtual_region() {
- const VA: usize = 0x0123_4567_89ab_cdef;
- const PA: usize = 0xfedc_ba98_7654_3210;
- const LENGTH: usize = 0x8000_0000_0000;
+ #[test]
+ fn test_virtual_region() {
+ const VA: usize = 0x0123_4567_89ab_cdef;
+ const PA: usize = 0xfedc_ba98_7654_3210;
+ const LENGTH: usize = 0x8000_0000_0000;
- let region = VirtualRegion::new(VA, LENGTH);
- assert_eq!(VA, region.va);
- assert_eq!(VA, region.base());
- assert_eq!(LENGTH, region.length);
- assert_eq!(LENGTH, region.length());
- assert!(matches!(region.physical_region, PhysicalRegion::Unused));
- assert!(!region.used());
+ let region = VirtualRegion::new(VA, LENGTH);
+ assert_eq!(VA, region.va);
+ assert_eq!(VA, region.base());
+ assert_eq!(LENGTH, region.length);
+ assert_eq!(LENGTH, region.length());
+ assert!(matches!(region.physical_region, PhysicalRegion::Unused));
+ assert!(!region.used());
- let region = VirtualRegion::new_with_pa(PA, VA, LENGTH);
- assert_eq!(VA, region.va);
- assert_eq!(VA, region.base());
- assert_eq!(LENGTH, region.length);
- assert_eq!(LENGTH, region.length());
- assert!(matches!(
- region.physical_region,
- PhysicalRegion::PhysicalAddress(_)
- ));
- assert_eq!(PA, region.get_pa());
- assert!(region.used());
-}
+ let region = VirtualRegion::new_with_pa(PA, VA, LENGTH);
+ assert_eq!(VA, region.va);
+ assert_eq!(VA, region.base());
+ assert_eq!(LENGTH, region.length);
+ assert_eq!(LENGTH, region.length());
+ assert!(matches!(
+ region.physical_region,
+ PhysicalRegion::PhysicalAddress(_)
+ ));
+ assert_eq!(PA, region.get_pa());
+ assert!(region.used());
+ }
-#[test]
-fn test_virtual_region_get_pa_for_va() {
- let region = VirtualRegion::new_with_pa(0x8000_0000_0000_0000, 0x4000_0000_0000_0000, 0x1000);
- assert_eq!(
- 0x8000_0000_0000_0000,
- region.get_pa_for_va(0x4000_0000_0000_0000)
- );
- assert_eq!(
- 0x8000_0000_0000_0001,
- region.get_pa_for_va(0x4000_0000_0000_0001)
- );
- assert_eq!(
- 0x8000_0000_0000_0fff,
- region.get_pa_for_va(0x4000_0000_0000_0fff)
- );
-}
+ #[test]
+ fn test_virtual_region_get_pa_for_va() {
+ let region =
+ VirtualRegion::new_with_pa(0x8000_0000_0000_0000, 0x4000_0000_0000_0000, 0x1000);
+ assert_eq!(
+ 0x8000_0000_0000_0000,
+ region.get_pa_for_va(0x4000_0000_0000_0000)
+ );
+ assert_eq!(
+ 0x8000_0000_0000_0001,
+ region.get_pa_for_va(0x4000_0000_0000_0001)
+ );
+ assert_eq!(
+ 0x8000_0000_0000_0fff,
+ region.get_pa_for_va(0x4000_0000_0000_0fff)
+ );
+ }
-#[test]
-#[should_panic]
-fn test_virtual_region_get_pa_for_va_low_va() {
- let region = VirtualRegion::new_with_pa(0x8000_0000_0000_0000, 0x4000_0000_0000_0000, 0x1000);
- region.get_pa_for_va(0x3fff_ffff_ffff_ffff);
-}
+ #[test]
+ #[should_panic]
+ fn test_virtual_region_get_pa_for_va_low_va() {
+ let region =
+ VirtualRegion::new_with_pa(0x8000_0000_0000_0000, 0x4000_0000_0000_0000, 0x1000);
+ region.get_pa_for_va(0x3fff_ffff_ffff_ffff);
+ }
-#[test]
-#[should_panic]
-fn test_virtual_region_get_pa_for_va_high_va() {
- let region = VirtualRegion::new_with_pa(0x8000_0000_0000_0000, 0x4000_0000_0000_0000, 0x1000);
- region.get_pa_for_va(0x4000_0000_0000_1000);
-}
+ #[test]
+ #[should_panic]
+ fn test_virtual_region_get_pa_for_va_high_va() {
+ let region =
+ VirtualRegion::new_with_pa(0x8000_0000_0000_0000, 0x4000_0000_0000_0000, 0x1000);
+ region.get_pa_for_va(0x4000_0000_0000_1000);
+ }
-#[test]
-fn test_virtual_region_contains() {
- const VA: usize = 0x8000_0000_0000_0000;
- const LENGTH: usize = 0x8000_0000_0000;
+ #[test]
+ fn test_virtual_region_contains() {
+ const VA: usize = 0x8000_0000_0000_0000;
+ const LENGTH: usize = 0x8000_0000_0000;
- let region_overflow_end = VirtualRegion::new(0x8000_0000_0000_0000, 0x8000_0000_0000_0000);
- assert!(!region_overflow_end.contains(0x8000_0000_0000_0000, 1));
+ let region_overflow_end = VirtualRegion::new(0x8000_0000_0000_0000, 0x8000_0000_0000_0000);
+ assert!(!region_overflow_end.contains(0x8000_0000_0000_0000, 1));
- let region = VirtualRegion::new(0x4000_0000_0000_0000, 0x8000_0000_0000_0000);
- assert!(!region.contains(0x8000_0000_0000_0000, 0x8000_0000_0000_0000));
+ let region = VirtualRegion::new(0x4000_0000_0000_0000, 0x8000_0000_0000_0000);
+ assert!(!region.contains(0x8000_0000_0000_0000, 0x8000_0000_0000_0000));
- assert!(!region.contains(0x4000_0000_0000_0000, 0x8000_0000_0000_0001));
- assert!(!region.contains(0x3fff_ffff_ffff_ffff, 0x8000_0000_0000_0000));
- assert!(region.contains(0x4000_0000_0000_0000, 0x8000_0000_0000_0000));
- assert!(region.contains(0x4000_0000_0000_0000, 0x7fff_ffff_ffff_ffff));
- assert!(region.contains(0x4000_0000_0000_0001, 0x7fff_ffff_ffff_ffff));
-}
+ assert!(!region.contains(0x4000_0000_0000_0000, 0x8000_0000_0000_0001));
+ assert!(!region.contains(0x3fff_ffff_ffff_ffff, 0x8000_0000_0000_0000));
+ assert!(region.contains(0x4000_0000_0000_0000, 0x8000_0000_0000_0000));
+ assert!(region.contains(0x4000_0000_0000_0000, 0x7fff_ffff_ffff_ffff));
+ assert!(region.contains(0x4000_0000_0000_0001, 0x7fff_ffff_ffff_ffff));
+ }
-#[test]
-fn test_virtual_region_try_append() {
- // Both unused
- let mut region_unused0 = VirtualRegion::new(0x4000_0000, 0x1000);
- let mut region_unused1 = VirtualRegion::new(0x4000_1000, 0x1000);
+ #[test]
+ fn test_virtual_region_try_append() {
+ // Both unused
+ let mut region_unused0 = VirtualRegion::new(0x4000_0000, 0x1000);
+ let mut region_unused1 = VirtualRegion::new(0x4000_1000, 0x1000);
- assert!(!region_unused1.try_append(®ion_unused0));
- assert_eq!(0x4000_0000, region_unused0.va);
- assert_eq!(0x1000, region_unused0.length);
- assert_eq!(0x4000_1000, region_unused1.va);
- assert_eq!(0x1000, region_unused1.length);
+ assert!(!region_unused1.try_append(®ion_unused0));
+ assert_eq!(0x4000_0000, region_unused0.va);
+ assert_eq!(0x1000, region_unused0.length);
+ assert_eq!(0x4000_1000, region_unused1.va);
+ assert_eq!(0x1000, region_unused1.length);
- assert!(region_unused0.try_append(®ion_unused1));
- assert_eq!(0x4000_0000, region_unused0.va);
- assert_eq!(0x2000, region_unused0.length);
- assert_eq!(0x4000_1000, region_unused1.va);
- assert_eq!(0x1000, region_unused1.length);
+ assert!(region_unused0.try_append(®ion_unused1));
+ assert_eq!(0x4000_0000, region_unused0.va);
+ assert_eq!(0x2000, region_unused0.length);
+ assert_eq!(0x4000_1000, region_unused1.va);
+ assert_eq!(0x1000, region_unused1.length);
- // Unused and PA region
- let mut region_unused = VirtualRegion::new(0x4000_0000, 0x1000);
- let region_physical = VirtualRegion::new_with_pa(0x8000_0000, 0x4000_1000, 0x1000);
- assert!(!region_unused.try_append(®ion_physical));
- assert_eq!(0x4000_0000, region_unused.va);
- assert_eq!(0x1000, region_unused.length);
- assert_eq!(0x4000_1000, region_physical.va);
- assert_eq!(0x1000, region_physical.length);
+ // Unused and PA region
+ let mut region_unused = VirtualRegion::new(0x4000_0000, 0x1000);
+ let region_physical = VirtualRegion::new_with_pa(0x8000_0000, 0x4000_1000, 0x1000);
+ assert!(!region_unused.try_append(®ion_physical));
+ assert_eq!(0x4000_0000, region_unused.va);
+ assert_eq!(0x1000, region_unused.length);
+ assert_eq!(0x4000_1000, region_physical.va);
+ assert_eq!(0x1000, region_physical.length);
- // Both PA regions but non-consecutive PA ranges
- let mut region_physical0 = VirtualRegion::new_with_pa(0x8000_0000, 0x4000_0000, 0x1000);
- let region_physical1 = VirtualRegion::new_with_pa(0x9000_0000, 0x4000_1000, 0x1000);
- assert!(!region_physical0.try_append(®ion_physical1));
- assert_eq!(0x4000_0000, region_physical0.va);
- assert_eq!(0x1000, region_physical0.length);
- assert_eq!(0x4000_1000, region_physical1.va);
- assert_eq!(0x1000, region_physical1.length);
+ // Both PA regions but non-consecutive PA ranges
+ let mut region_physical0 = VirtualRegion::new_with_pa(0x8000_0000, 0x4000_0000, 0x1000);
+ let region_physical1 = VirtualRegion::new_with_pa(0x9000_0000, 0x4000_1000, 0x1000);
+ assert!(!region_physical0.try_append(®ion_physical1));
+ assert_eq!(0x4000_0000, region_physical0.va);
+ assert_eq!(0x1000, region_physical0.length);
+ assert_eq!(0x4000_1000, region_physical1.va);
+ assert_eq!(0x1000, region_physical1.length);
- // Both PA regions with consecutive PA ranges
- let mut region_physical0 = VirtualRegion::new_with_pa(0x8000_0000, 0x4000_0000, 0x1000);
- let region_physical1 = VirtualRegion::new_with_pa(0x8000_1000, 0x4000_1000, 0x1000);
- assert!(region_physical0.try_append(®ion_physical1));
- assert_eq!(0x4000_0000, region_physical0.va);
- assert_eq!(0x2000, region_physical0.length);
- assert_eq!(0x4000_1000, region_physical1.va);
- assert_eq!(0x1000, region_physical1.length);
+ // Both PA regions with consecutive PA ranges
+ let mut region_physical0 = VirtualRegion::new_with_pa(0x8000_0000, 0x4000_0000, 0x1000);
+ let region_physical1 = VirtualRegion::new_with_pa(0x8000_1000, 0x4000_1000, 0x1000);
+ assert!(region_physical0.try_append(®ion_physical1));
+ assert_eq!(0x4000_0000, region_physical0.va);
+ assert_eq!(0x2000, region_physical0.length);
+ assert_eq!(0x4000_1000, region_physical1.va);
+ assert_eq!(0x1000, region_physical1.length);
- // VA overflow
- let mut region_unused0 = VirtualRegion::new(0x8000_0000_0000_0000, 0x8000_0000_0000_0000);
- let mut region_unused1 = VirtualRegion::new(0x4000_1000, 0x1000);
+ // VA overflow
+ let mut region_unused0 = VirtualRegion::new(0x8000_0000_0000_0000, 0x8000_0000_0000_0000);
+ let mut region_unused1 = VirtualRegion::new(0x4000_1000, 0x1000);
- assert!(!region_unused0.try_append(®ion_unused1));
- assert_eq!(0x8000_0000_0000_0000, region_unused0.va);
- assert_eq!(0x8000_0000_0000_0000, region_unused0.length);
- assert_eq!(0x4000_1000, region_unused1.va);
- assert_eq!(0x1000, region_unused1.length);
+ assert!(!region_unused0.try_append(®ion_unused1));
+ assert_eq!(0x8000_0000_0000_0000, region_unused0.va);
+ assert_eq!(0x8000_0000_0000_0000, region_unused0.length);
+ assert_eq!(0x4000_1000, region_unused1.va);
+ assert_eq!(0x1000, region_unused1.length);
- assert!(!region_unused1.try_append(®ion_unused0));
- assert_eq!(0x8000_0000_0000_0000, region_unused0.va);
- assert_eq!(0x8000_0000_0000_0000, region_unused0.length);
- assert_eq!(0x4000_1000, region_unused1.va);
- assert_eq!(0x1000, region_unused1.length);
+ assert!(!region_unused1.try_append(®ion_unused0));
+ assert_eq!(0x8000_0000_0000_0000, region_unused0.va);
+ assert_eq!(0x8000_0000_0000_0000, region_unused0.length);
+ assert_eq!(0x4000_1000, region_unused1.va);
+ assert_eq!(0x1000, region_unused1.length);
- // PA overflow
- let mut region_physical0 =
- VirtualRegion::new_with_pa(0x8000_0000_0000_0000, 0x4000_0000, 0x8000_0000_0000_0000);
- let region_physical1 = VirtualRegion::new_with_pa(0x9000_0000, 0x8000_0000_4000_0000, 0x1000);
- assert!(!region_physical0.try_append(®ion_physical1));
- assert_eq!(0x4000_0000, region_physical0.va);
- assert_eq!(0x8000_0000_0000_0000, region_physical0.length);
- assert_eq!(0x8000_0000_4000_0000, region_physical1.va);
- assert_eq!(0x1000, region_physical1.length);
-}
+ // PA overflow
+ let mut region_physical0 =
+ VirtualRegion::new_with_pa(0x8000_0000_0000_0000, 0x4000_0000, 0x8000_0000_0000_0000);
+ let region_physical1 =
+ VirtualRegion::new_with_pa(0x9000_0000, 0x8000_0000_4000_0000, 0x1000);
+ assert!(!region_physical0.try_append(®ion_physical1));
+ assert_eq!(0x4000_0000, region_physical0.va);
+ assert_eq!(0x8000_0000_0000_0000, region_physical0.length);
+ assert_eq!(0x8000_0000_4000_0000, region_physical1.va);
+ assert_eq!(0x1000, region_physical1.length);
+ }
-#[test]
-fn test_virtual_region_create_split_by_used() {
- let region_unused = VirtualRegion::new(0x4000_0000, 0x4000);
+ #[test]
+ fn test_virtual_region_create_split_by_used() {
+ let region_unused = VirtualRegion::new(0x4000_0000, 0x4000);
- // New region at the start
- let (new_region, splitted_regions) = region_unused.create_split(
- 0x4000_0000,
- 0x1000,
- Some(PhysicalRegion::PhysicalAddress(0x8000_0000)),
- );
+ // New region at the start
+ let (new_region, splitted_regions) = region_unused.create_split(
+ 0x4000_0000,
+ 0x1000,
+ Some(PhysicalRegion::PhysicalAddress(0x8000_0000)),
+ );
- assert_eq!(0x4000_0000, new_region.va);
- assert_eq!(0x1000, new_region.length);
- assert_eq!(0x8000_0000, new_region.get_pa());
- assert!(matches!(
- new_region.physical_region,
- PhysicalRegion::PhysicalAddress(_)
- ));
+ assert_eq!(0x4000_0000, new_region.va);
+ assert_eq!(0x1000, new_region.length);
+ assert_eq!(0x8000_0000, new_region.get_pa());
+ assert!(matches!(
+ new_region.physical_region,
+ PhysicalRegion::PhysicalAddress(_)
+ ));
- assert_eq!(0x4000_0000, splitted_regions[0].va);
- assert_eq!(0x1000, splitted_regions[0].length);
- assert_eq!(0x8000_0000, splitted_regions[0].get_pa());
- assert!(matches!(
- splitted_regions[0].physical_region,
- PhysicalRegion::PhysicalAddress(_)
- ));
+ assert_eq!(0x4000_0000, splitted_regions[0].va);
+ assert_eq!(0x1000, splitted_regions[0].length);
+ assert_eq!(0x8000_0000, splitted_regions[0].get_pa());
+ assert!(matches!(
+ splitted_regions[0].physical_region,
+ PhysicalRegion::PhysicalAddress(_)
+ ));
- assert_eq!(0x4000_1000, splitted_regions[1].va);
- assert_eq!(0x3000, splitted_regions[1].length);
- assert!(matches!(
- splitted_regions[1].physical_region,
- PhysicalRegion::Unused
- ));
+ assert_eq!(0x4000_1000, splitted_regions[1].va);
+ assert_eq!(0x3000, splitted_regions[1].length);
+ assert!(matches!(
+ splitted_regions[1].physical_region,
+ PhysicalRegion::Unused
+ ));
- // New region in the middle
- let (new_region, splitted_regions) = region_unused.create_split(
- 0x4000_1000,
- 0x1000,
- Some(PhysicalRegion::PhysicalAddress(0x8000_0000)),
- );
+ // New region in the middle
+ let (new_region, splitted_regions) = region_unused.create_split(
+ 0x4000_1000,
+ 0x1000,
+ Some(PhysicalRegion::PhysicalAddress(0x8000_0000)),
+ );
- assert_eq!(0x4000_1000, new_region.va);
- assert_eq!(0x1000, new_region.length);
- assert_eq!(0x8000_0000, new_region.get_pa());
- assert!(matches!(
- new_region.physical_region,
- PhysicalRegion::PhysicalAddress(_)
- ));
+ assert_eq!(0x4000_1000, new_region.va);
+ assert_eq!(0x1000, new_region.length);
+ assert_eq!(0x8000_0000, new_region.get_pa());
+ assert!(matches!(
+ new_region.physical_region,
+ PhysicalRegion::PhysicalAddress(_)
+ ));
- assert_eq!(0x4000_0000, splitted_regions[0].va);
- assert_eq!(0x1000, splitted_regions[0].length);
- assert!(matches!(
- splitted_regions[0].physical_region,
- PhysicalRegion::Unused
- ));
+ assert_eq!(0x4000_0000, splitted_regions[0].va);
+ assert_eq!(0x1000, splitted_regions[0].length);
+ assert!(matches!(
+ splitted_regions[0].physical_region,
+ PhysicalRegion::Unused
+ ));
- assert_eq!(0x4000_1000, splitted_regions[1].va);
- assert_eq!(0x1000, splitted_regions[1].length);
- assert_eq!(0x8000_0000, splitted_regions[1].get_pa());
- assert!(matches!(
- splitted_regions[1].physical_region,
- PhysicalRegion::PhysicalAddress(_)
- ));
+ assert_eq!(0x4000_1000, splitted_regions[1].va);
+ assert_eq!(0x1000, splitted_regions[1].length);
+ assert_eq!(0x8000_0000, splitted_regions[1].get_pa());
+ assert!(matches!(
+ splitted_regions[1].physical_region,
+ PhysicalRegion::PhysicalAddress(_)
+ ));
- assert_eq!(0x4000_2000, splitted_regions[2].va);
- assert_eq!(0x2000, splitted_regions[2].length);
- assert!(matches!(
- splitted_regions[2].physical_region,
- PhysicalRegion::Unused
- ));
+ assert_eq!(0x4000_2000, splitted_regions[2].va);
+ assert_eq!(0x2000, splitted_regions[2].length);
+ assert!(matches!(
+ splitted_regions[2].physical_region,
+ PhysicalRegion::Unused
+ ));
- // New region at the end
- let (new_region, splitted_regions) = region_unused.create_split(
- 0x4000_3000,
- 0x1000,
- Some(PhysicalRegion::PhysicalAddress(0x8000_0000)),
- );
+ // New region at the end
+ let (new_region, splitted_regions) = region_unused.create_split(
+ 0x4000_3000,
+ 0x1000,
+ Some(PhysicalRegion::PhysicalAddress(0x8000_0000)),
+ );
- assert_eq!(0x4000_3000, new_region.va);
- assert_eq!(0x1000, new_region.length);
- assert_eq!(0x8000_0000, new_region.get_pa());
- assert!(matches!(
- new_region.physical_region,
- PhysicalRegion::PhysicalAddress(_)
- ));
+ assert_eq!(0x4000_3000, new_region.va);
+ assert_eq!(0x1000, new_region.length);
+ assert_eq!(0x8000_0000, new_region.get_pa());
+ assert!(matches!(
+ new_region.physical_region,
+ PhysicalRegion::PhysicalAddress(_)
+ ));
- assert_eq!(0x4000_0000, splitted_regions[0].va);
- assert_eq!(0x3000, splitted_regions[0].length);
- assert!(matches!(
- splitted_regions[0].physical_region,
- PhysicalRegion::Unused
- ));
+ assert_eq!(0x4000_0000, splitted_regions[0].va);
+ assert_eq!(0x3000, splitted_regions[0].length);
+ assert!(matches!(
+ splitted_regions[0].physical_region,
+ PhysicalRegion::Unused
+ ));
- assert_eq!(0x4000_3000, splitted_regions[1].va);
- assert_eq!(0x1000, splitted_regions[1].length);
- assert_eq!(0x8000_0000, splitted_regions[1].get_pa());
- assert!(matches!(
- splitted_regions[1].physical_region,
- PhysicalRegion::PhysicalAddress(_)
- ));
-}
+ assert_eq!(0x4000_3000, splitted_regions[1].va);
+ assert_eq!(0x1000, splitted_regions[1].length);
+ assert_eq!(0x8000_0000, splitted_regions[1].get_pa());
+ assert!(matches!(
+ splitted_regions[1].physical_region,
+ PhysicalRegion::PhysicalAddress(_)
+ ));
+ }
-#[test]
-fn test_virtual_region_create_split_by_unused() {
- let region_unused = VirtualRegion::new_with_pa(0x8000_0000, 0x4000_0000, 0x4000);
+ #[test]
+ fn test_virtual_region_create_split_by_unused() {
+ let region_unused = VirtualRegion::new_with_pa(0x8000_0000, 0x4000_0000, 0x4000);
- // New region at the start
- let (new_region, splitted_regions) = region_unused.create_split(0x4000_0000, 0x1000, None);
+ // New region at the start
+ let (new_region, splitted_regions) = region_unused.create_split(0x4000_0000, 0x1000, None);
- assert_eq!(0x4000_0000, new_region.va);
- assert_eq!(0x1000, new_region.length);
- assert!(matches!(new_region.physical_region, PhysicalRegion::Unused));
+ assert_eq!(0x4000_0000, new_region.va);
+ assert_eq!(0x1000, new_region.length);
+ assert!(matches!(new_region.physical_region, PhysicalRegion::Unused));
- assert_eq!(0x4000_0000, splitted_regions[0].va);
- assert_eq!(0x1000, splitted_regions[0].length);
- assert!(matches!(
- splitted_regions[0].physical_region,
- PhysicalRegion::Unused
- ));
+ assert_eq!(0x4000_0000, splitted_regions[0].va);
+ assert_eq!(0x1000, splitted_regions[0].length);
+ assert!(matches!(
+ splitted_regions[0].physical_region,
+ PhysicalRegion::Unused
+ ));
- assert_eq!(0x4000_1000, splitted_regions[1].va);
- assert_eq!(0x3000, splitted_regions[1].length);
- assert_eq!(0x8000_1000, splitted_regions[1].get_pa());
- assert!(matches!(
- splitted_regions[1].physical_region,
- PhysicalRegion::PhysicalAddress(_)
- ));
+ assert_eq!(0x4000_1000, splitted_regions[1].va);
+ assert_eq!(0x3000, splitted_regions[1].length);
+ assert_eq!(0x8000_1000, splitted_regions[1].get_pa());
+ assert!(matches!(
+ splitted_regions[1].physical_region,
+ PhysicalRegion::PhysicalAddress(_)
+ ));
- // New region in the middle
- let (new_region, splitted_regions) = region_unused.create_split(0x4000_1000, 0x1000, None);
+ // New region in the middle
+ let (new_region, splitted_regions) = region_unused.create_split(0x4000_1000, 0x1000, None);
- assert_eq!(0x4000_1000, new_region.va);
- assert_eq!(0x1000, new_region.length);
- assert!(matches!(new_region.physical_region, PhysicalRegion::Unused));
+ assert_eq!(0x4000_1000, new_region.va);
+ assert_eq!(0x1000, new_region.length);
+ assert!(matches!(new_region.physical_region, PhysicalRegion::Unused));
- assert_eq!(0x4000_0000, splitted_regions[0].va);
- assert_eq!(0x1000, splitted_regions[0].length);
- assert_eq!(0x8000_0000, splitted_regions[0].get_pa());
- assert!(matches!(
- splitted_regions[0].physical_region,
- PhysicalRegion::PhysicalAddress(_)
- ));
+ assert_eq!(0x4000_0000, splitted_regions[0].va);
+ assert_eq!(0x1000, splitted_regions[0].length);
+ assert_eq!(0x8000_0000, splitted_regions[0].get_pa());
+ assert!(matches!(
+ splitted_regions[0].physical_region,
+ PhysicalRegion::PhysicalAddress(_)
+ ));
- assert_eq!(0x4000_1000, splitted_regions[1].va);
- assert_eq!(0x1000, splitted_regions[1].length);
- assert!(matches!(
- splitted_regions[1].physical_region,
- PhysicalRegion::Unused
- ));
+ assert_eq!(0x4000_1000, splitted_regions[1].va);
+ assert_eq!(0x1000, splitted_regions[1].length);
+ assert!(matches!(
+ splitted_regions[1].physical_region,
+ PhysicalRegion::Unused
+ ));
- assert_eq!(0x4000_2000, splitted_regions[2].va);
- assert_eq!(0x2000, splitted_regions[2].length);
- assert_eq!(0x8000_2000, splitted_regions[2].get_pa());
- assert!(matches!(
- splitted_regions[2].physical_region,
- PhysicalRegion::PhysicalAddress(_)
- ));
+ assert_eq!(0x4000_2000, splitted_regions[2].va);
+ assert_eq!(0x2000, splitted_regions[2].length);
+ assert_eq!(0x8000_2000, splitted_regions[2].get_pa());
+ assert!(matches!(
+ splitted_regions[2].physical_region,
+ PhysicalRegion::PhysicalAddress(_)
+ ));
- // New region at the end
- let (new_region, splitted_regions) = region_unused.create_split(0x4000_3000, 0x1000, None);
+ // New region at the end
+ let (new_region, splitted_regions) = region_unused.create_split(0x4000_3000, 0x1000, None);
- assert_eq!(0x4000_3000, new_region.va);
- assert_eq!(0x1000, new_region.length);
- assert!(matches!(new_region.physical_region, PhysicalRegion::Unused));
+ assert_eq!(0x4000_3000, new_region.va);
+ assert_eq!(0x1000, new_region.length);
+ assert!(matches!(new_region.physical_region, PhysicalRegion::Unused));
- assert_eq!(0x4000_0000, splitted_regions[0].va);
- assert_eq!(0x3000, splitted_regions[0].length);
- assert_eq!(0x8000_0000, splitted_regions[0].get_pa());
- assert!(matches!(
- splitted_regions[0].physical_region,
- PhysicalRegion::PhysicalAddress(_)
- ));
+ assert_eq!(0x4000_0000, splitted_regions[0].va);
+ assert_eq!(0x3000, splitted_regions[0].length);
+ assert_eq!(0x8000_0000, splitted_regions[0].get_pa());
+ assert!(matches!(
+ splitted_regions[0].physical_region,
+ PhysicalRegion::PhysicalAddress(_)
+ ));
- assert_eq!(0x4000_3000, splitted_regions[1].va);
- assert_eq!(0x1000, splitted_regions[1].length);
+ assert_eq!(0x4000_3000, splitted_regions[1].va);
+ assert_eq!(0x1000, splitted_regions[1].length);
- assert!(matches!(
- splitted_regions[1].physical_region,
- PhysicalRegion::Unused
- ));
-}
+ assert!(matches!(
+ splitted_regions[1].physical_region,
+ PhysicalRegion::Unused
+ ));
+ }
-#[test]
-#[should_panic]
-fn test_virtual_region_does_not_contain() {
- let region = VirtualRegion::new(0x4000_0000, 0x1000);
- region.create_split(
- 0x8000_0000,
- 0x1000,
- Some(PhysicalRegion::PhysicalAddress(0xc000_0000)),
- );
-}
+ #[test]
+ #[should_panic]
+ fn test_virtual_region_does_not_contain() {
+ let region = VirtualRegion::new(0x4000_0000, 0x1000);
+ region.create_split(
+ 0x8000_0000,
+ 0x1000,
+ Some(PhysicalRegion::PhysicalAddress(0xc000_0000)),
+ );
+ }
-#[test]
-#[should_panic]
-fn test_virtual_region_create_split_same_used() {
- let region = VirtualRegion::new(0x4000_0000, 0x1000);
- region.create_split(0x4000_0000, 0x1000, Some(PhysicalRegion::Unused));
-}
+ #[test]
+ #[should_panic]
+ fn test_virtual_region_create_split_same_used() {
+ let region = VirtualRegion::new(0x4000_0000, 0x1000);
+ region.create_split(0x4000_0000, 0x1000, Some(PhysicalRegion::Unused));
+ }
-#[test]
-fn test_virtual_region_drop() {
- const PA: usize = 0x0123_4567_89ab_cdef;
- const LENGTH: usize = 0x8000_0000_0000;
+ #[test]
+ fn test_virtual_region_drop() {
+ const PA: usize = 0x0123_4567_89ab_cdef;
+ const LENGTH: usize = 0x8000_0000_0000;
- static PAGE_POOL_AREA: PagePoolArea<8192> = PagePoolArea::new();
- let page_pool = PagePool::new(&PAGE_POOL_AREA);
- let page = page_pool.allocate_pages(4096).unwrap();
+ static PAGE_POOL_AREA: PagePoolArea<8192> = PagePoolArea::new();
+ let page_pool = PagePool::new(&PAGE_POOL_AREA);
+ let page = page_pool.allocate_pages(4096).unwrap();
- let physical_region = PhysicalRegion::Allocated(page_pool, page);
+ let physical_region = PhysicalRegion::Allocated(page_pool, page);
- // Testing physical region drop through virtualregion
- let virtual_region = VirtualRegion::new_from_fields(0x4000_0000, 1000, physical_region);
- drop(virtual_region);
+ // Testing physical region drop through virtualregion
+ let virtual_region = VirtualRegion::new_from_fields(0x4000_0000, 1000, physical_region);
+ drop(virtual_region);
+ }
}
diff --git a/src/region_pool.rs b/src/region_pool.rs
index f6fa3b4..df5a026 100644
--- a/src/region_pool.rs
+++ b/src/region_pool.rs
@@ -185,232 +185,234 @@
}
#[cfg(test)]
-#[derive(Debug, PartialEq, Eq)]
-struct RegionExample {
- base: usize,
- length: usize,
- used: bool,
-}
+mod tests {
+ use super::*;
-#[cfg(test)]
-impl RegionExample {
- fn new(base: usize, length: usize, used: bool) -> Self {
- Self { base, length, used }
- }
-}
-
-#[cfg(test)]
-impl Region for RegionExample {
- type Resource = ();
-
- fn base(&self) -> usize {
- self.base
- }
-
- fn length(&self) -> usize {
- self.length
- }
-
- fn used(&self) -> bool {
- self.used
- }
-
- fn contains(&self, base: usize, length: usize) -> bool {
- self.base <= base && base + length <= self.base + self.length
- }
-
- fn try_append(&mut self, other: &Self) -> bool {
- if self.used == other.used && self.base + self.length == other.base {
- self.length += other.length;
- true
- } else {
- false
- }
- }
-
- fn create_split(
- &self,
+ #[derive(Debug, PartialEq, Eq)]
+ struct RegionExample {
base: usize,
length: usize,
- resource: Option<Self::Resource>,
- ) -> (Self, Vec<Self>) {
- let mut res = Vec::new();
- if self.base != base {
- res.push(RegionExample::new(self.base, base - self.base, self.used));
- }
- res.push(RegionExample::new(base, length, resource.is_some()));
- if self.base + self.length != base + length {
- res.push(RegionExample::new(
- base + length,
- (self.base + self.length) - (base + length),
- self.used,
- ));
- }
-
- (RegionExample::new(base, length, resource.is_some()), res)
+ used: bool,
}
-}
-#[test]
-fn test_region_contains() {
- let region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
+ impl RegionExample {
+ fn new(base: usize, length: usize, used: bool) -> Self {
+ Self { base, length, used }
+ }
+ }
- assert!(region.contains(0x4000_0000, 0x1000_0000));
- assert!(!region.contains(0x4000_0000 - 1, 0x1000_0000 + 1));
- assert!(!region.contains(0x4000_0000, 0x1000_0000 + 1));
- assert!(region.contains(0x4000_0000 + 1, 0x1000_0000 - 1));
-}
+ impl Region for RegionExample {
+ type Resource = ();
-#[test]
-fn test_region_try_append() {
- // Normal append
- let mut region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
- let appending = RegionExample::new(0x5000_0000, 0x0000_1000, false);
+ fn base(&self) -> usize {
+ self.base
+ }
- assert!(region.try_append(&appending));
- assert_eq!(RegionExample::new(0x4000_0000, 0x1000_1000, false), region);
+ fn length(&self) -> usize {
+ self.length
+ }
- // Different used flags
- let mut region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
- let appending = RegionExample::new(0x5000_0000, 0x0000_1000, true);
+ fn used(&self) -> bool {
+ self.used
+ }
- assert!(!region.try_append(&appending));
- assert_eq!(RegionExample::new(0x4000_0000, 0x1000_0000, false), region);
+ fn contains(&self, base: usize, length: usize) -> bool {
+ self.base <= base && base + length <= self.base + self.length
+ }
- // Not continious
- let mut region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
- let appending = RegionExample::new(0x5000_1000, 0x0000_1000, false);
+ fn try_append(&mut self, other: &Self) -> bool {
+ if self.used == other.used && self.base + self.length == other.base {
+ self.length += other.length;
+ true
+ } else {
+ false
+ }
+ }
- assert!(!region.try_append(&appending));
- assert_eq!(RegionExample::new(0x4000_0000, 0x1000_0000, false), region);
-}
+ fn create_split(
+ &self,
+ base: usize,
+ length: usize,
+ resource: Option<Self::Resource>,
+ ) -> (Self, Vec<Self>) {
+ let mut res = Vec::new();
+ if self.base != base {
+ res.push(RegionExample::new(self.base, base - self.base, self.used));
+ }
+ res.push(RegionExample::new(base, length, resource.is_some()));
+ if self.base + self.length != base + length {
+ res.push(RegionExample::new(
+ base + length,
+ (self.base + self.length) - (base + length),
+ self.used,
+ ));
+ }
-#[test]
-fn test_region_create_split() {
- // Cut first part
- let region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
+ (RegionExample::new(base, length, resource.is_some()), res)
+ }
+ }
- let res = region.create_split(0x4000_0000, 0x0000_1000, Some(())).1;
- assert_eq!(RegionExample::new(0x4000_0000, 0x0000_1000, true), res[0]);
- assert_eq!(RegionExample::new(0x4000_1000, 0x0fff_f000, false), res[1]);
+ #[test]
+ fn test_region_contains() {
+ let region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
- // Cut last part
- let region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
+ assert!(region.contains(0x4000_0000, 0x1000_0000));
+ assert!(!region.contains(0x4000_0000 - 1, 0x1000_0000 + 1));
+ assert!(!region.contains(0x4000_0000, 0x1000_0000 + 1));
+ assert!(region.contains(0x4000_0000 + 1, 0x1000_0000 - 1));
+ }
- let res = region.create_split(0x4fff_f000, 0x0000_1000, Some(())).1;
- assert_eq!(RegionExample::new(0x4000_0000, 0x0fff_f000, false), res[0]);
- assert_eq!(RegionExample::new(0x4fff_f000, 0x0000_1000, true), res[1]);
+ #[test]
+ fn test_region_try_append() {
+ // Normal append
+ let mut region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
+ let appending = RegionExample::new(0x5000_0000, 0x0000_1000, false);
- // Cut middle part
- let region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
+ assert!(region.try_append(&appending));
+ assert_eq!(RegionExample::new(0x4000_0000, 0x1000_1000, false), region);
- let res = region.create_split(0x4020_0000, 0x0000_1000, Some(())).1;
- assert_eq!(RegionExample::new(0x4000_0000, 0x0020_0000, false), res[0]);
- assert_eq!(RegionExample::new(0x4020_0000, 0x0000_1000, true), res[1]);
- assert_eq!(RegionExample::new(0x4020_1000, 0x0fdf_f000, false), res[2]);
-}
+ // Different used flags
+ let mut region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
+ let appending = RegionExample::new(0x5000_0000, 0x0000_1000, true);
-#[test]
-fn test_region_pool_add() {
- let mut pool = RegionPool::new();
- assert_eq!(
- Ok(()),
+ assert!(!region.try_append(&appending));
+ assert_eq!(RegionExample::new(0x4000_0000, 0x1000_0000, false), region);
+
+ // Not continious
+ let mut region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
+ let appending = RegionExample::new(0x5000_1000, 0x0000_1000, false);
+
+ assert!(!region.try_append(&appending));
+ assert_eq!(RegionExample::new(0x4000_0000, 0x1000_0000, false), region);
+ }
+
+ #[test]
+ fn test_region_create_split() {
+ // Cut first part
+ let region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
+
+ let res = region.create_split(0x4000_0000, 0x0000_1000, Some(())).1;
+ assert_eq!(RegionExample::new(0x4000_0000, 0x0000_1000, true), res[0]);
+ assert_eq!(RegionExample::new(0x4000_1000, 0x0fff_f000, false), res[1]);
+
+ // Cut last part
+ let region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
+
+ let res = region.create_split(0x4fff_f000, 0x0000_1000, Some(())).1;
+ assert_eq!(RegionExample::new(0x4000_0000, 0x0fff_f000, false), res[0]);
+ assert_eq!(RegionExample::new(0x4fff_f000, 0x0000_1000, true), res[1]);
+
+ // Cut middle part
+ let region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
+
+ let res = region.create_split(0x4020_0000, 0x0000_1000, Some(())).1;
+ assert_eq!(RegionExample::new(0x4000_0000, 0x0020_0000, false), res[0]);
+ assert_eq!(RegionExample::new(0x4020_0000, 0x0000_1000, true), res[1]);
+ assert_eq!(RegionExample::new(0x4020_1000, 0x0fdf_f000, false), res[2]);
+ }
+
+ #[test]
+ fn test_region_pool_add() {
+ let mut pool = RegionPool::new();
+ assert_eq!(
+ Ok(()),
+ pool.add(RegionExample::new(0x4000_0000, 0x1000_0000, false))
+ );
+ assert_eq!(
+ Ok(()),
+ pool.add(RegionExample::new(0x5000_0000, 0x1000_0000, false))
+ );
+ assert_eq!(
+ Err(RegionPoolError::AlreadyUsed),
+ pool.add(RegionExample::new(0x4000_1000, 0x1000, false))
+ );
+ }
+
+ #[test]
+ fn test_pool_allocate() {
+ let mut pool = RegionPool::new();
pool.add(RegionExample::new(0x4000_0000, 0x1000_0000, false))
- );
- assert_eq!(
- Ok(()),
- pool.add(RegionExample::new(0x5000_0000, 0x1000_0000, false))
- );
- assert_eq!(
- Err(RegionPoolError::AlreadyUsed),
- pool.add(RegionExample::new(0x4000_1000, 0x1000, false))
- );
-}
+ .unwrap();
-#[test]
-fn test_pool_allocate() {
- let mut pool = RegionPool::new();
- pool.add(RegionExample::new(0x4000_0000, 0x1000_0000, false))
- .unwrap();
+ let res = pool.allocate(0x1000, ());
+ assert_eq!(Ok(RegionExample::new(0x4000_0000, 0x1000, true)), res);
+ let res = pool.allocate(0x1_0000, ());
+ assert_eq!(Ok(RegionExample::new(0x4000_1000, 0x1_0000, true)), res);
+ let res = pool.allocate(0x2000_0000, ());
+ assert_eq!(Err(RegionPoolError::NoSpace), res);
+ }
- let res = pool.allocate(0x1000, ());
- assert_eq!(Ok(RegionExample::new(0x4000_0000, 0x1000, true)), res);
- let res = pool.allocate(0x1_0000, ());
- assert_eq!(Ok(RegionExample::new(0x4000_1000, 0x1_0000, true)), res);
- let res = pool.allocate(0x2000_0000, ());
- assert_eq!(Err(RegionPoolError::NoSpace), res);
-}
+ #[test]
+ fn test_region_pool_acquire() {
+ let mut pool = RegionPool::new();
+ pool.add(RegionExample::new(0x4000_0000, 0x1000_0000, false))
+ .unwrap();
-#[test]
-fn test_region_pool_acquire() {
- let mut pool = RegionPool::new();
- pool.add(RegionExample::new(0x4000_0000, 0x1000_0000, false))
- .unwrap();
+ let res = pool.acquire(0x4000_1000, 0x1000, ());
+ assert_eq!(Ok(RegionExample::new(0x4000_1000, 0x1000, true)), res);
+ let res = pool.allocate(0x1_0000, ());
+ assert_eq!(Ok(RegionExample::new(0x4000_2000, 0x10000, true)), res);
+ let res = pool.acquire(0x4000_1000, 0x1000, ());
+ assert_eq!(Err(RegionPoolError::AlreadyUsed), res);
+ }
- let res = pool.acquire(0x4000_1000, 0x1000, ());
- assert_eq!(Ok(RegionExample::new(0x4000_1000, 0x1000, true)), res);
- let res = pool.allocate(0x1_0000, ());
- assert_eq!(Ok(RegionExample::new(0x4000_2000, 0x10000, true)), res);
- let res = pool.acquire(0x4000_1000, 0x1000, ());
- assert_eq!(Err(RegionPoolError::AlreadyUsed), res);
-}
+ #[test]
+ fn test_region_pool_release() {
+ let mut pool = RegionPool::new();
+ pool.add(RegionExample::new(0x4000_0000, 0x1000_0000, false))
+ .unwrap();
-#[test]
-fn test_region_pool_release() {
- let mut pool = RegionPool::new();
- pool.add(RegionExample::new(0x4000_0000, 0x1000_0000, false))
- .unwrap();
+ let res = pool.allocate(0x1000, ());
+ assert_eq!(Ok(RegionExample::new(0x4000_0000, 0x1000, true)), res);
+ assert_eq!(Ok(()), pool.release(res.unwrap()));
- let res = pool.allocate(0x1000, ());
- assert_eq!(Ok(RegionExample::new(0x4000_0000, 0x1000, true)), res);
- assert_eq!(Ok(()), pool.release(res.unwrap()));
+ let res = pool.allocate(0x1_0000, ());
+ assert_eq!(Ok(RegionExample::new(0x4000_0000, 0x10000, true)), res);
+ assert_eq!(Ok(()), pool.release(res.unwrap()));
- let res = pool.allocate(0x1_0000, ());
- assert_eq!(Ok(RegionExample::new(0x4000_0000, 0x10000, true)), res);
- assert_eq!(Ok(()), pool.release(res.unwrap()));
+ assert_eq!(
+ Err(RegionPoolError::NotFound),
+ pool.release(RegionExample::new(0x4000_0000, 0x1000, true))
+ );
+ }
- assert_eq!(
- Err(RegionPoolError::NotFound),
- pool.release(RegionExample::new(0x4000_0000, 0x1000, true))
- );
-}
+ #[test]
+ #[should_panic]
+ fn test_region_pool_release_not_used() {
+ let mut pool = RegionPool::new();
+ pool.release(RegionExample::new(0x4000_0000, 0x1000, false))
+ .unwrap();
+ }
-#[test]
-#[should_panic]
-fn test_region_pool_release_not_used() {
- let mut pool = RegionPool::new();
- pool.release(RegionExample::new(0x4000_0000, 0x1000, false))
- .unwrap();
-}
+ #[test]
+ fn test_region_pool_find_containing_region() {
+ let mut pool = RegionPool::<RegionExample>::new();
+ pool.add(RegionExample::new(0x4000_0000, 0x1000_0000, false))
+ .unwrap();
-#[test]
-fn test_region_pool_find_containing_region() {
- let mut pool = RegionPool::<RegionExample>::new();
- pool.add(RegionExample::new(0x4000_0000, 0x1000_0000, false))
- .unwrap();
+ assert_eq!(
+ Err(RegionPoolError::NotFound),
+ pool.find_containing_region(0x0000_0000, 0x1000)
+ );
- assert_eq!(
- Err(RegionPoolError::NotFound),
- pool.find_containing_region(0x0000_0000, 0x1000)
- );
+ assert_eq!(
+ Err(RegionPoolError::NotFound),
+ pool.find_containing_region(0x5000_0000, 0x1000)
+ );
- assert_eq!(
- Err(RegionPoolError::NotFound),
- pool.find_containing_region(0x5000_0000, 0x1000)
- );
+ assert_eq!(
+ Err(RegionPoolError::NotFound),
+ pool.find_containing_region(0x4000_0000, 0x2000_0000)
+ );
- assert_eq!(
- Err(RegionPoolError::NotFound),
- pool.find_containing_region(0x4000_0000, 0x2000_0000)
- );
+ assert_eq!(
+ Ok(&RegionExample::new(0x4000_0000, 0x1000_0000, false)),
+ pool.find_containing_region(0x4000_0000, 0x1000_0000)
+ );
- assert_eq!(
- Ok(&RegionExample::new(0x4000_0000, 0x1000_0000, false)),
- pool.find_containing_region(0x4000_0000, 0x1000_0000)
- );
-
- assert_eq!(
- Ok(&RegionExample::new(0x4000_0000, 0x1000_0000, false)),
- pool.find_containing_region(0x4000_1000, 0x1000)
- );
+ assert_eq!(
+ Ok(&RegionExample::new(0x4000_0000, 0x1000_0000, false)),
+ pool.find_containing_region(0x4000_1000, 0x1000)
+ );
+ }
}