test: use prop_assert* macros where appropriate

The prop_assert* macros clean-up the assertion output by eliminating the extra panics while it’s reducing inputs.

Signed-off-by: Stephen Waits <steve@waits.net>

src/height_vector.rs

@@ -240,6 +240,10 @@ mod tests {
     use assert_approx_eq::assert_approx_eq;
     use proptest::prelude::*;
 
+    fn approx_eq(a: FloatType, b: FloatType, margin: FloatType) -> bool {
+        (a - b).abs() <= margin
+    }
+
     proptest! {
         #[test]
         fn proptest_len(x: FloatType, y: FloatType, h: FloatType) {
@@ -248,13 +252,13 @@ mod tests {
             println!("a = {a:#?}");
             if x.is_nan() || x.is_infinite() || y.is_nan() || y.is_infinite() || h.is_nan() || h.is_infinite() || h < 0.0 {
                 // we should've gottne a random univ vector here
-                assert_approx_eq!(a.len(), 1.0);
+                prop_assert!(approx_eq(a.len(), 1.0, 0.0001));
             } else {
                 // `HeightVector` we created from proptest values should be valid and have a length
                 if len.is_nan() || len.is_infinite() {
-                    assert!(a.len().is_nan() || a.len().is_infinite());
+                    prop_assert!(a.len().is_nan() || a.len().is_infinite());
                 } else {
-                    assert_approx_eq!(a.len(), len);
+                    prop_assert!(approx_eq(a.len(), len, 0.0001));
                 }
             }
         }
@@ -268,9 +272,9 @@ mod tests {
             let a = HeightVector::<2>::from(([fx0 ,fy0 ],fh0 ));
             let b = HeightVector::<2>::from(([fx1 ,fy1 ],fh1 ));
             let c = a+b;
-            assert_approx_eq!(c.position[0], fx0 + fx1);
+            prop_assert!(approx_eq(c.position[0], fx0 + fx1, 0.0001));
-            assert_approx_eq!(c.position[1], fy0 + fy1);
+            prop_assert!(approx_eq(c.position[1], fy0 + fy1, 0.0001));
-            assert_approx_eq!(c.height, fh0 + fh1);
+            prop_assert!(approx_eq(c.height, fh0 + fh1, 0.0001));
         }
 
         #[test]
@@ -282,9 +286,9 @@ mod tests {
             let a = HeightVector::<2>::from(([fx0 ,fy0 ],fh0 ));
             let b = HeightVector::<2>::from(([fx1 ,fy1 ],fh1 ));
             let c = a-b;
-            assert_approx_eq!(c.position[0], fx0 - fx1);
+            prop_assert!(approx_eq(c.position[0], fx0 - fx1, 0.0001));
-            assert_approx_eq!(c.position[1], fy0 - fy1);
+            prop_assert!(approx_eq(c.position[1], fy0 - fy1, 0.0001));
-            assert_approx_eq!(c.height, fh0 + fh1);
+            prop_assert!(approx_eq(c.height, fh0 + fh1, 0.0001));
         }
 
         #[test]
@@ -295,11 +299,11 @@ mod tests {
             let a = HeightVector::<2>::from(([fx, fy], fh));
             let b = a * fm;
             if fm < 0.0 {
-                assert_approx_eq!(b.len(), 1.0);
+                prop_assert!(approx_eq(b.len(), 1.0, 0.0001));
             } else {
-                assert_approx_eq!(b.position[0], fx * fm);
+                prop_assert!(approx_eq(b.position[0], fx * fm, 0.0001));
-                assert_approx_eq!(b.position[1], fy * fm);
+                prop_assert!(approx_eq(b.position[1], fy * fm, 0.0001));
-                assert_approx_eq!(b.height, fh * fm);
+                prop_assert!(approx_eq(b.height, fh * fm, 0.0001));
             }
         }
     }

src/vector.rs

@@ -157,16 +157,20 @@ mod tests {
     use assert_approx_eq::assert_approx_eq;
     use proptest::prelude::*;
 
+    fn approx_eq(a: f32, b: f32, margin: f32) -> bool {
+        (a - b).abs() <= margin
+    }
+
     proptest! {
         #[test]
         fn proptest_new(x: f32, y: f32, z: f32){
             let v = Vector::<f32, 3>::from([x,y,z]);
-            assert_approx_eq!(v[0], x);
+            prop_assert!(approx_eq(v[0], x, 0.0001));
-            assert_approx_eq!(v[1], y);
+            prop_assert!(approx_eq(v[1], y, 0.0001));
-            assert_approx_eq!(v[2], z);
+            prop_assert!(approx_eq(v[2], z, 0.0001));
-            assert!(v[0].is_finite());
+            prop_assert!(v[0].is_finite());
-            assert!(v[1].is_finite());
+            prop_assert!(v[1].is_finite());
-            assert!(v[1].is_finite());
+            prop_assert!(v[1].is_finite());
         }
 
         #[test]
@@ -176,21 +180,21 @@ mod tests {
 
             let (x,y,z) = (v[0]*m, v[1]*m, v[2]*m);
             if x.is_nan() || x.is_infinite() {
-                assert!(w[0].is_nan() || w[0].is_infinite());
+                prop_assert!(w[0].is_nan() || w[0].is_infinite());
             } else {
-                assert_approx_eq!(w[0], x);
+                prop_assert!(approx_eq(w[0], x, 0.0001));
             }
 
             if y.is_nan() || y.is_infinite() {
-                assert!(w[1].is_nan() || w[1].is_infinite());
+                prop_assert!(w[1].is_nan() || w[1].is_infinite());
             } else {
-                assert_approx_eq!(w[1], y);
+                prop_assert!(approx_eq(w[1], y, 0.0001));
             }
 
             if z.is_nan() || z.is_infinite() {
-                assert!(w[2].is_nan() || w[2].is_infinite());
+                prop_assert!(w[2].is_nan() || w[2].is_infinite());
             } else {
-                assert_approx_eq!(w[2], z);
+                prop_assert!(approx_eq(w[2], z, 0.0001));
             }
         }
 
@@ -201,21 +205,21 @@ mod tests {
 
             let (x,y,z) = (v[0]/d, v[1]/d, v[2]/d);
             if x.is_nan() || x.is_infinite() {
-                assert!(w[0].is_nan() ||w[0].is_infinite());
+                prop_assert!(w[0].is_nan() ||w[0].is_infinite());
             } else {
-                assert_approx_eq!(w[0], x);
+                prop_assert!(approx_eq(w[0], x, 0.0001));
             }
 
             if y.is_nan() || y.is_infinite() {
-                assert!(w[1].is_nan() || w[1].is_infinite());
+                prop_assert!(w[1].is_nan() || w[1].is_infinite());
             } else {
-                assert_approx_eq!(w[1], y);
+                prop_assert!(approx_eq(w[1], y, 0.0001));
             }
 
             if z.is_nan() || z.is_infinite() {
-                assert!(w[2].is_nan() || w[2].is_infinite());
+                prop_assert!(w[2].is_nan() || w[2].is_infinite());
             } else {
-                assert_approx_eq!(w[2], z);
+                prop_assert!(approx_eq(w[2], z, 0.0001));
             }
         }
     }

tests/basic-usage.rs

@@ -0,0 +1,22 @@
+// This is just for basic interface and happy path testing. It doesn't do anything other than make
+// sure the expected public interface exists and works.
+
+use array_init::array_init;
+use core::time::Duration;
+use vivaldi_nc::NetworkCoordinate;
+
+const NUM_NODES: usize = 100;
+
+#[test]
+fn basic_usage() {
+    let mut nc: [NetworkCoordinate<2>; NUM_NODES] = array_init(|_| NetworkCoordinate::<2>::new());
+    for i in 0..NUM_NODES {
+        for j in 0..NUM_NODES {
+            if i == j {
+                continue;
+            }
+            let other = nc[j].clone();
+            nc[i].update(&other, Duration::from_millis(100));
+        }
+    }
+}