diff --git a/benches/mmap/mod.rs b/benches/mmap/mod.rs index 2b38dceb..7da8ea01 100644 --- a/benches/mmap/mod.rs +++ b/benches/mmap/mod.rs @@ -108,7 +108,7 @@ pub fn benchmark_for_mmap(c: &mut Criterion) { let address = GuestAddress(offset); // Check performance for read operations. - c.bench_function(format!("read_from_{:#0X}", offset).as_str(), |b| { + c.bench_function(format!("read_from_{offset:#0X}").as_str(), |b| { b.iter(|| { black_box(&memory) .read_volatile_from(address, &mut image.as_slice(), ACCESS_SIZE) @@ -117,7 +117,7 @@ pub fn benchmark_for_mmap(c: &mut Criterion) { }); #[cfg(feature = "rawfd")] - c.bench_function(format!("read_from_file_{:#0X}", offset).as_str(), |b| { + c.bench_function(format!("read_from_file_{offset:#0X}").as_str(), |b| { b.iter(|| { black_box(&memory) .read_volatile_from(address, &mut file, ACCESS_SIZE) @@ -125,7 +125,7 @@ pub fn benchmark_for_mmap(c: &mut Criterion) { }) }); - c.bench_function(format!("read_exact_from_{:#0X}", offset).as_str(), |b| { + c.bench_function(format!("read_exact_from_{offset:#0X}").as_str(), |b| { b.iter(|| { black_box(&memory) .read_exact_volatile_from(address, &mut image.as_slice(), ACCESS_SIZE) @@ -134,31 +134,30 @@ pub fn benchmark_for_mmap(c: &mut Criterion) { }); c.bench_function( - format!("read_entire_slice_from_{:#0X}", offset).as_str(), + format!("read_entire_slice_from_{offset:#0X}").as_str(), |b| b.iter(|| black_box(&memory).read_slice(buf, address).unwrap()), ); - c.bench_function(format!("read_slice_from_{:#0X}", offset).as_str(), |b| { + c.bench_function(format!("read_slice_from_{offset:#0X}").as_str(), |b| { b.iter(|| black_box(&memory).read(buf, address).unwrap()) }); let obj_off = access.make_offset(size_of::()); let obj_addr = GuestAddress(obj_off); - c.bench_function( - format!("read_small_obj_from_{:#0X}", obj_off).as_str(), - |b| b.iter(|| black_box(&memory).read_obj::(obj_addr).unwrap()), - ); + c.bench_function(format!("read_small_obj_from_{obj_off:#0X}").as_str(), |b| { + b.iter(|| black_box(&memory).read_obj::(obj_addr).unwrap()) + }); let obj_off = access.make_offset(size_of::()); let obj_addr = GuestAddress(obj_off); - c.bench_function(format!("read_big_obj_from_{:#0X}", obj_off).as_str(), |b| { + c.bench_function(format!("read_big_obj_from_{obj_off:#0X}").as_str(), |b| { b.iter(|| black_box(&memory).read_obj::(obj_addr).unwrap()) }); // Check performance for write operations. - c.bench_function(format!("write_to_{:#0X}", offset).as_str(), |b| { + c.bench_function(format!("write_to_{offset:#0X}").as_str(), |b| { b.iter(|| { black_box(&memory) .write_volatile_to(address, &mut image.as_mut_slice(), ACCESS_SIZE) @@ -167,7 +166,7 @@ pub fn benchmark_for_mmap(c: &mut Criterion) { }); #[cfg(feature = "rawfd")] - c.bench_function(format!("write_to_file_{:#0X}", offset).as_str(), |b| { + c.bench_function(format!("write_to_file_{offset:#0X}").as_str(), |b| { b.iter(|| { black_box(&memory) .write_volatile_to(address, &mut file_to_write, ACCESS_SIZE) @@ -175,7 +174,7 @@ pub fn benchmark_for_mmap(c: &mut Criterion) { }) }); - c.bench_function(format!("write_exact_to_{:#0X}", offset).as_str(), |b| { + c.bench_function(format!("write_exact_to_{offset:#0X}").as_str(), |b| { b.iter(|| { black_box(&memory) .write_all_volatile_to(address, &mut image.as_mut_slice(), ACCESS_SIZE) @@ -184,32 +183,29 @@ pub fn benchmark_for_mmap(c: &mut Criterion) { }); c.bench_function( - format!("write_entire_slice_to_{:#0X}", offset).as_str(), + format!("write_entire_slice_to_{offset:#0X}").as_str(), |b| b.iter(|| black_box(&memory).write_slice(buf, address).unwrap()), ); - c.bench_function(format!("write_slice_to_{:#0X}", offset).as_str(), |b| { + c.bench_function(format!("write_slice_to_{offset:#0X}").as_str(), |b| { b.iter(|| black_box(&memory).write(buf, address).unwrap()) }); let obj_off = access.make_offset(size_of::()); let obj_addr = GuestAddress(obj_off); - c.bench_function( - format!("write_small_obj_to_{:#0X}", obj_off).as_str(), - |b| { - b.iter(|| { - black_box(&memory) - .write_obj::(some_small_dummy, obj_addr) - .unwrap() - }) - }, - ); + c.bench_function(format!("write_small_obj_to_{obj_off:#0X}").as_str(), |b| { + b.iter(|| { + black_box(&memory) + .write_obj::(some_small_dummy, obj_addr) + .unwrap() + }) + }); let obj_off = access.make_offset(size_of::()); let obj_addr = GuestAddress(obj_off); - c.bench_function(format!("write_big_obj_to_{:#0X}", obj_off).as_str(), |b| { + c.bench_function(format!("write_big_obj_to_{obj_off:#0X}").as_str(), |b| { b.iter(|| { black_box(&memory) .write_obj::(some_big_dummy, obj_addr) diff --git a/src/address.rs b/src/address.rs index 639e226b..64f64154 100644 --- a/src/address.rs +++ b/src/address.rs @@ -324,7 +324,13 @@ mod tests { if expected_overflow { assert!(MockAddress(a).checked_add(b).is_none()); #[cfg(debug_assertions)] - assert!(std::panic::catch_unwind(|| MockAddress(a).unchecked_add(b)).is_err()); + { + let result = std::panic::catch_unwind(|| MockAddress(a).unchecked_add(b)); + assert_eq!( + result.unwrap_err().downcast_ref::<&str>().unwrap(), + &"attempt to add with overflow" + ); + } } else { assert_eq!( Some(MockAddress(expected_result)), @@ -358,7 +364,13 @@ mod tests { assert!(MockAddress(a).checked_sub(b).is_none()); assert!(MockAddress(a).checked_offset_from(MockAddress(b)).is_none()); #[cfg(debug_assertions)] - assert!(std::panic::catch_unwind(|| MockAddress(a).unchecked_sub(b)).is_err()); + { + let result = std::panic::catch_unwind(|| MockAddress(a).unchecked_sub(b)); + assert_eq!( + result.unwrap_err().downcast_ref::<&str>().unwrap(), + &"attempt to subtract with overflow" + ); + } } else { assert_eq!( Some(MockAddress(expected_result)), diff --git a/src/bytes.rs b/src/bytes.rs index dc92a05f..9ff74204 100644 --- a/src/bytes.rs +++ b/src/bytes.rs @@ -442,8 +442,8 @@ pub(crate) mod tests { b.store(val, addr, Ordering::Relaxed).unwrap(); assert_eq!(b.load::(addr, Ordering::Relaxed).unwrap(), val); - assert!(b.load::(bad_addr, Ordering::Relaxed).is_err()); - assert!(b.store(val, bad_addr, Ordering::Relaxed).is_err()); + b.load::(bad_addr, Ordering::Relaxed).unwrap_err(); + b.store(val, bad_addr, Ordering::Relaxed).unwrap_err(); } fn check_byte_valued_type() @@ -616,13 +616,14 @@ pub(crate) mod tests { fn test_bytes() { let bytes = MockBytesContainer::new(); - assert!(bytes.write_obj(u64::MAX, 0).is_ok()); + bytes.write_obj(u64::MAX, 0).unwrap(); assert_eq!(bytes.read_obj::(0).unwrap(), u64::MAX); - assert!(bytes - .write_obj(u64::MAX, MOCK_BYTES_CONTAINER_SIZE) - .is_err()); - assert!(bytes.read_obj::(MOCK_BYTES_CONTAINER_SIZE).is_err()); + assert_eq!( + bytes.write_obj(u64::MAX, MOCK_BYTES_CONTAINER_SIZE), + Err(()) + ); + assert_eq!(bytes.read_obj::(MOCK_BYTES_CONTAINER_SIZE), Err(())); } #[repr(C)] diff --git a/src/guest_memory.rs b/src/guest_memory.rs index fcb8942e..1271d793 100644 --- a/src/guest_memory.rs +++ b/src/guest_memory.rs @@ -1098,11 +1098,11 @@ mod tests { assert_eq!(mem.write(&[], addr).unwrap(), 0); assert_eq!(mem.read(&mut [], addr).unwrap(), 0); - assert!(mem.write_slice(&[], addr).is_ok()); - assert!(mem.read_slice(&mut [], addr).is_ok()); + mem.write_slice(&[], addr).unwrap(); + mem.read_slice(&mut [], addr).unwrap(); - assert!(mem.write_obj(obj, addr).is_ok()); - assert!(mem.read_obj::(addr).is_ok()); + mem.write_obj(obj, addr).unwrap(); + mem.read_obj::(addr).unwrap(); assert_eq!( mem.read_volatile_from(addr, &mut image.as_slice(), 0) @@ -1110,9 +1110,8 @@ mod tests { 0 ); - assert!(mem - .read_exact_volatile_from(addr, &mut image.as_slice(), 0) - .is_ok()); + mem.read_exact_volatile_from(addr, &mut image.as_slice(), 0) + .unwrap(); assert_eq!( mem.write_volatile_to(addr, &mut image.as_mut_slice(), 0) @@ -1120,9 +1119,8 @@ mod tests { 0 ); - assert!(mem - .write_all_volatile_to(addr, &mut image.as_mut_slice(), 0) - .is_ok()); + mem.write_all_volatile_to(addr, &mut image.as_mut_slice(), 0) + .unwrap(); } #[cfg(feature = "backend-mmap")] diff --git a/src/io.rs b/src/io.rs index 3c338491..83ac6f20 100644 --- a/src/io.rs +++ b/src/io.rs @@ -464,7 +464,7 @@ mod tests { VolatileMemoryError::IOError(ioe) => { assert_eq!(ioe.kind(), ErrorKind::UnexpectedEof) } - err => panic!("{:?}", err), + err => panic!("{err:?}"), } assert_eq!(memory, vec![0u8; 5]); } else { @@ -547,7 +547,7 @@ mod tests { VolatileMemoryError::IOError(ioe) => { assert_eq!(ioe.kind(), ErrorKind::WriteZero) } - err => panic!("{:?}", err), + err => panic!("{err:?}"), } // This quirky behavior of writing to the slice even in the case of failure is also // exhibited by the stdlib diff --git a/src/lib.rs b/src/lib.rs index dad56293..d00b630c 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -15,6 +15,7 @@ //! without knowing the implementation details of the VM memory provider. Thus hypervisor //! components, such as boot loader, virtual device drivers, virtio backend drivers and vhost //! drivers etc, could be shared and reused by multiple hypervisors. +#![warn(clippy::assertions_on_result_states)] #![warn(clippy::doc_markdown)] #![warn(missing_docs)] #![warn(missing_debug_implementations)] diff --git a/src/mmap/mod.rs b/src/mmap/mod.rs index 68475ca8..d125a419 100644 --- a/src/mmap/mod.rs +++ b/src/mmap/mod.rs @@ -271,7 +271,7 @@ mod tests { fn mapped_file_read() { let mut f = TempFile::new().unwrap().into_file(); let sample_buf = &[1, 2, 3, 4, 5]; - assert!(f.write_all(sample_buf).is_ok()); + f.write_all(sample_buf).unwrap(); let file = Some(FileOffset::new(f, 0)); let mem_map = GuestRegionMmap::from_range(GuestAddress(0), sample_buf.len(), file).unwrap(); @@ -330,7 +330,10 @@ mod tests { let guest_mem_list = [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_matches!( + guest_mem.get_host_address(GuestAddress(0x600)).unwrap_err(), + GuestMemoryError::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!( @@ -613,7 +616,10 @@ 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_matches!( + region.get_slice(slice_addr, slice_size).unwrap_err(), + GuestMemoryError::InvalidBackendAddress + ); } #[test] @@ -659,9 +665,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_matches!( + guest_mem.get_slice(GuestAddress(0), 0x500).unwrap_err(), + GuestMemoryError::InvalidBackendAddress + ); + assert_matches!( + guest_mem.get_slice(GuestAddress(0x600), 0x100).unwrap_err(), + GuestMemoryError::InvalidGuestAddress(GuestAddress(0x600)) + ); + assert_matches!( + guest_mem.get_slice(GuestAddress(0xc00), 0x100).unwrap_err(), + GuestMemoryError::InvalidGuestAddress(GuestAddress(0xc00)) + ); } #[test] @@ -698,13 +713,22 @@ mod tests { // Error cases, wrong size or base address. let mut slices = guest_mem.get_slices(GuestAddress(0), 0x500); assert_eq!(slices.next().unwrap().unwrap().len(), 0x400); - assert!(slices.next().unwrap().is_err()); + assert_matches!( + slices.next().unwrap().unwrap_err(), + GuestMemoryError::InvalidGuestAddress(GuestAddress(0x400)) + ); assert!(slices.next().is_none()); let mut slices = guest_mem.get_slices(GuestAddress(0x600), 0x100); - assert!(slices.next().unwrap().is_err()); + assert_matches!( + slices.next().unwrap().unwrap_err(), + GuestMemoryError::InvalidGuestAddress(GuestAddress(0x600)) + ); assert!(slices.next().is_none()); let mut slices = guest_mem.get_slices(GuestAddress(0x1000), 0x100); - assert!(slices.next().unwrap().is_err()); + assert_matches!( + slices.next().unwrap().unwrap_err(), + GuestMemoryError::InvalidGuestAddress(GuestAddress(0x1000)) + ); assert!(slices.next().is_none()); // Test fragmented case diff --git a/src/mmap/unix.rs b/src/mmap/unix.rs index f47e8e79..86ea3cd3 100644 --- a/src/mmap/unix.rs +++ b/src/mmap/unix.rs @@ -463,7 +463,7 @@ mod tests { #[test] fn test_mmap_region_new() { - assert!(MmapRegion::new(0).is_err()); + assert_matches!(MmapRegion::new(0).unwrap_err(), Error::Mmap(e) if e.kind() == io::ErrorKind::InvalidInput); let size = 4096; @@ -479,7 +479,7 @@ mod tests { #[test] fn test_mmap_region_set_hugetlbfs() { - assert!(MmapRegion::new(0).is_err()); + assert_matches!(MmapRegion::new(0).unwrap_err(), Error::Mmap(e) if e.kind() == io::ErrorKind::InvalidInput); let size = 4096; diff --git a/src/region.rs b/src/region.rs index 974e4f3b..849c547f 100644 --- a/src/region.rs +++ b/src/region.rs @@ -510,8 +510,6 @@ pub(crate) mod tests { maybe_guest_mem: Result, expected_regions_summary: &[(GuestAddress, u64)], ) { - assert!(maybe_guest_mem.is_ok()); - let guest_mem = maybe_guest_mem.unwrap(); assert_eq!(guest_mem.num_regions(), expected_regions_summary.len()); let maybe_last_mem_reg = expected_regions_summary.last(); diff --git a/src/volatile_memory.rs b/src/volatile_memory.rs index c4a24ae7..9229d6c5 100644 --- a/src/volatile_memory.rs +++ b/src/volatile_memory.rs @@ -85,10 +85,17 @@ pub type Result = result::Result; /// # Examples /// /// ``` -/// # use vm_memory::volatile_memory::compute_offset; +/// # use matches::assert_matches; +/// # use vm_memory::volatile_memory::{compute_offset, Error}; /// # /// assert_eq!(108, compute_offset(100, 8).unwrap()); -/// assert!(compute_offset(usize::MAX, 6).is_err()); +/// assert_matches!( +/// compute_offset(usize::MAX, 6).unwrap_err(), +/// Error::Overflow { +/// base: usize::MAX, +/// offset: 6 +/// } +/// ); /// ``` pub fn compute_offset(base: usize, offset: usize) -> Result { match base.checked_add(offset) { @@ -1560,8 +1567,11 @@ mod tests { let mut a = [5usize, 5usize]; 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()); + a_ref.get_atomic_ref::(0).unwrap(); + assert_matches!( + a_ref.get_atomic_ref::(1).unwrap_err(), + Error::OutOfBounds { addr: 9 } + ); } #[test] @@ -1677,31 +1687,56 @@ mod tests { let mut backing = vec![0u8; 100]; let mem = VolatileSlice::from(backing.as_mut_slice()); let slice = mem.get_slice(0, 100).unwrap(); - assert!(slice.write(&[1; 80], 10).is_ok()); + slice.write(&[1; 80], 10).unwrap(); - assert!(slice.subslice(0, 0).is_ok()); - assert!(slice.subslice(0, 101).is_err()); + slice.subslice(0, 0).unwrap(); + assert_matches!( + 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()); + slice.subslice(99, 0).unwrap(); + slice.subslice(99, 1).unwrap(); + assert_matches!( + slice.subslice(99, 2).unwrap_err(), + Error::OutOfBounds { addr: 101 } + ); - assert!(slice.subslice(100, 0).is_ok()); - assert!(slice.subslice(100, 1).is_err()); + slice.subslice(100, 0).unwrap(); + assert_matches!( + slice.subslice(100, 1).unwrap_err(), + Error::OutOfBounds { addr: 101 } + ); - assert!(slice.subslice(101, 0).is_err()); - assert!(slice.subslice(101, 1).is_err()); + assert_matches!( + slice.subslice(101, 0).unwrap_err(), + Error::OutOfBounds { addr: 101 } + ); + assert_matches!( + slice.subslice(101, 1).unwrap_err(), + Error::OutOfBounds { addr: 102 } + ); - assert!(slice.subslice(usize::MAX, 2).is_err()); - assert!(slice.subslice(2, usize::MAX).is_err()); + assert_matches!( + slice.subslice(usize::MAX, 2).unwrap_err(), + Error::Overflow { + base: usize::MAX, + offset: 2 + } + ); + assert_matches!( + slice.subslice(2, usize::MAX).unwrap_err(), + Error::Overflow { + base: 2, + offset: usize::MAX + } + ); - let maybe_offset_slice = slice.subslice(10, 80); - assert!(maybe_offset_slice.is_ok()); - let offset_slice = maybe_offset_slice.unwrap(); + let offset_slice = slice.subslice(10, 80).unwrap(); assert_eq!(offset_slice.len(), 80); let mut buf = [0; 80]; - assert!(offset_slice.read(&mut buf, 0).is_ok()); + offset_slice.read(&mut buf, 0).unwrap(); assert_eq!(&buf[0..80], &[1; 80][0..80]); } @@ -1710,16 +1745,17 @@ mod tests { let mut backing = vec![0u8; 100]; let mem = VolatileSlice::from(backing.as_mut_slice()); let slice = mem.get_slice(0, 100).unwrap(); - assert!(slice.write(&[1; 80], 10).is_ok()); + slice.write(&[1; 80], 10).unwrap(); - assert!(slice.offset(101).is_err()); + assert_matches!( + slice.offset(101).unwrap_err(), + Error::OutOfBounds { addr } if addr == slice.addr as usize + 101 + ); - let maybe_offset_slice = slice.offset(10); - assert!(maybe_offset_slice.is_ok()); - let offset_slice = maybe_offset_slice.unwrap(); + let offset_slice = slice.offset(10).unwrap(); assert_eq!(offset_slice.len(), 90); let mut buf = [0; 90]; - assert!(offset_slice.read(&mut buf, 0).is_ok()); + offset_slice.read(&mut buf, 0).unwrap(); assert_eq!(&buf[0..80], &[1; 80][0..80]); assert_eq!(&buf[80..90], &[0; 10][0..10]); } @@ -1869,7 +1905,6 @@ mod tests { let a = VolatileSlice::from(backing.as_mut_slice()); let s = a.as_volatile_slice(); let res = s.write(&[1, 2, 3, 4, 5, 6], 0); - assert!(res.is_ok()); assert_eq!(res.unwrap(), 5); } @@ -1879,11 +1914,17 @@ mod tests { let a = VolatileSlice::from(backing.as_mut_slice()); let s = a.as_volatile_slice(); let sample_buf = [1, 2, 3]; - assert!(s.write(&sample_buf, 5).is_err()); - assert!(s.write(&sample_buf, 2).is_ok()); + assert_matches!( + s.write(&sample_buf, 5).unwrap_err(), + Error::OutOfBounds { addr: 5 } + ); + s.write(&sample_buf, 2).unwrap(); let mut buf = [0u8; 3]; - assert!(s.read(&mut buf, 5).is_err()); - assert!(s.read_slice(&mut buf, 2).is_ok()); + assert_matches!( + s.read(&mut buf, 5).unwrap_err(), + Error::OutOfBounds { addr: 5 } + ); + s.read_slice(&mut buf, 2).unwrap(); assert_eq!(buf, sample_buf); // Writing an empty buffer at the end of the volatile slice works. @@ -1904,12 +1945,30 @@ mod tests { let mut backing = vec![0u8; 5]; let a = VolatileSlice::from(backing.as_mut_slice()); let s = a.as_volatile_slice(); - assert!(s.write_obj(55u16, 4).is_err()); - assert!(s.write_obj(55u16, usize::MAX).is_err()); - assert!(s.write_obj(55u16, 2).is_ok()); + assert_matches!( + s.write_obj(55u16, 4).unwrap_err(), + Error::PartialBuffer { + expected: 2, + completed: 1 + } + ); + assert_matches!( + s.write_obj(55u16, usize::MAX).unwrap_err(), + Error::OutOfBounds { addr: usize::MAX } + ); + s.write_obj(55u16, 2).unwrap(); assert_eq!(s.read_obj::(2).unwrap(), 55u16); - assert!(s.read_obj::(4).is_err()); - assert!(s.read_obj::(usize::MAX).is_err()); + assert_matches!( + s.read_obj::(4).unwrap_err(), + Error::PartialBuffer { + expected: 2, + completed: 1 + } + ); + assert_matches!( + s.read_obj::(usize::MAX).unwrap_err(), + Error::OutOfBounds { addr: usize::MAX } + ); } #[test] @@ -1918,16 +1977,15 @@ mod tests { let mut backing = vec![0u8; 5]; let a = VolatileSlice::from(backing.as_mut_slice()); let s = a.as_volatile_slice(); - assert!(s.write_obj(!0u32, 1).is_ok()); + s.write_obj(!0u32, 1).unwrap(); let mut file = if cfg!(target_family = "unix") { File::open(Path::new("/dev/zero")).unwrap() } else { File::open(Path::new("c:\\Windows\\system32\\ntoskrnl.exe")).unwrap() }; - assert!(file - .read_exact_volatile(&mut s.get_slice(1, size_of::()).unwrap()) - .is_ok()); + file.read_exact_volatile(&mut s.get_slice(1, size_of::()).unwrap()) + .unwrap(); let mut f = TempFile::new().unwrap().into_file(); assert!(f @@ -1942,10 +2000,9 @@ mod tests { } let mut sink = vec![0; size_of::()]; - assert!(sink - .as_mut_slice() + sink.as_mut_slice() .write_all_volatile(&s.get_slice(1, size_of::()).unwrap()) - .is_ok()); + .unwrap(); if cfg!(target_family = "unix") { assert_eq!(sink, vec![0; size_of::()]); @@ -1960,14 +2017,14 @@ mod tests { let a = VolatileSlice::from(backing.as_mut_slice()); let s = a.as_volatile_slice(); let sample_buf: [u8; 7] = [1, 2, 0xAA, 0xAA, 0xAA, 0xAA, 4]; - assert!(s.write_slice(&sample_buf, 0).is_ok()); + s.write_slice(&sample_buf, 0).unwrap(); let r = a.get_ref::(2).unwrap(); assert_eq!(r.load(), 0xAAAA_AAAA); r.store(0x5555_5555); let sample_buf: [u8; 7] = [1, 2, 0x55, 0x55, 0x55, 0x55, 4]; let mut buf: [u8; 7] = Default::default(); - assert!(s.read_slice(&mut buf, 0).is_ok()); + s.read_slice(&mut buf, 0).unwrap(); assert_eq!(buf, sample_buf); }