hodasemi/cgmath
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Add conversion tests for vectors, points, and quaternions

Browse source
This commit is contained in:
Brendan Zabarauskas 2015-09-27 17:20:02 +10:00
parent 17f51d4989
commit 7f73c2cdd9
3 changed files with 401 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

130
src/point.rs
View file

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

76
src/quaternion.rs
View file

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

195
src/vector.rs
View file

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