Skip to content

Commit 69ffd45

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 2c8f95d commit 69ffd45

File tree

4 files changed

+71
-199
lines changed

4 files changed

+71
-199
lines changed

‎src/mmap.rs

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

383383
use crate::bitmap::tests::test_guest_memory_and_region;
384384
use crate::bitmap::AtomicBitmap;
385-
use crate::{Error, GuestAddressSpace, GuestMemory};
385+
use crate::{Error, GuestAddressSpace, GuestMemory, GuestMemoryError};
386386

387387
use std::io::Write;
388388
use std::mem;
@@ -479,129 +479,66 @@ mod tests {
479479
fn test_no_memory_region() {
480480
let regions_summary = [];
481481

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

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

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

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

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

607544
#[test]
@@ -826,18 +763,13 @@ mod tests {
826763
for gm in gm_list.iter() {
827764
let val1: u64 = 0xaa55_aa55_aa55_aa55;
828765
let val2: u64 = 0x55aa_55aa_55aa_55aa;
829-
assert_eq!(
830-
format!("{:?}", gm.write_obj(val1, bad_addr).err().unwrap()),
831-
format!("InvalidGuestAddress({:?})", bad_addr,)
832-
);
833-
assert_eq!(
834-
format!("{:?}", gm.write_obj(val1, bad_addr2).err().unwrap()),
835-
format!(
836-
"PartialBuffer {{ expected: {:?}, completed: {:?} }}",
837-
mem::size_of::<u64>(),
838-
max_addr.checked_offset_from(bad_addr2).unwrap()
839-
)
840-
);
766+
assert!(matches!(
767+
gm.write_obj(val1, bad_addr).unwrap_err(),
768+
GuestMemoryError::InvalidGuestAddress(addr) if addr == bad_addr
769+
));
770+
assert!(matches!(
771+
gm.write_obj(val1, bad_addr2).unwrap_err(),
772+
GuestMemoryError::PartialBuffer { expected, completed} if expected == size_of::<u64>() && completed == max_addr.checked_offset_from(bad_addr2).unwrap() as usize));
841773

842774
gm.write_obj(val1, GuestAddress(0x500)).unwrap();
843775
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)