Skip to content

Commit b576045

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 deb90ab commit b576045

File tree

1 file changed

+172
-41
lines changed

1 file changed

+172
-41
lines changed

Diff for: ‎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 {
@@ -1508,7 +1563,10 @@ mod tests {
15081563
let a_ref =
15091564
unsafe { VolatileSlice::new(&mut a[0] as *mut usize as *mut u8, size_of::<usize>()) };
15101565
assert!(a_ref.get_atomic_ref::<AtomicUsize>(0).is_ok());
1511-
assert!(a_ref.get_atomic_ref::<AtomicUsize>(1).is_err());
1566+
assert_eq!(
1567+
a_ref.get_atomic_ref::<AtomicUsize>(1).unwrap_err(),
1568+
Error::OutOfBounds { addr: 9 }
1569+
);
15121570
}
15131571

15141572
#[test]
@@ -1625,20 +1683,46 @@ mod tests {
16251683
assert!(slice.write(&[1; 80], 10).is_ok());
16261684

16271685
assert!(slice.subslice(0, 0).is_ok());
1628-
assert!(slice.subslice(0, 101).is_err());
1686+
assert_eq!(
1687+
slice.subslice(0, 101).unwrap_err(),
1688+
Error::OutOfBounds { addr: 101 }
1689+
);
16291690

16301691
assert!(slice.subslice(99, 0).is_ok());
16311692
assert!(slice.subslice(99, 1).is_ok());
1632-
assert!(slice.subslice(99, 2).is_err());
1693+
assert_eq!(
1694+
slice.subslice(99, 2).unwrap_err(),
1695+
Error::OutOfBounds { addr: 101 }
1696+
);
16331697

16341698
assert!(slice.subslice(100, 0).is_ok());
1635-
assert!(slice.subslice(100, 1).is_err());
1636-
1637-
assert!(slice.subslice(101, 0).is_err());
1638-
assert!(slice.subslice(101, 1).is_err());
1699+
assert_eq!(
1700+
slice.subslice(100, 1).unwrap_err(),
1701+
Error::OutOfBounds { addr: 101 }
1702+
);
1703+
assert_eq!(
1704+
slice.subslice(101, 0).unwrap_err(),
1705+
Error::OutOfBounds { addr: 101 }
1706+
);
1707+
assert_eq!(
1708+
slice.subslice(101, 1).unwrap_err(),
1709+
Error::OutOfBounds { addr: 102 }
1710+
);
16391711

1640-
assert!(slice.subslice(std::usize::MAX, 2).is_err());
1641-
assert!(slice.subslice(2, std::usize::MAX).is_err());
1712+
assert_eq!(
1713+
slice.subslice(std::usize::MAX, 2).unwrap_err(),
1714+
Error::Overflow {
1715+
base: std::usize::MAX,
1716+
offset: 2
1717+
}
1718+
);
1719+
assert_eq!(
1720+
slice.subslice(2, std::usize::MAX).unwrap_err(),
1721+
Error::Overflow {
1722+
base: 2,
1723+
offset: std::usize::MAX
1724+
}
1725+
);
16421726

16431727
let maybe_offset_slice = slice.subslice(10, 80);
16441728
assert!(maybe_offset_slice.is_ok());
@@ -1655,7 +1739,6 @@ mod tests {
16551739
let mem = VecMem::new(100);
16561740
let slice = mem.get_slice(0, 100).unwrap();
16571741
assert!(slice.write(&[1; 80], 10).is_ok());
1658-
16591742
assert!(slice.offset(101).is_err());
16601743

16611744
let maybe_offset_slice = slice.offset(10);
@@ -1747,12 +1830,11 @@ mod tests {
17471830
fn slice_overflow_error() {
17481831
use std::usize::MAX;
17491832
let a = VecMem::new(1);
1750-
let res = a.get_slice(MAX, 1).unwrap_err();
1751-
assert_matches!(
1752-
res,
1833+
assert_eq!(
1834+
a.get_slice(MAX, 1).unwrap_err(),
17531835
Error::Overflow {
17541836
base: MAX,
1755-
offset: 1,
1837+
offset: 1
17561838
}
17571839
);
17581840
}
@@ -1761,17 +1843,18 @@ mod tests {
17611843
fn slice_oob_error() {
17621844
let a = VecMem::new(100);
17631845
a.get_slice(50, 50).unwrap();
1764-
let res = a.get_slice(55, 50).unwrap_err();
1765-
assert_matches!(res, Error::OutOfBounds { addr: 105 });
1846+
assert_eq!(
1847+
a.get_slice(55, 50).unwrap_err(),
1848+
Error::OutOfBounds { addr: 105 }
1849+
);
17661850
}
17671851

17681852
#[test]
17691853
fn ref_overflow_error() {
17701854
use std::usize::MAX;
17711855
let a = VecMem::new(1);
1772-
let res = a.get_ref::<u8>(MAX).unwrap_err();
1773-
assert_matches!(
1774-
res,
1856+
assert_eq!(
1857+
a.get_ref::<u8>(MAX).unwrap_err(),
17751858
Error::Overflow {
17761859
base: MAX,
17771860
offset: 1,
@@ -1783,15 +1866,19 @@ mod tests {
17831866
fn ref_oob_error() {
17841867
let a = VecMem::new(100);
17851868
a.get_ref::<u8>(99).unwrap();
1786-
let res = a.get_ref::<u16>(99).unwrap_err();
1787-
assert_matches!(res, Error::OutOfBounds { addr: 101 });
1869+
assert_eq!(
1870+
a.get_ref::<u16>(99).unwrap_err(),
1871+
Error::OutOfBounds { addr: 101 }
1872+
);
17881873
}
17891874

17901875
#[test]
17911876
fn ref_oob_too_large() {
17921877
let a = VecMem::new(3);
1793-
let res = a.get_ref::<u32>(0).unwrap_err();
1794-
assert_matches!(res, Error::OutOfBounds { addr: 4 });
1878+
assert_eq!(
1879+
a.get_ref::<u32>(0).unwrap_err(),
1880+
Error::OutOfBounds { addr: 4 }
1881+
);
17951882
}
17961883

17971884
#[test]
@@ -1817,10 +1904,16 @@ mod tests {
18171904
let a = VecMem::new(5);
18181905
let s = a.as_volatile_slice();
18191906
let sample_buf = [1, 2, 3];
1820-
assert!(s.write(&sample_buf, 5).is_err());
1907+
assert_eq!(
1908+
s.write(&sample_buf, 5).unwrap_err(),
1909+
Error::OutOfBounds { addr: 5 }
1910+
);
18211911
assert!(s.write(&sample_buf, 2).is_ok());
18221912
let mut buf = [0u8; 3];
1823-
assert!(s.read(&mut buf, 5).is_err());
1913+
assert_eq!(
1914+
s.read(&mut buf, 5).unwrap_err(),
1915+
Error::OutOfBounds { addr: 5 }
1916+
);
18241917
assert!(s.read_slice(&mut buf, 2).is_ok());
18251918
assert_eq!(buf, sample_buf);
18261919
}
@@ -1829,12 +1922,28 @@ mod tests {
18291922
fn obj_read_and_write() {
18301923
let a = VecMem::new(5);
18311924
let s = a.as_volatile_slice();
1832-
assert!(s.write_obj(55u16, 4).is_err());
1833-
assert!(s.write_obj(55u16, core::usize::MAX).is_err());
1925+
assert_eq!(
1926+
s.write_obj(55u16, 4).unwrap_err(),
1927+
Error::PartialBuffer {
1928+
expected: 2,
1929+
completed: 1
1930+
}
1931+
);
18341932
assert!(s.write_obj(55u16, 2).is_ok());
18351933
assert_eq!(s.read_obj::<u16>(2).unwrap(), 55u16);
1836-
assert!(s.read_obj::<u16>(4).is_err());
1837-
assert!(s.read_obj::<u16>(core::usize::MAX).is_err());
1934+
assert_eq!(
1935+
s.read_obj::<u16>(4).unwrap_err(),
1936+
Error::PartialBuffer {
1937+
expected: 2,
1938+
completed: 1
1939+
}
1940+
);
1941+
assert_eq!(
1942+
s.read_obj::<u16>(core::usize::MAX).unwrap_err(),
1943+
Error::OutOfBounds {
1944+
addr: core::usize::MAX
1945+
}
1946+
);
18381947
}
18391948

18401949
#[test]
@@ -1847,15 +1956,30 @@ mod tests {
18471956
} else {
18481957
File::open(Path::new("c:\\Windows\\system32\\ntoskrnl.exe")).unwrap()
18491958
};
1850-
assert!(s.read_exact_from(2, &mut file, size_of::<u32>()).is_err());
1851-
assert!(s
1852-
.read_exact_from(core::usize::MAX, &mut file, size_of::<u32>())
1853-
.is_err());
1959+
assert_eq!(
1960+
s.read_exact_from(2, &mut file, size_of::<u32>())
1961+
.unwrap_err(),
1962+
Error::OutOfBounds { addr: 6 }
1963+
);
1964+
assert_eq!(
1965+
s.read_exact_from(core::usize::MAX, &mut file, size_of::<u32>())
1966+
.unwrap_err(),
1967+
Error::Overflow {
1968+
base: core::usize::MAX,
1969+
offset: 4
1970+
}
1971+
);
18541972

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

18571975
let mut f = TempFile::new().unwrap().into_file();
1858-
assert!(s.read_exact_from(1, &mut f, size_of::<u32>()).is_err());
1976+
assert_eq!(
1977+
s.read_exact_from(1, &mut f, size_of::<u32>()).unwrap_err(),
1978+
Error::IOError(std::io::Error::new(
1979+
std::io::ErrorKind::UnexpectedEof,
1980+
"failed to fill the whole buffer"
1981+
))
1982+
);
18591983
format!("{:?}", s.read_exact_from(1, &mut f, size_of::<u32>()));
18601984

18611985
let value = s.read_obj::<u32>(1).unwrap();
@@ -1867,10 +1991,18 @@ mod tests {
18671991

18681992
let mut sink = Vec::new();
18691993
assert!(s.write_all_to(1, &mut sink, size_of::<u32>()).is_ok());
1870-
assert!(s.write_all_to(2, &mut sink, size_of::<u32>()).is_err());
1871-
assert!(s
1872-
.write_all_to(core::usize::MAX, &mut sink, size_of::<u32>())
1873-
.is_err());
1994+
assert_eq!(
1995+
s.write_all_to(2, &mut sink, size_of::<u32>()).unwrap_err(),
1996+
Error::OutOfBounds { addr: 6 }
1997+
);
1998+
assert_eq!(
1999+
s.write_all_to(core::usize::MAX, &mut sink, size_of::<u32>())
2000+
.unwrap_err(),
2001+
Error::Overflow {
2002+
base: core::usize::MAX,
2003+
offset: 4
2004+
}
2005+
);
18742006
format!("{:?}", s.write_all_to(2, &mut sink, size_of::<u32>()));
18752007
if cfg!(unix) {
18762008
assert_eq!(sink, vec![0; size_of::<u32>()]);
@@ -1945,9 +2077,8 @@ mod tests {
19452077
fn ref_array_overflow() {
19462078
let mut a = [0, 0, 2, 3, 10];
19472079
let a_ref = &mut a[..];
1948-
let res = a_ref.get_array_ref::<u32>(4, usize::MAX).unwrap_err();
1949-
assert_matches!(
1950-
res,
2080+
assert_eq!(
2081+
a_ref.get_array_ref::<u32>(4, usize::MAX).unwrap_err(),
19512082
Error::TooBig {
19522083
nelements: usize::MAX,
19532084
size: 4,

0 commit comments

Comments
 (0)