extern crate rand;

extern crate alchemy;
extern crate sigils;



macro_rules! transmutation_vector_test
{
   ($modName: ident, $varType: ident, $dataType:ty,
    $numBytes: expr, [$($var: ident)*]) =>
   {
      mod $modName
      {
         use rand::{thread_rng, Rng, ThreadRng};

         use alchemy::{Endianess, Transmutable};
         use sigils::Zero;
         use sigils::vector::$varType;



         #[test]
         pub fn transmutation()
         {
            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::<$dataType>::zero();
            $(vec.$var = rng.gen();)*
            buffer = [0u8; $numBytes];
            endianess = Endianess::PLATFORM;

            vec.to_bytes(&mut buffer, endianess);
            final_vec = $varType::from_bytes(&buffer, endianess);

            $(assert_eq!(vec.$var, final_vec.$var);)*
         }
      }
   }
}


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);
   }
}