Skip to content

Commit 4775dd7

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 c6bd80f commit 4775dd7

File tree

1 file changed

+175
-41
lines changed

1 file changed

+175
-41
lines changed

‎src/volatile_memory.rs

+175-41
Original file line numberDiff line numberDiff line change
@@ -61,6 +61,64 @@ 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.kind should be enough to assert equallity because each error
68+
// has the kind field set and the OS error numbers can be converted
69+
// to ErrorKind through `sys::decode_error_kind`.
70+
(Error::IOError(left), Error::IOError(right)) => left.kind() == right.kind(),
71+
(
72+
Error::OutOfBounds { addr: left_address },
73+
Error::OutOfBounds {
74+
addr: right_address,
75+
},
76+
) => left_address == right_address,
77+
(
78+
Error::Overflow {
79+
base: left_base,
80+
offset: left_offset,
81+
},
82+
Error::Overflow {
83+
base: right_base,
84+
offset: right_offset,
85+
},
86+
) => left_offset == right_offset && left_base == right_base,
87+
(
88+
Error::TooBig {
89+
nelements: left_nelements,
90+
size: left_size,
91+
},
92+
Error::TooBig {
93+
nelements: right_nelements,
94+
size: right_size,
95+
},
96+
) => left_nelements == right_nelements && left_size == right_size,
97+
(
98+
Error::Misaligned {
99+
addr: left_addr,
100+
alignment: left_align,
101+
},
102+
Error::Misaligned {
103+
addr: right_addr,
104+
alignment: right_align,
105+
},
106+
) => left_addr == right_addr && left_align == right_align,
107+
(
108+
Error::PartialBuffer {
109+
expected: left_expected,
110+
completed: left_completed,
111+
},
112+
Error::PartialBuffer {
113+
expected: right_expected,
114+
completed: right_completed,
115+
},
116+
) => left_expected == right_expected && left_completed == right_completed,
117+
_ => false,
118+
}
119+
}
120+
}
121+
64122
impl fmt::Display for Error {
65123
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
66124
match self {
@@ -1527,7 +1585,10 @@ mod tests {
15271585
let a_ref =
15281586
unsafe { VolatileSlice::new(&mut a[0] as *mut usize as *mut u8, size_of::<usize>()) };
15291587
assert!(a_ref.get_atomic_ref::<AtomicUsize>(0).is_ok());
1530-
assert!(a_ref.get_atomic_ref::<AtomicUsize>(1).is_err());
1588+
assert_eq!(
1589+
a_ref.get_atomic_ref::<AtomicUsize>(1).unwrap_err(),
1590+
Error::OutOfBounds { addr: 9 }
1591+
);
15311592
}
15321593

15331594
#[test]
@@ -1628,20 +1689,46 @@ mod tests {
16281689
assert!(slice.write(&[1; 80], 10).is_ok());
16291690

16301691
assert!(slice.subslice(0, 0).is_ok());
1631-
assert!(slice.subslice(0, 101).is_err());
1692+
assert_eq!(
1693+
slice.subslice(0, 101).unwrap_err(),
1694+
Error::OutOfBounds { addr: 101 }
1695+
);
16321696

16331697
assert!(slice.subslice(99, 0).is_ok());
16341698
assert!(slice.subslice(99, 1).is_ok());
1635-
assert!(slice.subslice(99, 2).is_err());
1699+
assert_eq!(
1700+
slice.subslice(99, 2).unwrap_err(),
1701+
Error::OutOfBounds { addr: 101 }
1702+
);
16361703

16371704
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());
1705+
assert_eq!(
1706+
slice.subslice(100, 1).unwrap_err(),
1707+
Error::OutOfBounds { addr: 101 }
1708+
);
1709+
assert_eq!(
1710+
slice.subslice(101, 0).unwrap_err(),
1711+
Error::OutOfBounds { addr: 101 }
1712+
);
1713+
assert_eq!(
1714+
slice.subslice(101, 1).unwrap_err(),
1715+
Error::OutOfBounds { addr: 102 }
1716+
);
16421717

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

16461733
let maybe_offset_slice = slice.subslice(10, 80);
16471734
assert!(maybe_offset_slice.is_ok());
@@ -1658,7 +1745,6 @@ mod tests {
16581745
let mem = VecMem::new(100);
16591746
let slice = mem.get_slice(0, 100).unwrap();
16601747
assert!(slice.write(&[1; 80], 10).is_ok());
1661-
16621748
assert!(slice.offset(101).is_err());
16631749

16641750
let maybe_offset_slice = slice.offset(10);
@@ -1750,12 +1836,11 @@ mod tests {
17501836
fn slice_overflow_error() {
17511837
use std::usize::MAX;
17521838
let a = VecMem::new(1);
1753-
let res = a.get_slice(MAX, 1).unwrap_err();
1754-
assert_matches!(
1755-
res,
1839+
assert_eq!(
1840+
a.get_slice(MAX, 1).unwrap_err(),
17561841
Error::Overflow {
17571842
base: MAX,
1758-
offset: 1,
1843+
offset: 1
17591844
}
17601845
);
17611846
}
@@ -1764,17 +1849,18 @@ mod tests {
17641849
fn slice_oob_error() {
17651850
let a = VecMem::new(100);
17661851
a.get_slice(50, 50).unwrap();
1767-
let res = a.get_slice(55, 50).unwrap_err();
1768-
assert_matches!(res, Error::OutOfBounds { addr: 105 });
1852+
assert_eq!(
1853+
a.get_slice(55, 50).unwrap_err(),
1854+
Error::OutOfBounds { addr: 105 }
1855+
);
17691856
}
17701857

17711858
#[test]
17721859
fn ref_overflow_error() {
17731860
use std::usize::MAX;
17741861
let a = VecMem::new(1);
1775-
let res = a.get_ref::<u8>(MAX).unwrap_err();
1776-
assert_matches!(
1777-
res,
1862+
assert_eq!(
1863+
a.get_ref::<u8>(MAX).unwrap_err(),
17781864
Error::Overflow {
17791865
base: MAX,
17801866
offset: 1,
@@ -1786,15 +1872,19 @@ mod tests {
17861872
fn ref_oob_error() {
17871873
let a = VecMem::new(100);
17881874
a.get_ref::<u8>(99).unwrap();
1789-
let res = a.get_ref::<u16>(99).unwrap_err();
1790-
assert_matches!(res, Error::OutOfBounds { addr: 101 });
1875+
assert_eq!(
1876+
a.get_ref::<u16>(99).unwrap_err(),
1877+
Error::OutOfBounds { addr: 101 }
1878+
);
17911879
}
17921880

17931881
#[test]
17941882
fn ref_oob_too_large() {
17951883
let a = VecMem::new(3);
1796-
let res = a.get_ref::<u32>(0).unwrap_err();
1797-
assert_matches!(res, Error::OutOfBounds { addr: 4 });
1884+
assert_eq!(
1885+
a.get_ref::<u32>(0).unwrap_err(),
1886+
Error::OutOfBounds { addr: 4 }
1887+
);
17981888
}
17991889

18001890
#[test]
@@ -1820,10 +1910,16 @@ mod tests {
18201910
let a = VecMem::new(5);
18211911
let s = a.as_volatile_slice();
18221912
let sample_buf = [1, 2, 3];
1823-
assert!(s.write(&sample_buf, 5).is_err());
1913+
assert_eq!(
1914+
s.write(&sample_buf, 5).unwrap_err(),
1915+
Error::OutOfBounds { addr: 5 }
1916+
);
18241917
assert!(s.write(&sample_buf, 2).is_ok());
18251918
let mut buf = [0u8; 3];
1826-
assert!(s.read(&mut buf, 5).is_err());
1919+
assert_eq!(
1920+
s.read(&mut buf, 5).unwrap_err(),
1921+
Error::OutOfBounds { addr: 5 }
1922+
);
18271923
assert!(s.read_slice(&mut buf, 2).is_ok());
18281924
assert_eq!(buf, sample_buf);
18291925

@@ -1843,12 +1939,28 @@ mod tests {
18431939
fn obj_read_and_write() {
18441940
let a = VecMem::new(5);
18451941
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());
1942+
assert_eq!(
1943+
s.write_obj(55u16, 4).unwrap_err(),
1944+
Error::PartialBuffer {
1945+
expected: 2,
1946+
completed: 1
1947+
}
1948+
);
18481949
assert!(s.write_obj(55u16, 2).is_ok());
18491950
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());
1951+
assert_eq!(
1952+
s.read_obj::<u16>(4).unwrap_err(),
1953+
Error::PartialBuffer {
1954+
expected: 2,
1955+
completed: 1
1956+
}
1957+
);
1958+
assert_eq!(
1959+
s.read_obj::<u16>(core::usize::MAX).unwrap_err(),
1960+
Error::OutOfBounds {
1961+
addr: core::usize::MAX
1962+
}
1963+
);
18521964
}
18531965

18541966
#[test]
@@ -1861,15 +1973,30 @@ mod tests {
18611973
} else {
18621974
File::open(Path::new("c:\\Windows\\system32\\ntoskrnl.exe")).unwrap()
18631975
};
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());
1976+
assert_eq!(
1977+
s.read_exact_from(2, &mut file, size_of::<u32>())
1978+
.unwrap_err(),
1979+
Error::OutOfBounds { addr: 6 }
1980+
);
1981+
assert_eq!(
1982+
s.read_exact_from(core::usize::MAX, &mut file, size_of::<u32>())
1983+
.unwrap_err(),
1984+
Error::Overflow {
1985+
base: core::usize::MAX,
1986+
offset: 4
1987+
}
1988+
);
18681989

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

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

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

18822009
let mut sink = Vec::new();
18832010
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());
2011+
assert_eq!(
2012+
s.write_all_to(2, &mut sink, size_of::<u32>()).unwrap_err(),
2013+
Error::OutOfBounds { addr: 6 }
2014+
);
2015+
assert_eq!(
2016+
s.write_all_to(core::usize::MAX, &mut sink, size_of::<u32>())
2017+
.unwrap_err(),
2018+
Error::Overflow {
2019+
base: core::usize::MAX,
2020+
offset: 4
2021+
}
2022+
);
18882023
format!("{:?}", s.write_all_to(2, &mut sink, size_of::<u32>()));
18892024
if cfg!(unix) {
18902025
assert_eq!(sink, vec![0; size_of::<u32>()]);
@@ -1959,9 +2094,8 @@ mod tests {
19592094
fn ref_array_overflow() {
19602095
let mut a = [0, 0, 2, 3, 10];
19612096
let a_ref = &mut a[..];
1962-
let res = a_ref.get_array_ref::<u32>(4, usize::MAX).unwrap_err();
1963-
assert_matches!(
1964-
res,
2097+
assert_eq!(
2098+
a_ref.get_array_ref::<u32>(4, usize::MAX).unwrap_err(),
19652099
Error::TooBig {
19662100
nelements: usize::MAX,
19672101
size: 4,

0 commit comments

Comments
 (0)