Skip to content

Commit e5f3851

Browse files
AlexandruCihodaruAlexandruCihodaru
committed
[volatile_memory]: Implement PartialEq for Error
Implement PartialEq for Error enum and update tests. Signed-off-by: Alexandru Cihodaru <[email protected]>
1 parent 8aa43de commit e5f3851

File tree

1 file changed

+172
-41
lines changed

1 file changed

+172
-41
lines changed

‎src/volatile_memory.rs

+172-41
Original file line numberDiff line numberDiff line change
@@ -61,6 +61,61 @@ pub enum Error {
6161
PartialBuffer { expected: usize, completed: usize },
6262
}
6363

64+
impl PartialEq for Error {
65+
fn eq(&self, other: &Self) -> bool {
66+
match (self, other) {
67+
(Error::IOError(left), Error::IOError(right)) => left.kind() == right.kind(),
68+
(
69+
Error::OutOfBounds { addr: left_address },
70+
Error::OutOfBounds {
71+
addr: right_address,
72+
},
73+
) => left_address == right_address,
74+
(
75+
Error::Overflow {
76+
base: left_base,
77+
offset: left_offset,
78+
},
79+
Error::Overflow {
80+
base: right_base,
81+
offset: right_offset,
82+
},
83+
) => left_offset == right_offset && left_base == right_base,
84+
(
85+
Error::TooBig {
86+
nelements: left_nelements,
87+
size: left_size,
88+
},
89+
Error::TooBig {
90+
nelements: right_nelements,
91+
size: right_size,
92+
},
93+
) => left_nelements == right_nelements && left_size == right_size,
94+
(
95+
Error::Misaligned {
96+
addr: left_addr,
97+
alignment: left_align,
98+
},
99+
Error::Misaligned {
100+
addr: right_addr,
101+
alignment: right_align,
102+
},
103+
) => left_addr == right_addr && left_align == right_align,
104+
(
105+
Error::PartialBuffer {
106+
expected: left_expected,
107+
completed: left_completed,
108+
},
109+
Error::PartialBuffer {
110+
expected: right_expected,
111+
completed: right_completed,
112+
},
113+
) => left_expected == right_expected && left_completed == right_completed,
114+
_ => false,
115+
}
116+
}
117+
}
118+
64119
impl fmt::Display for Error {
65120
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
66121
match self {
@@ -1527,7 +1582,10 @@ mod tests {
15271582
let a_ref =
15281583
unsafe { VolatileSlice::new(&mut a[0] as *mut usize as *mut u8, size_of::<usize>()) };
15291584
assert!(a_ref.get_atomic_ref::<AtomicUsize>(0).is_ok());
1530-
assert!(a_ref.get_atomic_ref::<AtomicUsize>(1).is_err());
1585+
assert_eq!(
1586+
a_ref.get_atomic_ref::<AtomicUsize>(1).unwrap_err(),
1587+
Error::OutOfBounds { addr: 9 }
1588+
);
15311589
}
15321590

15331591
#[test]
@@ -1628,20 +1686,46 @@ mod tests {
16281686
assert!(slice.write(&[1; 80], 10).is_ok());
16291687

16301688
assert!(slice.subslice(0, 0).is_ok());
1631-
assert!(slice.subslice(0, 101).is_err());
1689+
assert_eq!(
1690+
slice.subslice(0, 101).unwrap_err(),
1691+
Error::OutOfBounds { addr: 101 }
1692+
);
16321693

16331694
assert!(slice.subslice(99, 0).is_ok());
16341695
assert!(slice.subslice(99, 1).is_ok());
1635-
assert!(slice.subslice(99, 2).is_err());
1696+
assert_eq!(
1697+
slice.subslice(99, 2).unwrap_err(),
1698+
Error::OutOfBounds { addr: 101 }
1699+
);
16361700

16371701
assert!(slice.subslice(100, 0).is_ok());
1638-
assert!(slice.subslice(100, 1).is_err());
1639-
1640-
assert!(slice.subslice(101, 0).is_err());
1641-
assert!(slice.subslice(101, 1).is_err());
1702+
assert_eq!(
1703+
slice.subslice(100, 1).unwrap_err(),
1704+
Error::OutOfBounds { addr: 101 }
1705+
);
1706+
assert_eq!(
1707+
slice.subslice(101, 0).unwrap_err(),
1708+
Error::OutOfBounds { addr: 101 }
1709+
);
1710+
assert_eq!(
1711+
slice.subslice(101, 1).unwrap_err(),
1712+
Error::OutOfBounds { addr: 102 }
1713+
);
16421714

1643-
assert!(slice.subslice(std::usize::MAX, 2).is_err());
1644-
assert!(slice.subslice(2, std::usize::MAX).is_err());
1715+
assert_eq!(
1716+
slice.subslice(std::usize::MAX, 2).unwrap_err(),
1717+
Error::Overflow {
1718+
base: std::usize::MAX,
1719+
offset: 2
1720+
}
1721+
);
1722+
assert_eq!(
1723+
slice.subslice(2, std::usize::MAX).unwrap_err(),
1724+
Error::Overflow {
1725+
base: 2,
1726+
offset: std::usize::MAX
1727+
}
1728+
);
16451729

16461730
let maybe_offset_slice = slice.subslice(10, 80);
16471731
assert!(maybe_offset_slice.is_ok());
@@ -1658,7 +1742,6 @@ mod tests {
16581742
let mem = VecMem::new(100);
16591743
let slice = mem.get_slice(0, 100).unwrap();
16601744
assert!(slice.write(&[1; 80], 10).is_ok());
1661-
16621745
assert!(slice.offset(101).is_err());
16631746

16641747
let maybe_offset_slice = slice.offset(10);
@@ -1750,12 +1833,11 @@ mod tests {
17501833
fn slice_overflow_error() {
17511834
use std::usize::MAX;
17521835
let a = VecMem::new(1);
1753-
let res = a.get_slice(MAX, 1).unwrap_err();
1754-
assert_matches!(
1755-
res,
1836+
assert_eq!(
1837+
a.get_slice(MAX, 1).unwrap_err(),
17561838
Error::Overflow {
17571839
base: MAX,
1758-
offset: 1,
1840+
offset: 1
17591841
}
17601842
);
17611843
}
@@ -1764,17 +1846,18 @@ mod tests {
17641846
fn slice_oob_error() {
17651847
let a = VecMem::new(100);
17661848
a.get_slice(50, 50).unwrap();
1767-
let res = a.get_slice(55, 50).unwrap_err();
1768-
assert_matches!(res, Error::OutOfBounds { addr: 105 });
1849+
assert_eq!(
1850+
a.get_slice(55, 50).unwrap_err(),
1851+
Error::OutOfBounds { addr: 105 }
1852+
);
17691853
}
17701854

17711855
#[test]
17721856
fn ref_overflow_error() {
17731857
use std::usize::MAX;
17741858
let a = VecMem::new(1);
1775-
let res = a.get_ref::<u8>(MAX).unwrap_err();
1776-
assert_matches!(
1777-
res,
1859+
assert_eq!(
1860+
a.get_ref::<u8>(MAX).unwrap_err(),
17781861
Error::Overflow {
17791862
base: MAX,
17801863
offset: 1,
@@ -1786,15 +1869,19 @@ mod tests {
17861869
fn ref_oob_error() {
17871870
let a = VecMem::new(100);
17881871
a.get_ref::<u8>(99).unwrap();
1789-
let res = a.get_ref::<u16>(99).unwrap_err();
1790-
assert_matches!(res, Error::OutOfBounds { addr: 101 });
1872+
assert_eq!(
1873+
a.get_ref::<u16>(99).unwrap_err(),
1874+
Error::OutOfBounds { addr: 101 }
1875+
);
17911876
}
17921877

17931878
#[test]
17941879
fn ref_oob_too_large() {
17951880
let a = VecMem::new(3);
1796-
let res = a.get_ref::<u32>(0).unwrap_err();
1797-
assert_matches!(res, Error::OutOfBounds { addr: 4 });
1881+
assert_eq!(
1882+
a.get_ref::<u32>(0).unwrap_err(),
1883+
Error::OutOfBounds { addr: 4 }
1884+
);
17981885
}
17991886

18001887
#[test]
@@ -1820,10 +1907,16 @@ mod tests {
18201907
let a = VecMem::new(5);
18211908
let s = a.as_volatile_slice();
18221909
let sample_buf = [1, 2, 3];
1823-
assert!(s.write(&sample_buf, 5).is_err());
1910+
assert_eq!(
1911+
s.write(&sample_buf, 5).unwrap_err(),
1912+
Error::OutOfBounds { addr: 5 }
1913+
);
18241914
assert!(s.write(&sample_buf, 2).is_ok());
18251915
let mut buf = [0u8; 3];
1826-
assert!(s.read(&mut buf, 5).is_err());
1916+
assert_eq!(
1917+
s.read(&mut buf, 5).unwrap_err(),
1918+
Error::OutOfBounds { addr: 5 }
1919+
);
18271920
assert!(s.read_slice(&mut buf, 2).is_ok());
18281921
assert_eq!(buf, sample_buf);
18291922

@@ -1843,12 +1936,28 @@ mod tests {
18431936
fn obj_read_and_write() {
18441937
let a = VecMem::new(5);
18451938
let s = a.as_volatile_slice();
1846-
assert!(s.write_obj(55u16, 4).is_err());
1847-
assert!(s.write_obj(55u16, core::usize::MAX).is_err());
1939+
assert_eq!(
1940+
s.write_obj(55u16, 4).unwrap_err(),
1941+
Error::PartialBuffer {
1942+
expected: 2,
1943+
completed: 1
1944+
}
1945+
);
18481946
assert!(s.write_obj(55u16, 2).is_ok());
18491947
assert_eq!(s.read_obj::<u16>(2).unwrap(), 55u16);
1850-
assert!(s.read_obj::<u16>(4).is_err());
1851-
assert!(s.read_obj::<u16>(core::usize::MAX).is_err());
1948+
assert_eq!(
1949+
s.read_obj::<u16>(4).unwrap_err(),
1950+
Error::PartialBuffer {
1951+
expected: 2,
1952+
completed: 1
1953+
}
1954+
);
1955+
assert_eq!(
1956+
s.read_obj::<u16>(core::usize::MAX).unwrap_err(),
1957+
Error::OutOfBounds {
1958+
addr: core::usize::MAX
1959+
}
1960+
);
18521961
}
18531962

18541963
#[test]
@@ -1861,15 +1970,30 @@ mod tests {
18611970
} else {
18621971
File::open(Path::new("c:\\Windows\\system32\\ntoskrnl.exe")).unwrap()
18631972
};
1864-
assert!(s.read_exact_from(2, &mut file, size_of::<u32>()).is_err());
1865-
assert!(s
1866-
.read_exact_from(core::usize::MAX, &mut file, size_of::<u32>())
1867-
.is_err());
1973+
assert_eq!(
1974+
s.read_exact_from(2, &mut file, size_of::<u32>())
1975+
.unwrap_err(),
1976+
Error::OutOfBounds { addr: 6 }
1977+
);
1978+
assert_eq!(
1979+
s.read_exact_from(core::usize::MAX, &mut file, size_of::<u32>())
1980+
.unwrap_err(),
1981+
Error::Overflow {
1982+
base: core::usize::MAX,
1983+
offset: 4
1984+
}
1985+
);
18681986

18691987
assert!(s.read_exact_from(1, &mut file, size_of::<u32>()).is_ok());
18701988

18711989
let mut f = TempFile::new().unwrap().into_file();
1872-
assert!(s.read_exact_from(1, &mut f, size_of::<u32>()).is_err());
1990+
assert_eq!(
1991+
s.read_exact_from(1, &mut f, size_of::<u32>()).unwrap_err(),
1992+
Error::IOError(std::io::Error::new(
1993+
std::io::ErrorKind::UnexpectedEof,
1994+
"failed to fill the whole buffer"
1995+
))
1996+
);
18731997
format!("{:?}", s.read_exact_from(1, &mut f, size_of::<u32>()));
18741998

18751999
let value = s.read_obj::<u32>(1).unwrap();
@@ -1881,10 +2005,18 @@ mod tests {
18812005

18822006
let mut sink = Vec::new();
18832007
assert!(s.write_all_to(1, &mut sink, size_of::<u32>()).is_ok());
1884-
assert!(s.write_all_to(2, &mut sink, size_of::<u32>()).is_err());
1885-
assert!(s
1886-
.write_all_to(core::usize::MAX, &mut sink, size_of::<u32>())
1887-
.is_err());
2008+
assert_eq!(
2009+
s.write_all_to(2, &mut sink, size_of::<u32>()).unwrap_err(),
2010+
Error::OutOfBounds { addr: 6 }
2011+
);
2012+
assert_eq!(
2013+
s.write_all_to(core::usize::MAX, &mut sink, size_of::<u32>())
2014+
.unwrap_err(),
2015+
Error::Overflow {
2016+
base: core::usize::MAX,
2017+
offset: 4
2018+
}
2019+
);
18882020
format!("{:?}", s.write_all_to(2, &mut sink, size_of::<u32>()));
18892021
if cfg!(unix) {
18902022
assert_eq!(sink, vec![0; size_of::<u32>()]);
@@ -1959,9 +2091,8 @@ mod tests {
19592091
fn ref_array_overflow() {
19602092
let mut a = [0, 0, 2, 3, 10];
19612093
let a_ref = &mut a[..];
1962-
let res = a_ref.get_array_ref::<u32>(4, usize::MAX).unwrap_err();
1963-
assert_matches!(
1964-
res,
2094+
assert_eq!(
2095+
a_ref.get_array_ref::<u32>(4, usize::MAX).unwrap_err(),
19652096
Error::TooBig {
19662097
nelements: usize::MAX,
19672098
size: 4,

0 commit comments

Comments
 (0)