diff --git a/src/point.rs b/src/point.rs
index 3cf50c3..037ccf8 100644
--- a/src/point.rs
+++ b/src/point.rs
@@ -547,6 +547,71 @@ mod tests {
             assert_eq!(&POINT2[..], &[1, 2]);
             assert_eq!(POINT2[..].len(), 2);
         }
+
+        #[test]
+        fn test_into() {
+            let p = POINT2;
+            {
+                let p: [i32; 2] = p.into();
+                assert_eq!(p, [1, 2]);
+            }
+            {
+                let p: (i32, i32) = p.into();
+                assert_eq!(p, (1, 2));
+            }
+        }
+
+        #[test]
+        fn test_as_ref() {
+            let p = POINT2;
+            {
+                let p: &[i32; 2] = p.as_ref();
+                assert_eq!(p, &[1, 2]);
+            }
+            {
+                let p: &(i32, i32) = p.as_ref();
+                assert_eq!(p, &(1, 2));
+            }
+        }
+
+        #[test]
+        fn test_as_mut() {
+            let mut p = POINT2;
+            {
+                let p: &mut [i32; 2] = p.as_mut();
+                assert_eq!(p, &mut [1, 2]);
+            }
+            {
+                let p: &mut (i32, i32) = p.as_mut();
+                assert_eq!(p, &mut (1, 2));
+            }
+        }
+
+        #[test]
+        fn test_from() {
+            assert_eq!(Point2::from([1, 2]), POINT2);
+            {
+                let p = &[1, 2];
+                let p: &Point2<_> = From::from(p);
+                assert_eq!(p, &POINT2);
+            }
+            {
+                let p = &mut [1, 2];
+                let p: &mut Point2<_> = From::from(p);
+                assert_eq!(p, &POINT2);
+            }
+            assert_eq!(Point2::from((1, 2)), POINT2);
+            {
+                let p = &(1, 2);
+                let p: &Point2<_> = From::from(p);
+                assert_eq!(p, &POINT2);
+            }
+            {
+                let p = &mut (1, 2);
+                let p: &mut Point2<_> = From::from(p);
+                assert_eq!(p, &POINT2);
+            }
+        }
     }
 
     mod point3 {
@@ -587,5 +652,70 @@ mod tests {
             assert_eq!(&POINT3[..], &[1, 2, 3]);
             assert_eq!(POINT3[..].len(), 3);
         }
+
+        #[test]
+        fn test_into() {
+            let p = POINT3;
+            {
+                let p: [i32; 3] = p.into();
+                assert_eq!(p, [1, 2, 3]);
+            }
+            {
+                let p: (i32, i32, i32) = p.into();
+                assert_eq!(p, (1, 2, 3));
+            }
+        }
+
+        #[test]
+        fn test_as_ref() {
+            let p = POINT3;
+            {
+                let p: &[i32; 3] = p.as_ref();
+                assert_eq!(p, &[1, 2, 3]);
+            }
+            {
+                let p: &(i32, i32, i32) = p.as_ref();
+                assert_eq!(p, &(1, 2, 3));
+            }
+        }
+
+        #[test]
+        fn test_as_mut() {
+            let mut p = POINT3;
+            {
+                let p: &mut [i32; 3] = p.as_mut();
+                assert_eq!(p, &mut [1, 2, 3]);
+            }
+            {
+                let p: &mut (i32, i32, i32) = p.as_mut();
+                assert_eq!(p, &mut (1, 2, 3));
+            }
+        }
+
+        #[test]
+        fn test_from() {
+            assert_eq!(Point3::from([1, 2, 3]), POINT3);
+            {
+                let p = &[1, 2, 3];
+                let p: &Point3<_> = From::from(p);
+                assert_eq!(p, &POINT3);
+            }
+            {
+                let p = &mut [1, 2, 3];
+                let p: &mut Point3<_> = From::from(p);
+                assert_eq!(p, &POINT3);
+            }
+            assert_eq!(Point3::from((1, 2, 3)), POINT3);
+            {
+                let p = &(1, 2, 3);
+                let p: &Point3<_> = From::from(p);
+                assert_eq!(p, &POINT3);
+            }
+            {
+                let p = &mut (1, 2, 3);
+                let p: &mut Point3<_> = From::from(p);
+                assert_eq!(p, &POINT3);
+            }
+        }
     }
 }
diff --git a/src/quaternion.rs b/src/quaternion.rs
index 9db02e6..6280c45 100644
--- a/src/quaternion.rs
+++ b/src/quaternion.rs
@@ -535,3 +535,79 @@ impl<S: BaseFloat + Rand> Rand for Quaternion<S> {
        Quaternion::from_sv(rng.gen(), rng.gen())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use quaternion::*;
+    use vector::*;
+
+    const QUATERNION: Quaternion<f32> = Quaternion {
+        s: 1.0,
+        v: Vector3 { x: 2.0, y: 3.0, z: 4.0 },
+    };
+
+    #[test]
+    fn test_into() {
+        let v = QUATERNION;
+        {
+            let v: [f32; 4] = v.into();
+            assert_eq!(v, [1.0, 2.0, 3.0, 4.0]);
+        }
+        {
+            let v: (f32, f32, f32, f32) = v.into();
+            assert_eq!(v, (1.0, 2.0, 3.0, 4.0));
+        }
+    }
+
+    #[test]
+    fn test_as_ref() {
+        let v = QUATERNION;
+        {
+            let v: &[f32; 4] = v.as_ref();
+            assert_eq!(v, &[1.0, 2.0, 3.0, 4.0]);
+        }
+        {
+            let v: &(f32, f32, f32, f32) = v.as_ref();
+            assert_eq!(v, &(1.0, 2.0, 3.0, 4.0));
+        }
+    }
+
+    #[test]
+    fn test_as_mut() {
+        let mut v = QUATERNION;
+        {
+            let v: &mut[f32; 4] = v.as_mut();
+            assert_eq!(v, &mut [1.0, 2.0, 3.0, 4.0]);
+        }
+        {
+            let v: &mut(f32, f32, f32, f32) = v.as_mut();
+            assert_eq!(v, &mut (1.0, 2.0, 3.0, 4.0));
+        }
+    }
+
+    #[test]
+    fn test_from() {
+        assert_eq!(Quaternion::from([1.0, 2.0, 3.0, 4.0]), QUATERNION);
+        {
+            let v = &[1.0, 2.0, 3.0, 4.0];
+            let v: &Quaternion<_> = From::from(v);
+            assert_eq!(v, &QUATERNION);
+        }
+        {
+            let v = &mut [1.0, 2.0, 3.0, 4.0];
+            let v: &mut Quaternion<_> = From::from(v);
+            assert_eq!(v, &QUATERNION);
+        }
+        assert_eq!(Quaternion::from((1.0, 2.0, 3.0, 4.0)), QUATERNION);
+        {
+            let v = &(1.0, 2.0, 3.0, 4.0);
+            let v: &Quaternion<_> = From::from(v);
+            assert_eq!(v, &QUATERNION);
+        }
+        {
+            let v = &mut (1.0, 2.0, 3.0, 4.0);
+            let v: &mut Quaternion<_> = From::from(v);
+            assert_eq!(v, &QUATERNION);
+        }
+    }
+}
diff --git a/src/vector.rs b/src/vector.rs
index 4e42a93..20edc63 100644
--- a/src/vector.rs
+++ b/src/vector.rs
@@ -725,6 +725,71 @@ mod tests {
             assert_eq!(&VECTOR2[..], &[1, 2]);
             assert_eq!(VECTOR2[..].len(), 2);
         }
+
+        #[test]
+        fn test_into() {
+            let v = VECTOR2;
+            {
+                let v: [i32; 2] = v.into();
+                assert_eq!(v, [1, 2]);
+            }
+            {
+                let v: (i32, i32) = v.into();
+                assert_eq!(v, (1, 2));
+            }
+        }
+
+        #[test]
+        fn test_as_ref() {
+            let v = VECTOR2;
+            {
+                let v: &[i32; 2] = v.as_ref();
+                assert_eq!(v, &[1, 2]);
+            }
+            {
+                let v: &(i32, i32) = v.as_ref();
+                assert_eq!(v, &(1, 2));
+            }
+        }
+
+        #[test]
+        fn test_as_mut() {
+            let mut v = VECTOR2;
+            {
+                let v: &mut [i32; 2] = v.as_mut();
+                assert_eq!(v, &mut [1, 2]);
+            }
+            {
+                let v: &mut (i32, i32) = v.as_mut();
+                assert_eq!(v, &mut (1, 2));
+            }
+        }
+
+        #[test]
+        fn test_from() {
+            assert_eq!(Vector2::from([1, 2]), VECTOR2);
+            {
+                let v = &[1, 2];
+                let v: &Vector2<_> = From::from(v);
+                assert_eq!(v, &VECTOR2);
+            }
+            {
+                let v = &mut [1, 2];
+                let v: &mut Vector2<_> = From::from(v);
+                assert_eq!(v, &VECTOR2);
+            }
+            assert_eq!(Vector2::from((1, 2)), VECTOR2);
+            {
+                let v = &(1, 2);
+                let v: &Vector2<_> = From::from(v);
+                assert_eq!(v, &VECTOR2);
+            }
+            {
+                let v = &mut (1, 2);
+                let v: &mut Vector2<_> = From::from(v);
+                assert_eq!(v, &VECTOR2);
+            }
+        }
     }
 
     mod vector3 {
@@ -765,6 +830,71 @@ mod tests {
             assert_eq!(&VECTOR3[..], &[1, 2, 3]);
             assert_eq!(VECTOR3[..].len(), 3);
         }
+
+        #[test]
+        fn test_into() {
+            let v = VECTOR3;
+            {
+                let v: [i32; 3] = v.into();
+                assert_eq!(v, [1, 2, 3]);
+            }
+            {
+                let v: (i32, i32, i32) = v.into();
+                assert_eq!(v, (1, 2, 3));
+            }
+        }
+
+        #[test]
+        fn test_as_ref() {
+            let v = VECTOR3;
+            {
+                let v: &[i32; 3] = v.as_ref();
+                assert_eq!(v, &[1, 2, 3]);
+            }
+            {
+                let v: &(i32, i32, i32) = v.as_ref();
+                assert_eq!(v, &(1, 2, 3));
+            }
+        }
+
+        #[test]
+        fn test_as_mut() {
+            let mut v = VECTOR3;
+            {
+                let v: &mut [i32; 3] = v.as_mut();
+                assert_eq!(v, &mut [1, 2, 3]);
+            }
+            {
+                let v: &mut (i32, i32, i32) = v.as_mut();
+                assert_eq!(v, &mut (1, 2, 3));
+            }
+        }
+
+        #[test]
+        fn test_from() {
+            assert_eq!(Vector3::from([1, 2, 3]), VECTOR3);
+            {
+                let v = &[1, 2, 3];
+                let v: &Vector3<_> = From::from(v);
+                assert_eq!(v, &VECTOR3);
+            }
+            {
+                let v = &mut [1, 2, 3];
+                let v: &mut Vector3<_> = From::from(v);
+                assert_eq!(v, &VECTOR3);
+            }
+            assert_eq!(Vector3::from((1, 2, 3)), VECTOR3);
+            {
+                let v = &(1, 2, 3);
+                let v: &Vector3<_> = From::from(v);
+                assert_eq!(v, &VECTOR3);
+            }
+            {
+                let v = &mut (1, 2, 3);
+                let v: &mut Vector3<_> = From::from(v);
+                assert_eq!(v, &VECTOR3);
+            }
+        }
     }
 
     mod vector4 {
@@ -806,5 +936,70 @@ mod tests {
             assert_eq!(&VECTOR4[..], &[1, 2, 3, 4]);
             assert_eq!(VECTOR4[..].len(), 4);
         }
+
+        #[test]
+        fn test_into() {
+            let v = VECTOR4;
+            {
+                let v: [i32; 4] = v.into();
+                assert_eq!(v, [1, 2, 3, 4]);
+            }
+            {
+                let v: (i32, i32, i32, i32) = v.into();
+                assert_eq!(v, (1, 2, 3, 4));
+            }
+        }
+
+        #[test]
+        fn test_as_ref() {
+            let v = VECTOR4;
+            {
+                let v: &[i32; 4] = v.as_ref();
+                assert_eq!(v, &[1, 2, 3, 4]);
+            }
+            {
+                let v: &(i32, i32, i32, i32) = v.as_ref();
+                assert_eq!(v, &(1, 2, 3, 4));
+            }
+        }
+
+        #[test]
+        fn test_as_mut() {
+            let mut v = VECTOR4;
+            {
+                let v: &mut[i32; 4] = v.as_mut();
+                assert_eq!(v, &mut [1, 2, 3, 4]);
+            }
+            {
+                let v: &mut(i32, i32, i32, i32) = v.as_mut();
+                assert_eq!(v, &mut (1, 2, 3, 4));
+            }
+        }
+
+        #[test]
+        fn test_from() {
+            assert_eq!(Vector4::from([1, 2, 3, 4]), VECTOR4);
+            {
+                let v = &[1, 2, 3, 4];
+                let v: &Vector4<_> = From::from(v);
+                assert_eq!(v, &VECTOR4);
+            }
+            {
+                let v = &mut [1, 2, 3, 4];
+                let v: &mut Vector4<_> = From::from(v);
+                assert_eq!(v, &VECTOR4);
+            }
+            assert_eq!(Vector4::from((1, 2, 3, 4)), VECTOR4);
+            {
+                let v = &(1, 2, 3, 4);
+                let v: &Vector4<_> = From::from(v);
+                assert_eq!(v, &VECTOR4);
+            }
+            {
+                let v = &mut (1, 2, 3, 4);
+                let v: &mut Vector4<_> = From::from(v);
+                assert_eq!(v, &VECTOR4);
+            }
+        }
     }
 }