Skip to content

Commit 8de505f

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 <roypat@amazon.co.uk>
1 parent f1718b8 commit 8de505f

File tree

4 files changed

+71
-199
lines changed

4 files changed

+71
-199
lines changed

‎src/mmap/mod.rs‎

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

385385
use crate::bitmap::tests::test_guest_memory_and_region;
386386
use crate::bitmap::AtomicBitmap;
387-
use crate::{Error, GuestAddressSpace, GuestMemory};
387+
use crate::{Error, GuestAddressSpace, GuestMemory, GuestMemoryError};
388388

389389
use std::io::Write;
390390
use std::mem;
@@ -481,129 +481,66 @@ mod tests {
481481
fn test_no_memory_region() {
482482
let regions_summary = [];
483483

484-
assert_eq!(
485-
format!(
486-
"{:?}",
487-
new_guest_memory_mmap(&regions_summary).err().unwrap()
488-
),
489-
format!("{:?}", Error::NoMemoryRegion)
490-
);
491-
492-
assert_eq!(
493-
format!(
494-
"{:?}",
495-
new_guest_memory_mmap_with_files(&regions_summary)
496-
.err()
497-
.unwrap()
498-
),
499-
format!("{:?}", Error::NoMemoryRegion)
500-
);
501-
502-
assert_eq!(
503-
format!(
504-
"{:?}",
505-
new_guest_memory_mmap_from_regions(&regions_summary)
506-
.err()
507-
.unwrap()
508-
),
509-
format!("{:?}", Error::NoMemoryRegion)
510-
);
511-
512-
assert_eq!(
513-
format!(
514-
"{:?}",
515-
new_guest_memory_mmap_from_arc_regions(&regions_summary)
516-
.err()
517-
.unwrap()
518-
),
519-
format!("{:?}", Error::NoMemoryRegion)
520-
);
484+
assert!(matches!(
485+
new_guest_memory_mmap(&regions_summary).unwrap_err(),
486+
Error::NoMemoryRegion
487+
));
488+
assert!(matches!(
489+
new_guest_memory_mmap_with_files(&regions_summary).unwrap_err(),
490+
Error::NoMemoryRegion
491+
));
492+
assert!(matches!(
493+
new_guest_memory_mmap_from_regions(&regions_summary).unwrap_err(),
494+
Error::NoMemoryRegion
495+
));
496+
assert!(matches!(
497+
new_guest_memory_mmap_from_regions(&regions_summary).unwrap_err(),
498+
Error::NoMemoryRegion
499+
));
521500
}
522501

523502
#[test]
524503
fn test_overlapping_memory_regions() {
525504
let regions_summary = [(GuestAddress(0), 100_usize), (GuestAddress(99), 100_usize)];
526505

527-
assert_eq!(
528-
format!(
529-
"{:?}",
530-
new_guest_memory_mmap(&regions_summary).err().unwrap()
531-
),
532-
format!("{:?}", Error::MemoryRegionOverlap)
533-
);
534-
535-
assert_eq!(
536-
format!(
537-
"{:?}",
538-
new_guest_memory_mmap_with_files(&regions_summary)
539-
.err()
540-
.unwrap()
541-
),
542-
format!("{:?}", Error::MemoryRegionOverlap)
543-
);
544-
545-
assert_eq!(
546-
format!(
547-
"{:?}",
548-
new_guest_memory_mmap_from_regions(&regions_summary)
549-
.err()
550-
.unwrap()
551-
),
552-
format!("{:?}", Error::MemoryRegionOverlap)
553-
);
554-
555-
assert_eq!(
556-
format!(
557-
"{:?}",
558-
new_guest_memory_mmap_from_arc_regions(&regions_summary)
559-
.err()
560-
.unwrap()
561-
),
562-
format!("{:?}", Error::MemoryRegionOverlap)
563-
);
506+
assert!(matches!(
507+
new_guest_memory_mmap(&regions_summary).unwrap_err(),
508+
Error::MemoryRegionOverlap
509+
));
510+
assert!(matches!(
511+
new_guest_memory_mmap_with_files(&regions_summary).unwrap_err(),
512+
Error::MemoryRegionOverlap
513+
));
514+
assert!(matches!(
515+
new_guest_memory_mmap_from_regions(&regions_summary).unwrap_err(),
516+
Error::MemoryRegionOverlap
517+
));
518+
assert!(matches!(
519+
new_guest_memory_mmap_from_regions(&regions_summary).unwrap_err(),
520+
Error::MemoryRegionOverlap
521+
));
564522
}
565523

566524
#[test]
567525
fn test_unsorted_memory_regions() {
568526
let regions_summary = [(GuestAddress(100), 100_usize), (GuestAddress(0), 100_usize)];
569527

570-
assert_eq!(
571-
format!(
572-
"{:?}",
573-
new_guest_memory_mmap(&regions_summary).err().unwrap()
574-
),
575-
format!("{:?}", Error::UnsortedMemoryRegions)
576-
);
577-
578-
assert_eq!(
579-
format!(
580-
"{:?}",
581-
new_guest_memory_mmap_with_files(&regions_summary)
582-
.err()
583-
.unwrap()
584-
),
585-
format!("{:?}", Error::UnsortedMemoryRegions)
586-
);
587-
588-
assert_eq!(
589-
format!(
590-
"{:?}",
591-
new_guest_memory_mmap_from_regions(&regions_summary)
592-
.err()
593-
.unwrap()
594-
),
595-
format!("{:?}", Error::UnsortedMemoryRegions)
596-
);
597-
598-
assert_eq!(
599-
format!(
600-
"{:?}",
601-
new_guest_memory_mmap_from_arc_regions(&regions_summary)
602-
.err()
603-
.unwrap()
604-
),
605-
format!("{:?}", Error::UnsortedMemoryRegions)
606-
);
528+
assert!(matches!(
529+
new_guest_memory_mmap(&regions_summary).unwrap_err(),
530+
Error::UnsortedMemoryRegions
531+
));
532+
assert!(matches!(
533+
new_guest_memory_mmap_with_files(&regions_summary).unwrap_err(),
534+
Error::UnsortedMemoryRegions
535+
));
536+
assert!(matches!(
537+
new_guest_memory_mmap_from_regions(&regions_summary).unwrap_err(),
538+
Error::UnsortedMemoryRegions
539+
));
540+
assert!(matches!(
541+
new_guest_memory_mmap_from_regions(&regions_summary).unwrap_err(),
542+
Error::UnsortedMemoryRegions
543+
));
607544
}
608545

609546
#[test]
@@ -828,18 +765,13 @@ mod tests {
828765
for gm in gm_list.iter() {
829766
let val1: u64 = 0xaa55_aa55_aa55_aa55;
830767
let val2: u64 = 0x55aa_55aa_55aa_55aa;
831-
assert_eq!(
832-
format!("{:?}", gm.write_obj(val1, bad_addr).err().unwrap()),
833-
format!("InvalidGuestAddress({:?})", bad_addr,)
834-
);
835-
assert_eq!(
836-
format!("{:?}", gm.write_obj(val1, bad_addr2).err().unwrap()),
837-
format!(
838-
"PartialBuffer {{ expected: {:?}, completed: {:?} }}",
839-
mem::size_of::<u64>(),
840-
max_addr.checked_offset_from(bad_addr2).unwrap()
841-
)
842-
);
768+
assert!(matches!(
769+
gm.write_obj(val1, bad_addr).unwrap_err(),
770+
GuestMemoryError::InvalidGuestAddress(addr) if addr == bad_addr
771+
));
772+
assert!(matches!(
773+
gm.write_obj(val1, bad_addr2).unwrap_err(),
774+
GuestMemoryError::PartialBuffer { expected, completed} if expected == size_of::<u64>() && completed == max_addr.checked_offset_from(bad_addr2).unwrap() as usize));
843775

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

‎src/mmap/unix.rs‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -558,7 +558,7 @@ mod tests {
558558
prot,
559559
flags,
560560
);
561-
assert_eq!(format!("{:?}", r.unwrap_err()), "InvalidOffsetLength");
561+
assert!(matches!(r.unwrap_err(), Error::InvalidOffsetLength));
562562

563563
// Offset + size is greater than the size of the file (which is 0 at this point).
564564
let r = MmapRegion::build(
@@ -567,7 +567,7 @@ mod tests {
567567
prot,
568568
flags,
569569
);
570-
assert_eq!(format!("{:?}", r.unwrap_err()), "MappingPastEof");
570+
assert!(matches!(r.unwrap_err(), Error::MappingPastEof));
571571

572572
// MAP_FIXED was specified among the flags.
573573
let r = MmapRegion::build(
@@ -576,7 +576,7 @@ mod tests {
576576
prot,
577577
flags | libc::MAP_FIXED,
578578
);
579-
assert_eq!(format!("{:?}", r.unwrap_err()), "MapFixed");
579+
assert!(matches!(r.unwrap_err(), Error::MapFixed));
580580

581581
// Let's resize the file.
582582
assert_eq!(unsafe { libc::ftruncate(a.as_raw_fd(), 1024 * 10) }, 0);
@@ -621,7 +621,7 @@ mod tests {
621621
let flags = libc::MAP_NORESERVE | libc::MAP_PRIVATE;
622622

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

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

‎src/mmap/xen.rs‎

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

10791079
let r = MmapXen::new(&range);
1080-
assert_eq!(
1081-
format!("{:?}", r.unwrap_err()),
1082-
format!("MmapFlags({})", range.mmap_flags),
1083-
);
1080+
assert!(matches!(r.unwrap_err(), Error::MmapFlags(flags) if flags == range.mmap_flags));
10841081

10851082
range.mmap_flags = MmapXenFlags::FOREIGN.bits() | MmapXenFlags::GRANT.bits();
10861083
let r = MmapXen::new(&range);
1087-
assert_eq!(
1088-
format!("{:?}", r.unwrap_err()),
1089-
format!("MmapFlags({:x})", MmapXenFlags::ALL.bits()),
1084+
assert!(
1085+
matches!(r.unwrap_err(), Error::MmapFlags(flags) if flags == MmapXenFlags::ALL.bits())
10901086
);
10911087

10921088
range.mmap_flags = MmapXenFlags::FOREIGN.bits() | MmapXenFlags::NO_ADVANCE_MAP.bits();
10931089
let r = MmapXen::new(&range);
1094-
assert_eq!(
1095-
format!("{:?}", r.unwrap_err()),
1096-
format!(
1097-
"MmapFlags({:x})",
1098-
MmapXenFlags::NO_ADVANCE_MAP.bits() | MmapXenFlags::FOREIGN.bits(),
1099-
),
1090+
assert!(
1091+
matches!(r.unwrap_err(), Error::MmapFlags(flags) if flags == MmapXenFlags::NO_ADVANCE_MAP.bits() | MmapXenFlags::FOREIGN.bits())
11001092
);
11011093
}
11021094

@@ -1132,17 +1124,17 @@ mod tests {
11321124
range.file_offset = Some(FileOffset::new(TempFile::new().unwrap().into_file(), 0));
11331125
range.prot = None;
11341126
let r = MmapXenForeign::new(&range);
1135-
assert_eq!(format!("{:?}", r.unwrap_err()), "UnexpectedError");
1127+
assert!(matches!(r.unwrap_err(), Error::UnexpectedError));
11361128

11371129
let mut range = MmapRange::initialized(true);
11381130
range.flags = None;
11391131
let r = MmapXenForeign::new(&range);
1140-
assert_eq!(format!("{:?}", r.unwrap_err()), "UnexpectedError");
1132+
assert!(matches!(r.unwrap_err(), Error::UnexpectedError));
11411133

11421134
let mut range = MmapRange::initialized(true);
11431135
range.file_offset = Some(FileOffset::new(TempFile::new().unwrap().into_file(), 1));
11441136
let r = MmapXenForeign::new(&range);
1145-
assert_eq!(format!("{:?}", r.unwrap_err()), "InvalidOffsetLength");
1137+
assert!(matches!(r.unwrap_err(), Error::InvalidOffsetLength));
11461138

11471139
let mut range = MmapRange::initialized(true);
11481140
range.size = 0;
@@ -1164,7 +1156,7 @@ mod tests {
11641156
let mut range = MmapRange::initialized(true);
11651157
range.prot = None;
11661158
let r = MmapXenGrant::new(&range, MmapXenFlags::empty());
1167-
assert_eq!(format!("{:?}", r.unwrap_err()), "UnexpectedError");
1159+
assert!(matches!(r.unwrap_err(), Error::UnexpectedError));
11681160

11691161
let mut range = MmapRange::initialized(true);
11701162
range.prot = None;
@@ -1174,12 +1166,12 @@ mod tests {
11741166
let mut range = MmapRange::initialized(true);
11751167
range.flags = None;
11761168
let r = MmapXenGrant::new(&range, MmapXenFlags::NO_ADVANCE_MAP);
1177-
assert_eq!(format!("{:?}", r.unwrap_err()), "UnexpectedError");
1169+
assert!(matches!(r.unwrap_err(), Error::UnexpectedError));
11781170

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

11841176
let mut range = MmapRange::initialized(true);
11851177
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)