diff options
Diffstat (limited to 'tests/vec3.rs')
| -rw-r--r-- | tests/vec3.rs | 863 |
1 files changed, 809 insertions, 54 deletions
diff --git a/tests/vec3.rs b/tests/vec3.rs index 5df8d09..0997826 100644 --- a/tests/vec3.rs +++ b/tests/vec3.rs @@ -20,6 +20,8 @@ macro_rules! impl_vec3_tests { assert_eq!($vec3::X, $new(1 as $t, 0 as $t, 0 as $t)); assert_eq!($vec3::Y, $new(0 as $t, 1 as $t, 0 as $t)); assert_eq!($vec3::Z, $new(0 as $t, 0 as $t, 1 as $t)); + assert_eq!($vec3::MIN, $new($t::MIN, $t::MIN, $t::MIN)); + assert_eq!($vec3::MAX, $new($t::MAX, $t::MAX, $t::MAX)); }); glam_test!(test_new, { @@ -108,6 +110,18 @@ macro_rules! impl_vec3_tests { let y = $new(0 as $t, 1 as $t, 0 as $t); assert_eq!(1 as $t, x.dot(x)); assert_eq!(0 as $t, x.dot(y)); + + assert_eq!( + $new(14 as $t, 14 as $t, 14 as $t), + $new(0 as $t, 4 as $t, 6 as $t).dot_into_vec($new(3 as $t, 2 as $t, 1 as $t)) + ); + }); + + glam_test!(test_length_squared_unsigned, { + let x = $new(1 as $t, 0 as $t, 0 as $t); + let z = $new(0 as $t, 0 as $t, 1 as $t); + assert_eq!(4 as $t, (2 as $t * x).length_squared()); + assert_eq!(16 as $t, (4 as $t * z).length_squared()); }); glam_test!(test_cross, { @@ -462,6 +476,36 @@ macro_rules! impl_vec3_tests { assert_ne!(b, c); }); + glam_test!(test_mask_test, { + let a = $mask::new(true, false, true); + assert_eq!(a.test(0), true); + assert_eq!(a.test(1), false); + assert_eq!(a.test(2), true); + + let b = $mask::new(false, true, false); + assert_eq!(b.test(0), false); + assert_eq!(b.test(1), true); + assert_eq!(b.test(2), false); + }); + + glam_test!(test_mask_set, { + let mut a = $mask::new(false, true, false); + a.set(0, true); + assert_eq!(a.test(0), true); + a.set(1, false); + assert_eq!(a.test(1), false); + a.set(2, true); + assert_eq!(a.test(2), true); + + let mut b = $mask::new(true, false, true); + b.set(0, false); + assert_eq!(b.test(0), false); + b.set(1, true); + assert_eq!(b.test(1), true); + b.set(2, false); + assert_eq!(b.test(2), false); + }); + glam_test!(test_mask_hash, { use std::collections::hash_map::DefaultHasher; use std::hash::Hash; @@ -501,14 +545,14 @@ macro_rules! impl_vec3_tests { glam_test!(test_sum, { let one = $vec3::ONE; - assert_eq!(vec![one, one].iter().sum::<$vec3>(), one + one); - assert_eq!(vec![one, one].into_iter().sum::<$vec3>(), one + one); + assert_eq!([one, one].iter().sum::<$vec3>(), one + one); + assert_eq!([one, one].into_iter().sum::<$vec3>(), one + one); }); glam_test!(test_product, { let two = $vec3::new(2 as $t, 2 as $t, 2 as $t); - assert_eq!(vec![two, two].iter().product::<$vec3>(), two * two); - assert_eq!(vec![two, two].into_iter().product::<$vec3>(), two * two); + assert_eq!([two, two].iter().product::<$vec3>(), two * two); + assert_eq!([two, two].into_iter().product::<$vec3>(), two * two); }); }; } @@ -530,6 +574,38 @@ macro_rules! impl_vec3_signed_tests { ); }); + glam_test!(test_is_negative_bitmask, { + assert_eq!($vec3::ZERO.is_negative_bitmask(), 0b000); + assert_eq!($vec3::ONE.is_negative_bitmask(), 0b000); + assert_eq!((-$vec3::ONE).is_negative_bitmask(), 0b111); + assert_eq!( + $vec3::new(-1 as $t, 2 as $t, 3 as $t).is_negative_bitmask(), + 0b001 + ); + assert_eq!( + $vec3::new(8 as $t, 3 as $t, 1 as $t).is_negative_bitmask(), + 0b000 + ); + assert_eq!( + $vec3::new(1 as $t, 5 as $t, -3 as $t).is_negative_bitmask(), + 0b100 + ); + assert_eq!( + $vec3::new(3 as $t, -4 as $t, 1 as $t).is_negative_bitmask(), + 0b010 + ); + assert_eq!( + $vec3::new(-2 as $t, 6 as $t, -5 as $t).is_negative_bitmask(), + 0b101 + ); + }); + + glam_test!(test_abs, { + assert_eq!($vec3::ZERO.abs(), $vec3::ZERO); + assert_eq!($vec3::ONE.abs(), $vec3::ONE); + assert_eq!((-$vec3::ONE).abs(), $vec3::ONE); + }); + glam_test!(test_dot_signed, { let x = $new(1 as $t, 0 as $t, 0 as $t); let y = $new(0 as $t, 1 as $t, 0 as $t); @@ -538,6 +614,52 @@ macro_rules! impl_vec3_signed_tests { assert_eq!(0 as $t, x.dot(y)); assert_eq!(-1 as $t, z.dot(-z)); }); + + glam_test!(test_length_squared_signed, { + let x = $new(1 as $t, 0 as $t, 0 as $t); + let y = $new(0 as $t, 1 as $t, 0 as $t); + let z = $new(0 as $t, 0 as $t, 1 as $t); + assert_eq!(9 as $t, (-3 as $t * y).length_squared()); + assert_eq!( + 2 as $t * 2 as $t + 3 as $t * 3 as $t + 4 as $t * 4 as $t, + $new(2 as $t, 3 as $t, 4 as $t).length_squared() + ); + assert_eq!(2 as $t, x.distance_squared(y)); + assert_eq!(13 as $t, (2 as $t * x).distance_squared(-3 as $t * z)); + }); + + glam_test!(test_div_euclid, { + let one = $vec3::ONE; + let two = one + one; + let three = two + one; + assert_eq!(three.div_euclid(two), one); + assert_eq!((-three).div_euclid(two), -two); + assert_eq!(three.div_euclid(-two), -one); + assert_eq!((-three).div_euclid(-two), two); + }); + + glam_test!(test_rem_euclid, { + let one = $vec3::ONE; + let two = one + one; + let three = two + one; + let four = three + one; + assert_eq!(four.rem_euclid(three), one); + assert_eq!((-four).rem_euclid(three), two); + assert_eq!(four.rem_euclid(-three), one); + assert_eq!((-four).rem_euclid(-three), two); + }); + }; +} + +macro_rules! impl_vec3_signed_integer_tests { + ($t:ident, $new:ident, $vec3:ident, $mask:ident) => { + impl_vec3_signed_tests!($t, $new, $vec3, $mask); + + glam_test!(test_signum, { + assert_eq!($vec3::ZERO.signum(), $vec3::ZERO); + assert_eq!($vec3::ONE.signum(), $vec3::ONE); + assert_eq!((-$vec3::ONE).signum(), -$vec3::ONE); + }); }; } @@ -592,14 +714,9 @@ macro_rules! impl_vec3_float_tests { let z = $new(0.0, 0.0, 1.0); assert_eq!(y, z.cross(x)); assert_eq!(z, x.cross(y)); - assert_eq!(4.0, (2.0 * x).length_squared()); - assert_eq!(9.0, (-3.0 * y).length_squared()); - assert_eq!(16.0, (4.0 * z).length_squared()); assert_eq!(2.0, (-2.0 * x).length()); assert_eq!(3.0, (3.0 * y).length()); assert_eq!(4.0, (-4.0 * z).length()); - assert_eq!(2.0, x.distance_squared(y)); - assert_eq!(13.0, (2.0 * x).distance_squared(-3.0 * z)); assert_eq!((2.0 as $t).sqrt(), x.distance(y)); assert_eq!(5.0, (3.0 * x).distance(-4.0 * y)); assert_eq!(13.0, (-5.0 * z).distance(12.0 * y)); @@ -609,14 +726,6 @@ macro_rules! impl_vec3_float_tests { $new(1.0, 2.0, 3.0).dot($new(4.0, 5.0, 6.0)) ); assert_eq!( - $new(14.0, 14.0, 14.0), - $new(0.0, 4.0, 6.0).dot_into_vec($new(3.0, 2.0, 1.0)) - ); - assert_eq!( - 2.0 * 2.0 + 3.0 * 3.0 + 4.0 * 4.0, - $new(2.0, 3.0, 4.0).length_squared() - ); - assert_eq!( (2.0 as $t * 2.0 + 3.0 * 3.0 + 4.0 * 4.0).sqrt(), $new(2.0, 3.0, 4.0).length() ); @@ -660,9 +769,9 @@ macro_rules! impl_vec3_float_tests { assert_eq!((-$vec3::ZERO).signum(), -$vec3::ONE); assert_eq!($vec3::ONE.signum(), $vec3::ONE); assert_eq!((-$vec3::ONE).signum(), -$vec3::ONE); - assert_eq!($vec3::splat(INFINITY).signum(), $vec3::ONE); - assert_eq!($vec3::splat(NEG_INFINITY).signum(), -$vec3::ONE); - assert!($vec3::splat(NAN).signum().is_nan_mask().all()); + assert_eq!($vec3::INFINITY.signum(), $vec3::ONE); + assert_eq!($vec3::NEG_INFINITY.signum(), -$vec3::ONE); + assert!($vec3::NAN.signum().is_nan_mask().all()); }); glam_test!(test_copysign, { @@ -682,42 +791,27 @@ macro_rules! impl_vec3_float_tests { assert_eq!((-$vec3::ONE).copysign(-$vec3::ONE), -$vec3::ONE); assert_eq!($vec3::ONE.copysign($vec3::ONE), $vec3::ONE); assert_eq!((-$vec3::ONE).copysign($vec3::ONE), $vec3::ONE); + assert_eq!($vec3::INFINITY.copysign($vec3::ONE), $vec3::INFINITY); + assert_eq!($vec3::INFINITY.copysign(-$vec3::ONE), $vec3::NEG_INFINITY); + assert_eq!($vec3::NEG_INFINITY.copysign($vec3::ONE), $vec3::INFINITY); assert_eq!( - $vec3::splat(INFINITY).copysign($vec3::ONE), - $vec3::splat(INFINITY) + $vec3::NEG_INFINITY.copysign(-$vec3::ONE), + $vec3::NEG_INFINITY ); - assert_eq!( - $vec3::splat(INFINITY).copysign(-$vec3::ONE), - $vec3::splat(NEG_INFINITY) - ); - assert_eq!( - $vec3::splat(NEG_INFINITY).copysign($vec3::ONE), - $vec3::splat(INFINITY) - ); - assert_eq!( - $vec3::splat(NEG_INFINITY).copysign(-$vec3::ONE), - $vec3::splat(NEG_INFINITY) - ); - assert!($vec3::splat(NAN).copysign($vec3::ONE).is_nan_mask().all()); - assert!($vec3::splat(NAN).copysign(-$vec3::ONE).is_nan_mask().all()); + assert!($vec3::NAN.copysign($vec3::ONE).is_nan_mask().all()); + assert!($vec3::NAN.copysign(-$vec3::ONE).is_nan_mask().all()); }); - glam_test!(test_is_negative_bitmask, { + glam_test!(test_float_is_negative_bitmask, { assert_eq!($vec3::ZERO.is_negative_bitmask(), 0b000); assert_eq!((-$vec3::ZERO).is_negative_bitmask(), 0b111); assert_eq!($vec3::ONE.is_negative_bitmask(), 0b000); assert_eq!((-$vec3::ONE).is_negative_bitmask(), 0b111); - assert_eq!($vec3::new(-0.1, 0.2, 0.3).is_negative_bitmask(), 0b001); - assert_eq!($vec3::new(0.8, 0.3, 0.1).is_negative_bitmask(), 0b000); - assert_eq!($vec3::new(0.1, 0.5, -0.3).is_negative_bitmask(), 0b100); - assert_eq!($vec3::new(0.3, -0.4, 0.1).is_negative_bitmask(), 0b010); - assert_eq!($vec3::new(-0.2, 0.6, -0.5).is_negative_bitmask(), 0b101); - }); - - glam_test!(test_abs, { - assert_eq!($vec3::ZERO.abs(), $vec3::ZERO); - assert_eq!($vec3::ONE.abs(), $vec3::ONE); - assert_eq!((-$vec3::ONE).abs(), $vec3::ONE); + assert_eq!($vec3::new(-1.0, 2.0, 3.0).is_negative_bitmask(), 0b001); + assert_eq!($vec3::new(8.0, 3.0, 1.0).is_negative_bitmask(), 0b000); + assert_eq!($vec3::new(1.0, 5.0, -3.0).is_negative_bitmask(), 0b100); + assert_eq!($vec3::new(3.0, -4.0, 1.0).is_negative_bitmask(), 0b010); + assert_eq!($vec3::new(-2.0, 6.0, -5.0).is_negative_bitmask(), 0b101); }); glam_test!(test_round, { @@ -779,6 +873,22 @@ macro_rules! impl_vec3_float_tests { ); }); + glam_test!(test_trunc, { + assert_eq!( + $vec3::new(1.35, 1.5, -1.5).trunc(), + $vec3::new(1.0, 1.0, -1.0) + ); + assert_eq!( + $vec3::new(INFINITY, NEG_INFINITY, 0.0).trunc(), + $vec3::new(INFINITY, NEG_INFINITY, 0.0) + ); + assert!($vec3::new(0.0, NAN, 0.0).trunc().y.is_nan()); + assert_eq!( + $vec3::new(-0.0, -2000000.123, 10000000.123).trunc(), + $vec3::new(-0.0, -2000000.0, 10000000.0) + ); + }); + glam_test!(test_lerp, { let v0 = $vec3::new(-1.0, -1.0, -1.0); let v1 = $vec3::new(1.0, 1.0, 1.0); @@ -793,7 +903,9 @@ macro_rules! impl_vec3_float_tests { assert!(!$vec3::new(INFINITY, 0.0, 0.0).is_finite()); assert!(!$vec3::new(0.0, NAN, 0.0).is_finite()); assert!(!$vec3::new(0.0, 0.0, NEG_INFINITY).is_finite()); - assert!(!$vec3::splat(NAN).is_finite()); + assert!(!$vec3::NAN.is_finite()); + assert!(!$vec3::INFINITY.is_finite()); + assert!(!$vec3::NEG_INFINITY.is_finite()); }); glam_test!(test_powf, { @@ -933,6 +1045,10 @@ macro_rules! impl_vec3_scalar_shift_op_tests { use glam::$vec3; impl_vec3_scalar_shift_op_test!($vec3, $t_min, $t_max, 0i32, 2); } + mod shift_by_i64 { + use glam::$vec3; + impl_vec3_scalar_shift_op_test!($vec3, $t_min, $t_max, 0i64, 2); + } mod shift_by_u8 { use glam::$vec3; impl_vec3_scalar_shift_op_test!($vec3, $t_min, $t_max, 0u8, 2); @@ -945,6 +1061,10 @@ macro_rules! impl_vec3_scalar_shift_op_tests { use glam::$vec3; impl_vec3_scalar_shift_op_test!($vec3, $t_min, $t_max, 0u32, 2); } + mod shift_by_u64 { + use glam::$vec3; + impl_vec3_scalar_shift_op_test!($vec3, $t_min, $t_max, 0u64, 2); + } }; } @@ -1060,33 +1180,75 @@ mod vec3 { }); glam_test!(test_as, { - use glam::{DVec3, IVec3, UVec3, Vec3A}; + use glam::{DVec3, I16Vec3, I64Vec3, IVec3, U16Vec3, U64Vec3, UVec3, Vec3A}; assert_eq!( DVec3::new(-1.0, -2.0, -3.0), Vec3::new(-1.0, -2.0, -3.0).as_dvec3() ); assert_eq!( + I16Vec3::new(-1, -2, -3), + Vec3::new(-1.0, -2.0, -3.0).as_i16vec3() + ); + assert_eq!(U16Vec3::new(1, 2, 3), Vec3::new(1.0, 2.0, 3.0).as_u16vec3()); + assert_eq!( IVec3::new(-1, -2, -3), Vec3::new(-1.0, -2.0, -3.0).as_ivec3() ); assert_eq!(UVec3::new(1, 2, 3), Vec3::new(1.0, 2.0, 3.0).as_uvec3()); + assert_eq!( + I64Vec3::new(-1, -2, -3), + Vec3::new(-1.0, -2.0, -3.0).as_i64vec3() + ); + assert_eq!(U64Vec3::new(1, 2, 3), Vec3::new(1.0, 2.0, 3.0).as_u64vec3()); assert_eq!( DVec3::new(-1.0, -2.0, -3.0), Vec3A::new(-1.0, -2.0, -3.0).as_dvec3() ); assert_eq!( + I16Vec3::new(-1, -2, -3), + Vec3A::new(-1.0, -2.0, -3.0).as_i16vec3() + ); + assert_eq!( + U16Vec3::new(1, 2, 3), + Vec3A::new(1.0, 2.0, 3.0).as_u16vec3() + ); + assert_eq!( IVec3::new(-1, -2, -3), Vec3A::new(-1.0, -2.0, -3.0).as_ivec3() ); assert_eq!(UVec3::new(1, 2, 3), Vec3A::new(1.0, 2.0, 3.0).as_uvec3()); + assert_eq!( + I64Vec3::new(-1, -2, -3), + Vec3A::new(-1.0, -2.0, -3.0).as_i64vec3() + ); + assert_eq!( + U64Vec3::new(1, 2, 3), + Vec3A::new(1.0, 2.0, 3.0).as_u64vec3() + ); assert_eq!( + I16Vec3::new(-1, -2, -3), + DVec3::new(-1.0, -2.0, -3.0).as_i16vec3() + ); + assert_eq!( + U16Vec3::new(1, 2, 3), + DVec3::new(1.0, 2.0, 3.0).as_u16vec3() + ); + assert_eq!( IVec3::new(-1, -2, -3), DVec3::new(-1.0, -2.0, -3.0).as_ivec3() ); assert_eq!(UVec3::new(1, 2, 3), DVec3::new(1.0, 2.0, 3.0).as_uvec3()); assert_eq!( + I64Vec3::new(-1, -2, -3), + DVec3::new(-1.0, -2.0, -3.0).as_i64vec3() + ); + assert_eq!( + U64Vec3::new(1, 2, 3), + DVec3::new(1.0, 2.0, 3.0).as_u64vec3() + ); + assert_eq!( Vec3::new(-1.0, -2.0, -3.0), DVec3::new(-1.0, -2.0, -3.0).as_vec3() ); @@ -1097,10 +1259,50 @@ mod vec3 { assert_eq!( DVec3::new(-1.0, -2.0, -3.0), + I16Vec3::new(-1, -2, -3).as_dvec3() + ); + assert_eq!(U16Vec3::new(1, 2, 3), I16Vec3::new(1, 2, 3).as_u16vec3()); + assert_eq!(IVec3::new(-1, -2, -3), I16Vec3::new(-1, -2, -3).as_ivec3()); + assert_eq!(UVec3::new(1, 2, 3), I16Vec3::new(1, 2, 3).as_uvec3()); + assert_eq!( + I64Vec3::new(-1, -2, -3), + I16Vec3::new(-1, -2, -3).as_i64vec3() + ); + assert_eq!(U64Vec3::new(1, 2, 3), I16Vec3::new(1, 2, 3).as_u64vec3()); + assert_eq!( + Vec3::new(-1.0, -2.0, -3.0), + I16Vec3::new(-1, -2, -3).as_vec3() + ); + assert_eq!( + Vec3A::new(-1.0, -2.0, -3.0), + I16Vec3::new(-1, -2, -3).as_vec3a() + ); + + assert_eq!(DVec3::new(1.0, 2.0, 3.0), U16Vec3::new(1, 2, 3).as_dvec3()); + assert_eq!(I16Vec3::new(1, 2, 3), U16Vec3::new(1, 2, 3).as_i16vec3()); + assert_eq!(IVec3::new(1, 2, 3), U16Vec3::new(1, 2, 3).as_ivec3()); + assert_eq!(UVec3::new(1, 2, 3), U16Vec3::new(1, 2, 3).as_uvec3()); + assert_eq!(I64Vec3::new(1, 2, 3), U16Vec3::new(1, 2, 3).as_i64vec3()); + assert_eq!(U64Vec3::new(1, 2, 3), U16Vec3::new(1, 2, 3).as_u64vec3()); + assert_eq!(Vec3::new(1.0, 2.0, 3.0), U16Vec3::new(1, 2, 3).as_vec3()); + assert_eq!(Vec3A::new(1.0, 2.0, 3.0), U16Vec3::new(1, 2, 3).as_vec3a()); + + assert_eq!( + DVec3::new(-1.0, -2.0, -3.0), IVec3::new(-1, -2, -3).as_dvec3() ); + assert_eq!( + I16Vec3::new(-1, -2, -3), + IVec3::new(-1, -2, -3).as_i16vec3() + ); + assert_eq!(U16Vec3::new(1, 2, 3), IVec3::new(1, 2, 3).as_u16vec3()); assert_eq!(UVec3::new(1, 2, 3), IVec3::new(1, 2, 3).as_uvec3()); assert_eq!( + I64Vec3::new(-1, -2, -3), + IVec3::new(-1, -2, -3).as_i64vec3() + ); + assert_eq!(U64Vec3::new(1, 2, 3), IVec3::new(1, 2, 3).as_u64vec3()); + assert_eq!( Vec3::new(-1.0, -2.0, -3.0), IVec3::new(-1, -2, -3).as_vec3() ); @@ -1110,9 +1312,43 @@ mod vec3 { ); assert_eq!(DVec3::new(1.0, 2.0, 3.0), UVec3::new(1, 2, 3).as_dvec3()); + assert_eq!(I16Vec3::new(1, 2, 3), UVec3::new(1, 2, 3).as_i16vec3()); + assert_eq!(U16Vec3::new(1, 2, 3), UVec3::new(1, 2, 3).as_u16vec3()); assert_eq!(IVec3::new(1, 2, 3), UVec3::new(1, 2, 3).as_ivec3()); + assert_eq!(I64Vec3::new(1, 2, 3), UVec3::new(1, 2, 3).as_i64vec3()); + assert_eq!(U64Vec3::new(1, 2, 3), UVec3::new(1, 2, 3).as_u64vec3()); assert_eq!(Vec3::new(1.0, 2.0, 3.0), UVec3::new(1, 2, 3).as_vec3()); assert_eq!(Vec3A::new(1.0, 2.0, 3.0), UVec3::new(1, 2, 3).as_vec3a()); + + assert_eq!( + DVec3::new(-1.0, -2.0, -3.0), + I64Vec3::new(-1, -2, -3).as_dvec3() + ); + assert_eq!(U16Vec3::new(1, 2, 3), I64Vec3::new(1, 2, 3).as_u16vec3()); + assert_eq!( + I16Vec3::new(-1, -2, -3), + I64Vec3::new(-1, -2, -3).as_i16vec3() + ); + assert_eq!(UVec3::new(1, 2, 3), I64Vec3::new(1, 2, 3).as_uvec3()); + assert_eq!(IVec3::new(-1, -2, -3), I64Vec3::new(-1, -2, -3).as_ivec3()); + assert_eq!(U64Vec3::new(1, 2, 3), I64Vec3::new(1, 2, 3).as_u64vec3()); + assert_eq!( + Vec3::new(-1.0, -2.0, -3.0), + I64Vec3::new(-1, -2, -3).as_vec3() + ); + assert_eq!( + Vec3A::new(-1.0, -2.0, -3.0), + I64Vec3::new(-1, -2, -3).as_vec3a() + ); + + assert_eq!(DVec3::new(1.0, 2.0, 3.0), U64Vec3::new(1, 2, 3).as_dvec3()); + assert_eq!(I16Vec3::new(1, 2, 3), U64Vec3::new(1, 2, 3).as_i16vec3()); + assert_eq!(U16Vec3::new(1, 2, 3), U64Vec3::new(1, 2, 3).as_u16vec3()); + assert_eq!(IVec3::new(1, 2, 3), U64Vec3::new(1, 2, 3).as_ivec3()); + assert_eq!(UVec3::new(1, 2, 3), U64Vec3::new(1, 2, 3).as_uvec3()); + assert_eq!(I64Vec3::new(1, 2, 3), U64Vec3::new(1, 2, 3).as_i64vec3()); + assert_eq!(Vec3::new(1.0, 2.0, 3.0), U64Vec3::new(1, 2, 3).as_vec3()); + assert_eq!(Vec3A::new(1.0, 2.0, 3.0), U64Vec3::new(1, 2, 3).as_vec3a()); }); impl_vec3_float_tests!(f32, vec3, Vec3, BVec3); @@ -1189,7 +1425,7 @@ mod vec3a { } mod dvec3 { - use glam::{dvec3, BVec3, DVec3}; + use glam::{dvec3, BVec3, DVec3, IVec3, UVec3, Vec3}; glam_test!(test_align, { use std::mem; @@ -1199,11 +1435,262 @@ mod dvec3 { assert_eq!(1, mem::align_of::<BVec3>()); }); + glam_test!(test_try_from, { + assert_eq!( + DVec3::new(1.0, 2.0, 3.0), + DVec3::from(Vec3::new(1.0, 2.0, 3.0)) + ); + assert_eq!(DVec3::new(1.0, 2.0, 3.0), DVec3::from(IVec3::new(1, 2, 3))); + assert_eq!(DVec3::new(1.0, 2.0, 3.0), DVec3::from(UVec3::new(1, 2, 3))); + }); + impl_vec3_float_tests!(f64, dvec3, DVec3, BVec3); } +mod i16vec3 { + use glam::{i16vec3, BVec3, I16Vec3, I64Vec3, IVec3, U16Vec3, U64Vec3, UVec3}; + + glam_test!(test_align, { + use std::mem; + assert_eq!(6, mem::size_of::<I16Vec3>()); + assert_eq!(2, mem::align_of::<I16Vec3>()); + }); + + glam_test!(test_try_from, { + assert_eq!( + I16Vec3::new(1, 2, 3), + I16Vec3::try_from(U16Vec3::new(1, 2, 3)).unwrap() + ); + assert!(I16Vec3::try_from(U16Vec3::new(u16::MAX, 2, 3)).is_err()); + assert!(I16Vec3::try_from(U16Vec3::new(1, u16::MAX, 3)).is_err()); + assert!(I16Vec3::try_from(U16Vec3::new(1, 2, u16::MAX)).is_err()); + + assert_eq!( + I16Vec3::new(1, 2, 3), + I16Vec3::try_from(IVec3::new(1, 2, 3)).unwrap() + ); + assert!(I16Vec3::try_from(IVec3::new(i32::MAX, 2, 3)).is_err()); + assert!(I16Vec3::try_from(IVec3::new(1, i32::MAX, 3)).is_err()); + assert!(I16Vec3::try_from(IVec3::new(1, 2, i32::MAX)).is_err()); + + assert_eq!( + I16Vec3::new(1, 2, 3), + I16Vec3::try_from(UVec3::new(1, 2, 3)).unwrap() + ); + assert!(I16Vec3::try_from(UVec3::new(u32::MAX, 2, 3)).is_err()); + assert!(I16Vec3::try_from(UVec3::new(1, u32::MAX, 3)).is_err()); + assert!(I16Vec3::try_from(UVec3::new(1, 2, u32::MAX)).is_err()); + + assert_eq!( + I16Vec3::new(1, 2, 3), + I16Vec3::try_from(I64Vec3::new(1, 2, 3)).unwrap() + ); + assert!(I16Vec3::try_from(I64Vec3::new(i64::MAX, 2, 3)).is_err()); + assert!(I16Vec3::try_from(I64Vec3::new(1, i64::MAX, 3)).is_err()); + assert!(I16Vec3::try_from(I64Vec3::new(1, 2, i64::MAX)).is_err()); + + assert_eq!( + I16Vec3::new(1, 2, 3), + I16Vec3::try_from(U64Vec3::new(1, 2, 3)).unwrap() + ); + assert!(I16Vec3::try_from(U64Vec3::new(u64::MAX, 2, 3)).is_err()); + assert!(I16Vec3::try_from(U64Vec3::new(1, u64::MAX, 3)).is_err()); + assert!(I16Vec3::try_from(U64Vec3::new(1, 2, u64::MAX)).is_err()); + }); + + glam_test!(test_wrapping_add, { + assert_eq!( + I16Vec3::new(i16::MAX, 5, i16::MIN).wrapping_add(I16Vec3::new(1, 3, i16::MAX)), + I16Vec3::new(i16::MIN, 8, -1), + ); + }); + + glam_test!(test_wrapping_sub, { + assert_eq!( + I16Vec3::new(i16::MAX, 5, i16::MIN).wrapping_sub(I16Vec3::new(1, 3, i16::MAX)), + I16Vec3::new(32766, 2, 1), + ); + }); + + glam_test!(test_wrapping_mul, { + assert_eq!( + I16Vec3::new(i16::MAX, 5, i16::MIN).wrapping_mul(I16Vec3::new(3, 3, 5)), + I16Vec3::new(32765, 15, -32768) + ); + }); + + glam_test!(test_wrapping_div, { + assert_eq!( + I16Vec3::new(i16::MAX, 5, i16::MIN).wrapping_div(I16Vec3::new(3, 3, 5)), + I16Vec3::new(10922, 1, -6553) + ); + }); + + glam_test!(test_saturating_add, { + assert_eq!( + I16Vec3::new(i16::MAX, i16::MIN, 0).saturating_add(I16Vec3::new(1, -1, 2)), + I16Vec3::new(i16::MAX, i16::MIN, 2) + ); + }); + + glam_test!(test_saturating_sub, { + assert_eq!( + I16Vec3::new(i16::MIN, i16::MAX, 0).saturating_sub(I16Vec3::new(1, -1, 2)), + I16Vec3::new(i16::MIN, i16::MAX, -2) + ); + }); + + glam_test!(test_saturating_mul, { + assert_eq!( + I16Vec3::new(i16::MAX, i16::MIN, 0).saturating_mul(I16Vec3::new(2, 2, 0)), + I16Vec3::new(i16::MAX, i16::MIN, 0) + ); + }); + + glam_test!(test_saturating_div, { + assert_eq!( + I16Vec3::new(i16::MAX, i16::MIN, 0).saturating_div(I16Vec3::new(2, 2, 3)), + I16Vec3::new(16383, -16384, 0) + ); + }); + + impl_vec3_signed_integer_tests!(i16, i16vec3, I16Vec3, BVec3); + impl_vec3_eq_hash_tests!(i16, i16vec3); + + impl_vec3_scalar_shift_op_tests!(I16Vec3, -2, 2); + impl_vec3_shift_op_tests!(I16Vec3); + + impl_vec3_scalar_bit_op_tests!(I16Vec3, -2, 2); + impl_vec3_bit_op_tests!(I16Vec3, -2, 2); +} + +mod u16vec3 { + use glam::{u16vec3, BVec3, I16Vec3, I64Vec3, IVec3, U16Vec3, U64Vec3, UVec3}; + + glam_test!(test_align, { + use std::mem; + assert_eq!(6, mem::size_of::<U16Vec3>()); + assert_eq!(2, mem::align_of::<U16Vec3>()); + }); + + glam_test!(test_try_from, { + assert_eq!( + U16Vec3::new(1, 2, 3), + U16Vec3::try_from(I16Vec3::new(1, 2, 3)).unwrap() + ); + assert!(U16Vec3::try_from(I16Vec3::new(-1, 2, 3)).is_err()); + assert!(U16Vec3::try_from(I16Vec3::new(1, -2, 3)).is_err()); + assert!(U16Vec3::try_from(I16Vec3::new(1, 2, -3)).is_err()); + + assert_eq!( + U16Vec3::new(1, 2, 3), + U16Vec3::try_from(IVec3::new(1, 2, 3)).unwrap() + ); + assert!(U16Vec3::try_from(IVec3::new(-1, 2, 3)).is_err()); + assert!(U16Vec3::try_from(IVec3::new(1, -2, 3)).is_err()); + assert!(U16Vec3::try_from(IVec3::new(1, 2, -3)).is_err()); + + assert!(U16Vec3::try_from(IVec3::new(i32::MAX, 2, 3)).is_err()); + assert!(U16Vec3::try_from(IVec3::new(1, i32::MAX, 3)).is_err()); + assert!(U16Vec3::try_from(IVec3::new(1, 2, i32::MAX)).is_err()); + + assert_eq!( + U16Vec3::new(1, 2, 3), + U16Vec3::try_from(UVec3::new(1, 2, 3)).unwrap() + ); + assert!(U16Vec3::try_from(UVec3::new(u32::MAX, 2, 3)).is_err()); + assert!(U16Vec3::try_from(UVec3::new(1, u32::MAX, 3)).is_err()); + assert!(U16Vec3::try_from(UVec3::new(1, 2, u32::MAX)).is_err()); + + assert_eq!( + U16Vec3::new(1, 2, 3), + U16Vec3::try_from(I64Vec3::new(1, 2, 3)).unwrap() + ); + assert!(U16Vec3::try_from(I64Vec3::new(-1, 2, 3)).is_err()); + assert!(U16Vec3::try_from(I64Vec3::new(1, -2, 3)).is_err()); + assert!(U16Vec3::try_from(I64Vec3::new(1, 2, -3)).is_err()); + + assert!(U16Vec3::try_from(I64Vec3::new(i64::MAX, 2, 3)).is_err()); + assert!(U16Vec3::try_from(I64Vec3::new(1, i64::MAX, 3)).is_err()); + assert!(U16Vec3::try_from(I64Vec3::new(1, 2, i64::MAX)).is_err()); + + assert_eq!( + U16Vec3::new(1, 2, 3), + U16Vec3::try_from(U64Vec3::new(1, 2, 3)).unwrap() + ); + assert!(U16Vec3::try_from(U64Vec3::new(u64::MAX, 2, 3)).is_err()); + assert!(U16Vec3::try_from(U64Vec3::new(1, u64::MAX, 3)).is_err()); + assert!(U16Vec3::try_from(U64Vec3::new(1, 2, u64::MAX)).is_err()); + }); + + glam_test!(test_wrapping_add, { + assert_eq!( + U16Vec3::new(u16::MAX, 5, u16::MAX).wrapping_add(U16Vec3::new(1, 3, u16::MAX)), + U16Vec3::new(0, 8, 65534), + ); + }); + + glam_test!(test_wrapping_sub, { + assert_eq!( + U16Vec3::new(u16::MAX, 5, u16::MAX - 1).wrapping_sub(U16Vec3::new(1, 3, u16::MAX)), + U16Vec3::new(65534, 2, 65535) + ); + }); + + glam_test!(test_wrapping_mul, { + assert_eq!( + U16Vec3::new(u16::MAX, 5, u16::MAX).wrapping_mul(U16Vec3::new(3, 3, 5)), + U16Vec3::new(65533, 15, 65531) + ); + }); + + glam_test!(test_wrapping_div, { + assert_eq!( + U16Vec3::new(u16::MAX, 5, u16::MAX).wrapping_div(U16Vec3::new(3, 3, 5)), + U16Vec3::new(21845, 1, 13107) + ); + }); + + glam_test!(test_saturating_add, { + assert_eq!( + U16Vec3::new(u16::MAX, u16::MAX, 0).saturating_add(U16Vec3::new(1, u16::MAX, 2)), + U16Vec3::new(u16::MAX, u16::MAX, 2) + ); + }); + + glam_test!(test_saturating_sub, { + assert_eq!( + U16Vec3::new(0, u16::MAX, 0).saturating_sub(U16Vec3::new(1, 1, 2)), + U16Vec3::new(0, 65534, 0) + ); + }); + + glam_test!(test_saturating_mul, { + assert_eq!( + U16Vec3::new(u16::MAX, u16::MAX, 0).saturating_mul(U16Vec3::new(2, u16::MAX, 0)), + U16Vec3::new(u16::MAX, u16::MAX, 0) + ); + }); + + glam_test!(test_saturating_div, { + assert_eq!( + U16Vec3::new(u16::MAX, u16::MAX, 0).saturating_div(U16Vec3::new(2, u16::MAX, 3)), + U16Vec3::new(32767, 1, 0) + ); + }); + + impl_vec3_tests!(u16, u16vec3, U16Vec3, BVec3); + impl_vec3_eq_hash_tests!(u16, u16vec3); + + impl_vec3_scalar_shift_op_tests!(U16Vec3, 0, 2); + impl_vec3_shift_op_tests!(U16Vec3); + + impl_vec3_scalar_bit_op_tests!(U16Vec3, 0, 2); + impl_vec3_bit_op_tests!(U16Vec3, 0, 2); +} + mod ivec3 { - use glam::{ivec3, BVec3, IVec3, UVec3}; + use glam::{ivec3, BVec3, I16Vec3, I64Vec3, IVec3, U16Vec3, U64Vec3, UVec3}; glam_test!(test_align, { use std::mem; @@ -1213,7 +1700,92 @@ mod ivec3 { assert_eq!(1, mem::align_of::<BVec3>()); }); - impl_vec3_signed_tests!(i32, ivec3, IVec3, BVec3); + glam_test!(test_try_from, { + assert_eq!(IVec3::new(1, 2, 3), IVec3::from(U16Vec3::new(1, 2, 3))); + assert_eq!(IVec3::new(1, 2, 3), IVec3::from(I16Vec3::new(1, 2, 3))); + + assert_eq!( + IVec3::new(1, 2, 3), + IVec3::try_from(UVec3::new(1, 2, 3)).unwrap() + ); + assert!(IVec3::try_from(UVec3::new(u32::MAX, 2, 3)).is_err()); + assert!(IVec3::try_from(UVec3::new(1, u32::MAX, 3)).is_err()); + assert!(IVec3::try_from(UVec3::new(1, 2, u32::MAX)).is_err()); + + assert_eq!( + IVec3::new(1, 2, 3), + IVec3::try_from(I64Vec3::new(1, 2, 3)).unwrap() + ); + assert!(IVec3::try_from(I64Vec3::new(i64::MAX, 2, 3)).is_err()); + assert!(IVec3::try_from(I64Vec3::new(1, i64::MAX, 3)).is_err()); + assert!(IVec3::try_from(I64Vec3::new(1, 2, i64::MAX)).is_err()); + + assert_eq!( + IVec3::new(1, 2, 3), + IVec3::try_from(U64Vec3::new(1, 2, 3)).unwrap() + ); + assert!(IVec3::try_from(U64Vec3::new(u64::MAX, 2, 3)).is_err()); + assert!(IVec3::try_from(U64Vec3::new(1, u64::MAX, 3)).is_err()); + assert!(IVec3::try_from(U64Vec3::new(1, 2, u64::MAX)).is_err()); + }); + + glam_test!(test_wrapping_add, { + assert_eq!( + IVec3::new(i32::MAX, 5, i32::MIN).wrapping_add(IVec3::new(1, 3, i32::MAX)), + IVec3::new(i32::MIN, 8, -1), + ); + }); + + glam_test!(test_wrapping_sub, { + assert_eq!( + IVec3::new(i32::MAX, 5, i32::MIN).wrapping_sub(IVec3::new(1, 3, i32::MAX)), + IVec3::new(2147483646, 2, 1), + ); + }); + + glam_test!(test_wrapping_mul, { + assert_eq!( + IVec3::new(i32::MAX, 5, i32::MIN).wrapping_mul(IVec3::new(3, 3, 5)), + IVec3::new(2147483645, 15, -2147483648) + ); + }); + + glam_test!(test_wrapping_div, { + assert_eq!( + IVec3::new(i32::MAX, 5, i32::MIN).wrapping_div(IVec3::new(3, 3, 5)), + IVec3::new(715827882, 1, -429496729) + ); + }); + + glam_test!(test_saturating_add, { + assert_eq!( + IVec3::new(i32::MAX, i32::MIN, 0).saturating_add(IVec3::new(1, -1, 2)), + IVec3::new(i32::MAX, i32::MIN, 2) + ); + }); + + glam_test!(test_saturating_sub, { + assert_eq!( + IVec3::new(i32::MIN, i32::MAX, 0).saturating_sub(IVec3::new(1, -1, 2)), + IVec3::new(i32::MIN, i32::MAX, -2) + ); + }); + + glam_test!(test_saturating_mul, { + assert_eq!( + IVec3::new(i32::MAX, i32::MIN, 0).saturating_mul(IVec3::new(2, 2, 0)), + IVec3::new(i32::MAX, i32::MIN, 0) + ); + }); + + glam_test!(test_saturating_div, { + assert_eq!( + IVec3::new(i32::MAX, i32::MIN, 0).saturating_div(IVec3::new(2, 2, 3)), + IVec3::new(1073741823, -1073741824, 0) + ); + }); + + impl_vec3_signed_integer_tests!(i32, ivec3, IVec3, BVec3); impl_vec3_eq_hash_tests!(i32, ivec3); impl_vec3_scalar_shift_op_tests!(IVec3, -2, 2); @@ -1224,7 +1796,7 @@ mod ivec3 { } mod uvec3 { - use glam::{uvec3, BVec3, IVec3, UVec3}; + use glam::{uvec3, BVec3, I16Vec3, I64Vec3, IVec3, U16Vec3, U64Vec3, UVec3}; glam_test!(test_align, { use std::mem; @@ -1234,6 +1806,102 @@ mod uvec3 { assert_eq!(1, mem::align_of::<BVec3>()); }); + glam_test!(test_try_from, { + assert_eq!( + UVec3::new(1, 2, 3), + UVec3::try_from(I16Vec3::new(1, 2, 3)).unwrap() + ); + assert!(UVec3::try_from(I16Vec3::new(-1, 2, 3)).is_err()); + assert!(UVec3::try_from(I16Vec3::new(1, -2, 3)).is_err()); + assert!(UVec3::try_from(I16Vec3::new(1, 2, -3)).is_err()); + + assert_eq!(UVec3::new(1, 2, 3), UVec3::from(U16Vec3::new(1, 2, 3))); + + assert_eq!( + UVec3::new(1, 2, 3), + UVec3::try_from(IVec3::new(1, 2, 3)).unwrap() + ); + assert!(UVec3::try_from(IVec3::new(-1, 2, 3)).is_err()); + assert!(UVec3::try_from(IVec3::new(1, -2, 3)).is_err()); + assert!(UVec3::try_from(IVec3::new(1, 2, -3)).is_err()); + + assert_eq!( + UVec3::new(1, 2, 3), + UVec3::try_from(I64Vec3::new(1, 2, 3)).unwrap() + ); + assert!(UVec3::try_from(I64Vec3::new(-1, 2, 3)).is_err()); + assert!(UVec3::try_from(I64Vec3::new(1, -2, 3)).is_err()); + assert!(UVec3::try_from(I64Vec3::new(1, 2, -3)).is_err()); + + assert!(UVec3::try_from(I64Vec3::new(i64::MAX, 2, 3)).is_err()); + assert!(UVec3::try_from(I64Vec3::new(1, i64::MAX, 3)).is_err()); + assert!(UVec3::try_from(I64Vec3::new(1, 2, i64::MAX)).is_err()); + + assert_eq!( + UVec3::new(1, 2, 3), + UVec3::try_from(U64Vec3::new(1, 2, 3)).unwrap() + ); + assert!(UVec3::try_from(U64Vec3::new(u64::MAX, 2, 3)).is_err()); + assert!(UVec3::try_from(U64Vec3::new(1, u64::MAX, 3)).is_err()); + assert!(UVec3::try_from(U64Vec3::new(1, 2, u64::MAX)).is_err()); + }); + + glam_test!(test_wrapping_add, { + assert_eq!( + UVec3::new(u32::MAX, 5, u32::MAX).wrapping_add(UVec3::new(1, 3, u32::MAX)), + UVec3::new(0, 8, 4294967294), + ); + }); + + glam_test!(test_wrapping_sub, { + assert_eq!( + UVec3::new(u32::MAX, 5, u32::MAX - 1).wrapping_sub(UVec3::new(1, 3, u32::MAX)), + UVec3::new(4294967294, 2, 4294967295) + ); + }); + + glam_test!(test_wrapping_mul, { + assert_eq!( + UVec3::new(u32::MAX, 5, u32::MAX).wrapping_mul(UVec3::new(3, 3, 5)), + UVec3::new(4294967293, 15, 4294967291) + ); + }); + + glam_test!(test_wrapping_div, { + assert_eq!( + UVec3::new(u32::MAX, 5, u32::MAX).wrapping_div(UVec3::new(3, 3, 5)), + UVec3::new(1431655765, 1, 858993459) + ); + }); + + glam_test!(test_saturating_add, { + assert_eq!( + UVec3::new(u32::MAX, u32::MAX, 0).saturating_add(UVec3::new(1, u32::MAX, 2)), + UVec3::new(u32::MAX, u32::MAX, 2) + ); + }); + + glam_test!(test_saturating_sub, { + assert_eq!( + UVec3::new(0, u32::MAX, 0).saturating_sub(UVec3::new(1, 1, 2)), + UVec3::new(0, 4294967294, 0) + ); + }); + + glam_test!(test_saturating_mul, { + assert_eq!( + UVec3::new(u32::MAX, u32::MAX, 0).saturating_mul(UVec3::new(2, u32::MAX, 0)), + UVec3::new(u32::MAX, u32::MAX, 0) + ); + }); + + glam_test!(test_saturating_div, { + assert_eq!( + UVec3::new(u32::MAX, u32::MAX, 0).saturating_div(UVec3::new(2, u32::MAX, 3)), + UVec3::new(2147483647, 1, 0) + ); + }); + impl_vec3_tests!(u32, uvec3, UVec3, BVec3); impl_vec3_eq_hash_tests!(u32, uvec3); @@ -1243,3 +1911,90 @@ mod uvec3 { impl_vec3_scalar_bit_op_tests!(UVec3, 0, 2); impl_vec3_bit_op_tests!(UVec3, 0, 2); } + +mod i64vec3 { + use glam::{i64vec3, BVec3, I16Vec3, I64Vec3, IVec3, U16Vec3, U64Vec3, UVec3}; + + glam_test!(test_align, { + use std::mem; + assert_eq!(24, mem::size_of::<I64Vec3>()); + assert_eq!(8, mem::align_of::<I64Vec3>()); + assert_eq!(3, mem::size_of::<BVec3>()); + assert_eq!(1, mem::align_of::<BVec3>()); + }); + + glam_test!(test_try_from, { + assert_eq!(I64Vec3::new(1, 2, 3), I64Vec3::from(I16Vec3::new(1, 2, 3))); + assert_eq!(I64Vec3::new(1, 2, 3), I64Vec3::from(U16Vec3::new(1, 2, 3))); + assert_eq!(I64Vec3::new(1, 2, 3), I64Vec3::from(IVec3::new(1, 2, 3))); + assert_eq!(I64Vec3::new(1, 2, 3), I64Vec3::from(UVec3::new(1, 2, 3))); + + assert_eq!( + I64Vec3::new(1, 2, 3), + I64Vec3::try_from(U64Vec3::new(1, 2, 3)).unwrap() + ); + assert!(I64Vec3::try_from(U64Vec3::new(u64::MAX, 2, 3)).is_err()); + assert!(I64Vec3::try_from(U64Vec3::new(1, u64::MAX, 3)).is_err()); + assert!(I64Vec3::try_from(U64Vec3::new(1, 2, u64::MAX)).is_err()); + }); + + impl_vec3_signed_integer_tests!(i64, i64vec3, I64Vec3, BVec3); + impl_vec3_eq_hash_tests!(i64, i64vec3); + + impl_vec3_scalar_shift_op_tests!(I64Vec3, -2, 2); + impl_vec3_shift_op_tests!(I64Vec3); + + impl_vec3_scalar_bit_op_tests!(I64Vec3, -2, 2); + impl_vec3_bit_op_tests!(I64Vec3, -2, 2); +} + +mod u64vec3 { + use glam::{u64vec3, BVec3, I16Vec3, I64Vec3, IVec3, U16Vec3, U64Vec3, UVec3}; + + glam_test!(test_align, { + use std::mem; + assert_eq!(24, mem::size_of::<U64Vec3>()); + assert_eq!(8, mem::align_of::<U64Vec3>()); + assert_eq!(3, mem::size_of::<BVec3>()); + assert_eq!(1, mem::align_of::<BVec3>()); + }); + + glam_test!(test_try_from, { + assert_eq!( + U64Vec3::new(1, 2, 3), + U64Vec3::try_from(I16Vec3::new(1, 2, 3)).unwrap() + ); + assert!(U64Vec3::try_from(I16Vec3::new(-1, 2, 3)).is_err()); + assert!(U64Vec3::try_from(I16Vec3::new(1, -2, 3)).is_err()); + assert!(U64Vec3::try_from(I16Vec3::new(1, 2, -3)).is_err()); + + assert_eq!(U64Vec3::new(1, 2, 3), U64Vec3::from(U16Vec3::new(1, 2, 3))); + + assert_eq!( + U64Vec3::new(1, 2, 3), + U64Vec3::try_from(IVec3::new(1, 2, 3)).unwrap() + ); + assert!(U64Vec3::try_from(IVec3::new(-1, 2, 3)).is_err()); + assert!(U64Vec3::try_from(IVec3::new(1, -2, 3)).is_err()); + assert!(U64Vec3::try_from(IVec3::new(1, 2, -3)).is_err()); + + assert_eq!(U64Vec3::new(1, 2, 3), U64Vec3::from(UVec3::new(1, 2, 3))); + + assert_eq!( + U64Vec3::new(1, 2, 3), + U64Vec3::try_from(I64Vec3::new(1, 2, 3)).unwrap() + ); + assert!(U64Vec3::try_from(I64Vec3::new(-1, 2, 3)).is_err()); + assert!(U64Vec3::try_from(I64Vec3::new(1, -2, 3)).is_err()); + assert!(U64Vec3::try_from(I64Vec3::new(1, 2, -3)).is_err()); + }); + + impl_vec3_tests!(u64, u64vec3, U64Vec3, BVec3); + impl_vec3_eq_hash_tests!(u64, u64vec3); + + impl_vec3_scalar_shift_op_tests!(U64Vec3, 0, 2); + impl_vec3_shift_op_tests!(U64Vec3); + + impl_vec3_scalar_bit_op_tests!(U64Vec3, 0, 2); + impl_vec3_bit_op_tests!(U64Vec3, 0, 2); +} |