Add Rem arithmetic operation on BlockNumber

Author: Alenar

mithril-common/src/entities/block_number.rs

@@ -5,7 +5,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::entities::wrapper_helpers::{
     impl_add_to_wrapper, impl_div_to_wrapper, impl_mul_to_wrapper, impl_partial_eq_to_wrapper,
-    impl_sub_to_wrapper,
+    impl_rem_to_wrapper, impl_sub_to_wrapper,
 };
 use crate::signable_builder::Beacon;
 
@@ -41,6 +41,7 @@ impl_add_to_wrapper!(BlockNumber, u64);
 impl_sub_to_wrapper!(BlockNumber, u64);
 impl_mul_to_wrapper!(BlockNumber, u64);
 impl_div_to_wrapper!(BlockNumber, u64);
+impl_rem_to_wrapper!(BlockNumber, u64);
 impl_partial_eq_to_wrapper!(BlockNumber, u64);
 
 #[cfg(test)]
@@ -152,6 +153,26 @@ mod tests {
         test_op_assign!(18_u64, /=, &BlockNumber(3) => 6_u64);
     }
 
+    #[test]
+    #[allow(clippy::op_ref)]
+    fn test_rem() {
+        assert_eq!(BlockNumber(3), BlockNumber(18) % BlockNumber(5));
+        assert_eq!(BlockNumber(3), BlockNumber(18) % 5_u64);
+        assert_eq!(BlockNumber(3), BlockNumber(18) % &5_u64);
+
+        assert_eq!(BlockNumber(6), 20_u64 % BlockNumber(7));
+        assert_eq!(BlockNumber(6), 20_u64 % &BlockNumber(7));
+        assert_eq!(BlockNumber(6), &20_u64 % BlockNumber(7));
+        assert_eq!(BlockNumber(6), &20_u64 % &BlockNumber(7));
+
+        test_op_assign!(BlockNumber(18), %=, BlockNumber(5) => BlockNumber(3));
+        test_op_assign!(BlockNumber(18), %=, 5_u64 => BlockNumber(3));
+        test_op_assign!(BlockNumber(18), %=, &5_u64 => BlockNumber(3));
+
+        test_op_assign!(18_u64, %=, BlockNumber(5) => 3_u64);
+        test_op_assign!(18_u64, %=, &BlockNumber(5) => 3_u64);
+    }
+
     #[test]
     fn test_eq() {
         assert_eq!(BlockNumber(1), BlockNumber(1));

mithril-common/src/entities/wrapper_helpers.rs

@@ -370,6 +370,99 @@ macro_rules! impl_div_to_wrapper {
 }
 pub(crate) use impl_div_to_wrapper;
 
+macro_rules! impl_rem_to_wrapper {
+    ( $wrapper:ident, $inner:ty ) => {
+        use std::ops::{Rem, RemAssign};
+
+        impl Rem for $wrapper {
+            type Output = Self;
+
+            fn rem(self, rhs: Self) -> Self::Output {
+                self % *rhs
+            }
+        }
+
+        impl Rem<$inner> for $wrapper {
+            type Output = Self;
+
+            fn rem(self, rhs: $inner) -> Self::Output {
+                $wrapper(*self % rhs)
+            }
+        }
+
+        impl Rem<&$inner> for $wrapper {
+            type Output = Self;
+
+            fn rem(self, rhs: &$inner) -> Self::Output {
+                self.rem(*rhs)
+            }
+        }
+
+        impl Rem<$wrapper> for $inner {
+            type Output = $wrapper;
+
+            fn rem(self, rhs: $wrapper) -> Self::Output {
+                $wrapper(self.rem(rhs.0))
+            }
+        }
+
+        impl Rem<&$wrapper> for $inner {
+            type Output = $wrapper;
+
+            fn rem(self, rhs: &$wrapper) -> Self::Output {
+                self.rem(*rhs)
+            }
+        }
+
+        impl Rem<$wrapper> for &$inner {
+            type Output = $wrapper;
+
+            fn rem(self, rhs: $wrapper) -> Self::Output {
+                (*self).rem(rhs)
+            }
+        }
+
+        impl Rem<&$wrapper> for &$inner {
+            type Output = $wrapper;
+
+            fn rem(self, rhs: &$wrapper) -> Self::Output {
+                (*self).rem(*rhs)
+            }
+        }
+
+        impl RemAssign for $wrapper {
+            fn rem_assign(&mut self, rhs: Self) {
+                *self = self.rem(rhs);
+            }
+        }
+
+        impl RemAssign<$inner> for $wrapper {
+            fn rem_assign(&mut self, rhs: $inner) {
+                *self = self.rem(rhs);
+            }
+        }
+
+        impl RemAssign<&$inner> for $wrapper {
+            fn rem_assign(&mut self, rhs: &$inner) {
+                *self = self.rem(rhs);
+            }
+        }
+
+        impl RemAssign<$wrapper> for $inner {
+            fn rem_assign(&mut self, rhs: $wrapper) {
+                *self = self.rem(rhs.0);
+            }
+        }
+
+        impl RemAssign<&$wrapper> for $inner {
+            fn rem_assign(&mut self, rhs: &$wrapper) {
+                *self = self.rem(rhs.0);
+            }
+        }
+    };
+}
+pub(crate) use impl_rem_to_wrapper;
+
 macro_rules! impl_partial_eq_to_wrapper {
     ( $wrapper:ty, $inner:ty ) => {
         impl PartialEq<$inner> for $wrapper {
@@ -446,6 +539,11 @@ pub(crate) mod tests {
             number /= $left;
             assert_eq!($expected, number);
         }};
+        ( $right:expr, %=, $left:expr => $expected:expr ) => {{
+            let mut number = $right;
+            number %= $left;
+            assert_eq!($expected, number);
+        }};
     }
     pub(crate) use test_op_assign;
 }