From c6bd80f460837cd944405651613421f4a5dc79d5 Mon Sep 17 00:00:00 2001 From: Alexandru Cihodaru Date: Mon, 10 Oct 2022 10:03:44 +0300 Subject: [PATCH 1/4] [guest_memory]: Implement PartialEq for Error enum Signed-off-by: Alexandru Cihodaru --- src/guest_memory.rs | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/src/guest_memory.rs b/src/guest_memory.rs index 6bbd02f1..f774a639 100644 --- a/src/guest_memory.rs +++ b/src/guest_memory.rs @@ -73,6 +73,33 @@ pub enum Error { HostAddressNotAvailable, } +impl PartialEq for Error { + fn eq(&self, other: &Self) -> bool { + match (self, other) { + (Error::InvalidGuestAddress(left), Error::InvalidGuestAddress(right)) => left == right, + (Error::InvalidBackendAddress, Error::InvalidBackendAddress) => true, + (Error::HostAddressNotAvailable, Error::HostAddressNotAvailable) => true, + ( + Error::PartialBuffer { + expected: left_expected, + completed: left_completed, + }, + Error::PartialBuffer { + expected: right_expected, + completed: right_completed, + }, + ) => left_expected == right_expected && left_completed == right_completed, + (Error::IOError(left), Error::IOError(right)) => { + // error.kind should be enough to assert equallity because each error + // has the kind field set and the OS error numbers can be converted + // to ErrorKind through `sys::decode_error_kind`. + left.kind() == right.kind() + } + _ => false, + } + } +} + impl From for Error { fn from(e: volatile_memory::Error) -> Self { match e { From 4775dd7953596dfa4698678139a9e93bb1701cd7 Mon Sep 17 00:00:00 2001 From: Alexandru Cihodaru Date: Mon, 10 Oct 2022 10:08:42 +0300 Subject: [PATCH 2/4] [volatile_memory]: Implement PartialEq for Error Implement PartialEq for Error enum and update tests. Signed-off-by: Alexandru Cihodaru --- src/volatile_memory.rs | 216 +++++++++++++++++++++++++++++++++-------- 1 file changed, 175 insertions(+), 41 deletions(-) diff --git a/src/volatile_memory.rs b/src/volatile_memory.rs index 889ea587..893af846 100644 --- a/src/volatile_memory.rs +++ b/src/volatile_memory.rs @@ -61,6 +61,64 @@ pub enum Error { PartialBuffer { expected: usize, completed: usize }, } +impl PartialEq for Error { + fn eq(&self, other: &Self) -> bool { + match (self, other) { + // error.kind should be enough to assert equallity because each error + // has the kind field set and the OS error numbers can be converted + // to ErrorKind through `sys::decode_error_kind`. + (Error::IOError(left), Error::IOError(right)) => left.kind() == right.kind(), + ( + Error::OutOfBounds { addr: left_address }, + Error::OutOfBounds { + addr: right_address, + }, + ) => left_address == right_address, + ( + Error::Overflow { + base: left_base, + offset: left_offset, + }, + Error::Overflow { + base: right_base, + offset: right_offset, + }, + ) => left_offset == right_offset && left_base == right_base, + ( + Error::TooBig { + nelements: left_nelements, + size: left_size, + }, + Error::TooBig { + nelements: right_nelements, + size: right_size, + }, + ) => left_nelements == right_nelements && left_size == right_size, + ( + Error::Misaligned { + addr: left_addr, + alignment: left_align, + }, + Error::Misaligned { + addr: right_addr, + alignment: right_align, + }, + ) => left_addr == right_addr && left_align == right_align, + ( + Error::PartialBuffer { + expected: left_expected, + completed: left_completed, + }, + Error::PartialBuffer { + expected: right_expected, + completed: right_completed, + }, + ) => left_expected == right_expected && left_completed == right_completed, + _ => false, + } + } +} + impl fmt::Display for Error { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { @@ -1527,7 +1585,10 @@ mod tests { let a_ref = unsafe { VolatileSlice::new(&mut a[0] as *mut usize as *mut u8, size_of::()) }; assert!(a_ref.get_atomic_ref::(0).is_ok()); - assert!(a_ref.get_atomic_ref::(1).is_err()); + assert_eq!( + a_ref.get_atomic_ref::(1).unwrap_err(), + Error::OutOfBounds { addr: 9 } + ); } #[test] @@ -1628,20 +1689,46 @@ mod tests { assert!(slice.write(&[1; 80], 10).is_ok()); assert!(slice.subslice(0, 0).is_ok()); - assert!(slice.subslice(0, 101).is_err()); + assert_eq!( + slice.subslice(0, 101).unwrap_err(), + Error::OutOfBounds { addr: 101 } + ); assert!(slice.subslice(99, 0).is_ok()); assert!(slice.subslice(99, 1).is_ok()); - assert!(slice.subslice(99, 2).is_err()); + assert_eq!( + slice.subslice(99, 2).unwrap_err(), + Error::OutOfBounds { addr: 101 } + ); assert!(slice.subslice(100, 0).is_ok()); - assert!(slice.subslice(100, 1).is_err()); - - assert!(slice.subslice(101, 0).is_err()); - assert!(slice.subslice(101, 1).is_err()); + assert_eq!( + slice.subslice(100, 1).unwrap_err(), + Error::OutOfBounds { addr: 101 } + ); + assert_eq!( + slice.subslice(101, 0).unwrap_err(), + Error::OutOfBounds { addr: 101 } + ); + assert_eq!( + slice.subslice(101, 1).unwrap_err(), + Error::OutOfBounds { addr: 102 } + ); - assert!(slice.subslice(std::usize::MAX, 2).is_err()); - assert!(slice.subslice(2, std::usize::MAX).is_err()); + assert_eq!( + slice.subslice(std::usize::MAX, 2).unwrap_err(), + Error::Overflow { + base: std::usize::MAX, + offset: 2 + } + ); + assert_eq!( + slice.subslice(2, std::usize::MAX).unwrap_err(), + Error::Overflow { + base: 2, + offset: std::usize::MAX + } + ); let maybe_offset_slice = slice.subslice(10, 80); assert!(maybe_offset_slice.is_ok()); @@ -1658,7 +1745,6 @@ mod tests { let mem = VecMem::new(100); let slice = mem.get_slice(0, 100).unwrap(); assert!(slice.write(&[1; 80], 10).is_ok()); - assert!(slice.offset(101).is_err()); let maybe_offset_slice = slice.offset(10); @@ -1750,12 +1836,11 @@ mod tests { fn slice_overflow_error() { use std::usize::MAX; let a = VecMem::new(1); - let res = a.get_slice(MAX, 1).unwrap_err(); - assert_matches!( - res, + assert_eq!( + a.get_slice(MAX, 1).unwrap_err(), Error::Overflow { base: MAX, - offset: 1, + offset: 1 } ); } @@ -1764,17 +1849,18 @@ mod tests { fn slice_oob_error() { let a = VecMem::new(100); a.get_slice(50, 50).unwrap(); - let res = a.get_slice(55, 50).unwrap_err(); - assert_matches!(res, Error::OutOfBounds { addr: 105 }); + assert_eq!( + a.get_slice(55, 50).unwrap_err(), + Error::OutOfBounds { addr: 105 } + ); } #[test] fn ref_overflow_error() { use std::usize::MAX; let a = VecMem::new(1); - let res = a.get_ref::(MAX).unwrap_err(); - assert_matches!( - res, + assert_eq!( + a.get_ref::(MAX).unwrap_err(), Error::Overflow { base: MAX, offset: 1, @@ -1786,15 +1872,19 @@ mod tests { fn ref_oob_error() { let a = VecMem::new(100); a.get_ref::(99).unwrap(); - let res = a.get_ref::(99).unwrap_err(); - assert_matches!(res, Error::OutOfBounds { addr: 101 }); + assert_eq!( + a.get_ref::(99).unwrap_err(), + Error::OutOfBounds { addr: 101 } + ); } #[test] fn ref_oob_too_large() { let a = VecMem::new(3); - let res = a.get_ref::(0).unwrap_err(); - assert_matches!(res, Error::OutOfBounds { addr: 4 }); + assert_eq!( + a.get_ref::(0).unwrap_err(), + Error::OutOfBounds { addr: 4 } + ); } #[test] @@ -1820,10 +1910,16 @@ mod tests { let a = VecMem::new(5); let s = a.as_volatile_slice(); let sample_buf = [1, 2, 3]; - assert!(s.write(&sample_buf, 5).is_err()); + assert_eq!( + s.write(&sample_buf, 5).unwrap_err(), + Error::OutOfBounds { addr: 5 } + ); assert!(s.write(&sample_buf, 2).is_ok()); let mut buf = [0u8; 3]; - assert!(s.read(&mut buf, 5).is_err()); + assert_eq!( + s.read(&mut buf, 5).unwrap_err(), + Error::OutOfBounds { addr: 5 } + ); assert!(s.read_slice(&mut buf, 2).is_ok()); assert_eq!(buf, sample_buf); @@ -1843,12 +1939,28 @@ mod tests { fn obj_read_and_write() { let a = VecMem::new(5); let s = a.as_volatile_slice(); - assert!(s.write_obj(55u16, 4).is_err()); - assert!(s.write_obj(55u16, core::usize::MAX).is_err()); + assert_eq!( + s.write_obj(55u16, 4).unwrap_err(), + Error::PartialBuffer { + expected: 2, + completed: 1 + } + ); assert!(s.write_obj(55u16, 2).is_ok()); assert_eq!(s.read_obj::(2).unwrap(), 55u16); - assert!(s.read_obj::(4).is_err()); - assert!(s.read_obj::(core::usize::MAX).is_err()); + assert_eq!( + s.read_obj::(4).unwrap_err(), + Error::PartialBuffer { + expected: 2, + completed: 1 + } + ); + assert_eq!( + s.read_obj::(core::usize::MAX).unwrap_err(), + Error::OutOfBounds { + addr: core::usize::MAX + } + ); } #[test] @@ -1861,15 +1973,30 @@ mod tests { } else { File::open(Path::new("c:\\Windows\\system32\\ntoskrnl.exe")).unwrap() }; - assert!(s.read_exact_from(2, &mut file, size_of::()).is_err()); - assert!(s - .read_exact_from(core::usize::MAX, &mut file, size_of::()) - .is_err()); + assert_eq!( + s.read_exact_from(2, &mut file, size_of::()) + .unwrap_err(), + Error::OutOfBounds { addr: 6 } + ); + assert_eq!( + s.read_exact_from(core::usize::MAX, &mut file, size_of::()) + .unwrap_err(), + Error::Overflow { + base: core::usize::MAX, + offset: 4 + } + ); assert!(s.read_exact_from(1, &mut file, size_of::()).is_ok()); let mut f = TempFile::new().unwrap().into_file(); - assert!(s.read_exact_from(1, &mut f, size_of::()).is_err()); + assert_eq!( + s.read_exact_from(1, &mut f, size_of::()).unwrap_err(), + Error::IOError(std::io::Error::new( + std::io::ErrorKind::UnexpectedEof, + "failed to fill the whole buffer" + )) + ); format!("{:?}", s.read_exact_from(1, &mut f, size_of::())); let value = s.read_obj::(1).unwrap(); @@ -1881,10 +2008,18 @@ mod tests { let mut sink = Vec::new(); assert!(s.write_all_to(1, &mut sink, size_of::()).is_ok()); - assert!(s.write_all_to(2, &mut sink, size_of::()).is_err()); - assert!(s - .write_all_to(core::usize::MAX, &mut sink, size_of::()) - .is_err()); + assert_eq!( + s.write_all_to(2, &mut sink, size_of::()).unwrap_err(), + Error::OutOfBounds { addr: 6 } + ); + assert_eq!( + s.write_all_to(core::usize::MAX, &mut sink, size_of::()) + .unwrap_err(), + Error::Overflow { + base: core::usize::MAX, + offset: 4 + } + ); format!("{:?}", s.write_all_to(2, &mut sink, size_of::())); if cfg!(unix) { assert_eq!(sink, vec![0; size_of::()]); @@ -1959,9 +2094,8 @@ mod tests { fn ref_array_overflow() { let mut a = [0, 0, 2, 3, 10]; let a_ref = &mut a[..]; - let res = a_ref.get_array_ref::(4, usize::MAX).unwrap_err(); - assert_matches!( - res, + assert_eq!( + a_ref.get_array_ref::(4, usize::MAX).unwrap_err(), Error::TooBig { nelements: usize::MAX, size: 4, From 80f6dc8717a9f9913217dcbdccd16d6d18562e76 Mon Sep 17 00:00:00 2001 From: Alexandru Cihodaru Date: Mon, 10 Oct 2022 10:22:55 +0300 Subject: [PATCH 3/4] [mmap_unix]: Implement PartialEq for Error enum Implemented PartialEq for Error enum. Considering that from this file the only io error returned are OS error usage of raw_os_error offers anything that is needed. Updated tests to use PartialEq for error cases. Signed-off-by: Alexandru Cihodaru --- src/mmap_unix.rs | 52 +++++++++++++++++++++++++++++++----------------- 1 file changed, 34 insertions(+), 18 deletions(-) diff --git a/src/mmap_unix.rs b/src/mmap_unix.rs index 39c0d504..5c708e53 100644 --- a/src/mmap_unix.rs +++ b/src/mmap_unix.rs @@ -43,6 +43,24 @@ pub enum Error { SeekStart(io::Error), } +impl PartialEq for Error { + fn eq(&self, other: &Self) -> bool { + match (self, other) { + // error.kind should be enough to assert equallity because each error + // has the kind field set and the OS error numbers can be converted + // to ErrorKind through `sys::decode_error_kind`. + (Error::Mmap(left), Error::Mmap(right)) + | (Error::SeekEnd(left), Error::SeekEnd(right)) + | (Error::SeekStart(left), Error::SeekStart(right)) => left.kind() == right.kind(), + (Error::InvalidOffsetLength, Error::InvalidOffsetLength) => true, + (Error::InvalidPointer, Error::InvalidPointer) => true, + (Error::MapFixed, Error::MapFixed) => true, + (Error::MappingOverlap, Error::MappingOverlap) => true, + (Error::MappingPastEof, Error::MappingPastEof) => true, + _ => false, + } + } +} impl fmt::Display for Error { fn fmt(&self, f: &mut std::fmt::Formatter) -> fmt::Result { match self { @@ -467,20 +485,12 @@ mod tests { type MmapRegion = super::MmapRegion<()>; - // Adding a helper method to extract the errno within an Error::Mmap(e), or return a - // distinctive value when the error is represented by another variant. - impl Error { - pub fn raw_os_error(&self) -> i32 { - match self { - Error::Mmap(e) => e.raw_os_error().unwrap(), - _ => std::i32::MIN, - } - } - } - #[test] fn test_mmap_region_new() { - assert!(MmapRegion::new(0).is_err()); + assert_eq!( + MmapRegion::new(0).unwrap_err(), + Error::Mmap(std::io::Error::from_raw_os_error(libc::EINVAL)) + ); let size = 4096; @@ -496,7 +506,10 @@ mod tests { #[test] fn test_mmap_region_set_hugetlbfs() { - assert!(MmapRegion::new(0).is_err()); + assert_eq!( + MmapRegion::new(0).unwrap_err(), + Error::Mmap(std::io::Error::from_raw_os_error(libc::EINVAL)) + ); let size = 4096; @@ -567,7 +580,7 @@ mod tests { prot, flags, ); - assert_eq!(format!("{:?}", r.unwrap_err()), "InvalidOffsetLength"); + assert_eq!(r.unwrap_err(), Error::InvalidOffsetLength); // Offset + size is greater than the size of the file (which is 0 at this point). let r = MmapRegion::build( @@ -576,7 +589,7 @@ mod tests { prot, flags, ); - assert_eq!(format!("{:?}", r.unwrap_err()), "MappingPastEof"); + assert_eq!(r.unwrap_err(), Error::MappingPastEof); // MAP_FIXED was specified among the flags. let r = MmapRegion::build( @@ -585,7 +598,7 @@ mod tests { prot, flags | libc::MAP_FIXED, ); - assert_eq!(format!("{:?}", r.unwrap_err()), "MapFixed"); + assert_eq!(r.unwrap_err(), Error::MapFixed); // Let's resize the file. assert_eq!(unsafe { libc::ftruncate(a.as_raw_fd(), 1024 * 10) }, 0); @@ -597,7 +610,10 @@ mod tests { prot, flags, ); - assert_eq!(r.unwrap_err().raw_os_error(), libc::EINVAL); + assert_eq!( + r.unwrap_err(), + Error::Mmap(std::io::Error::from_raw_os_error(libc::EINVAL)) + ); // The build should be successful now. let r = @@ -629,7 +645,7 @@ mod tests { let flags = libc::MAP_NORESERVE | libc::MAP_PRIVATE; let r = unsafe { MmapRegion::build_raw((addr + 1) as *mut u8, size, prot, flags) }; - assert_eq!(format!("{:?}", r.unwrap_err()), "InvalidPointer"); + assert_eq!(r.unwrap_err(), Error::InvalidPointer); let r = unsafe { MmapRegion::build_raw(addr as *mut u8, size, prot, flags).unwrap() }; From 0ac2b3509225e9ad155cbd7345e21008fe8a3ad6 Mon Sep 17 00:00:00 2001 From: Alexandru Cihodaru Date: Mon, 10 Oct 2022 10:25:33 +0300 Subject: [PATCH 4/4] [mmap]: Derive PartialEq for Error enum Derive PartialEq and update tests to check for equality on error cases. Signed-off-by: Alexandru Cihodaru --- src/mmap.rs | 156 ++++++++++++++++++---------------------------------- 1 file changed, 53 insertions(+), 103 deletions(-) diff --git a/src/mmap.rs b/src/mmap.rs index 5c2500ca..679c89b1 100644 --- a/src/mmap.rs +++ b/src/mmap.rs @@ -71,7 +71,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. @@ -775,43 +775,21 @@ mod tests { #[test] fn test_no_memory_region() { let regions_summary = []; - assert_eq!( - format!( - "{:?}", - new_guest_memory_mmap(®ions_summary).err().unwrap() - ), - format!("{:?}", Error::NoMemoryRegion) + new_guest_memory_mmap(®ions_summary).unwrap_err(), + Error::NoMemoryRegion ); - assert_eq!( - format!( - "{:?}", - new_guest_memory_mmap_with_files(®ions_summary) - .err() - .unwrap() - ), - format!("{:?}", Error::NoMemoryRegion) + new_guest_memory_mmap_with_files(®ions_summary).unwrap_err(), + Error::NoMemoryRegion ); - assert_eq!( - format!( - "{:?}", - new_guest_memory_mmap_from_regions(®ions_summary) - .err() - .unwrap() - ), - format!("{:?}", Error::NoMemoryRegion) + new_guest_memory_mmap_from_regions(®ions_summary).unwrap_err(), + Error::NoMemoryRegion ); - assert_eq!( - format!( - "{:?}", - new_guest_memory_mmap_from_arc_regions(®ions_summary) - .err() - .unwrap() - ), - format!("{:?}", Error::NoMemoryRegion) + new_guest_memory_mmap_from_arc_regions(®ions_summary).unwrap_err(), + Error::NoMemoryRegion ); } @@ -820,41 +798,20 @@ mod tests { let regions_summary = [(GuestAddress(0), 100_usize), (GuestAddress(99), 100_usize)]; assert_eq!( - format!( - "{:?}", - new_guest_memory_mmap(®ions_summary).err().unwrap() - ), - format!("{:?}", Error::MemoryRegionOverlap) + new_guest_memory_mmap(®ions_summary).unwrap_err(), + Error::MemoryRegionOverlap ); - assert_eq!( - format!( - "{:?}", - new_guest_memory_mmap_with_files(®ions_summary) - .err() - .unwrap() - ), - format!("{:?}", Error::MemoryRegionOverlap) + new_guest_memory_mmap_with_files(®ions_summary).unwrap_err(), + Error::MemoryRegionOverlap ); - assert_eq!( - format!( - "{:?}", - new_guest_memory_mmap_from_regions(®ions_summary) - .err() - .unwrap() - ), - format!("{:?}", Error::MemoryRegionOverlap) + new_guest_memory_mmap_from_regions(®ions_summary).unwrap_err(), + Error::MemoryRegionOverlap ); - assert_eq!( - format!( - "{:?}", - new_guest_memory_mmap_from_arc_regions(®ions_summary) - .err() - .unwrap() - ), - format!("{:?}", Error::MemoryRegionOverlap) + new_guest_memory_mmap_from_arc_regions(®ions_summary).unwrap_err(), + Error::MemoryRegionOverlap ); } @@ -863,41 +820,20 @@ mod tests { let regions_summary = [(GuestAddress(100), 100_usize), (GuestAddress(0), 100_usize)]; assert_eq!( - format!( - "{:?}", - new_guest_memory_mmap(®ions_summary).err().unwrap() - ), - format!("{:?}", Error::UnsortedMemoryRegions) + new_guest_memory_mmap(®ions_summary).unwrap_err(), + Error::UnsortedMemoryRegions ); - assert_eq!( - format!( - "{:?}", - new_guest_memory_mmap_with_files(®ions_summary) - .err() - .unwrap() - ), - format!("{:?}", Error::UnsortedMemoryRegions) + new_guest_memory_mmap_with_files(®ions_summary).unwrap_err(), + Error::UnsortedMemoryRegions ); - assert_eq!( - format!( - "{:?}", - new_guest_memory_mmap_from_regions(®ions_summary) - .err() - .unwrap() - ), - format!("{:?}", Error::UnsortedMemoryRegions) + new_guest_memory_mmap_from_regions(®ions_summary).unwrap_err(), + Error::UnsortedMemoryRegions ); - assert_eq!( - format!( - "{:?}", - new_guest_memory_mmap_from_arc_regions(®ions_summary) - .err() - .unwrap() - ), - format!("{:?}", Error::UnsortedMemoryRegions) + new_guest_memory_mmap_from_arc_regions(®ions_summary).unwrap_err(), + Error::UnsortedMemoryRegions ); } @@ -1054,7 +990,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!( @@ -1122,18 +1061,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::(), - max_addr.checked_offset_from(bad_addr2).unwrap() - ) + gm.write_obj(val1, bad_addr2).unwrap_err(), + guest_memory::Error::PartialBuffer { + expected: mem::size_of::(), + 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(); @@ -1435,7 +1372,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] @@ -1483,9 +1424,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]