Styling fixes to the quaternion arc code

src/quaternion.rs

@@ -73,8 +73,8 @@ impl<S: BaseFloat> Quaternion<S> {
         let mag_avg = (src.magnitude2() * dst.magnitude2()).sqrt();
         let dot = src.dot(dst);
         if dot.approx_eq(&mag_avg) {
-            One::one()
-        }else if dot.approx_eq(&-mag_avg) {
+            Quaternion::one()
+        } else if dot.approx_eq(&-mag_avg) {
             let axis = fallback.unwrap_or_else(|| {
                 let mut v = Vector3::unit_x().cross(src);
                 if v.approx_eq(&Zero::zero()) {
@@ -82,8 +82,8 @@ impl<S: BaseFloat> Quaternion<S> {
                 }
                 v.normalize()
             });
-            Rotation3::from_axis_angle(axis, Angle::turn_div_2())
-        }else {
+            Quaternion::from_axis_angle(axis, Rad::turn_div_2())
+        } else {
             Quaternion::from_sv(mag_avg + dot, src.cross(dst)).normalize()
         }
     }

tests/quaternion.rs

@@ -116,25 +116,36 @@ mod from {
 mod arc {
     use cgmath::*;
 
+    #[inline]
     fn test(src: Vector3<f32>, dst: Vector3<f32>) {
         let q = Quaternion::from_arc(src, dst, None);
         let v = q.rotate_vector(src);
-        assert_approx_eq!(v, dst);
+        assert_approx_eq!(v.normalize(), dst.normalize());
     }
 
     #[test]
-    fn test_arc() {
+    fn test_same() {
+        let v = Vector3::unit_x();
+        let q = Quaternion::from_arc(v, v, None);
+        assert_eq!(q, Quaternion::new(1.0, 0.0, 0.0, 0.0));
+    }
+
+    #[test]
+    fn test_opposite() {
         let v = Vector3::unit_x();
-        {
-            let q = Quaternion::from_arc(v, v, None);
-            assert_eq!(q, Quaternion::new(1.0, 0.0, 0.0, 0.0));
-        }
         test(v, -v);
-        {
-            let q: Quaternion<f32> = Quaternion::from_arc(v, Vector3::unit_y(), None);
-            let q2 = Quaternion::from_axis_angle(Vector3::unit_z(), Angle::turn_div_4());
-            assert_approx_eq!(q, q2);
-        }
+    }
+
+    #[test]
+    fn test_random() {
+        test(vec3(1.0, 2.0, 3.0), vec3(-4.0, 5.0, -6.0));
+    }
+
+    #[test]
+    fn test_ortho() {
+        let q: Quaternion<f32> = Quaternion::from_arc(Vector3::unit_x(), Vector3::unit_y(), None);
+        let q2 = Quaternion::from_axis_angle(Vector3::unit_z(), Rad::turn_div_4());
+        assert_approx_eq!(q, q2);
     }
 }