clippy: remove assertions on result states

Signed-off-by: Daniel Vallance <[email protected]>

Author: danielvallance

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)),

src/bytes.rs

@@ -442,8 +442,8 @@ pub(crate) mod tests {
         b.store(val, addr, Ordering::Relaxed).unwrap();
         assert_eq!(b.load::<u32>(addr, Ordering::Relaxed).unwrap(), val);
 
-        assert!(b.load::<u32>(bad_addr, Ordering::Relaxed).is_err());
-        assert!(b.store(val, bad_addr, Ordering::Relaxed).is_err());
+        b.load::<u32>(bad_addr, Ordering::Relaxed).unwrap_err();
+        b.store(val, bad_addr, Ordering::Relaxed).unwrap_err();
     }
 
     fn check_byte_valued_type<T>()
@@ -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::<u64>(0).unwrap(), u64::MAX);
 
-        assert!(bytes
-            .write_obj(u64::MAX, MOCK_BYTES_CONTAINER_SIZE)
-            .is_err());
-        assert!(bytes.read_obj::<u64>(MOCK_BYTES_CONTAINER_SIZE).is_err());
+        assert_eq!(
+            bytes.write_obj(u64::MAX, MOCK_BYTES_CONTAINER_SIZE),
+            Err(())
+        );
+        assert_eq!(bytes.read_obj::<u64>(MOCK_BYTES_CONTAINER_SIZE), Err(()));
     }
 
     #[repr(C)]

src/guest_memory.rs

@@ -1098,31 +1098,29 @@ 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::<ZeroSizedStruct>(addr).is_ok());
+        mem.write_obj(obj, addr).unwrap();
+        mem.read_obj::<ZeroSizedStruct>(addr).unwrap();
 
         assert_eq!(
             mem.read_volatile_from(addr, &mut image.as_slice(), 0)
                 .unwrap(),
             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)
                 .unwrap(),
             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")]

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)]

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

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;
 

src/region.rs

@@ -509,8 +509,6 @@ pub(crate) mod tests {
         maybe_guest_mem: Result<Collection, GuestRegionCollectionError>,
         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();