Clippy test warnings

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,15 +117,15 @@ 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)
                     .unwrap()
             })
         });
 
-        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::<SmallDummy>());
         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::<SmallDummy>(obj_addr).unwrap()),
-        );
+        c.bench_function(format!("read_small_obj_from_{obj_off:#0X}").as_str(), |b| {
+            b.iter(|| black_box(&memory).read_obj::<SmallDummy>(obj_addr).unwrap())
+        });
 
         let obj_off = access.make_offset(size_of::<BigDummy>());
         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::<BigDummy>(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,15 +166,15 @@ 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)
                     .unwrap()
             })
         });
 
-        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::<SmallDummy>());
         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::<SmallDummy>(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::<SmallDummy>(some_small_dummy, obj_addr)
+                    .unwrap()
+            })
+        });
 
         let obj_off = access.make_offset(size_of::<BigDummy>());
         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::<BigDummy>(some_big_dummy, obj_addr)

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/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

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

@@ -510,8 +510,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();