Skip to content

Commit 4a4d07a

Browse files
roypatroypat
committed
refactor: use matches! instead of to_string() for tests
Some tests that were explicitly testing for error conditions used converted errors to strings to determine whether two errors are the same (by saying they're only the same if their string representation was identical). Replace this with more roboust assertions on `matches!`. Signed-off-by: Patrick Roy <[email protected]>
1 parent 5e8db29 commit 4a4d07a

File tree

4 files changed

+69
-197
lines changed

4 files changed

+69
-197
lines changed

‎src/mmap/mod.rs‎

Lines changed: 56 additions & 124 deletions
Original file line numberDiff line numberDiff line change
@@ -354,7 +354,7 @@ mod tests {
354354

355355
use crate::bitmap::tests::test_guest_memory_and_region;
356356
use crate::bitmap::AtomicBitmap;
357-
use crate::{Error, GuestAddressSpace, GuestMemory};
357+
use crate::{Error, GuestAddressSpace, GuestMemory, GuestMemoryError};
358358

359359
use std::io::Write;
360360
use std::mem;
@@ -451,129 +451,66 @@ mod tests {
451451
fn test_no_memory_region() {
452452
let regions_summary = [];
453453

454-
assert_eq!(
455-
format!(
456-
"{:?}",
457-
new_guest_memory_mmap(&regions_summary).err().unwrap()
458-
),
459-
format!("{:?}", Error::NoMemoryRegion)
460-
);
461-
462-
assert_eq!(
463-
format!(
464-
"{:?}",
465-
new_guest_memory_mmap_with_files(&regions_summary)
466-
.err()
467-
.unwrap()
468-
),
469-
format!("{:?}", Error::NoMemoryRegion)
470-
);
471-
472-
assert_eq!(
473-
format!(
474-
"{:?}",
475-
new_guest_memory_mmap_from_regions(&regions_summary)
476-
.err()
477-
.unwrap()
478-
),
479-
format!("{:?}", Error::NoMemoryRegion)
480-
);
481-
482-
assert_eq!(
483-
format!(
484-
"{:?}",
485-
new_guest_memory_mmap_from_arc_regions(&regions_summary)
486-
.err()
487-
.unwrap()
488-
),
489-
format!("{:?}", Error::NoMemoryRegion)
490-
);
454+
assert!(matches!(
455+
new_guest_memory_mmap(&regions_summary).unwrap_err(),
456+
Error::NoMemoryRegion
457+
));
458+
assert!(matches!(
459+
new_guest_memory_mmap_with_files(&regions_summary).unwrap_err(),
460+
Error::NoMemoryRegion
461+
));
462+
assert!(matches!(
463+
new_guest_memory_mmap_from_regions(&regions_summary).unwrap_err(),
464+
Error::NoMemoryRegion
465+
));
466+
assert!(matches!(
467+
new_guest_memory_mmap_from_regions(&regions_summary).unwrap_err(),
468+
Error::NoMemoryRegion
469+
));
491470
}
492471

493472
#[test]
494473
fn test_overlapping_memory_regions() {
495474
let regions_summary = [(GuestAddress(0), 100_usize), (GuestAddress(99), 100_usize)];
496475

497-
assert_eq!(
498-
format!(
499-
"{:?}",
500-
new_guest_memory_mmap(&regions_summary).err().unwrap()
501-
),
502-
format!("{:?}", Error::MemoryRegionOverlap)
503-
);
504-
505-
assert_eq!(
506-
format!(
507-
"{:?}",
508-
new_guest_memory_mmap_with_files(&regions_summary)
509-
.err()
510-
.unwrap()
511-
),
512-
format!("{:?}", Error::MemoryRegionOverlap)
513-
);
514-
515-
assert_eq!(
516-
format!(
517-
"{:?}",
518-
new_guest_memory_mmap_from_regions(&regions_summary)
519-
.err()
520-
.unwrap()
521-
),
522-
format!("{:?}", Error::MemoryRegionOverlap)
523-
);
524-
525-
assert_eq!(
526-
format!(
527-
"{:?}",
528-
new_guest_memory_mmap_from_arc_regions(&regions_summary)
529-
.err()
530-
.unwrap()
531-
),
532-
format!("{:?}", Error::MemoryRegionOverlap)
533-
);
476+
assert!(matches!(
477+
new_guest_memory_mmap(&regions_summary).unwrap_err(),
478+
Error::MemoryRegionOverlap
479+
));
480+
assert!(matches!(
481+
new_guest_memory_mmap_with_files(&regions_summary).unwrap_err(),
482+
Error::MemoryRegionOverlap
483+
));
484+
assert!(matches!(
485+
new_guest_memory_mmap_from_regions(&regions_summary).unwrap_err(),
486+
Error::MemoryRegionOverlap
487+
));
488+
assert!(matches!(
489+
new_guest_memory_mmap_from_regions(&regions_summary).unwrap_err(),
490+
Error::MemoryRegionOverlap
491+
));
534492
}
535493

536494
#[test]
537495
fn test_unsorted_memory_regions() {
538496
let regions_summary = [(GuestAddress(100), 100_usize), (GuestAddress(0), 100_usize)];
539497

540-
assert_eq!(
541-
format!(
542-
"{:?}",
543-
new_guest_memory_mmap(&regions_summary).err().unwrap()
544-
),
545-
format!("{:?}", Error::UnsortedMemoryRegions)
546-
);
547-
548-
assert_eq!(
549-
format!(
550-
"{:?}",
551-
new_guest_memory_mmap_with_files(&regions_summary)
552-
.err()
553-
.unwrap()
554-
),
555-
format!("{:?}", Error::UnsortedMemoryRegions)
556-
);
557-
558-
assert_eq!(
559-
format!(
560-
"{:?}",
561-
new_guest_memory_mmap_from_regions(&regions_summary)
562-
.err()
563-
.unwrap()
564-
),
565-
format!("{:?}", Error::UnsortedMemoryRegions)
566-
);
567-
568-
assert_eq!(
569-
format!(
570-
"{:?}",
571-
new_guest_memory_mmap_from_arc_regions(&regions_summary)
572-
.err()
573-
.unwrap()
574-
),
575-
format!("{:?}", Error::UnsortedMemoryRegions)
576-
);
498+
assert!(matches!(
499+
new_guest_memory_mmap(&regions_summary).unwrap_err(),
500+
Error::UnsortedMemoryRegions
501+
));
502+
assert!(matches!(
503+
new_guest_memory_mmap_with_files(&regions_summary).unwrap_err(),
504+
Error::UnsortedMemoryRegions
505+
));
506+
assert!(matches!(
507+
new_guest_memory_mmap_from_regions(&regions_summary).unwrap_err(),
508+
Error::UnsortedMemoryRegions
509+
));
510+
assert!(matches!(
511+
new_guest_memory_mmap_from_regions(&regions_summary).unwrap_err(),
512+
Error::UnsortedMemoryRegions
513+
));
577514
}
578515

579516
#[test]
@@ -798,18 +735,13 @@ mod tests {
798735
for gm in gm_list.iter() {
799736
let val1: u64 = 0xaa55_aa55_aa55_aa55;
800737
let val2: u64 = 0x55aa_55aa_55aa_55aa;
801-
assert_eq!(
802-
format!("{:?}", gm.write_obj(val1, bad_addr).err().unwrap()),
803-
format!("InvalidGuestAddress({:?})", bad_addr,)
804-
);
805-
assert_eq!(
806-
format!("{:?}", gm.write_obj(val1, bad_addr2).err().unwrap()),
807-
format!(
808-
"PartialBuffer {{ expected: {:?}, completed: {:?} }}",
809-
mem::size_of::<u64>(),
810-
max_addr.checked_offset_from(bad_addr2).unwrap()
811-
)
812-
);
738+
assert!(matches!(
739+
gm.write_obj(val1, bad_addr).unwrap_err(),
740+
GuestMemoryError::InvalidGuestAddress(addr) if addr == bad_addr
741+
));
742+
assert!(matches!(
743+
gm.write_obj(val1, bad_addr2).unwrap_err(),
744+
GuestMemoryError::PartialBuffer { expected, completed} if expected == size_of::<u64>() && completed == max_addr.checked_offset_from(bad_addr2).unwrap() as usize));
813745

814746
gm.write_obj(val1, GuestAddress(0x500)).unwrap();
815747
gm.write_obj(val2, GuestAddress(0x1000 + 32)).unwrap();

‎src/mmap/unix.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -561,7 +561,7 @@ mod tests {
561561
prot,
562562
flags | libc::MAP_FIXED,
563563
);
564-
assert_eq!(format!("{:?}", r.unwrap_err()), "MapFixed");
564+
assert!(matches!(r.unwrap_err(), Error::MapFixed));
565565

566566
// Let's resize the file.
567567
assert_eq!(unsafe { libc::ftruncate(a.as_raw_fd(), 1024 * 10) }, 0);
@@ -606,7 +606,7 @@ mod tests {
606606
let flags = libc::MAP_NORESERVE | libc::MAP_PRIVATE;
607607

608608
let r = unsafe { MmapRegion::build_raw((addr + 1) as *mut u8, size, prot, flags) };
609-
assert_eq!(format!("{:?}", r.unwrap_err()), "InvalidPointer");
609+
assert!(matches!(r.unwrap_err(), Error::InvalidPointer));
610610

611611
let r = unsafe { MmapRegion::build_raw(addr as *mut u8, size, prot, flags).unwrap() };
612612

‎src/mmap/xen.rs‎

Lines changed: 11 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -1069,26 +1069,18 @@ mod tests {
10691069
range.mmap_flags = 16;
10701070

10711071
let r = MmapXen::new(&range);
1072-
assert_eq!(
1073-
format!("{:?}", r.unwrap_err()),
1074-
format!("MmapFlags({})", range.mmap_flags),
1075-
);
1072+
assert!(matches!(r.unwrap_err(), Error::MmapFlags(flags) if flags == range.mmap_flags));
10761073

10771074
range.mmap_flags = MmapXenFlags::FOREIGN.bits() | MmapXenFlags::GRANT.bits();
10781075
let r = MmapXen::new(&range);
1079-
assert_eq!(
1080-
format!("{:?}", r.unwrap_err()),
1081-
format!("MmapFlags({:x})", MmapXenFlags::ALL.bits()),
1076+
assert!(
1077+
matches!(r.unwrap_err(), Error::MmapFlags(flags) if flags == MmapXenFlags::ALL.bits())
10821078
);
10831079

10841080
range.mmap_flags = MmapXenFlags::FOREIGN.bits() | MmapXenFlags::NO_ADVANCE_MAP.bits();
10851081
let r = MmapXen::new(&range);
1086-
assert_eq!(
1087-
format!("{:?}", r.unwrap_err()),
1088-
format!(
1089-
"MmapFlags({:x})",
1090-
MmapXenFlags::NO_ADVANCE_MAP.bits() | MmapXenFlags::FOREIGN.bits(),
1091-
),
1082+
assert!(
1083+
matches!(r.unwrap_err(), Error::MmapFlags(flags) if flags == MmapXenFlags::NO_ADVANCE_MAP.bits() | MmapXenFlags::FOREIGN.bits())
10921084
);
10931085
}
10941086

@@ -1124,17 +1116,17 @@ mod tests {
11241116
range.file_offset = Some(FileOffset::new(TempFile::new().unwrap().into_file(), 0));
11251117
range.prot = None;
11261118
let r = MmapXenForeign::new(&range);
1127-
assert_eq!(format!("{:?}", r.unwrap_err()), "UnexpectedError");
1119+
assert!(matches!(r.unwrap_err(), Error::UnexpectedError));
11281120

11291121
let mut range = MmapRange::initialized(true);
11301122
range.flags = None;
11311123
let r = MmapXenForeign::new(&range);
1132-
assert_eq!(format!("{:?}", r.unwrap_err()), "UnexpectedError");
1124+
assert!(matches!(r.unwrap_err(), Error::UnexpectedError));
11331125

11341126
let mut range = MmapRange::initialized(true);
11351127
range.file_offset = Some(FileOffset::new(TempFile::new().unwrap().into_file(), 1));
11361128
let r = MmapXenForeign::new(&range);
1137-
assert_eq!(format!("{:?}", r.unwrap_err()), "InvalidOffsetLength");
1129+
assert!(matches!(r.unwrap_err(), Error::InvalidOffsetLength));
11381130

11391131
let mut range = MmapRange::initialized(true);
11401132
range.size = 0;
@@ -1156,7 +1148,7 @@ mod tests {
11561148
let mut range = MmapRange::initialized(true);
11571149
range.prot = None;
11581150
let r = MmapXenGrant::new(&range, MmapXenFlags::empty());
1159-
assert_eq!(format!("{:?}", r.unwrap_err()), "UnexpectedError");
1151+
assert!(matches!(r.unwrap_err(), Error::UnexpectedError));
11601152

11611153
let mut range = MmapRange::initialized(true);
11621154
range.prot = None;
@@ -1166,12 +1158,12 @@ mod tests {
11661158
let mut range = MmapRange::initialized(true);
11671159
range.flags = None;
11681160
let r = MmapXenGrant::new(&range, MmapXenFlags::NO_ADVANCE_MAP);
1169-
assert_eq!(format!("{:?}", r.unwrap_err()), "UnexpectedError");
1161+
assert!(matches!(r.unwrap_err(), Error::UnexpectedError));
11701162

11711163
let mut range = MmapRange::initialized(true);
11721164
range.file_offset = Some(FileOffset::new(TempFile::new().unwrap().into_file(), 1));
11731165
let r = MmapXenGrant::new(&range, MmapXenFlags::NO_ADVANCE_MAP);
1174-
assert_eq!(format!("{:?}", r.unwrap_err()), "InvalidOffsetLength");
1166+
assert!(matches!(r.unwrap_err(), Error::InvalidOffsetLength));
11751167

11761168
let mut range = MmapRange::initialized(true);
11771169
range.size = 0;

‎src/volatile_memory.rs‎

Lines changed: 0 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -1488,58 +1488,6 @@ mod tests {
14881488
slice.compute_end_offset(6, 0).unwrap_err();
14891489
}
14901490

1491-
#[test]
1492-
fn test_display_error() {
1493-
assert_eq!(
1494-
format!("{}", Error::OutOfBounds { addr: 0x10 }),
1495-
"address 0x10 is out of bounds"
1496-
);
1497-
1498-
assert_eq!(
1499-
format!(
1500-
"{}",
1501-
Error::Overflow {
1502-
base: 0x0,
1503-
offset: 0x10
1504-
}
1505-
),
1506-
"address 0x0 offset by 0x10 would overflow"
1507-
);
1508-
1509-
assert_eq!(
1510-
format!(
1511-
"{}",
1512-
Error::TooBig {
1513-
nelements: 100_000,
1514-
size: 1_000_000_000
1515-
}
1516-
),
1517-
"100000 elements of size 1000000000 would overflow a usize"
1518-
);
1519-
1520-
assert_eq!(
1521-
format!(
1522-
"{}",
1523-
Error::Misaligned {
1524-
addr: 0x4,
1525-
alignment: 8
1526-
}
1527-
),
1528-
"address 0x4 is not aligned to 8"
1529-
);
1530-
1531-
assert_eq!(
1532-
format!(
1533-
"{}",
1534-
Error::PartialBuffer {
1535-
expected: 100,
1536-
completed: 90
1537-
}
1538-
),
1539-
"only used 90 bytes in 100 long buffer"
1540-
);
1541-
}
1542-
15431491
#[test]
15441492
fn misaligned_ref() {
15451493
let mut a = [0u8; 3];

0 commit comments

Comments
 (0)