refactor(test): Use mock regions in atomic.rs tests

These tests only test properties of the GuestMemoryAtomic implementation
that are independent of the actual M: GuestMemory being used. So
simplify it to drop the dependency on backend-mmap.

Signed-off-by: Patrick Roy <[email protected]>

Author: roypat

src/atomic.rs

@@ -140,14 +140,12 @@ impl<M: GuestMemory> GuestMemoryExclusiveGuard<'_, M> {
 }
 
 #[cfg(test)]
-#[cfg(feature = "backend-mmap")]
 mod tests {
     use super::*;
-    use crate::{GuestAddress, GuestMemory, GuestMemoryRegion, GuestUsize, MmapRegion};
+    use crate::region::tests::{new_guest_memory_collection_from_regions, Collection, MockRegion};
+    use crate::{GuestAddress, GuestMemory, GuestMemoryRegion, GuestUsize};
 
-    type GuestMemoryMmap = crate::GuestMemoryMmap<()>;
-    type GuestRegionMmap = crate::GuestRegionMmap<()>;
-    type GuestMemoryMmapAtomic = GuestMemoryAtomic<GuestMemoryMmap>;
+    type GuestMemoryMmapAtomic = GuestMemoryAtomic<Collection>;
 
     #[test]
     fn test_atomic_memory() {
@@ -157,7 +155,7 @@ mod tests {
             (GuestAddress(0x1000), region_size),
         ];
         let mut iterated_regions = Vec::new();
-        let gmm = GuestMemoryMmap::from_ranges(&regions).unwrap();
+        let gmm = new_guest_memory_collection_from_regions(&regions).unwrap();
         let gm = GuestMemoryMmapAtomic::new(gmm);
         let mem = gm.memory();
 
@@ -166,7 +164,7 @@ mod tests {
         }
 
         for region in mem.iter() {
-            iterated_regions.push((region.start_addr(), region.len() as usize));
+            iterated_regions.push((region.start_addr(), region.len()));
         }
         assert_eq!(regions, iterated_regions);
         assert_eq!(mem.num_regions(), 2);
@@ -207,7 +205,7 @@ mod tests {
             (GuestAddress(0x0), region_size),
             (GuestAddress(0x1000), region_size),
         ];
-        let gmm = GuestMemoryMmap::from_ranges(&regions).unwrap();
+        let gmm = new_guest_memory_collection_from_regions(&regions).unwrap();
         let gm = GuestMemoryMmapAtomic::new(gmm);
         let mem = {
             let guard1 = gm.memory();
@@ -219,38 +217,44 @@ mod tests {
     #[test]
     fn test_atomic_hotplug() {
         let region_size = 0x1000;
-        let regions = vec![
+        let regions = [
             (GuestAddress(0x0), region_size),
             (GuestAddress(0x10_0000), region_size),
         ];
-        let mut gmm = Arc::new(GuestMemoryMmap::from_ranges(&regions).unwrap());
+        let mut gmm = Arc::new(new_guest_memory_collection_from_regions(&regions).unwrap());
         let gm: GuestMemoryAtomic<_> = gmm.clone().into();
         let mem_orig = gm.memory();
         assert_eq!(mem_orig.num_regions(), 2);
 
         {
             let guard = gm.lock().unwrap();
             let new_gmm = Arc::make_mut(&mut gmm);
-            let mmap = Arc::new(
-                GuestRegionMmap::new(MmapRegion::new(0x1000).unwrap(), GuestAddress(0x8000))
-                    .unwrap(),
-            );
-            let new_gmm = new_gmm.insert_region(mmap).unwrap();
-            let mmap = Arc::new(
-                GuestRegionMmap::new(MmapRegion::new(0x1000).unwrap(), GuestAddress(0x4000))
-                    .unwrap(),
-            );
-            let new_gmm = new_gmm.insert_region(mmap).unwrap();
-            let mmap = Arc::new(
-                GuestRegionMmap::new(MmapRegion::new(0x1000).unwrap(), GuestAddress(0xc000))
-                    .unwrap(),
-            );
-            let new_gmm = new_gmm.insert_region(mmap).unwrap();
-            let mmap = Arc::new(
-                GuestRegionMmap::new(MmapRegion::new(0x1000).unwrap(), GuestAddress(0xc000))
-                    .unwrap(),
-            );
-            new_gmm.insert_region(mmap).unwrap_err();
+            let new_gmm = new_gmm
+                .insert_region(Arc::new(MockRegion {
+                    start: GuestAddress(0x8000),
+                    len: 0x1000,
+                }))
+                .unwrap();
+            let new_gmm = new_gmm
+                .insert_region(Arc::new(MockRegion {
+                    start: GuestAddress(0x4000),
+                    len: 0x1000,
+                }))
+                .unwrap();
+            let new_gmm = new_gmm
+                .insert_region(Arc::new(MockRegion {
+                    start: GuestAddress(0xc000),
+                    len: 0x1000,
+                }))
+                .unwrap();
+
+            new_gmm
+                .insert_region(Arc::new(MockRegion {
+                    start: GuestAddress(0x8000),
+                    len: 0x1000,
+                }))
+                .unwrap_err();
+
             guard.replace(new_gmm);
         }
 

src/region.rs

@@ -451,17 +451,17 @@ impl<R: GuestMemoryRegionBytes> Bytes<MemoryRegionAddress> for R {
 }
 
 #[cfg(test)]
-mod tests {
+pub(crate) mod tests {
     use crate::region::{GuestMemoryRegionBytes, GuestRegionError};
     use crate::{
         Address, GuestAddress, GuestMemory, GuestMemoryRegion, GuestRegionCollection, GuestUsize,
     };
     use std::sync::Arc;
 
     #[derive(Debug, PartialEq, Eq)]
-    struct MockRegion {
-        start: GuestAddress,
-        len: GuestUsize,
+    pub(crate) struct MockRegion {
+        pub(crate) start: GuestAddress,
+        pub(crate) len: GuestUsize,
     }
 
     impl GuestMemoryRegion for MockRegion {
@@ -482,7 +482,7 @@ mod tests {
 
     impl GuestMemoryRegionBytes for MockRegion {}
 
-    type Collection = GuestRegionCollection<MockRegion>;
+    pub(crate) type Collection = GuestRegionCollection<MockRegion>;
 
     fn check_guest_memory_mmap(
         maybe_guest_mem: Result<Collection, GuestRegionError>,
@@ -510,7 +510,7 @@ mod tests {
         }
     }
 
-    fn new_guest_memory_collection_from_regions(
+    pub(crate) fn new_guest_memory_collection_from_regions(
         regions_summary: &[(GuestAddress, u64)],
     ) -> Result<Collection, GuestRegionError> {
         Collection::from_regions(