Add should_be_approx for floats

Author: rick-de-water

src/impls/mod.rs

@@ -1,5 +1,6 @@
 pub mod generic;
 pub mod iterator;
+pub mod numeric;
 pub mod option;
 pub mod result;
 pub mod string;

src/impls/numeric.rs

@@ -0,0 +1,53 @@
+use crate::{caller_name::get_caller_name, expected::Expected, ShouldBeApproximatelyEqual};
+
+impl ShouldBeApproximatelyEqual<f32> for f32 {
+    fn should_be_approx(&self, expected: impl Expected<f32>, tolerance: impl Expected<f32>) {
+        let other = expected.value();
+        let tolerance = tolerance.value();
+        let high = other + tolerance;
+        let low = other - tolerance;
+        let caller_name = get_caller_name().unwrap_or("UNKNOWN".to_string());
+
+        if *self > high || *self < low {
+            panic!("{} should be between {:?} and {:?} but was {:?}", caller_name, low, high, self)
+        }
+    }
+
+    fn should_not_be_approx(&self, expected: impl Expected<f32>, tolerance: impl Expected<f32>) {
+        let other = expected.value();
+        let tolerance = tolerance.value();
+        let high = other + tolerance;
+        let low = other - tolerance;
+        let caller_name = get_caller_name().unwrap_or("UNKNOWN".to_string());
+
+        if *self <= high && *self >= low {
+            panic!("{} should not be between {:?} and {:?} but was {:?}", caller_name, low, high, self)
+        }
+    }
+}
+
+impl ShouldBeApproximatelyEqual<f64> for f64 {
+    fn should_be_approx(&self, expected: impl Expected<f64>, tolerance: impl Expected<f64>) {
+        let other = expected.value();
+        let tolerance = tolerance.value();
+        let high = other + tolerance;
+        let low = other - tolerance;
+        let caller_name = get_caller_name().unwrap_or("UNKNOWN".to_string());
+
+        if *self > high || *self < low {
+            panic!("{} should be between {:?} and {:?} but was {:?}", caller_name, low, high, self)
+        }
+    }
+
+    fn should_not_be_approx(&self, expected: impl Expected<f64>, tolerance: impl Expected<f64>) {
+        let other = expected.value();
+        let tolerance = tolerance.value();
+        let high = other + tolerance;
+        let low = other - tolerance;
+        let caller_name = get_caller_name().unwrap_or("UNKNOWN".to_string());
+
+        if *self <= high && *self >= low {
+            panic!("{} should not be between {:?} and {:?} but was {:?}", caller_name, low, high, self)
+        }
+    }
+}

src/tests/mod.rs

@@ -1,5 +1,6 @@
 pub mod generic;
 pub mod iterator;
+pub mod numeric;
 pub mod option;
 pub mod result;
 pub mod string;

src/tests/numeric.rs

@@ -0,0 +1,25 @@
+use crate::ShouldBeApproximatelyEqual;
+
+
+#[test]
+fn success() {
+    let value =  0.25;
+
+    value.should_be_approx(0.0, 0.25);
+    value.should_be_approx(0.25, 0.25);
+    value.should_be_approx(0.5, 0.25);
+    value.should_not_be_approx(0.75, 0.25);
+}
+
+
+#[test]
+#[should_panic(expected = "0.25 should be between 0.5 and 1.0 but was 0.25")]
+fn should_be_approx_fail() {
+    0.25.should_be_approx(0.75, 0.25);
+}
+
+#[test]
+#[should_panic(expected = "0.25 should not be between -0.25 and 0.25 but was 0.25")]
+fn should_not_be_approx_fail() {
+    0.25.should_not_be_approx(0.0, 0.25);
+}

src/traits/approx_equal.rs

@@ -0,0 +1,6 @@
+use crate::expected::Expected;
+
+pub trait ShouldBeApproximatelyEqual<T: ?Sized> {
+    fn should_be_approx(&self, expected: impl Expected<T>, tolerance: impl Expected<T>);
+    fn should_not_be_approx(&self, expected: impl Expected<T>, tolerance: impl Expected<T>);
+}

src/traits/mod.rs

@@ -1,3 +1,4 @@
+mod approx_equal;
 mod equal;
 mod empty;
 mod option;
@@ -6,6 +7,7 @@ mod result;
 mod same;
 mod start_end;
 
+pub use approx_equal::*;
 pub use equal::*;
 pub use empty::*;
 pub use option::*;