Move rem tests to impl_ops_rem.rs

Author: akubera

src/impl_ops_rem.rs

@@ -33,6 +33,7 @@ impl<'a> Rem<&'a BigDecimal> for BigDecimal {
         BigDecimal::new(result, scale)
     }
 }
+
 impl<'a> Rem<BigDecimal> for &'a BigDecimal {
     type Output = BigDecimal;
 
@@ -76,3 +77,80 @@ impl<'a, 'b> Rem<&'b BigDecimal> for &'a BigDecimal {
         BigDecimal::new(result, scale)
     }
 }
+
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use paste::paste;
+
+    macro_rules! impl_case {
+        ($a:literal % $b:literal => $c:literal ) => {
+            paste! {
+                impl_case!([< case_ $a _ $b >]: $a % $b => $c);
+            }
+        };
+        ($name:ident: $a:literal % $b:literal => $c:literal ) => {
+            #[test]
+            fn $name() {
+                let mut a: BigDecimal = $a.parse().unwrap();
+                let b: BigDecimal = $b.parse().unwrap();
+                let c: BigDecimal = $c.parse().unwrap();
+
+                assert_eq!(a.clone() % b.clone(), c);
+
+                assert_eq!(a.clone() % &b, c);
+                assert_eq!(&a % b.clone(), c);
+                assert_eq!(&a % &b, c);
+            }
+        };
+    }
+
+    impl_case!("100" % "5" => "0");
+    impl_case!("2e1" % "1" => "0");
+    impl_case!("2" % "1" => "0");
+    impl_case!("1" % "3" => "1");
+    impl_case!("1" % "5e-1" => "0");
+    impl_case!("15e-1" % "1" => "0.5");
+    impl_case!("1" % "3e-2" => "1e-2");
+    impl_case!("10" % "3e-3" => "0.001");
+    impl_case!("3" % "2" => "1");
+    impl_case!("1234e-2" % "1233e-3" => "0.01");
+
+    impl_case!(case_neg3_2: "-3" % "2" => "-1");
+    impl_case!(case_3_neg2: "3" % "-2" => "1");
+    impl_case!(case_neg3_neg2: "3" % "-2" => "1");
+
+    impl_case!(case_neg95eneg1_515eneg2: "-9.5" % "5.15" => "-4.35");
+
+
+    #[cfg(property_tests)]
+    mod prop {
+        use super::*;
+        use proptest::*;
+        use num_traits::FromPrimitive;
+
+        proptest! {
+            #[test]
+            fn quotient_and_remainder(f: f32, g: f32) {
+                // ignore non-normal numbers
+                prop_assume!(f.is_normal());
+                prop_assume!(g.is_normal());
+                prop_assume!(!g.is_zero());
+
+                let (f, g) = if f.abs() > g.abs() {
+                    (f, g)
+                } else {
+                    (g, f)
+                };
+
+                let a = BigDecimal::from_f32(f).unwrap();
+                let b = BigDecimal::from_f32(g).unwrap();
+
+                let r = &a % &b;
+                let q = (&a / &b).with_scale(0);
+                assert_eq!(a, q * b + r);
+            }
+        }
+    }
+}

src/lib.rs

@@ -1763,55 +1763,6 @@ mod bigdecimal_tests {
         assert!(BigDecimal::try_from(f64::NAN).is_err());
     }
 
-    #[test]
-    fn test_rem() {
-        let vals = vec![
-            ("100", "5", "0"),
-            ("2e1", "1", "0"),
-            ("2", "1", "0"),
-            ("1", "3", "1"),
-            ("1", "0.5", "0"),
-            ("1.5", "1", "0.5"),
-            ("1", "3e-2", "1e-2"),
-            ("10", "0.003", "0.001"),
-            ("3", "2", "1"),
-            ("-3", "2", "-1"),
-            ("3", "-2", "1"),
-            ("-3", "-2", "-1"),
-            ("12.34", "1.233", "0.01"),
-        ];
-        for &(x, y, z) in vals.iter() {
-            let a = BigDecimal::from_str(x).unwrap();
-            let b = BigDecimal::from_str(y).unwrap();
-            let c = BigDecimal::from_str(z).unwrap();
-
-            let rem = &a % &b;
-            assert_eq!(rem, c, "{} [&{} % &{}] == {}", rem, a, b, c);
-
-            let rem = a.clone() % &b;
-            assert_eq!(rem, c, "{} [{} % &{}] == {}", rem, a, b, c);
-
-            let rem = &a % b.clone();
-            assert_eq!(rem, c, "{} [&{} % {}] == {}", rem, a, b, c);
-
-            let rem = a.clone() % b.clone();
-            assert_eq!(rem, c, "{} [{} % {}] == {}", rem, a, b, c);
-        }
-        let vals = vec![
-            (("100", -2), ("50", -1), "0"),
-            (("100", 0), ("50", -1), "0"),
-            (("100", -2), ("30", 0), "10"),
-            (("100", 0), ("30", -1), "10"),
-        ];
-        for &((x, xs), (y, ys), z) in vals.iter() {
-            let a = BigDecimal::from_str(x).unwrap().with_scale(xs);
-            let b = BigDecimal::from_str(y).unwrap().with_scale(ys);
-            let c = BigDecimal::from_str(z).unwrap();
-            let rem = &a % &b;
-            assert_eq!(rem, c, "{} [{} % {}] == {}", rem, a, b, c);
-        }
-    }
-
     #[test]
     fn test_equal() {
         let vals = vec![