From 52da8d9637e7c151dc0e7ab0b5370ee54ef3377a Mon Sep 17 00:00:00 2001
From: gnxlxnxx <gnxlxnxx@web.de>
Date: Mon, 8 Jun 2020 22:15:50 +0200
Subject: [PATCH] use float_cmp

I've acknoledged there are approximate equality checks in euclid itself,
and I'm going to look into using them since I believe the ugly angle approximation
is probably handled better there, but for now this works!
I've just seen it too late :D
---
 Cargo.toml         |  3 ++
 tests/unit_test.rs | 80 ++++++++++++----------------------------------
 2 files changed, 24 insertions(+), 59 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 7ae4ca8..bd374fe 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -17,3 +17,6 @@ edition = "2018"
 [dependencies]
 euclid = "0.20.11"
 thiserror = "1.0"
+
+[dev-dependencies]
+float-cmp = "0.8.0"
diff --git a/tests/unit_test.rs b/tests/unit_test.rs
index d2f7829..03899fc 100644
--- a/tests/unit_test.rs
+++ b/tests/unit_test.rs
@@ -1,74 +1,36 @@
 #[cfg(test)]
 mod tests {
     use dubins_path::*;
-
-    const ERROR: f64 = 0.000000000000001;
+    use float_cmp::approx_eq;
 
     fn circle_in_error_margin(
         result: CircleVector,
         expected_result: CircleVector,
     ) -> Result<(), ()> {
-        if result.center.x - expected_result.center.x > ERROR {
-            return Err(());
-        }
-        if result.center.x - expected_result.center.x < -ERROR {
-            return Err(());
-        }
-        if result.center.y - expected_result.center.y > ERROR {
-            return Err(());
-        }
-        if result.center.y - expected_result.center.y < -ERROR {
-            return Err(());
-        }
-        if result.radius - expected_result.radius > ERROR {
-            return Err(());
-        }
-        if result.radius - expected_result.radius < -ERROR {
-            return Err(());
-        }
-        if result.angle.radians - expected_result.angle.radians > ERROR
-            && result.angle.signed().radians - expected_result.angle.signed().radians > ERROR
-        {
-            return Err(());
-        }
-
-        if result.angle.radians - expected_result.angle.radians < -ERROR
-            && result.angle.signed().radians - expected_result.angle.signed().radians < -ERROR
-        {
-            return Err(());
-        }
+        assert!(approx_eq!(f64, result.center.x, expected_result.center.x));
+        assert!(approx_eq!(f64, result.center.x, expected_result.center.x));
+        assert!(approx_eq!(f64, result.center.y, expected_result.center.y));
+        assert!(approx_eq!(f64, result.center.y, expected_result.center.y));
+        assert!(approx_eq!(f64, result.radius, expected_result.radius));
+        assert!(approx_eq!(f64, result.radius, expected_result.radius));
+        assert!(approx_eq!(f64, result.angle.radians, expected_result.angle.radians) ||
+        	    approx_eq!(f64, result.angle.signed().radians, expected_result.angle.signed().radians));
+        assert!(approx_eq!(f64, result.angle.radians, expected_result.angle.radians) ||
+                approx_eq!(f64, result.angle.signed().radians, expected_result.angle.signed().radians));
         Ok(())
     }
 
     fn vector_in_error_margin(result: Vector, expected_result: Vector) -> Result<(), ()> {
-        if result.origin.x - expected_result.origin.x > ERROR {
-            return Err(());
-        }
-        if result.origin.x - expected_result.origin.x < -ERROR {
-            return Err(());
-        }
-        if result.origin.y - expected_result.origin.y > ERROR {
-            return Err(());
-        }
-        if result.origin.y - expected_result.origin.y < -ERROR {
-            return Err(());
-        }
-        if result.angle.radians - expected_result.angle.radians > ERROR
-            || result.angle.signed().radians - expected_result.angle.signed().radians > ERROR
-        {
-            return Err(());
-        }
-        if result.angle.radians - expected_result.angle.radians < -ERROR
-            || result.angle.signed().radians - expected_result.angle.signed().radians < -ERROR
-        {
-            return Err(());
-        }
-        if result.magnitude - expected_result.magnitude > ERROR {
-            return Err(());
-        }
-        if result.magnitude - expected_result.magnitude < -ERROR {
-            return Err(());
-        }
+        assert!(approx_eq!(f64, result.origin.x, expected_result.origin.x));
+        assert!(approx_eq!(f64, result.origin.x, expected_result.origin.x));
+        assert!(approx_eq!(f64, result.origin.y, expected_result.origin.y));
+        assert!(approx_eq!(f64, result.origin.y, expected_result.origin.y));
+        assert!(approx_eq!(f64, result.angle.radians, expected_result.angle.radians) ||
+                approx_eq!(f64, result.angle.signed().radians, expected_result.angle.signed().radians));
+        assert!(approx_eq!(f64, result.angle.radians, expected_result.angle.radians) ||
+        	    approx_eq!(f64, result.angle.signed().radians, expected_result.angle.signed().radians));
+        assert!(approx_eq!(f64, result.magnitude, expected_result.magnitude));
+        assert!(approx_eq!(f64, result.magnitude, expected_result.magnitude));
         Ok(())
     }