Skip to content

Commit

Permalink
[mmap]: Derive PartialEq for Error enum
Browse files Browse the repository at this point in the history 
Derive PartialEq and update tests to check for equality on error
cases.

Signed-off-by: Alexandru Cihodaru <[email protected]>
  • Loading branch information
@AlexandruCihodaru
AlexandruCihodaru committed Oct 10, 2022
1 parent 3ca41ec commit deb90ab
Showing 1 changed file with 53 additions and 104 deletions.
157 changes: 53 additions & 104 deletions src/mmap.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -69,7 +69,7 @@ pub(crate) trait AsSlice {
}

/// Errors that can occur when creating a memory map.
#[derive(Debug)]
#[derive(Debug, PartialEq)]
pub enum Error {
/// Adding the guest base address to the length of the underlying mapping resulted
/// in an overflow.
Expand Down Expand Up @@ -770,43 +770,21 @@ mod tests {
#[test]
fn test_no_memory_region() {
let regions_summary = [];

assert_eq!(
format!(
"{:?}",
new_guest_memory_mmap(&regions_summary).err().unwrap()
),
format!("{:?}", Error::NoMemoryRegion)
new_guest_memory_mmap(&regions_summary).unwrap_err(),
Error::NoMemoryRegion
);

assert_eq!(
format!(
"{:?}",
new_guest_memory_mmap_with_files(&regions_summary)
.err()
.unwrap()
),
format!("{:?}", Error::NoMemoryRegion)
new_guest_memory_mmap_with_files(&regions_summary).unwrap_err(),
Error::NoMemoryRegion
);

assert_eq!(
format!(
"{:?}",
new_guest_memory_mmap_from_regions(&regions_summary)
.err()
.unwrap()
),
format!("{:?}", Error::NoMemoryRegion)
new_guest_memory_mmap_from_regions(&regions_summary).unwrap_err(),
Error::NoMemoryRegion
);

assert_eq!(
format!(
"{:?}",
new_guest_memory_mmap_from_arc_regions(&regions_summary)
.err()
.unwrap()
),
format!("{:?}", Error::NoMemoryRegion)
new_guest_memory_mmap_from_arc_regions(&regions_summary).unwrap_err(),
Error::NoMemoryRegion
);
}

Expand All @@ -818,41 +796,20 @@ mod tests {
];

assert_eq!(
format!(
"{:?}",
new_guest_memory_mmap(&regions_summary).err().unwrap()
),
format!("{:?}", Error::MemoryRegionOverlap)
new_guest_memory_mmap(&regions_summary).unwrap_err(),
Error::MemoryRegionOverlap
);

assert_eq!(
format!(
"{:?}",
new_guest_memory_mmap_with_files(&regions_summary)
.err()
.unwrap()
),
format!("{:?}", Error::MemoryRegionOverlap)
new_guest_memory_mmap_with_files(&regions_summary).unwrap_err(),
Error::MemoryRegionOverlap
);

assert_eq!(
format!(
"{:?}",
new_guest_memory_mmap_from_regions(&regions_summary)
.err()
.unwrap()
),
format!("{:?}", Error::MemoryRegionOverlap)
new_guest_memory_mmap_from_regions(&regions_summary).unwrap_err(),
Error::MemoryRegionOverlap
);

assert_eq!(
format!(
"{:?}",
new_guest_memory_mmap_from_arc_regions(&regions_summary)
.err()
.unwrap()
),
format!("{:?}", Error::MemoryRegionOverlap)
new_guest_memory_mmap_from_arc_regions(&regions_summary).unwrap_err(),
Error::MemoryRegionOverlap
);
}

Expand All @@ -862,43 +819,21 @@ mod tests {
(GuestAddress(100), 100 as usize),
(GuestAddress(0), 100 as usize),
];

assert_eq!(
format!(
"{:?}",
new_guest_memory_mmap(&regions_summary).err().unwrap()
),
format!("{:?}", Error::UnsortedMemoryRegions)
new_guest_memory_mmap(&regions_summary).unwrap_err(),
Error::UnsortedMemoryRegions
);

assert_eq!(
format!(
"{:?}",
new_guest_memory_mmap_with_files(&regions_summary)
.err()
.unwrap()
),
format!("{:?}", Error::UnsortedMemoryRegions)
new_guest_memory_mmap_with_files(&regions_summary).unwrap_err(),
Error::UnsortedMemoryRegions
);

assert_eq!(
format!(
"{:?}",
new_guest_memory_mmap_from_regions(&regions_summary)
.err()
.unwrap()
),
format!("{:?}", Error::UnsortedMemoryRegions)
new_guest_memory_mmap_from_regions(&regions_summary).unwrap_err(),
Error::UnsortedMemoryRegions
);

assert_eq!(
format!(
"{:?}",
new_guest_memory_mmap_from_arc_regions(&regions_summary)
.err()
.unwrap()
),
format!("{:?}", Error::UnsortedMemoryRegions)
new_guest_memory_mmap_from_arc_regions(&regions_summary).unwrap_err(),
Error::UnsortedMemoryRegions
);
}

Expand Down Expand Up @@ -1058,7 +993,10 @@ mod tests {

let guest_mem_list = vec![guest_mem, guest_mem_backed_by_file];
for guest_mem in guest_mem_list.iter() {
assert!(guest_mem.get_host_address(GuestAddress(0x600)).is_err());
assert_eq!(
guest_mem.get_host_address(GuestAddress(0x600)).unwrap_err(),
guest_memory::Error::InvalidGuestAddress(GuestAddress(0x600))
);
let ptr0 = guest_mem.get_host_address(GuestAddress(0x800)).unwrap();
let ptr1 = guest_mem.get_host_address(GuestAddress(0xa00)).unwrap();
assert_eq!(
Expand Down Expand Up @@ -1126,18 +1064,16 @@ mod tests {
let val1: u64 = 0xaa55_aa55_aa55_aa55;
let val2: u64 = 0x55aa_55aa_55aa_55aa;
assert_eq!(
format!("{:?}", gm.write_obj(val1, bad_addr).err().unwrap()),
format!("InvalidGuestAddress({:?})", bad_addr,)
gm.write_obj(val1, bad_addr).unwrap_err(),
guest_memory::Error::InvalidGuestAddress(bad_addr)
);
assert_eq!(
format!("{:?}", gm.write_obj(val1, bad_addr2).err().unwrap()),
format!(
"PartialBuffer {{ expected: {:?}, completed: {:?} }}",
mem::size_of::<u64>(),
max_addr.checked_offset_from(bad_addr2).unwrap()
)
gm.write_obj(val1, bad_addr2).unwrap_err(),
guest_memory::Error::PartialBuffer {
expected: mem::size_of::<u64>(),
completed: max_addr.checked_offset_from(bad_addr2).unwrap() as usize
}
);

gm.write_obj(val1, GuestAddress(0x500)).unwrap();
gm.write_obj(val2, GuestAddress(0x1000 + 32)).unwrap();
let num1: u64 = gm.read_obj(GuestAddress(0x500)).unwrap();
Expand Down Expand Up @@ -1439,7 +1375,11 @@ mod tests {
// Error case when slice_size is beyond the boundary.
let slice_addr = MemoryRegionAddress(0x300);
let slice_size = 0x200;
assert!(region.get_slice(slice_addr, slice_size).is_err());

assert_eq!(
region.get_slice(slice_addr, slice_size).unwrap_err(),
guest_memory::Error::InvalidBackendAddress
);
}

#[test]
Expand Down Expand Up @@ -1487,9 +1427,18 @@ mod tests {
.is_empty());

// Error cases, wrong size or base address.
assert!(guest_mem.get_slice(GuestAddress(0), 0x500).is_err());
assert!(guest_mem.get_slice(GuestAddress(0x600), 0x100).is_err());
assert!(guest_mem.get_slice(GuestAddress(0xc00), 0x100).is_err());
assert_eq!(
guest_mem.get_slice(GuestAddress(0), 0x500).unwrap_err(),
guest_memory::Error::InvalidBackendAddress
);
assert_eq!(
guest_mem.get_slice(GuestAddress(0x600), 0x100).unwrap_err(),
guest_memory::Error::InvalidGuestAddress(GuestAddress(0x600))
);
assert_eq!(
guest_mem.get_slice(GuestAddress(0xc00), 0x100).unwrap_err(),
guest_memory::Error::InvalidGuestAddress(GuestAddress(0xc00))
);
}

#[test]
Expand Down

0 comments on commit deb90ab

Please sign in to comment.