[mmap_unix]: Implement PartialEq for Error enum

Implemented PartialEq for Error enum. Considering that from this file
the only io error returned are OS error usage of raw_os_error offers
anything that is needed.
Updated tests to use PartialEq for error cases.

Signed-off-by: Alexandru Cihodaru <[email protected]>

Author: AlexandruCihodaru

src/mmap_unix.rs

@@ -41,6 +41,30 @@ pub enum Error {
     Mmap(io::Error),
 }
 
+impl PartialEq for Error {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Error::Mmap(left), Error::Mmap(right)) => {
+                match (left.raw_os_error(), right.raw_os_error()) {
+                    // Considering that in this file the only std::io::Error returned is of type
+                    // OS error, we can leverage raw_os_error for this PartialEq implementation.
+                    (Some(left_os_error), Some(right_os_error)) => left_os_error == right_os_error,
+                    (Some(_), None) => false,
+                    (None, Some(_)) => false,
+                    _ => unreachable!(),
+                }
+            }
+            (Error::InvalidOffsetLength, Error::InvalidOffsetLength) => true,
+            (Error::InvalidPointer, Error::InvalidPointer) => true,
+            (Error::InvalidSize, Error::InvalidSize) => true,
+            (Error::MapFixed, Error::MapFixed) => true,
+            (Error::MappingOverlap, Error::MappingOverlap) => true,
+            (Error::MappingPastEof, Error::MappingPastEof) => true,
+            _ => false,
+        }
+    }
+}
+
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> fmt::Result {
         match self {
@@ -369,20 +393,12 @@ mod tests {
 
     type MmapRegion = super::MmapRegion<()>;
 
-    // Adding a helper method to extract the errno within an Error::Mmap(e), or return a
-    // distinctive value when the error is represented by another variant.
-    impl Error {
-        pub fn raw_os_error(&self) -> i32 {
-            match self {
-                Error::Mmap(e) => e.raw_os_error().unwrap(),
-                _ => std::i32::MIN,
-            }
-        }
-    }
-
     #[test]
     fn test_mmap_region_new() {
-        assert!(MmapRegion::new(0).is_err());
+        assert_eq!(
+            MmapRegion::new(0).unwrap_err(),
+            Error::Mmap(std::io::Error::from_raw_os_error(libc::EINVAL))
+        );
 
         let size = 4096;
 
@@ -398,7 +414,10 @@ mod tests {
 
     #[test]
     fn test_mmap_region_set_hugetlbfs() {
-        assert!(MmapRegion::new(0).is_err());
+        assert_eq!(
+            MmapRegion::new(0).unwrap_err(),
+            Error::Mmap(std::io::Error::from_raw_os_error(libc::EINVAL))
+        );
 
         let size = 4096;
 
@@ -469,7 +488,7 @@ mod tests {
             prot,
             flags,
         );
-        assert_eq!(format!("{:?}", r.unwrap_err()), "InvalidOffsetLength");
+        assert_eq!(r.unwrap_err(), Error::InvalidOffsetLength);
 
         // Offset + size is greater than the size of the file (which is 0 at this point).
         let r = MmapRegion::build(
@@ -478,7 +497,7 @@ mod tests {
             prot,
             flags,
         );
-        assert_eq!(format!("{:?}", r.unwrap_err()), "MappingPastEof");
+        assert_eq!(r.unwrap_err(), Error::MappingPastEof);
 
         // MAP_FIXED was specified among the flags.
         let r = MmapRegion::build(
@@ -487,7 +506,7 @@ mod tests {
             prot,
             flags | libc::MAP_FIXED,
         );
-        assert_eq!(format!("{:?}", r.unwrap_err()), "MapFixed");
+        assert_eq!(r.unwrap_err(), Error::MapFixed);
 
         // Let's resize the file.
         assert_eq!(unsafe { libc::ftruncate(a.as_raw_fd(), 1024 * 10) }, 0);
@@ -499,7 +518,10 @@ mod tests {
             prot,
             flags,
         );
-        assert_eq!(r.unwrap_err().raw_os_error(), libc::EINVAL);
+        assert_eq!(
+            r.unwrap_err(),
+            Error::Mmap(std::io::Error::from_raw_os_error(libc::EINVAL))
+        );
 
         // The build should be successful now.
         let r =
@@ -520,10 +542,10 @@ mod tests {
         let flags = libc::MAP_NORESERVE | libc::MAP_PRIVATE;
 
         let r = unsafe { MmapRegion::build_raw((addr + 1) as *mut u8, size, prot, flags) };
-        assert_eq!(format!("{:?}", r.unwrap_err()), "InvalidPointer");
+        assert_eq!(r.unwrap_err(), Error::InvalidPointer);
 
         let r = unsafe { MmapRegion::build_raw(addr as *mut u8, size + 1, prot, flags) };
-        assert_eq!(format!("{:?}", r.unwrap_err()), "InvalidSize");
+        assert_eq!(r.unwrap_err(), Error::InvalidSize);
 
         let r = unsafe { MmapRegion::build_raw(addr as *mut u8, size, prot, flags).unwrap() };