Quaternions are now Transmutable.

This implements Transmutable for Quaternions and creates a
test and example for this conversion.

tests/transmutable.rs

@@ -5,9 +5,10 @@ extern crate sigils;
 
 
 
-macro_rules! transmutation_test
+macro_rules! transmutation_vector_test
 {
-   ($modName: ident, $varType: ident, $numBytes: expr, [$($var: ident)*]) =>
+   ($modName: ident, $varType: ident, $dataType:ty,
+    $numBytes: expr, [$($var: ident)*]) =>
    {
       mod $modName
       {
@@ -22,16 +23,16 @@ macro_rules! transmutation_test
          #[test]
          pub fn transmutation()
          {
-            let mut vec: $varType<u64>;
-            let final_vec: $varType<u64>;
+            let mut vec: $varType<$dataType>;
+            let final_vec: $varType<$dataType>;
             let endianess: Endianess;
             let mut rng: ThreadRng;
             let mut buffer: [u8; $numBytes];
 
             // Initialize the variables.
             rng = thread_rng();
-            vec = $varType::<u64>::zero();
-            $(vec.$var = rng.next_u64();)*
+            vec = $varType::<$dataType>::zero();
+            $(vec.$var = rng.gen();)*
             buffer = [0u8; $numBytes];
             endianess = Endianess::PLATFORM;
 
@@ -45,6 +46,47 @@ macro_rules! transmutation_test
 }
 
 
-transmutation_test!(vec2, Vector2, 16, [x y]);
-transmutation_test!(vec3, Vector3, 24, [x y z]);
-transmutation_test!(vec4, Vector4, 32, [x y z w]);
+transmutation_vector_test!(vec2, Vector2, u64, 16, [x y]);
+transmutation_vector_test!(vec3, Vector3, u32, 12, [x y z]);
+transmutation_vector_test!(vec4, Vector4, u16, 8, [x y z w]);
+
+
+
+mod quat
+{
+   use rand::{thread_rng, Rng, ThreadRng};
+
+   use alchemy::{Endianess, Transmutable};
+   use sigils::Zero;
+   use sigils::quaternion::Quaternion;
+
+
+
+   #[test]
+   pub fn transmutation()
+   {
+      let mut quat: Quaternion<f64>;
+      let final_quat: Quaternion<f64>;
+      let endianess: Endianess;
+      let mut rng: ThreadRng;
+      let mut buffer: [u8; 32];
+
+      // Initialize the variables.
+      rng = thread_rng();
+      quat = Quaternion::<f64>::zero();
+      quat.scalar = rng.gen();
+      quat.vector.x = rng.gen();
+      quat.vector.y = rng.gen();
+      quat.vector.z = rng.gen();
+      buffer = [0u8; 32];
+      endianess = Endianess::PLATFORM;
+
+      quat.to_bytes(&mut buffer, endianess);
+      final_quat = Quaternion::from_bytes(&buffer, endianess);
+
+      assert_eq!(quat.scalar, final_quat.scalar);
+      assert_eq!(quat.vector.x, final_quat.vector.x);
+      assert_eq!(quat.vector.y, final_quat.vector.y);
+      assert_eq!(quat.vector.z, final_quat.vector.z);
+   }
+}