1 #![allow(clippy::excessive_precision)] 2 3 #[macro_use] 4 mod support; 5 6 macro_rules! impl_vec3_tests { 7 ($t:ident, $new:ident, $vec3:ident, $mask:ident, $masknew:ident) => { 8 glam_test!(test_const, { 9 const V0: $vec3 = $vec3::splat(1 as $t); 10 const V1: $vec3 = $vec3::new(1 as $t, 2 as $t, 3 as $t); 11 const V2: $vec3 = $vec3::from_array([1 as $t, 2 as $t, 3 as $t]); 12 assert_eq!([1 as $t, 1 as $t, 1 as $t], *V0.as_ref()); 13 assert_eq!([1 as $t, 2 as $t, 3 as $t], *V1.as_ref()); 14 assert_eq!([1 as $t, 2 as $t, 3 as $t], *V2.as_ref()); 15 }); 16 17 glam_test!(test_vec3_consts, { 18 assert_eq!($vec3::ZERO, $new(0 as $t, 0 as $t, 0 as $t)); 19 assert_eq!($vec3::ONE, $new(1 as $t, 1 as $t, 1 as $t)); 20 assert_eq!($vec3::X, $new(1 as $t, 0 as $t, 0 as $t)); 21 assert_eq!($vec3::Y, $new(0 as $t, 1 as $t, 0 as $t)); 22 assert_eq!($vec3::Z, $new(0 as $t, 0 as $t, 1 as $t)); 23 assert_eq!($vec3::MIN, $new($t::MIN, $t::MIN, $t::MIN)); 24 assert_eq!($vec3::MAX, $new($t::MAX, $t::MAX, $t::MAX)); 25 }); 26 27 glam_test!(test_new, { 28 let v = $new(1 as $t, 2 as $t, 3 as $t); 29 30 assert_eq!(v.x, 1 as $t); 31 assert_eq!(v.y, 2 as $t); 32 assert_eq!(v.z, 3 as $t); 33 34 let t = (1 as $t, 2 as $t, 3 as $t); 35 let v = $vec3::from(t); 36 assert_eq!(t, v.into()); 37 38 let a = [1 as $t, 2 as $t, 3 as $t]; 39 let v = $vec3::from(a); 40 let a1: [$t; 3] = v.into(); 41 assert_eq!(a, a1); 42 43 assert_eq!(a, v.to_array()); 44 assert_eq!(a, *v.as_ref()); 45 46 let mut v2 = $vec3::default(); 47 *v2.as_mut() = a; 48 assert_eq!(a, v2.to_array()); 49 50 let v = $vec3::new(t.0, t.1, t.2); 51 assert_eq!(t, v.into()); 52 53 assert_eq!( 54 $vec3::new(1 as $t, 0 as $t, 0 as $t), 55 glam::BVec3::new(true, false, false).into() 56 ); 57 assert_eq!( 58 $vec3::new(0 as $t, 1 as $t, 0 as $t), 59 glam::BVec3::new(false, true, false).into() 60 ); 61 assert_eq!( 62 $vec3::new(0 as $t, 0 as $t, 1 as $t), 63 glam::BVec3::new(false, false, true).into() 64 ); 65 assert_eq!( 66 $vec3::new(1 as $t, 0 as $t, 0 as $t), 67 glam::BVec3A::new(true, false, false).into() 68 ); 69 assert_eq!( 70 $vec3::new(0 as $t, 1 as $t, 0 as $t), 71 glam::BVec3A::new(false, true, false).into() 72 ); 73 assert_eq!( 74 $vec3::new(0 as $t, 0 as $t, 1 as $t), 75 glam::BVec3A::new(false, false, true).into() 76 ); 77 78 assert_eq!($vec3::new(1 as $t, 0 as $t, 0 as $t), $vec3::X); 79 assert_eq!($vec3::new(0 as $t, 1 as $t, 0 as $t), $vec3::Y); 80 assert_eq!($vec3::new(0 as $t, 0 as $t, 1 as $t), $vec3::Z); 81 }); 82 83 glam_test!(test_fmt, { 84 let a = $vec3::new(1 as $t, 2 as $t, 3 as $t); 85 assert_eq!( 86 format!("{:?}", a), 87 format!("{}({:?}, {:?}, {:?})", stringify!($vec3), a.x, a.y, a.z) 88 ); 89 assert_eq!( 90 format!("{:#?}", a), 91 format!( 92 "{}(\n {:#?},\n {:#?},\n {:#?},\n)", 93 stringify!($vec3), 94 a.x, 95 a.y, 96 a.z 97 ) 98 ); 99 assert_eq!(format!("{}", a), "[1, 2, 3]"); 100 }); 101 102 glam_test!(test_zero, { 103 let v = $vec3::ZERO; 104 assert_eq!((0 as $t, 0 as $t, 0 as $t), v.into()); 105 assert_eq!(v, $vec3::default()); 106 }); 107 108 glam_test!(test_splat, { 109 let v = $vec3::splat(1 as $t); 110 assert_eq!($vec3::ONE, v); 111 }); 112 113 glam_test!(test_map, { 114 let v = $vec3::new(1 as $t, 2 as $t, 3 as $t); 115 assert_eq!(v.map(|n| n + 3 as $t), v + $vec3::splat(3 as $t)); 116 assert_eq!(v.map(|_| 0 as $t), $vec3::ZERO); 117 }); 118 119 glam_test!(test_with, { 120 assert_eq!($vec3::X, $vec3::ZERO.with_x(1 as $t)); 121 assert_eq!($vec3::Y, $vec3::ZERO.with_y(1 as $t)); 122 assert_eq!($vec3::Z, $vec3::ZERO.with_z(1 as $t)); 123 }); 124 125 glam_test!(test_accessors, { 126 let mut a = $vec3::ZERO; 127 a.x = 1 as $t; 128 a.y = 2 as $t; 129 a.z = 3 as $t; 130 assert_eq!(1 as $t, a.x); 131 assert_eq!(2 as $t, a.y); 132 assert_eq!(3 as $t, a.z); 133 assert_eq!((1 as $t, 2 as $t, 3 as $t), a.into()); 134 135 let mut a = $vec3::ZERO; 136 a[0] = 1 as $t; 137 a[1] = 2 as $t; 138 a[2] = 3 as $t; 139 assert_eq!(1 as $t, a[0]); 140 assert_eq!(2 as $t, a[1]); 141 assert_eq!(3 as $t, a[2]); 142 assert_eq!((1 as $t, 2 as $t, 3 as $t), a.into()); 143 }); 144 145 glam_test!(test_dot_unsigned, { 146 let x = $new(1 as $t, 0 as $t, 0 as $t); 147 let y = $new(0 as $t, 1 as $t, 0 as $t); 148 assert_eq!(1 as $t, x.dot(x)); 149 assert_eq!(0 as $t, x.dot(y)); 150 151 assert_eq!( 152 $new(14 as $t, 14 as $t, 14 as $t), 153 $new(0 as $t, 4 as $t, 6 as $t).dot_into_vec($new(3 as $t, 2 as $t, 1 as $t)) 154 ); 155 }); 156 157 glam_test!(test_length_squared_unsigned, { 158 let x = $new(1 as $t, 0 as $t, 0 as $t); 159 let z = $new(0 as $t, 0 as $t, 1 as $t); 160 assert_eq!(4 as $t, (2 as $t * x).length_squared()); 161 assert_eq!(16 as $t, (4 as $t * z).length_squared()); 162 }); 163 164 glam_test!(test_cross, { 165 let x = $new(1 as $t, 0 as $t, 0 as $t); 166 let y = $new(0 as $t, 1 as $t, 0 as $t); 167 let z = $new(0 as $t, 0 as $t, 1 as $t); 168 assert_eq!(y, z.cross(x)); 169 assert_eq!(z, x.cross(y)); 170 }); 171 172 glam_test!(test_ops, { 173 let a = $new(2 as $t, 4 as $t, 8 as $t); 174 assert_eq!($new(4 as $t, 8 as $t, 16 as $t), a + a); 175 assert_eq!($new(2 as $t, 4 as $t, 8 as $t), 0 as $t + a); 176 assert_eq!($new(0 as $t, 0 as $t, 0 as $t), a - a); 177 assert_eq!($new(14 as $t, 12 as $t, 8 as $t), 16 as $t - a); 178 assert_eq!($new(4 as $t, 16 as $t, 64 as $t), a * a); 179 assert_eq!($new(4 as $t, 8 as $t, 16 as $t), a * 2 as $t); 180 assert_eq!($new(4 as $t, 8 as $t, 16 as $t), 2 as $t * a); 181 assert_eq!($new(1 as $t, 1 as $t, 1 as $t), a / a); 182 assert_eq!($new(1 as $t, 2 as $t, 4 as $t), a / 2 as $t); 183 assert_eq!($new(4 as $t, 2 as $t, 1 as $t), 8 as $t / a); 184 assert_eq!($new(0 as $t, 0 as $t, 0 as $t), a % a); 185 assert_eq!($new(0 as $t, 1 as $t, 1 as $t), a % (a - 1 as $t)); 186 assert_eq!($new(0 as $t, 0 as $t, 0 as $t), a % 1 as $t); 187 assert_eq!($new(2 as $t, 1 as $t, 2 as $t), a % 3 as $t); 188 assert_eq!($new(1 as $t, 1 as $t, 1 as $t), 17 as $t % a); 189 assert_eq!($new(2 as $t, 4 as $t, 0 as $t), a % 8 as $t); 190 }); 191 192 glam_test!(test_ops_propagated, { 193 let vec = $new(2 as $t, 4 as $t, 8 as $t); 194 let scalar = 2 as $t; 195 let g_scalar = 16 as $t; 196 197 assert_eq!((vec + vec), (vec + &vec)); 198 assert_eq!((vec + vec), (&vec + vec)); 199 assert_eq!((vec + vec), (&vec + &vec)); 200 assert_eq!((vec + scalar), (vec + &scalar)); 201 assert_eq!((vec + scalar), (&vec + &scalar)); 202 assert_eq!((vec + scalar), (&vec + scalar)); 203 assert_eq!((scalar + vec), (&scalar + vec)); 204 assert_eq!((scalar + vec), (&scalar + &vec)); 205 assert_eq!((scalar + vec), (scalar + &vec)); 206 207 assert_eq!((vec - vec), (vec - &vec)); 208 assert_eq!((vec - vec), (&vec - vec)); 209 assert_eq!((vec - vec), (&vec - &vec)); 210 assert_eq!((vec - scalar), (vec - &scalar)); 211 assert_eq!((vec - scalar), (&vec - &scalar)); 212 assert_eq!((vec - scalar), (&vec - scalar)); 213 assert_eq!((g_scalar - vec), (&g_scalar - vec)); 214 assert_eq!((g_scalar - vec), (&g_scalar - &vec)); 215 assert_eq!((g_scalar - vec), (g_scalar - &vec)); 216 217 assert_eq!((vec * vec), (vec * &vec)); 218 assert_eq!((vec * vec), (&vec * vec)); 219 assert_eq!((vec * vec), (&vec * &vec)); 220 assert_eq!((vec * scalar), (vec * &scalar)); 221 assert_eq!((vec * scalar), (&vec * &scalar)); 222 assert_eq!((vec * scalar), (&vec * scalar)); 223 assert_eq!((scalar * vec), (&scalar * vec)); 224 assert_eq!((scalar * vec), (&scalar * &vec)); 225 assert_eq!((scalar * vec), (scalar * &vec)); 226 227 assert_eq!((vec / vec), (vec / &vec)); 228 assert_eq!((vec / vec), (&vec / vec)); 229 assert_eq!((vec / vec), (&vec / &vec)); 230 assert_eq!((vec / scalar), (vec / &scalar)); 231 assert_eq!((vec / scalar), (&vec / &scalar)); 232 assert_eq!((vec / scalar), (&vec / scalar)); 233 assert_eq!((scalar / vec), (&scalar / vec)); 234 assert_eq!((scalar / vec), (&scalar / &vec)); 235 assert_eq!((scalar / vec), (scalar / &vec)); 236 237 assert_eq!((vec % vec), (vec % &vec)); 238 assert_eq!((vec % vec), (&vec % vec)); 239 assert_eq!((vec % vec), (&vec % &vec)); 240 assert_eq!((vec % scalar), (vec % &scalar)); 241 assert_eq!((vec % scalar), (&vec % &scalar)); 242 assert_eq!((vec % scalar), (&vec % scalar)); 243 assert_eq!((scalar % vec), (&scalar % vec)); 244 assert_eq!((scalar % vec), (&scalar % &vec)); 245 assert_eq!((scalar % vec), (scalar % &vec)); 246 }); 247 248 glam_test!(test_assign_ops, { 249 let a = $new(1 as $t, 2 as $t, 3 as $t); 250 let mut b = a; 251 252 b += 2 as $t; 253 assert_eq!($new(3 as $t, 4 as $t, 5 as $t), b); 254 b -= 2 as $t; 255 assert_eq!($new(1 as $t, 2 as $t, 3 as $t), b); 256 b *= 2 as $t; 257 assert_eq!($new(2 as $t, 4 as $t, 6 as $t), b); 258 b /= 2 as $t; 259 assert_eq!($new(1 as $t, 2 as $t, 3 as $t), b); 260 b %= 2 as $t; 261 assert_eq!($new(1 as $t, 0 as $t, 1 as $t), b); 262 263 b = a; 264 b += a; 265 assert_eq!($new(2 as $t, 4 as $t, 6 as $t), b); 266 b -= a; 267 assert_eq!($new(1 as $t, 2 as $t, 3 as $t), b); 268 b *= a; 269 assert_eq!($new(1 as $t, 4 as $t, 9 as $t), b); 270 b /= a; 271 assert_eq!($new(1 as $t, 2 as $t, 3 as $t), b); 272 b *= 2 as $t; 273 assert_eq!($new(2 as $t, 4 as $t, 6 as $t), b); 274 b /= 2 as $t; 275 assert_eq!($new(1 as $t, 2 as $t, 3 as $t), b); 276 b %= (b + 1 as $t); 277 assert_eq!($new(1 as $t, 2 as $t, 3 as $t), b); 278 b %= b; 279 assert_eq!($new(0 as $t, 0 as $t, 0 as $t), b); 280 }); 281 282 glam_test!(test_assign_ops_propagation, { 283 let vec = $new(1 as $t, 2 as $t, 3 as $t); 284 let mut a = vec; 285 let mut b = vec; 286 let scalar = 2 as $t; 287 288 a += &scalar; 289 b += scalar; 290 assert_eq!(b, a, "AddAssign<Scalar>"); 291 a -= &scalar; 292 b -= scalar; 293 assert_eq!(b, a, "SubAssign<Scalar>"); 294 a *= &scalar; 295 b *= scalar; 296 assert_eq!(b, a, "MulAssign<Scalar>"); 297 a /= &scalar; 298 b /= scalar; 299 assert_eq!(b, a, "DivAssign<Scalar>"); 300 a %= &scalar; 301 b %= scalar; 302 assert_eq!(b, a, "MulAssign<Scalar>"); 303 304 a = vec; 305 b = vec; 306 a += &vec; 307 b += vec; 308 assert_eq!(b, a, "AddAssign<Vec>"); 309 a -= &vec; 310 b -= vec; 311 assert_eq!(b, a, "SubAssign<Vec>"); 312 a *= &vec; 313 b *= vec; 314 assert_eq!(b, a, "MulAssign<Vec>"); 315 a /= &vec; 316 b /= vec; 317 assert_eq!(b, a, "DivAssign<Vec>"); 318 a %= &vec; 319 b %= vec; 320 assert_eq!(b, a, "RemAssign<Vec>"); 321 }); 322 323 glam_test!(test_min_max, { 324 let a = $new(3 as $t, 5 as $t, 1 as $t); 325 let b = $new(4 as $t, 2 as $t, 6 as $t); 326 assert_eq!((3 as $t, 2 as $t, 1 as $t), a.min(b).into()); 327 assert_eq!((3 as $t, 2 as $t, 1 as $t), b.min(a).into()); 328 assert_eq!((4 as $t, 5 as $t, 6 as $t), a.max(b).into()); 329 assert_eq!((4 as $t, 5 as $t, 6 as $t), b.max(a).into()); 330 }); 331 332 glam_test!(test_clamp, { 333 fn vec(x: i32, y: i32, z: i32) -> $vec3 { 334 $vec3::new(x as $t, y as $t, z as $t) 335 } 336 let min = vec(1, 3, 3); 337 let max = vec(6, 8, 8); 338 assert_eq!(vec(0, 0, 0).clamp(min, max), vec(1, 3, 3)); 339 assert_eq!(vec(2, 2, 2).clamp(min, max), vec(2, 3, 3)); 340 assert_eq!(vec(4, 5, 5).clamp(min, max), vec(4, 5, 5)); 341 assert_eq!(vec(6, 6, 6).clamp(min, max), vec(6, 6, 6)); 342 assert_eq!(vec(7, 7, 7).clamp(min, max), vec(6, 7, 7)); 343 assert_eq!(vec(9, 9, 9).clamp(min, max), vec(6, 8, 8)); 344 345 should_glam_assert!({ $vec3::clamp($vec3::ZERO, $vec3::ONE, $vec3::ZERO) }); 346 }); 347 348 glam_test!(test_hmin_hmax, { 349 assert_eq!(1 as $t, $new(1 as $t, 2 as $t, 3 as $t).min_element()); 350 assert_eq!(1 as $t, $new(3 as $t, 1 as $t, 2 as $t).min_element()); 351 assert_eq!(1 as $t, $new(2 as $t, 3 as $t, 1 as $t).min_element()); 352 assert_eq!(3 as $t, $new(1 as $t, 2 as $t, 3 as $t).max_element()); 353 assert_eq!(3 as $t, $new(3 as $t, 1 as $t, 2 as $t).max_element()); 354 assert_eq!(3 as $t, $new(2 as $t, 3 as $t, 1 as $t).max_element()); 355 }); 356 357 glam_test!(test_sum_product, { 358 let a = $new(2 as $t, 3 as $t, 5 as $t); 359 assert_eq!(a.element_sum(), 10 as $t); 360 assert_eq!(a.element_product(), 30 as $t); 361 }); 362 363 glam_test!(test_eq, { 364 let a = $new(1 as $t, 1 as $t, 1 as $t); 365 let b = $new(1 as $t, 2 as $t, 3 as $t); 366 assert!(a.cmpeq(a).all()); 367 assert!(b.cmpeq(b).all()); 368 assert!(a.cmpne(b).any()); 369 assert!(b.cmpne(a).any()); 370 assert!(b.cmpeq(a).any()); 371 }); 372 373 glam_test!(test_cmp, { 374 assert!(!$mask::default().any()); 375 assert!(!$mask::default().all()); 376 assert_eq!($mask::default().bitmask(), 0x0); 377 let a = $new(1 as $t, 1 as $t, 1 as $t); 378 let b = $new(2 as $t, 2 as $t, 2 as $t); 379 let c = $new(1 as $t, 1 as $t, 2 as $t); 380 let d = $new(2 as $t, 1 as $t, 1 as $t); 381 assert_eq!(a.cmplt(a).bitmask(), 0x0); 382 assert_eq!(a.cmplt(b).bitmask(), 0x7); 383 assert_eq!(a.cmplt(c).bitmask(), 0x4); 384 assert_eq!(c.cmple(a).bitmask(), 0x3); 385 assert_eq!(a.cmplt(d).bitmask(), 0x1); 386 assert!(a.cmplt(b).all()); 387 assert!(a.cmplt(c).any()); 388 assert!(a.cmple(b).all()); 389 assert!(a.cmple(a).all()); 390 assert!(b.cmpgt(a).all()); 391 assert!(b.cmpge(a).all()); 392 assert!(b.cmpge(b).all()); 393 assert!(!(a.cmpge(c).all())); 394 assert!(c.cmple(c).all()); 395 assert!(c.cmpge(c).all()); 396 assert!(a == a); 397 }); 398 399 glam_test!(test_extend_truncate, { 400 let a = $new(1 as $t, 2 as $t, 3 as $t); 401 let b = a.extend(4 as $t); 402 assert_eq!((1 as $t, 2 as $t, 3 as $t, 4 as $t), b.into()); 403 let c = $vec3::from(b.truncate()); 404 assert_eq!(a, c); 405 }); 406 407 glam_test!(test_mask, { 408 let mut a = $vec3::ZERO; 409 a.x = 1 as $t; 410 a.y = 1 as $t; 411 a.z = 1 as $t; 412 assert!(!a.cmpeq($vec3::ZERO).any()); 413 assert!(a.cmpeq($vec3::ONE).all()); 414 }); 415 416 glam_test!(test_mask_new, { 417 assert_eq!( 418 $mask::new(false, false, false), 419 $masknew(false, false, false) 420 ); 421 assert_eq!($mask::new(true, false, false), $masknew(true, false, false)); 422 assert_eq!($mask::new(false, true, true), $masknew(false, true, true)); 423 assert_eq!($mask::new(false, true, false), $masknew(false, true, false)); 424 assert_eq!($mask::new(true, false, true), $masknew(true, false, true)); 425 assert_eq!($mask::new(true, true, true), $masknew(true, true, true)); 426 }); 427 428 glam_test!(test_mask_from_array_bool, { 429 assert_eq!( 430 $mask::new(false, false, false), 431 $mask::from([false, false, false]) 432 ); 433 assert_eq!( 434 $mask::new(true, false, false), 435 $mask::from([true, false, false]) 436 ); 437 assert_eq!( 438 $mask::new(false, true, true), 439 $mask::from([false, true, true]) 440 ); 441 assert_eq!( 442 $mask::new(false, true, false), 443 $mask::from([false, true, false]) 444 ); 445 assert_eq!( 446 $mask::new(true, false, true), 447 $mask::from([true, false, true]) 448 ); 449 assert_eq!( 450 $mask::new(true, true, true), 451 $mask::from([true, true, true]) 452 ); 453 }); 454 455 glam_test!(test_mask_into_array_u32, { 456 assert_eq!( 457 Into::<[u32; 3]>::into($mask::new(false, false, false)), 458 [0, 0, 0] 459 ); 460 assert_eq!( 461 Into::<[u32; 3]>::into($mask::new(true, false, false)), 462 [!0, 0, 0] 463 ); 464 assert_eq!( 465 Into::<[u32; 3]>::into($mask::new(false, true, true)), 466 [0, !0, !0] 467 ); 468 assert_eq!( 469 Into::<[u32; 3]>::into($mask::new(false, true, false)), 470 [0, !0, 0] 471 ); 472 assert_eq!( 473 Into::<[u32; 3]>::into($mask::new(true, false, true)), 474 [!0, 0, !0] 475 ); 476 assert_eq!( 477 Into::<[u32; 3]>::into($mask::new(true, true, true)), 478 [!0, !0, !0] 479 ); 480 }); 481 482 glam_test!(test_mask_into_array_bool, { 483 assert_eq!( 484 Into::<[bool; 3]>::into($mask::new(false, false, false)), 485 [false, false, false] 486 ); 487 assert_eq!( 488 Into::<[bool; 3]>::into($mask::new(true, false, false)), 489 [true, false, false] 490 ); 491 assert_eq!( 492 Into::<[bool; 3]>::into($mask::new(false, true, true)), 493 [false, true, true] 494 ); 495 assert_eq!( 496 Into::<[bool; 3]>::into($mask::new(false, true, false)), 497 [false, true, false] 498 ); 499 assert_eq!( 500 Into::<[bool; 3]>::into($mask::new(true, false, true)), 501 [true, false, true] 502 ); 503 assert_eq!( 504 Into::<[bool; 3]>::into($mask::new(true, true, true)), 505 [true, true, true] 506 ); 507 }); 508 509 glam_test!(test_mask_splat, { 510 assert_eq!($mask::splat(false), $mask::new(false, false, false)); 511 assert_eq!($mask::splat(true), $mask::new(true, true, true)); 512 }); 513 514 glam_test!(test_mask_bitmask, { 515 assert_eq!($mask::new(false, false, false).bitmask(), 0b000); 516 assert_eq!($mask::new(true, false, false).bitmask(), 0b001); 517 assert_eq!($mask::new(false, true, true).bitmask(), 0b110); 518 assert_eq!($mask::new(false, true, false).bitmask(), 0b010); 519 assert_eq!($mask::new(true, false, true).bitmask(), 0b101); 520 assert_eq!($mask::new(true, true, true).bitmask(), 0b111); 521 }); 522 523 glam_test!(test_mask_any, { 524 assert_eq!($mask::new(false, false, false).any(), false); 525 assert_eq!($mask::new(true, false, false).any(), true); 526 assert_eq!($mask::new(false, true, false).any(), true); 527 assert_eq!($mask::new(false, false, true).any(), true); 528 }); 529 530 glam_test!(test_mask_all, { 531 assert_eq!($mask::new(true, true, true).all(), true); 532 assert_eq!($mask::new(false, true, true).all(), false); 533 assert_eq!($mask::new(true, false, true).all(), false); 534 assert_eq!($mask::new(true, true, false).all(), false); 535 }); 536 537 glam_test!(test_mask_select, { 538 let a = $vec3::new(1 as $t, 2 as $t, 3 as $t); 539 let b = $vec3::new(4 as $t, 5 as $t, 6 as $t); 540 assert_eq!( 541 $vec3::select($mask::new(true, true, true), a, b), 542 $vec3::new(1 as $t, 2 as $t, 3 as $t), 543 ); 544 assert_eq!( 545 $vec3::select($mask::new(true, false, true), a, b), 546 $vec3::new(1 as $t, 5 as $t, 3 as $t), 547 ); 548 assert_eq!( 549 $vec3::select($mask::new(false, true, false), a, b), 550 $vec3::new(4 as $t, 2 as $t, 6 as $t), 551 ); 552 assert_eq!( 553 $vec3::select($mask::new(false, false, false), a, b), 554 $vec3::new(4 as $t, 5 as $t, 6 as $t), 555 ); 556 }); 557 558 glam_test!(test_mask_and, { 559 assert_eq!( 560 ($mask::new(false, false, false) & $mask::new(false, false, false)).bitmask(), 561 0b000, 562 ); 563 assert_eq!( 564 ($mask::new(true, true, true) & $mask::new(true, true, true)).bitmask(), 565 0b111, 566 ); 567 assert_eq!( 568 ($mask::new(true, false, true) & $mask::new(false, true, false)).bitmask(), 569 0b000, 570 ); 571 assert_eq!( 572 ($mask::new(true, false, true) & $mask::new(true, true, true)).bitmask(), 573 0b101, 574 ); 575 576 let mut mask = $mask::new(true, true, false); 577 mask &= $mask::new(true, false, false); 578 assert_eq!(mask.bitmask(), 0b001); 579 }); 580 581 glam_test!(test_mask_or, { 582 assert_eq!( 583 ($mask::new(false, false, false) | $mask::new(false, false, false)).bitmask(), 584 0b000, 585 ); 586 assert_eq!( 587 ($mask::new(true, true, true) | $mask::new(true, true, true)).bitmask(), 588 0b111, 589 ); 590 assert_eq!( 591 ($mask::new(true, false, true) | $mask::new(false, true, false)).bitmask(), 592 0b111, 593 ); 594 assert_eq!( 595 ($mask::new(true, false, true) | $mask::new(true, false, true)).bitmask(), 596 0b101, 597 ); 598 599 let mut mask = $mask::new(true, true, false); 600 mask |= $mask::new(true, false, false); 601 assert_eq!(mask.bitmask(), 0b011); 602 }); 603 604 glam_test!(test_mask_xor, { 605 assert_eq!( 606 ($mask::new(false, false, false) ^ $mask::new(false, false, false)).bitmask(), 607 0b000, 608 ); 609 assert_eq!( 610 ($mask::new(true, true, true) ^ $mask::new(true, true, true)).bitmask(), 611 0b000, 612 ); 613 assert_eq!( 614 ($mask::new(true, false, true) ^ $mask::new(false, true, false)).bitmask(), 615 0b111, 616 ); 617 assert_eq!( 618 ($mask::new(true, false, true) ^ $mask::new(true, false, true)).bitmask(), 619 0b000, 620 ); 621 622 let mut mask = $mask::new(true, true, false); 623 mask ^= $mask::new(true, false, false); 624 assert_eq!(mask.bitmask(), 0b010); 625 }); 626 627 glam_test!(test_mask_not, { 628 assert_eq!((!$mask::new(false, false, false)).bitmask(), 0b111); 629 assert_eq!((!$mask::new(true, true, true)).bitmask(), 0b000); 630 assert_eq!((!$mask::new(true, false, true)).bitmask(), 0b010); 631 assert_eq!((!$mask::new(false, true, false)).bitmask(), 0b101); 632 }); 633 634 glam_test!(test_mask_fmt, { 635 let a = $mask::new(true, false, false); 636 637 // debug fmt 638 assert_eq!( 639 format!("{:?}", a), 640 format!("{}(0xffffffff, 0x0, 0x0)", stringify!($mask)) 641 ); 642 643 // display fmt 644 assert_eq!(format!("{}", a), "[true, false, false]"); 645 }); 646 647 glam_test!(test_mask_eq, { 648 let a = $mask::new(true, false, true); 649 let b = $mask::new(true, false, true); 650 let c = $mask::new(false, true, true); 651 652 assert_eq!(a, b); 653 assert_eq!(b, a); 654 assert_ne!(a, c); 655 assert_ne!(b, c); 656 }); 657 658 glam_test!(test_mask_test, { 659 let a = $mask::new(true, false, true); 660 assert_eq!(a.test(0), true); 661 assert_eq!(a.test(1), false); 662 assert_eq!(a.test(2), true); 663 664 let b = $mask::new(false, true, false); 665 assert_eq!(b.test(0), false); 666 assert_eq!(b.test(1), true); 667 assert_eq!(b.test(2), false); 668 }); 669 670 glam_test!(test_mask_set, { 671 let mut a = $mask::new(false, true, false); 672 a.set(0, true); 673 assert_eq!(a.test(0), true); 674 a.set(1, false); 675 assert_eq!(a.test(1), false); 676 a.set(2, true); 677 assert_eq!(a.test(2), true); 678 679 let mut b = $mask::new(true, false, true); 680 b.set(0, false); 681 assert_eq!(b.test(0), false); 682 b.set(1, true); 683 assert_eq!(b.test(1), true); 684 b.set(2, false); 685 assert_eq!(b.test(2), false); 686 }); 687 688 glam_test!(test_mask_hash, { 689 use std::collections::hash_map::DefaultHasher; 690 use std::hash::Hash; 691 use std::hash::Hasher; 692 693 let a = $mask::new(true, false, true); 694 let b = $mask::new(true, false, true); 695 let c = $mask::new(false, true, true); 696 697 let mut hasher = DefaultHasher::new(); 698 a.hash(&mut hasher); 699 let a_hashed = hasher.finish(); 700 701 let mut hasher = DefaultHasher::new(); 702 b.hash(&mut hasher); 703 let b_hashed = hasher.finish(); 704 705 let mut hasher = DefaultHasher::new(); 706 c.hash(&mut hasher); 707 let c_hashed = hasher.finish(); 708 709 assert_eq!(a, b); 710 assert_eq!(a_hashed, b_hashed); 711 assert_ne!(a, c); 712 assert_ne!(a_hashed, c_hashed); 713 }); 714 715 glam_test!(test_to_from_slice, { 716 let v = $vec3::new(1 as $t, 2 as $t, 3 as $t); 717 let mut a = [0 as $t, 0 as $t, 0 as $t]; 718 v.write_to_slice(&mut a); 719 assert_eq!(v, $vec3::from_slice(&a)); 720 721 let mut a = [0 as $t; 17]; 722 v.write_to_slice(&mut a); 723 assert_eq!(v, $vec3::from_slice(&a[..3])); 724 assert_eq!([0 as $t; 14], a[3..]); 725 726 should_panic!({ $vec3::ONE.write_to_slice(&mut [0 as $t; 2]) }); 727 should_panic!({ $vec3::from_slice(&[0 as $t; 2]) }); 728 }); 729 730 glam_test!(test_sum, { 731 let one = $vec3::ONE; 732 assert_eq!([one, one].iter().sum::<$vec3>(), one + one); 733 assert_eq!([one, one].into_iter().sum::<$vec3>(), one + one); 734 }); 735 736 glam_test!(test_product, { 737 let two = $vec3::new(2 as $t, 2 as $t, 2 as $t); 738 assert_eq!([two, two].iter().product::<$vec3>(), two * two); 739 assert_eq!([two, two].into_iter().product::<$vec3>(), two * two); 740 }); 741 }; 742 } 743 744 macro_rules! impl_vec3_signed_tests { 745 ($t:ident, $new:ident, $vec3:ident, $mask:ident, $masknew:ident) => { 746 impl_vec3_tests!($t, $new, $vec3, $mask, $masknew); 747 748 glam_test!(test_neg, { 749 let a = $new(1 as $t, 2 as $t, 3 as $t); 750 assert_eq!((-1 as $t, -2 as $t, -3 as $t), (-a).into()); 751 assert_eq!( 752 $new(-0.0 as $t, -0.0 as $t, -0.0 as $t), 753 -$new(0.0 as $t, 0.0 as $t, 0.0 as $t) 754 ); 755 assert_eq!( 756 $new(0.0 as $t, -0.0 as $t, -0.0 as $t), 757 -$new(-0.0 as $t, 0.0 as $t, 0.0 as $t) 758 ); 759 }); 760 761 glam_test!(test_neg_propagation, { 762 let a = $new(1 as $t, 2 as $t, 3 as $t); 763 assert_eq!(-a, -(&a)); 764 }); 765 766 glam_test!(test_is_negative_bitmask, { 767 assert_eq!($vec3::ZERO.is_negative_bitmask(), 0b000); 768 assert_eq!($vec3::ONE.is_negative_bitmask(), 0b000); 769 assert_eq!((-$vec3::ONE).is_negative_bitmask(), 0b111); 770 assert_eq!( 771 $vec3::new(-1 as $t, 2 as $t, 3 as $t).is_negative_bitmask(), 772 0b001 773 ); 774 assert_eq!( 775 $vec3::new(8 as $t, 3 as $t, 1 as $t).is_negative_bitmask(), 776 0b000 777 ); 778 assert_eq!( 779 $vec3::new(1 as $t, 5 as $t, -3 as $t).is_negative_bitmask(), 780 0b100 781 ); 782 assert_eq!( 783 $vec3::new(3 as $t, -4 as $t, 1 as $t).is_negative_bitmask(), 784 0b010 785 ); 786 assert_eq!( 787 $vec3::new(-2 as $t, 6 as $t, -5 as $t).is_negative_bitmask(), 788 0b101 789 ); 790 }); 791 792 glam_test!(test_abs, { 793 assert_eq!($vec3::ZERO.abs(), $vec3::ZERO); 794 assert_eq!($vec3::ONE.abs(), $vec3::ONE); 795 assert_eq!((-$vec3::ONE).abs(), $vec3::ONE); 796 }); 797 798 glam_test!(test_dot_signed, { 799 let x = $new(1 as $t, 0 as $t, 0 as $t); 800 let y = $new(0 as $t, 1 as $t, 0 as $t); 801 let z = $new(0 as $t, 0 as $t, 1 as $t); 802 assert_eq!(1 as $t, x.dot(x)); 803 assert_eq!(0 as $t, x.dot(y)); 804 assert_eq!(-1 as $t, z.dot(-z)); 805 }); 806 807 glam_test!(test_length_squared_signed, { 808 let x = $new(1 as $t, 0 as $t, 0 as $t); 809 let y = $new(0 as $t, 1 as $t, 0 as $t); 810 let z = $new(0 as $t, 0 as $t, 1 as $t); 811 assert_eq!(9 as $t, (-3 as $t * y).length_squared()); 812 assert_eq!( 813 2 as $t * 2 as $t + 3 as $t * 3 as $t + 4 as $t * 4 as $t, 814 $new(2 as $t, 3 as $t, 4 as $t).length_squared() 815 ); 816 assert_eq!(2 as $t, x.distance_squared(y)); 817 assert_eq!(13 as $t, (2 as $t * x).distance_squared(-3 as $t * z)); 818 }); 819 820 glam_test!(test_div_euclid, { 821 let one = $vec3::ONE; 822 let two = one + one; 823 let three = two + one; 824 assert_eq!(three.div_euclid(two), one); 825 assert_eq!((-three).div_euclid(two), -two); 826 assert_eq!(three.div_euclid(-two), -one); 827 assert_eq!((-three).div_euclid(-two), two); 828 }); 829 830 glam_test!(test_rem_euclid, { 831 let one = $vec3::ONE; 832 let two = one + one; 833 let three = two + one; 834 let four = three + one; 835 assert_eq!(four.rem_euclid(three), one); 836 assert_eq!((-four).rem_euclid(three), two); 837 assert_eq!(four.rem_euclid(-three), one); 838 assert_eq!((-four).rem_euclid(-three), two); 839 }); 840 }; 841 } 842 843 macro_rules! impl_vec3_signed_integer_tests { 844 ($t:ident, $new:ident, $vec3:ident, $mask:ident, $masknew:ident) => { 845 impl_vec3_signed_tests!($t, $new, $vec3, $mask, $masknew); 846 847 glam_test!(test_signum, { 848 assert_eq!($vec3::ZERO.signum(), $vec3::ZERO); 849 assert_eq!($vec3::ONE.signum(), $vec3::ONE); 850 assert_eq!((-$vec3::ONE).signum(), -$vec3::ONE); 851 }); 852 853 glam_test!(test_checked_add, { 854 assert_eq!($vec3::MAX.checked_add($vec3::ONE), None); 855 assert_eq!($vec3::MAX.checked_add($vec3::X), None); 856 assert_eq!($vec3::MAX.checked_add($vec3::Y), None); 857 assert_eq!($vec3::MAX.checked_add($vec3::Z), None); 858 assert_eq!($vec3::MAX.checked_add($vec3::ZERO), Some($vec3::MAX)); 859 }); 860 861 glam_test!(test_checked_sub, { 862 assert_eq!($vec3::MIN.checked_sub($vec3::ONE), None); 863 assert_eq!($vec3::MIN.checked_sub($vec3::X), None); 864 assert_eq!($vec3::MIN.checked_sub($vec3::Y), None); 865 assert_eq!($vec3::MIN.checked_sub($vec3::Z), None); 866 assert_eq!($vec3::MIN.checked_sub($vec3::ZERO), Some($vec3::MIN)); 867 }); 868 869 glam_test!(test_checked_mul, { 870 assert_eq!($vec3::MIN.checked_mul($vec3::MIN), None); 871 assert_eq!($vec3::MAX.checked_mul($vec3::MIN), None); 872 assert_eq!($vec3::MIN.checked_mul($vec3::MAX), None); 873 assert_eq!($vec3::MAX.checked_mul($vec3::MAX), None); 874 assert_eq!($vec3::ZERO.checked_mul($vec3::MIN), Some($vec3::ZERO)); 875 assert_eq!($vec3::MAX.checked_mul($vec3::ZERO), Some($vec3::ZERO)); 876 assert_eq!($vec3::MIN.checked_mul($vec3::ONE), Some($vec3::MIN)); 877 assert_eq!($vec3::MAX.checked_mul($vec3::ONE), Some($vec3::MAX)); 878 assert_eq!($vec3::ZERO.checked_mul($vec3::ZERO), Some($vec3::ZERO)); 879 assert_eq!($vec3::ONE.checked_mul($vec3::ONE), Some($vec3::ONE)); 880 }); 881 882 glam_test!(test_checked_div, { 883 assert_eq!($vec3::MIN.checked_div($vec3::ZERO), None); 884 assert_eq!($vec3::MAX.checked_div($vec3::ZERO), None); 885 assert_eq!($vec3::MAX.checked_div($vec3::X), None); 886 assert_eq!($vec3::MAX.checked_div($vec3::Y), None); 887 assert_eq!($vec3::MAX.checked_div($vec3::Z), None); 888 assert_eq!($vec3::ZERO.checked_div($vec3::ONE), Some($vec3::ZERO)); 889 assert_eq!($vec3::MIN.checked_div($vec3::ONE), Some($vec3::MIN)); 890 assert_eq!($vec3::MAX.checked_div($vec3::ONE), Some($vec3::MAX)); 891 }); 892 893 glam_test!(test_manhattan_distance, { 894 assert_eq!( 895 $vec3::new(3, 27, 98).manhattan_distance($vec3::new(20, 65, 97)), 896 56 897 ); 898 assert_eq!( 899 $vec3::new(8, 12, 12).manhattan_distance($vec3::new(24, 56, 2)), 900 70 901 ); 902 assert_eq!( 903 $vec3::new(-23, 2, -99).manhattan_distance($vec3::new(22, -12, 24)), 904 182 905 ); 906 907 assert_eq!( 908 $vec3::new(3, 27, 98).checked_manhattan_distance($vec3::new(20, 65, 97)), 909 Some(56) 910 ); 911 assert_eq!( 912 $vec3::new(8, 12, 12).checked_manhattan_distance($vec3::new(24, 56, 2)), 913 Some(70) 914 ); 915 assert_eq!( 916 $vec3::new(-23, 2, -99).checked_manhattan_distance($vec3::new(22, -12, 24)), 917 Some(182) 918 ); 919 920 assert_eq!( 921 $vec3::new($t::MIN, $t::MIN, $t::MIN).checked_manhattan_distance($vec3::new( 922 $t::MAX, 923 $t::MAX, 924 $t::MAX 925 )), 926 None 927 ); 928 }); 929 930 glam_test!(test_chebyshev_distance, { 931 assert_eq!( 932 $vec3::new(3, 27, 98).chebyshev_distance($vec3::new(20, 65, 97)), 933 38 934 ); 935 assert_eq!( 936 $vec3::new(8, 12, 12).chebyshev_distance($vec3::new(24, 56, 2)), 937 44 938 ); 939 assert_eq!( 940 $vec3::new(-23, 2, -99).chebyshev_distance($vec3::new(22, -12, 24)), 941 123 942 ); 943 }); 944 }; 945 } 946 947 macro_rules! impl_vec3_unsigned_integer_tests { 948 ($t:ident, $new:ident, $vec3:ident, $mask:ident, $masknew:ident) => { 949 impl_vec3_tests!($t, $new, $vec3, $mask, $masknew); 950 951 glam_test!(test_checked_add, { 952 assert_eq!($vec3::MAX.checked_add($vec3::ONE), None); 953 assert_eq!($vec3::MAX.checked_add($vec3::X), None); 954 assert_eq!($vec3::MAX.checked_add($vec3::Y), None); 955 assert_eq!($vec3::MAX.checked_add($vec3::Z), None); 956 assert_eq!($vec3::MAX.checked_add($vec3::ZERO), Some($vec3::MAX)); 957 }); 958 959 glam_test!(test_checked_sub, { 960 assert_eq!($vec3::ZERO.checked_sub($vec3::ONE), None); 961 assert_eq!($vec3::ZERO.checked_sub($vec3::X), None); 962 assert_eq!($vec3::ZERO.checked_sub($vec3::Y), None); 963 assert_eq!($vec3::ZERO.checked_sub($vec3::Z), None); 964 assert_eq!($vec3::ZERO.checked_sub($vec3::ZERO), Some($vec3::MIN)); 965 }); 966 967 glam_test!(test_checked_mul, { 968 assert_eq!($vec3::MAX.checked_mul($vec3::MAX), None); 969 assert_eq!($vec3::MAX.checked_mul($vec3::ZERO), Some($vec3::ZERO)); 970 assert_eq!($vec3::MAX.checked_mul($vec3::ONE), Some($vec3::MAX)); 971 assert_eq!($vec3::ZERO.checked_mul($vec3::ZERO), Some($vec3::ZERO)); 972 assert_eq!($vec3::ONE.checked_mul($vec3::ONE), Some($vec3::ONE)); 973 }); 974 975 glam_test!(test_checked_div, { 976 assert_eq!($vec3::MAX.checked_div($vec3::ZERO), None); 977 assert_eq!($vec3::MAX.checked_div($vec3::X), None); 978 assert_eq!($vec3::MAX.checked_div($vec3::Y), None); 979 assert_eq!($vec3::MAX.checked_div($vec3::Z), None); 980 assert_eq!($vec3::ZERO.checked_div($vec3::ONE), Some($vec3::ZERO)); 981 assert_eq!($vec3::MAX.checked_div($vec3::ONE), Some($vec3::MAX)); 982 }); 983 984 glam_test!(test_manhattan_distance, { 985 assert_eq!( 986 $vec3::new(3, 27, 98).manhattan_distance($vec3::new(20, 65, 97)), 987 56 988 ); 989 assert_eq!( 990 $vec3::new(8, 12, 12).manhattan_distance($vec3::new(24, 56, 2)), 991 70 992 ); 993 994 assert_eq!( 995 $vec3::new(3, 27, 98).checked_manhattan_distance($vec3::new(20, 65, 97)), 996 Some(56) 997 ); 998 assert_eq!( 999 $vec3::new(8, 12, 12).checked_manhattan_distance($vec3::new(24, 56, 2)), 1000 Some(70) 1001 ); 1002 1003 assert_eq!( 1004 $vec3::new($t::MIN, $t::MIN, $t::MIN).checked_manhattan_distance($vec3::new( 1005 $t::MAX, 1006 $t::MAX, 1007 $t::MAX 1008 )), 1009 None 1010 ); 1011 }); 1012 1013 glam_test!(test_chebyshev_distance, { 1014 assert_eq!( 1015 $vec3::new(3, 27, 98).chebyshev_distance($vec3::new(20, 65, 97)), 1016 38 1017 ); 1018 assert_eq!( 1019 $vec3::new(8, 12, 12).chebyshev_distance($vec3::new(24, 56, 2)), 1020 44 1021 ); 1022 }); 1023 }; 1024 } 1025 1026 macro_rules! impl_vec3_eq_hash_tests { 1027 ($t:ident, $new:ident) => { 1028 glam_test!(test_vec3_hash, { 1029 use std::collections::hash_map::DefaultHasher; 1030 use std::hash::Hash; 1031 use std::hash::Hasher; 1032 1033 let a = $new(1 as $t, 2 as $t, 3 as $t); 1034 let b = $new(1 as $t, 2 as $t, 3 as $t); 1035 let c = $new(3 as $t, 2 as $t, 1 as $t); 1036 1037 let mut hasher = DefaultHasher::new(); 1038 a.hash(&mut hasher); 1039 let a_hashed = hasher.finish(); 1040 1041 let mut hasher = DefaultHasher::new(); 1042 b.hash(&mut hasher); 1043 let b_hashed = hasher.finish(); 1044 1045 let mut hasher = DefaultHasher::new(); 1046 c.hash(&mut hasher); 1047 let c_hashed = hasher.finish(); 1048 1049 assert_eq!(a, b); 1050 assert_eq!(a_hashed, b_hashed); 1051 assert_ne!(a, c); 1052 assert_ne!(a_hashed, c_hashed); 1053 }); 1054 }; 1055 } 1056 1057 macro_rules! impl_vec3_float_tests { 1058 ($t:ident, $new:ident, $vec3:ident, $mask:ident, $masknew:ident) => { 1059 impl_vec3_signed_tests!($t, $new, $vec3, $mask, $masknew); 1060 impl_vec_float_normalize_tests!($t, $vec3); 1061 1062 glam_test!(test_nan, { 1063 assert!($vec3::NAN.is_nan()); 1064 assert!(!$vec3::NAN.is_finite()); 1065 }); 1066 1067 glam_test!(test_funcs, { 1068 let x = $new(1.0, 0.0, 0.0); 1069 let y = $new(0.0, 1.0, 0.0); 1070 let z = $new(0.0, 0.0, 1.0); 1071 assert_eq!(y, z.cross(x)); 1072 assert_eq!(z, x.cross(y)); 1073 assert_eq!(2.0, (-2.0 * x).length()); 1074 assert_eq!(3.0, (3.0 * y).length()); 1075 assert_eq!(4.0, (-4.0 * z).length()); 1076 assert_eq!((2.0 as $t).sqrt(), x.distance(y)); 1077 assert_eq!(5.0, (3.0 * x).distance(-4.0 * y)); 1078 assert_eq!(13.0, (-5.0 * z).distance(12.0 * y)); 1079 assert_eq!(x, (2.0 * x).normalize()); 1080 assert_eq!( 1081 1.0 * 4.0 + 2.0 * 5.0 + 3.0 * 6.0, 1082 $new(1.0, 2.0, 3.0).dot($new(4.0, 5.0, 6.0)) 1083 ); 1084 assert_eq!( 1085 (2.0 as $t * 2.0 + 3.0 * 3.0 + 4.0 * 4.0).sqrt(), 1086 $new(2.0, 3.0, 4.0).length() 1087 ); 1088 assert_eq!( 1089 1.0 / (2.0 as $t * 2.0 + 3.0 * 3.0 + 4.0 * 4.0).sqrt(), 1090 $new(2.0, 3.0, 4.0).length_recip() 1091 ); 1092 assert!($new(2.0, 3.0, 4.0).normalize().is_normalized()); 1093 assert_approx_eq!( 1094 $new(2.0, 3.0, 4.0) / (2.0 as $t * 2.0 + 3.0 * 3.0 + 4.0 * 4.0).sqrt(), 1095 $new(2.0, 3.0, 4.0).normalize() 1096 ); 1097 assert_eq!($new(0.5, 0.25, 0.125), $new(2.0, 4.0, 8.0).recip()); 1098 }); 1099 1100 glam_test!(test_project_reject, { 1101 assert_eq!( 1102 $new(0.0, 0.0, 1.0), 1103 $new(1.0, 0.0, 1.0).project_onto($new(0.0, 0.0, 2.0)) 1104 ); 1105 assert_eq!( 1106 $new(1.0, 0.0, 0.0), 1107 $new(1.0, 0.0, 1.0).reject_from($new(0.0, 0.0, 2.0)) 1108 ); 1109 assert_eq!( 1110 $new(0.0, 0.0, 1.0), 1111 $new(1.0, 0.0, 1.0).project_onto_normalized($new(0.0, 0.0, 1.0)) 1112 ); 1113 assert_eq!( 1114 $new(1.0, 0.0, 0.0), 1115 $new(1.0, 0.0, 1.0).reject_from_normalized($new(0.0, 0.0, 1.0)) 1116 ); 1117 should_glam_assert!({ $vec3::ONE.project_onto($vec3::ZERO) }); 1118 should_glam_assert!({ $vec3::ONE.reject_from($vec3::ZERO) }); 1119 should_glam_assert!({ $vec3::ONE.project_onto_normalized($vec3::ONE) }); 1120 should_glam_assert!({ $vec3::ONE.reject_from_normalized($vec3::ONE) }); 1121 }); 1122 1123 glam_test!(test_signum, { 1124 assert_eq!($vec3::ZERO.signum(), $vec3::ONE); 1125 assert_eq!((-$vec3::ZERO).signum(), -$vec3::ONE); 1126 assert_eq!($vec3::ONE.signum(), $vec3::ONE); 1127 assert_eq!((-$vec3::ONE).signum(), -$vec3::ONE); 1128 assert_eq!($vec3::INFINITY.signum(), $vec3::ONE); 1129 assert_eq!($vec3::NEG_INFINITY.signum(), -$vec3::ONE); 1130 assert!($vec3::NAN.signum().is_nan_mask().all()); 1131 }); 1132 1133 glam_test!(test_copysign, { 1134 assert_eq!($vec3::ZERO.copysign(-$vec3::ZERO), -$vec3::ZERO); 1135 assert_eq!((-$vec3::ZERO).copysign(-$vec3::ZERO), -$vec3::ZERO); 1136 assert_eq!($vec3::ZERO.copysign($vec3::ZERO), $vec3::ZERO); 1137 assert_eq!((-$vec3::ZERO).copysign($vec3::ZERO), $vec3::ZERO); 1138 assert_eq!($vec3::ONE.copysign(-$vec3::ZERO), -$vec3::ONE); 1139 assert_eq!((-$vec3::ONE).copysign(-$vec3::ZERO), -$vec3::ONE); 1140 assert_eq!($vec3::ONE.copysign($vec3::ZERO), $vec3::ONE); 1141 assert_eq!((-$vec3::ONE).copysign($vec3::ZERO), $vec3::ONE); 1142 assert_eq!($vec3::ZERO.copysign(-$vec3::ONE), -$vec3::ZERO); 1143 assert_eq!((-$vec3::ZERO).copysign(-$vec3::ONE), -$vec3::ZERO); 1144 assert_eq!($vec3::ZERO.copysign($vec3::ONE), $vec3::ZERO); 1145 assert_eq!((-$vec3::ZERO).copysign($vec3::ONE), $vec3::ZERO); 1146 assert_eq!($vec3::ONE.copysign(-$vec3::ONE), -$vec3::ONE); 1147 assert_eq!((-$vec3::ONE).copysign(-$vec3::ONE), -$vec3::ONE); 1148 assert_eq!($vec3::ONE.copysign($vec3::ONE), $vec3::ONE); 1149 assert_eq!((-$vec3::ONE).copysign($vec3::ONE), $vec3::ONE); 1150 assert_eq!($vec3::INFINITY.copysign($vec3::ONE), $vec3::INFINITY); 1151 assert_eq!($vec3::INFINITY.copysign(-$vec3::ONE), $vec3::NEG_INFINITY); 1152 assert_eq!($vec3::NEG_INFINITY.copysign($vec3::ONE), $vec3::INFINITY); 1153 assert_eq!( 1154 $vec3::NEG_INFINITY.copysign(-$vec3::ONE), 1155 $vec3::NEG_INFINITY 1156 ); 1157 assert!($vec3::NAN.copysign($vec3::ONE).is_nan_mask().all()); 1158 assert!($vec3::NAN.copysign(-$vec3::ONE).is_nan_mask().all()); 1159 }); 1160 1161 glam_test!(test_float_is_negative_bitmask, { 1162 assert_eq!($vec3::ZERO.is_negative_bitmask(), 0b000); 1163 assert_eq!((-$vec3::ZERO).is_negative_bitmask(), 0b111); 1164 assert_eq!($vec3::ONE.is_negative_bitmask(), 0b000); 1165 assert_eq!((-$vec3::ONE).is_negative_bitmask(), 0b111); 1166 assert_eq!($vec3::new(-1.0, 2.0, 3.0).is_negative_bitmask(), 0b001); 1167 assert_eq!($vec3::new(8.0, 3.0, 1.0).is_negative_bitmask(), 0b000); 1168 assert_eq!($vec3::new(1.0, 5.0, -3.0).is_negative_bitmask(), 0b100); 1169 assert_eq!($vec3::new(3.0, -4.0, 1.0).is_negative_bitmask(), 0b010); 1170 assert_eq!($vec3::new(-2.0, 6.0, -5.0).is_negative_bitmask(), 0b101); 1171 }); 1172 1173 glam_test!(test_round, { 1174 assert_eq!($vec3::new(1.35, 0.0, 0.0).round().x, 1.0); 1175 assert_eq!($vec3::new(0.0, 1.5, 0.0).round().y, 2.0); 1176 assert_eq!($vec3::new(0.0, 0.0, -15.5).round().z, -16.0); 1177 assert_eq!($vec3::new(0.0, 0.0, 0.0).round().z, 0.0); 1178 assert_eq!($vec3::new(0.0, 21.1, 0.0).round().y, 21.0); 1179 assert_eq!($vec3::new(0.0, 11.123, 0.0).round().y, 11.0); 1180 assert_eq!($vec3::new(0.0, 11.499, 0.0).round().y, 11.0); 1181 assert_eq!( 1182 $vec3::new($t::NEG_INFINITY, $t::INFINITY, 0.0).round(), 1183 $vec3::new($t::NEG_INFINITY, $t::INFINITY, 0.0) 1184 ); 1185 assert!($vec3::new($t::NAN, 0.0, 0.0).round().x.is_nan()); 1186 }); 1187 1188 glam_test!(test_floor, { 1189 assert_eq!( 1190 $vec3::new(1.35, 1.5, -1.5).floor(), 1191 $vec3::new(1.0, 1.0, -2.0) 1192 ); 1193 assert_eq!( 1194 $vec3::new($t::INFINITY, $t::NEG_INFINITY, 0.0).floor(), 1195 $vec3::new($t::INFINITY, $t::NEG_INFINITY, 0.0) 1196 ); 1197 assert!($vec3::new($t::NAN, 0.0, 0.0).floor().x.is_nan()); 1198 assert_eq!( 1199 $vec3::new(-2000000.123, 10000000.123, 1000.9).floor(), 1200 $vec3::new(-2000001.0, 10000000.0, 1000.0) 1201 ); 1202 }); 1203 1204 glam_test!(test_fract_gl, { 1205 assert_approx_eq!( 1206 $vec3::new(1.35, 1.5, -1.5).fract_gl(), 1207 $vec3::new(0.35, 0.5, 0.5) 1208 ); 1209 assert_approx_eq!( 1210 $vec3::new(-200000.123, 1000000.123, 1000.9).fract_gl(), 1211 $vec3::new(0.877, 0.123, 0.9), 1212 0.002 1213 ); 1214 }); 1215 1216 glam_test!(test_fract, { 1217 assert_approx_eq!( 1218 $vec3::new(1.35, 1.5, -1.5).fract(), 1219 $vec3::new(0.35, 0.5, -0.5) 1220 ); 1221 assert_approx_eq!( 1222 $vec3::new(-200000.123, 1000000.123, 1000.9).fract(), 1223 $vec3::new(-0.123, 0.123, 0.9), 1224 0.002 1225 ); 1226 }); 1227 1228 glam_test!(test_ceil, { 1229 assert_eq!( 1230 $vec3::new(1.35, 1.5, -1.5).ceil(), 1231 $vec3::new(2.0, 2.0, -1.0) 1232 ); 1233 assert_eq!( 1234 $vec3::new($t::INFINITY, $t::NEG_INFINITY, 0.0).ceil(), 1235 $vec3::new($t::INFINITY, $t::NEG_INFINITY, 0.0) 1236 ); 1237 assert!($vec3::new($t::NAN, 0.0, 0.0).ceil().x.is_nan()); 1238 assert_eq!( 1239 $vec3::new(-2000000.123, 1000000.123, 1000.9).ceil(), 1240 $vec3::new(-2000000.0, 1000001.0, 1001.0) 1241 ); 1242 }); 1243 1244 glam_test!(test_trunc, { 1245 assert_eq!( 1246 $vec3::new(1.35, 1.5, -1.5).trunc(), 1247 $vec3::new(1.0, 1.0, -1.0) 1248 ); 1249 assert_eq!( 1250 $vec3::new($t::INFINITY, $t::NEG_INFINITY, 0.0).trunc(), 1251 $vec3::new($t::INFINITY, $t::NEG_INFINITY, 0.0) 1252 ); 1253 assert!($vec3::new(0.0, $t::NAN, 0.0).trunc().y.is_nan()); 1254 assert_eq!( 1255 $vec3::new(-0.0, -2000000.123, 10000000.123).trunc(), 1256 $vec3::new(-0.0, -2000000.0, 10000000.0) 1257 ); 1258 }); 1259 1260 glam_test!(test_lerp, { 1261 let v0 = $vec3::new(-1.0, -1.0, -1.0); 1262 let v1 = $vec3::new(1.0, 1.0, 1.0); 1263 assert_approx_eq!(v0, v0.lerp(v1, 0.0)); 1264 assert_approx_eq!(v1, v0.lerp(v1, 1.0)); 1265 assert_approx_eq!($vec3::ZERO, v0.lerp(v1, 0.5)); 1266 }); 1267 1268 glam_test!(test_lerp_big_difference, { 1269 let v0 = $vec3::new(-1e30, -1e30, -1e30); 1270 let v1 = $vec3::new(16.0, 16.0, 16.0); 1271 assert_approx_eq!(v0, v0.lerp(v1, 0.0)); 1272 assert_approx_eq!(v1, v0.lerp(v1, 1.0)); 1273 }); 1274 1275 glam_test!(test_slerp, { 1276 let v0 = $vec3::new(1.0, 2.0, 3.0); 1277 let v1 = $vec3::new(4.0, 5.0, 6.0); 1278 assert_approx_eq!(v0.slerp(v1, 0.0), v0); 1279 assert_approx_eq!(v0.slerp(v1, 1.0), v1); 1280 assert_approx_eq!( 1281 v0.slerp(v1, 0.5).length(), 1282 (v0.length() + v1.length()) / 2., 1283 5e-7 1284 ); 1285 assert_approx_eq!( 1286 v0.angle_between(v0.slerp(v1, 0.5)) * 2.0, 1287 v0.angle_between(v1) 1288 ); 1289 assert_approx_eq!( 1290 $vec3::new(5.0, 0.0, 0.0).slerp($vec3::new(0.0, 5.0, 0.0), 0.5), 1291 $vec3::new(5.0, 5.0, 0.0) * std::$t::consts::FRAC_1_SQRT_2 1292 ); 1293 }); 1294 glam_test!(test_slerp_extrapolate, { 1295 let v0 = $vec3::Y; 1296 let v1 = $vec3::X; 1297 // Normalized 1298 assert_approx_eq!(v0.slerp(v1, -1.0), $vec3::NEG_X, 2e-7); 1299 assert_approx_eq!(v0.slerp(v1, 2.0), $vec3::NEG_Y, 2e-7); 1300 // Scaled 1301 assert_approx_eq!(v0.slerp(v1 * 1.5, -1.0), $vec3::NEG_X * 0.5); 1302 assert_approx_eq!(v0.slerp(v1 * 1.5, 2.0), $vec3::NEG_Y * 2.0, 4e-7); 1303 }); 1304 glam_test!(test_slerp_parallel, { 1305 // Same direction 1306 assert_approx_eq!($vec3::ONE.slerp($vec3::splat(2.), 0.5), $vec3::splat(1.5)); 1307 assert_approx_eq!($vec3::splat(2.).slerp($vec3::ONE, 0.5), $vec3::splat(1.5)); 1308 // Opposite direction 1309 assert_approx_eq!($vec3::Y.slerp($vec3::NEG_Y, 0.5), $vec3::X); 1310 assert_approx_eq!(($vec3::Y * 1.5).slerp($vec3::NEG_Y * 0.5, 0.5), $vec3::X); 1311 assert_approx_eq!(($vec3::Y * 0.5).slerp($vec3::NEG_Y * 1.5, 0.5), $vec3::X); 1312 }); 1313 glam_test!(test_slerp_zero_length, { 1314 assert_approx_eq!($vec3::ZERO.slerp($vec3::ZERO, 0.5), $vec3::ZERO); 1315 assert_approx_eq!($vec3::ZERO.slerp($vec3::ONE, 0.5), $vec3::splat(0.5)); 1316 assert_approx_eq!($vec3::ONE.slerp($vec3::ZERO, 0.5), $vec3::splat(0.5)); 1317 }); 1318 1319 glam_test!(test_move_towards, { 1320 let v0 = $vec3::new(-1.0, -1.0, -1.0); 1321 let v1 = $vec3::new(1.0, 1.0, 1.0); 1322 assert_approx_eq!(v0, v0.move_towards(v1, 0.0)); 1323 assert_approx_eq!(v1, v0.move_towards(v1, v0.distance(v1))); 1324 assert_approx_eq!(v1, v0.move_towards(v1, v0.distance(v1) + 1.0)); 1325 }); 1326 1327 glam_test!(test_midpoint, { 1328 let v0 = $vec3::new(-1.0, -1.0, -1.0); 1329 let v1 = $vec3::new(1.0, 1.0, 1.0); 1330 let v2 = $vec3::new(-1.5, 0.0, 1.0); 1331 assert_approx_eq!($vec3::ZERO, v0.midpoint(v1)); 1332 assert_approx_eq!($vec3::new(-0.25, 0.5, 1.0), v1.midpoint(v2)); 1333 }); 1334 1335 glam_test!(test_is_finite, { 1336 assert!($vec3::new(0.0, 0.0, 0.0).is_finite()); 1337 assert!($vec3::new(-1e-10, 1.0, 1e10).is_finite()); 1338 assert!(!$vec3::new($t::INFINITY, 0.0, 0.0).is_finite()); 1339 assert!(!$vec3::new(0.0, $t::NAN, 0.0).is_finite()); 1340 assert!(!$vec3::new(0.0, 0.0, $t::NEG_INFINITY).is_finite()); 1341 assert!(!$vec3::NAN.is_finite()); 1342 assert!(!$vec3::INFINITY.is_finite()); 1343 assert!(!$vec3::NEG_INFINITY.is_finite()); 1344 }); 1345 1346 glam_test!(test_powf, { 1347 assert_eq!( 1348 $vec3::new(2.0, 4.0, 8.0).powf(2.0), 1349 $vec3::new(4.0, 16.0, 64.0) 1350 ); 1351 }); 1352 1353 glam_test!(test_exp, { 1354 assert_approx_eq!( 1355 $vec3::new(1.0, 2.0, 3.0).exp(), 1356 $vec3::new((1.0 as $t).exp(), (2.0 as $t).exp(), (3.0 as $t).exp()) 1357 ); 1358 }); 1359 1360 glam_test!(test_angle_between, { 1361 let angle = $vec3::new(1.0, 0.0, 1.0).angle_between($vec3::new(1.0, 1.0, 0.0)); 1362 assert_approx_eq!(core::$t::consts::FRAC_PI_3, angle, 1e-6); 1363 1364 let angle = $vec3::new(10.0, 0.0, 10.0).angle_between($vec3::new(5.0, 5.0, 0.0)); 1365 assert_approx_eq!(core::$t::consts::FRAC_PI_3, angle, 1e-6); 1366 1367 let angle = $vec3::new(-1.0, 0.0, -1.0).angle_between($vec3::new(1.0, -1.0, 0.0)); 1368 assert_approx_eq!(2.0 * core::$t::consts::FRAC_PI_3, angle, 1e-6); 1369 }); 1370 1371 glam_test!(test_clamp_length, { 1372 // Too long gets shortened 1373 assert_eq!( 1374 $vec3::new(12.0, 16.0, 0.0).clamp_length(7.0, 10.0), 1375 $vec3::new(6.0, 8.0, 0.0) // shortened to length 10.0 1376 ); 1377 // In the middle is unchanged 1378 assert_eq!( 1379 $vec3::new(2.0, 1.0, 0.0).clamp_length(0.5, 5.0), 1380 $vec3::new(2.0, 1.0, 0.0) // unchanged 1381 ); 1382 // Too short gets lengthened 1383 assert_eq!( 1384 $vec3::new(0.6, 0.8, 0.0).clamp_length(10.0, 20.0), 1385 $vec3::new(6.0, 8.0, 0.0) // lengthened to length 10.0 1386 ); 1387 should_glam_assert!({ $vec3::ONE.clamp_length(1.0, 0.0) }); 1388 }); 1389 1390 glam_test!(test_clamp_length_max, { 1391 // Too long gets shortened 1392 assert_eq!( 1393 $vec3::new(12.0, 16.0, 0.0).clamp_length_max(10.0), 1394 $vec3::new(6.0, 8.0, 0.0) // shortened to length 10.0 1395 ); 1396 // Not too long is unchanged 1397 assert_eq!( 1398 $vec3::new(2.0, 1.0, 0.0).clamp_length_max(5.0), 1399 $vec3::new(2.0, 1.0, 0.0) // unchanged 1400 ); 1401 }); 1402 1403 glam_test!(test_clamp_length_min, { 1404 // Not too short is unchanged 1405 assert_eq!( 1406 $vec3::new(2.0, 1.0, 0.0).clamp_length_min(0.5), 1407 $vec3::new(2.0, 1.0, 0.0) // unchanged 1408 ); 1409 // Too short gets lengthened 1410 assert_eq!( 1411 $vec3::new(0.6, 0.8, 0.0).clamp_length_min(10.0), 1412 $vec3::new(6.0, 8.0, 0.0) // lengthened to length 10.0 1413 ); 1414 }); 1415 1416 glam_test!(test_any_ortho, { 1417 let eps = 2.0 * $t::EPSILON; 1418 1419 for &v in &vec3_float_test_vectors!($vec3) { 1420 let orthogonal = v.any_orthogonal_vector(); 1421 assert!(orthogonal != $vec3::ZERO && orthogonal.is_finite()); 1422 assert!(v.dot(orthogonal).abs() < eps); 1423 1424 let n = v.normalize(); 1425 1426 let orthonormal = n.any_orthonormal_vector(); 1427 assert!(orthonormal.is_normalized()); 1428 assert!(n.dot(orthonormal).abs() < eps); 1429 1430 let (a, b) = n.any_orthonormal_pair(); 1431 assert!(a.is_normalized() && n.dot(a).abs() < eps); 1432 assert!(b.is_normalized() && n.dot(b).abs() < eps); 1433 } 1434 }); 1435 1436 glam_test!(test_mul_add, { 1437 assert_eq!( 1438 $vec3::new(1.0, 1.0, 1.0) 1439 .mul_add($vec3::new(0.5, 2.0, -4.0), $vec3::new(-1.0, -1.0, -1.0)), 1440 $vec3::new(-0.5, 1.0, -5.0) 1441 ); 1442 }); 1443 1444 glam_test!(test_fmt_float, { 1445 let a = $vec3::new(1.0, 2.0, 3.0); 1446 assert_eq!(format!("{:.2}", a), "[1.00, 2.00, 3.00]"); 1447 }); 1448 1449 glam_test!(test_reflect, { 1450 let incident = $vec3::new(1.0, -1.0, 1.0); 1451 let normal = $vec3::Y; 1452 assert_approx_eq!(incident.reflect(normal), $vec3::ONE); 1453 }); 1454 1455 glam_test!(test_refract, { 1456 let incident = $vec3::NEG_ONE.normalize(); 1457 let normal = $vec3::ONE.normalize(); 1458 assert_approx_eq!(incident.refract(normal, 0.5), incident); 1459 1460 let incident = $vec3::new(1.0, -1.0, 0.0).normalize(); 1461 let normal = $vec3::Y; 1462 assert_approx_eq!(incident.refract(normal, 1.5), $vec3::ZERO); 1463 }); 1464 }; 1465 } 1466 1467 macro_rules! impl_vec3_scalar_shift_op_test { 1468 ($vec3:ident, $t_min:literal, $t_max:literal, $rhs_min:literal, $rhs_max:literal) => { 1469 glam_test!(test_vec3_scalar_shift_ops, { 1470 for x in $t_min..$t_max { 1471 for y in $t_min..$t_max { 1472 for z in $t_min..$t_max { 1473 for rhs in $rhs_min..$rhs_max { 1474 assert_eq!( 1475 $vec3::new(x, y, z) << rhs, 1476 $vec3::new(x << rhs, y << rhs, z << rhs) 1477 ); 1478 assert_eq!( 1479 $vec3::new(x, y, z) >> rhs, 1480 $vec3::new(x >> rhs, y >> rhs, z >> rhs) 1481 ); 1482 } 1483 } 1484 } 1485 } 1486 }); 1487 }; 1488 } 1489 1490 macro_rules! impl_vec3_scalar_shift_op_tests { 1491 ($vec3:ident, $t_min:literal, $t_max:literal) => { 1492 mod shift_by_i8 { 1493 use glam::$vec3; 1494 impl_vec3_scalar_shift_op_test!($vec3, $t_min, $t_max, 0i8, 2); 1495 } 1496 mod shift_by_i16 { 1497 use glam::$vec3; 1498 impl_vec3_scalar_shift_op_test!($vec3, $t_min, $t_max, 0i16, 2); 1499 } 1500 mod shift_by_i32 { 1501 use glam::$vec3; 1502 impl_vec3_scalar_shift_op_test!($vec3, $t_min, $t_max, 0i32, 2); 1503 } 1504 mod shift_by_i64 { 1505 use glam::$vec3; 1506 impl_vec3_scalar_shift_op_test!($vec3, $t_min, $t_max, 0i64, 2); 1507 } 1508 mod shift_by_u8 { 1509 use glam::$vec3; 1510 impl_vec3_scalar_shift_op_test!($vec3, $t_min, $t_max, 0u8, 2); 1511 } 1512 mod shift_by_u16 { 1513 use glam::$vec3; 1514 impl_vec3_scalar_shift_op_test!($vec3, $t_min, $t_max, 0u16, 2); 1515 } 1516 mod shift_by_u32 { 1517 use glam::$vec3; 1518 impl_vec3_scalar_shift_op_test!($vec3, $t_min, $t_max, 0u32, 2); 1519 } 1520 mod shift_by_u64 { 1521 use glam::$vec3; 1522 impl_vec3_scalar_shift_op_test!($vec3, $t_min, $t_max, 0u64, 2); 1523 } 1524 }; 1525 } 1526 1527 macro_rules! impl_vec3_shift_op_test { 1528 ($vec3:ident, $rhs:ident, $t_min:literal, $t_max:literal) => { 1529 glam_test!(test_vec3_shift_ops, { 1530 for x1 in $t_min..$t_max { 1531 for y1 in $t_min..$t_max { 1532 for z1 in $t_min..$t_max { 1533 for x2 in $t_min..$t_max { 1534 for y2 in $t_min..$t_max { 1535 for z2 in $t_min..$t_max { 1536 assert_eq!( 1537 $vec3::new(x1, y1, z1) << $rhs::new(x2, y2, z2), 1538 $vec3::new(x1 << x2, y1 << y2, z1 << z2) 1539 ); 1540 assert_eq!( 1541 $vec3::new(x1, y1, z1) >> $rhs::new(x2, y2, z2), 1542 $vec3::new(x1 >> x2, y1 >> y2, z1 >> z2) 1543 ); 1544 } 1545 } 1546 } 1547 } 1548 } 1549 } 1550 }); 1551 }; 1552 } 1553 1554 macro_rules! impl_vec3_shift_op_tests { 1555 ($vec3:ident) => { 1556 mod shift_ivec3_by_ivec3 { 1557 use super::*; 1558 impl_vec3_shift_op_test!($vec3, IVec3, 0, 2); 1559 } 1560 mod shift_ivec3_by_uvec3 { 1561 use super::*; 1562 impl_vec3_shift_op_test!($vec3, UVec3, 0, 2); 1563 } 1564 }; 1565 } 1566 1567 macro_rules! impl_vec3_scalar_bit_op_tests { 1568 ($vec3:ident, $t_min:literal, $t_max:literal) => { 1569 glam_test!(test_vec3_scalar_bit_ops, { 1570 for x in $t_min..$t_max { 1571 for y in $t_min..$t_max { 1572 for z in $t_min..$t_max { 1573 for rhs in $t_min..$t_max { 1574 assert_eq!( 1575 $vec3::new(x, y, z) & rhs, 1576 $vec3::new(x & rhs, y & rhs, z & rhs) 1577 ); 1578 assert_eq!( 1579 $vec3::new(x, y, z) | rhs, 1580 $vec3::new(x | rhs, y | rhs, z | rhs) 1581 ); 1582 assert_eq!( 1583 $vec3::new(x, y, z) ^ rhs, 1584 $vec3::new(x ^ rhs, y ^ rhs, z ^ rhs) 1585 ); 1586 } 1587 } 1588 } 1589 } 1590 }); 1591 }; 1592 } 1593 1594 macro_rules! impl_vec3_bit_op_tests { 1595 ($vec3:ident, $t_min:literal, $t_max:literal) => { 1596 glam_test!(test_vec3_bit_ops, { 1597 for x1 in $t_min..$t_max { 1598 for y1 in $t_min..$t_max { 1599 for z1 in $t_min..$t_max { 1600 assert_eq!(!$vec3::new(x1, y1, z1), $vec3::new(!x1, !y1, !z1)); 1601 1602 for x2 in $t_min..$t_max { 1603 for y2 in $t_min..$t_max { 1604 for z2 in $t_min..$t_max { 1605 assert_eq!( 1606 $vec3::new(x1, y1, z1) & $vec3::new(x2, y2, z2), 1607 $vec3::new(x1 & x2, y1 & y2, z1 & z2) 1608 ); 1609 assert_eq!( 1610 $vec3::new(x1, y1, z1) | $vec3::new(x2, y2, z2), 1611 $vec3::new(x1 | x2, y1 | y2, z1 | z2) 1612 ); 1613 assert_eq!( 1614 $vec3::new(x1, y1, z1) ^ $vec3::new(x2, y2, z2), 1615 $vec3::new(x1 ^ x2, y1 ^ y2, z1 ^ z2) 1616 ); 1617 } 1618 } 1619 } 1620 } 1621 } 1622 } 1623 }); 1624 }; 1625 } 1626 1627 mod vec3 { 1628 use glam::{bvec3, vec3, BVec3, Vec3}; 1629 1630 glam_test!(test_align, { 1631 use std::mem; 1632 assert_eq!(12, mem::size_of::<Vec3>()); 1633 assert_eq!(4, mem::align_of::<Vec3>()); 1634 assert_eq!(3, mem::size_of::<BVec3>()); 1635 assert_eq!(1, mem::align_of::<BVec3>()); 1636 }); 1637 1638 glam_test!(test_as, { 1639 use glam::{ 1640 DVec3, I16Vec3, I64Vec3, I8Vec3, IVec3, U16Vec3, U64Vec3, U8Vec3, UVec3, Vec3A, 1641 }; 1642 assert_eq!( 1643 DVec3::new(-1.0, -2.0, -3.0), 1644 Vec3::new(-1.0, -2.0, -3.0).as_dvec3() 1645 ); 1646 assert_eq!( 1647 I8Vec3::new(-1, -2, -3), 1648 Vec3::new(-1.0, -2.0, -3.0).as_i8vec3() 1649 ); 1650 assert_eq!(U8Vec3::new(1, 2, 3), Vec3::new(1.0, 2.0, 3.0).as_u8vec3()); 1651 assert_eq!( 1652 I16Vec3::new(-1, -2, -3), 1653 Vec3::new(-1.0, -2.0, -3.0).as_i16vec3() 1654 ); 1655 assert_eq!(U16Vec3::new(1, 2, 3), Vec3::new(1.0, 2.0, 3.0).as_u16vec3()); 1656 assert_eq!( 1657 IVec3::new(-1, -2, -3), 1658 Vec3::new(-1.0, -2.0, -3.0).as_ivec3() 1659 ); 1660 assert_eq!(UVec3::new(1, 2, 3), Vec3::new(1.0, 2.0, 3.0).as_uvec3()); 1661 assert_eq!( 1662 I64Vec3::new(-1, -2, -3), 1663 Vec3::new(-1.0, -2.0, -3.0).as_i64vec3() 1664 ); 1665 assert_eq!(U64Vec3::new(1, 2, 3), Vec3::new(1.0, 2.0, 3.0).as_u64vec3()); 1666 1667 assert_eq!( 1668 DVec3::new(-1.0, -2.0, -3.0), 1669 Vec3A::new(-1.0, -2.0, -3.0).as_dvec3() 1670 ); 1671 assert_eq!( 1672 I8Vec3::new(-1, -2, -3), 1673 Vec3A::new(-1.0, -2.0, -3.0).as_i8vec3() 1674 ); 1675 assert_eq!(U8Vec3::new(1, 2, 3), Vec3A::new(1.0, 2.0, 3.0).as_u8vec3()); 1676 assert_eq!( 1677 I16Vec3::new(-1, -2, -3), 1678 Vec3A::new(-1.0, -2.0, -3.0).as_i16vec3() 1679 ); 1680 assert_eq!( 1681 U16Vec3::new(1, 2, 3), 1682 Vec3A::new(1.0, 2.0, 3.0).as_u16vec3() 1683 ); 1684 assert_eq!( 1685 IVec3::new(-1, -2, -3), 1686 Vec3A::new(-1.0, -2.0, -3.0).as_ivec3() 1687 ); 1688 assert_eq!(UVec3::new(1, 2, 3), Vec3A::new(1.0, 2.0, 3.0).as_uvec3()); 1689 assert_eq!( 1690 I64Vec3::new(-1, -2, -3), 1691 Vec3A::new(-1.0, -2.0, -3.0).as_i64vec3() 1692 ); 1693 assert_eq!( 1694 U64Vec3::new(1, 2, 3), 1695 Vec3A::new(1.0, 2.0, 3.0).as_u64vec3() 1696 ); 1697 1698 assert_eq!( 1699 I8Vec3::new(-1, -2, -3), 1700 DVec3::new(-1.0, -2.0, -3.0).as_i8vec3() 1701 ); 1702 assert_eq!(U8Vec3::new(1, 2, 3), DVec3::new(1.0, 2.0, 3.0).as_u8vec3()); 1703 assert_eq!( 1704 I16Vec3::new(-1, -2, -3), 1705 DVec3::new(-1.0, -2.0, -3.0).as_i16vec3() 1706 ); 1707 assert_eq!( 1708 U16Vec3::new(1, 2, 3), 1709 DVec3::new(1.0, 2.0, 3.0).as_u16vec3() 1710 ); 1711 assert_eq!( 1712 IVec3::new(-1, -2, -3), 1713 DVec3::new(-1.0, -2.0, -3.0).as_ivec3() 1714 ); 1715 assert_eq!(UVec3::new(1, 2, 3), DVec3::new(1.0, 2.0, 3.0).as_uvec3()); 1716 assert_eq!( 1717 I64Vec3::new(-1, -2, -3), 1718 DVec3::new(-1.0, -2.0, -3.0).as_i64vec3() 1719 ); 1720 assert_eq!( 1721 U64Vec3::new(1, 2, 3), 1722 DVec3::new(1.0, 2.0, 3.0).as_u64vec3() 1723 ); 1724 assert_eq!( 1725 Vec3::new(-1.0, -2.0, -3.0), 1726 DVec3::new(-1.0, -2.0, -3.0).as_vec3() 1727 ); 1728 assert_eq!( 1729 Vec3A::new(-1.0, -2.0, -3.0), 1730 DVec3::new(-1.0, -2.0, -3.0).as_vec3a() 1731 ); 1732 1733 assert_eq!( 1734 DVec3::new(-1.0, -2.0, -3.0), 1735 I8Vec3::new(-1, -2, -3).as_dvec3() 1736 ); 1737 assert_eq!(U8Vec3::new(1, 2, 3), I8Vec3::new(1, 2, 3).as_u8vec3()); 1738 assert_eq!( 1739 I16Vec3::new(-1, -2, -3), 1740 I8Vec3::new(-1, -2, -3).as_i16vec3() 1741 ); 1742 assert_eq!(U16Vec3::new(1, 2, 3), I8Vec3::new(1, 2, 3).as_u16vec3()); 1743 assert_eq!(IVec3::new(-1, -2, -3), I8Vec3::new(-1, -2, -3).as_ivec3()); 1744 assert_eq!(UVec3::new(1, 2, 3), I8Vec3::new(1, 2, 3).as_uvec3()); 1745 assert_eq!( 1746 I64Vec3::new(-1, -2, -3), 1747 I8Vec3::new(-1, -2, -3).as_i64vec3() 1748 ); 1749 assert_eq!(U64Vec3::new(1, 2, 3), I8Vec3::new(1, 2, 3).as_u64vec3()); 1750 assert_eq!( 1751 Vec3::new(-1.0, -2.0, -3.0), 1752 I8Vec3::new(-1, -2, -3).as_vec3() 1753 ); 1754 assert_eq!( 1755 Vec3A::new(-1.0, -2.0, -3.0), 1756 I8Vec3::new(-1, -2, -3).as_vec3a() 1757 ); 1758 1759 assert_eq!(DVec3::new(1.0, 2.0, 3.0), U8Vec3::new(1, 2, 3).as_dvec3()); 1760 assert_eq!(I8Vec3::new(1, 2, 3), U8Vec3::new(1, 2, 3).as_i8vec3()); 1761 assert_eq!(I16Vec3::new(1, 2, 3), U8Vec3::new(1, 2, 3).as_i16vec3()); 1762 assert_eq!(U16Vec3::new(1, 2, 3), U8Vec3::new(1, 2, 3).as_u16vec3()); 1763 assert_eq!(IVec3::new(1, 2, 3), U8Vec3::new(1, 2, 3).as_ivec3()); 1764 assert_eq!(UVec3::new(1, 2, 3), U8Vec3::new(1, 2, 3).as_uvec3()); 1765 assert_eq!(I64Vec3::new(1, 2, 3), U8Vec3::new(1, 2, 3).as_i64vec3()); 1766 assert_eq!(U64Vec3::new(1, 2, 3), U8Vec3::new(1, 2, 3).as_u64vec3()); 1767 assert_eq!(Vec3::new(1.0, 2.0, 3.0), U8Vec3::new(1, 2, 3).as_vec3()); 1768 assert_eq!(Vec3A::new(1.0, 2.0, 3.0), U8Vec3::new(1, 2, 3).as_vec3a()); 1769 1770 assert_eq!( 1771 DVec3::new(-1.0, -2.0, -3.0), 1772 I16Vec3::new(-1, -2, -3).as_dvec3() 1773 ); 1774 assert_eq!( 1775 I8Vec3::new(-1, -2, -3), 1776 I16Vec3::new(-1, -2, -3).as_i8vec3() 1777 ); 1778 assert_eq!(U8Vec3::new(1, 2, 3), I16Vec3::new(1, 2, 3).as_u8vec3()); 1779 assert_eq!(U16Vec3::new(1, 2, 3), I16Vec3::new(1, 2, 3).as_u16vec3()); 1780 assert_eq!(IVec3::new(-1, -2, -3), I16Vec3::new(-1, -2, -3).as_ivec3()); 1781 assert_eq!(UVec3::new(1, 2, 3), I16Vec3::new(1, 2, 3).as_uvec3()); 1782 assert_eq!( 1783 I64Vec3::new(-1, -2, -3), 1784 I16Vec3::new(-1, -2, -3).as_i64vec3() 1785 ); 1786 assert_eq!(U64Vec3::new(1, 2, 3), I16Vec3::new(1, 2, 3).as_u64vec3()); 1787 assert_eq!( 1788 Vec3::new(-1.0, -2.0, -3.0), 1789 I16Vec3::new(-1, -2, -3).as_vec3() 1790 ); 1791 assert_eq!( 1792 Vec3A::new(-1.0, -2.0, -3.0), 1793 I16Vec3::new(-1, -2, -3).as_vec3a() 1794 ); 1795 1796 assert_eq!(DVec3::new(1.0, 2.0, 3.0), U16Vec3::new(1, 2, 3).as_dvec3()); 1797 assert_eq!(I8Vec3::new(1, 2, 3), U16Vec3::new(1, 2, 3).as_i8vec3()); 1798 assert_eq!(U8Vec3::new(1, 2, 3), U16Vec3::new(1, 2, 3).as_u8vec3()); 1799 assert_eq!(I16Vec3::new(1, 2, 3), U16Vec3::new(1, 2, 3).as_i16vec3()); 1800 assert_eq!(IVec3::new(1, 2, 3), U16Vec3::new(1, 2, 3).as_ivec3()); 1801 assert_eq!(UVec3::new(1, 2, 3), U16Vec3::new(1, 2, 3).as_uvec3()); 1802 assert_eq!(I64Vec3::new(1, 2, 3), U16Vec3::new(1, 2, 3).as_i64vec3()); 1803 assert_eq!(U64Vec3::new(1, 2, 3), U16Vec3::new(1, 2, 3).as_u64vec3()); 1804 assert_eq!(Vec3::new(1.0, 2.0, 3.0), U16Vec3::new(1, 2, 3).as_vec3()); 1805 assert_eq!(Vec3A::new(1.0, 2.0, 3.0), U16Vec3::new(1, 2, 3).as_vec3a()); 1806 1807 assert_eq!( 1808 DVec3::new(-1.0, -2.0, -3.0), 1809 IVec3::new(-1, -2, -3).as_dvec3() 1810 ); 1811 assert_eq!(I8Vec3::new(-1, -2, -3), IVec3::new(-1, -2, -3).as_i8vec3()); 1812 assert_eq!(U8Vec3::new(1, 2, 3), IVec3::new(1, 2, 3).as_u8vec3()); 1813 assert_eq!( 1814 I16Vec3::new(-1, -2, -3), 1815 IVec3::new(-1, -2, -3).as_i16vec3() 1816 ); 1817 assert_eq!(U16Vec3::new(1, 2, 3), IVec3::new(1, 2, 3).as_u16vec3()); 1818 assert_eq!(UVec3::new(1, 2, 3), IVec3::new(1, 2, 3).as_uvec3()); 1819 assert_eq!( 1820 I64Vec3::new(-1, -2, -3), 1821 IVec3::new(-1, -2, -3).as_i64vec3() 1822 ); 1823 assert_eq!(U64Vec3::new(1, 2, 3), IVec3::new(1, 2, 3).as_u64vec3()); 1824 assert_eq!( 1825 Vec3::new(-1.0, -2.0, -3.0), 1826 IVec3::new(-1, -2, -3).as_vec3() 1827 ); 1828 assert_eq!( 1829 Vec3A::new(-1.0, -2.0, -3.0), 1830 IVec3::new(-1, -2, -3).as_vec3a() 1831 ); 1832 1833 assert_eq!(DVec3::new(1.0, 2.0, 3.0), UVec3::new(1, 2, 3).as_dvec3()); 1834 assert_eq!(I8Vec3::new(1, 2, 3), UVec3::new(1, 2, 3).as_i8vec3()); 1835 assert_eq!(U8Vec3::new(1, 2, 3), UVec3::new(1, 2, 3).as_u8vec3()); 1836 assert_eq!(I16Vec3::new(1, 2, 3), UVec3::new(1, 2, 3).as_i16vec3()); 1837 assert_eq!(U16Vec3::new(1, 2, 3), UVec3::new(1, 2, 3).as_u16vec3()); 1838 assert_eq!(IVec3::new(1, 2, 3), UVec3::new(1, 2, 3).as_ivec3()); 1839 assert_eq!(I64Vec3::new(1, 2, 3), UVec3::new(1, 2, 3).as_i64vec3()); 1840 assert_eq!(U64Vec3::new(1, 2, 3), UVec3::new(1, 2, 3).as_u64vec3()); 1841 assert_eq!(Vec3::new(1.0, 2.0, 3.0), UVec3::new(1, 2, 3).as_vec3()); 1842 assert_eq!(Vec3A::new(1.0, 2.0, 3.0), UVec3::new(1, 2, 3).as_vec3a()); 1843 1844 assert_eq!( 1845 DVec3::new(-1.0, -2.0, -3.0), 1846 I64Vec3::new(-1, -2, -3).as_dvec3() 1847 ); 1848 assert_eq!( 1849 I8Vec3::new(-1, -2, -3), 1850 I64Vec3::new(-1, -2, -3).as_i8vec3() 1851 ); 1852 assert_eq!(U8Vec3::new(1, 2, 3), I64Vec3::new(1, 2, 3).as_u8vec3()); 1853 assert_eq!(U16Vec3::new(1, 2, 3), I64Vec3::new(1, 2, 3).as_u16vec3()); 1854 assert_eq!( 1855 I16Vec3::new(-1, -2, -3), 1856 I64Vec3::new(-1, -2, -3).as_i16vec3() 1857 ); 1858 assert_eq!(UVec3::new(1, 2, 3), I64Vec3::new(1, 2, 3).as_uvec3()); 1859 assert_eq!(IVec3::new(-1, -2, -3), I64Vec3::new(-1, -2, -3).as_ivec3()); 1860 assert_eq!(U64Vec3::new(1, 2, 3), I64Vec3::new(1, 2, 3).as_u64vec3()); 1861 assert_eq!( 1862 Vec3::new(-1.0, -2.0, -3.0), 1863 I64Vec3::new(-1, -2, -3).as_vec3() 1864 ); 1865 assert_eq!( 1866 Vec3A::new(-1.0, -2.0, -3.0), 1867 I64Vec3::new(-1, -2, -3).as_vec3a() 1868 ); 1869 1870 assert_eq!(DVec3::new(1.0, 2.0, 3.0), U64Vec3::new(1, 2, 3).as_dvec3()); 1871 assert_eq!(I8Vec3::new(1, 2, 3), U64Vec3::new(1, 2, 3).as_i8vec3()); 1872 assert_eq!(U8Vec3::new(1, 2, 3), U64Vec3::new(1, 2, 3).as_u8vec3()); 1873 assert_eq!(I16Vec3::new(1, 2, 3), U64Vec3::new(1, 2, 3).as_i16vec3()); 1874 assert_eq!(U16Vec3::new(1, 2, 3), U64Vec3::new(1, 2, 3).as_u16vec3()); 1875 assert_eq!(IVec3::new(1, 2, 3), U64Vec3::new(1, 2, 3).as_ivec3()); 1876 assert_eq!(UVec3::new(1, 2, 3), U64Vec3::new(1, 2, 3).as_uvec3()); 1877 assert_eq!(I64Vec3::new(1, 2, 3), U64Vec3::new(1, 2, 3).as_i64vec3()); 1878 assert_eq!(Vec3::new(1.0, 2.0, 3.0), U64Vec3::new(1, 2, 3).as_vec3()); 1879 assert_eq!(Vec3A::new(1.0, 2.0, 3.0), U64Vec3::new(1, 2, 3).as_vec3a()); 1880 }); 1881 1882 impl_vec3_float_tests!(f32, vec3, Vec3, BVec3, bvec3); 1883 } 1884 1885 mod vec3a { 1886 use glam::{bvec3a, vec3a, BVec3A, Vec3A, Vec4}; 1887 1888 glam_test!(test_align, { 1889 use std::mem; 1890 assert_eq!(16, mem::size_of::<Vec3A>()); 1891 assert_eq!(16, mem::align_of::<Vec3A>()); 1892 assert_eq!(16, mem::size_of::<BVec3A>()); 1893 assert_eq!(16, mem::align_of::<BVec3A>()); 1894 }); 1895 1896 glam_test!(test_mask_align16, { 1897 // make sure the unused 'w' value doesn't break Vec3Ab behaviour 1898 let a = Vec4::ZERO; 1899 let mut b = Vec3A::from_vec4(a); 1900 b.x = 1.0; 1901 b.y = 1.0; 1902 b.z = 1.0; 1903 assert!(!b.cmpeq(Vec3A::ZERO).any()); 1904 assert!(b.cmpeq(Vec3A::splat(1.0)).all()); 1905 }); 1906 1907 #[cfg(all( 1908 target_feature = "sse2", 1909 not(any(feature = "core-simd", feature = "scalar-math")) 1910 ))] 1911 #[test] test_m128()1912 fn test_m128() { 1913 #[cfg(target_arch = "x86")] 1914 use core::arch::x86::*; 1915 #[cfg(target_arch = "x86_64")] 1916 use core::arch::x86_64::*; 1917 1918 #[repr(C, align(16))] 1919 struct F32x3_A16([f32; 3]); 1920 1921 let v0 = Vec3A::new(1.0, 2.0, 3.0); 1922 let m0: __m128 = v0.into(); 1923 let mut a0 = F32x3_A16([0.0, 0.0, 0.0]); 1924 unsafe { 1925 _mm_store_ps(a0.0.as_mut_ptr(), m0); 1926 } 1927 assert_eq!([1.0, 2.0, 3.0], a0.0); 1928 let v1 = Vec3A::from(m0); 1929 assert_eq!(v0, v1); 1930 1931 #[repr(C, align(16))] 1932 struct U32x3_A16([u32; 3]); 1933 1934 let v0 = BVec3A::new(true, false, true); 1935 let m0: __m128 = v0.into(); 1936 let mut a0 = U32x3_A16([1, 2, 3]); 1937 unsafe { 1938 _mm_store_ps(a0.0.as_mut_ptr() as *mut f32, m0); 1939 } 1940 assert_eq!([0xffffffff, 0, 0xffffffff], a0.0); 1941 } 1942 1943 glam_test!(test_min_max_from_vec4, { 1944 // checks that the 4th element is unused. 1945 let v1 = Vec3A::from_vec4(Vec4::new(1.0, 2.0, 3.0, 4.0)); 1946 assert_eq!(v1.max_element(), 3.0); 1947 let v2 = Vec3A::from_vec4(Vec4::new(4.0, 3.0, 2.0, 1.0)); 1948 assert_eq!(v2.min_element(), 2.0); 1949 }); 1950 1951 impl_vec3_float_tests!(f32, vec3a, Vec3A, BVec3A, bvec3a); 1952 } 1953 1954 mod dvec3 { 1955 use glam::{bvec3, dvec3, BVec3, DVec3, IVec3, UVec3, Vec3}; 1956 1957 glam_test!(test_align, { 1958 use std::mem; 1959 assert_eq!(24, mem::size_of::<DVec3>()); 1960 assert_eq!(mem::align_of::<f64>(), mem::align_of::<DVec3>()); 1961 assert_eq!(3, mem::size_of::<BVec3>()); 1962 assert_eq!(1, mem::align_of::<BVec3>()); 1963 }); 1964 1965 glam_test!(test_try_from, { 1966 assert_eq!( 1967 DVec3::new(1.0, 2.0, 3.0), 1968 DVec3::from(Vec3::new(1.0, 2.0, 3.0)) 1969 ); 1970 assert_eq!(DVec3::new(1.0, 2.0, 3.0), DVec3::from(IVec3::new(1, 2, 3))); 1971 assert_eq!(DVec3::new(1.0, 2.0, 3.0), DVec3::from(UVec3::new(1, 2, 3))); 1972 }); 1973 1974 impl_vec3_float_tests!(f64, dvec3, DVec3, BVec3, bvec3); 1975 } 1976 1977 mod i8vec3 { 1978 use glam::{ 1979 bvec3, i8vec3, BVec3, I16Vec3, I64Vec3, I8Vec3, IVec3, U16Vec3, U64Vec3, U8Vec3, UVec3, 1980 }; 1981 1982 glam_test!(test_align, { 1983 use std::mem; 1984 assert_eq!(3, mem::size_of::<I8Vec3>()); 1985 assert_eq!(1, mem::align_of::<I8Vec3>()); 1986 }); 1987 1988 glam_test!(test_try_from, { 1989 assert_eq!( 1990 I8Vec3::new(1, 2, 3), 1991 I8Vec3::try_from(U8Vec3::new(1, 2, 3)).unwrap() 1992 ); 1993 assert!(I8Vec3::try_from(U8Vec3::new(u8::MAX, 2, 3)).is_err()); 1994 assert!(I8Vec3::try_from(U8Vec3::new(1, u8::MAX, 3)).is_err()); 1995 assert!(I8Vec3::try_from(U8Vec3::new(1, 2, u8::MAX)).is_err()); 1996 1997 assert_eq!( 1998 I8Vec3::new(1, 2, 3), 1999 I8Vec3::try_from(I16Vec3::new(1, 2, 3)).unwrap() 2000 ); 2001 assert!(I8Vec3::try_from(I16Vec3::new(i16::MAX, 2, 3)).is_err()); 2002 assert!(I8Vec3::try_from(I16Vec3::new(1, i16::MAX, 3)).is_err()); 2003 assert!(I8Vec3::try_from(I16Vec3::new(1, 2, i16::MAX)).is_err()); 2004 2005 assert_eq!( 2006 I8Vec3::new(1, 2, 3), 2007 I8Vec3::try_from(U16Vec3::new(1, 2, 3)).unwrap() 2008 ); 2009 assert!(I8Vec3::try_from(U16Vec3::new(u16::MAX, 2, 3)).is_err()); 2010 assert!(I8Vec3::try_from(U16Vec3::new(1, u16::MAX, 3)).is_err()); 2011 assert!(I8Vec3::try_from(U16Vec3::new(1, 2, u16::MAX)).is_err()); 2012 2013 assert_eq!( 2014 I8Vec3::new(1, 2, 3), 2015 I8Vec3::try_from(IVec3::new(1, 2, 3)).unwrap() 2016 ); 2017 assert!(I8Vec3::try_from(IVec3::new(i32::MAX, 2, 3)).is_err()); 2018 assert!(I8Vec3::try_from(IVec3::new(1, i32::MAX, 3)).is_err()); 2019 assert!(I8Vec3::try_from(IVec3::new(1, 2, i32::MAX)).is_err()); 2020 2021 assert_eq!( 2022 I8Vec3::new(1, 2, 3), 2023 I8Vec3::try_from(UVec3::new(1, 2, 3)).unwrap() 2024 ); 2025 assert!(I8Vec3::try_from(UVec3::new(u32::MAX, 2, 3)).is_err()); 2026 assert!(I8Vec3::try_from(UVec3::new(1, u32::MAX, 3)).is_err()); 2027 assert!(I8Vec3::try_from(UVec3::new(1, 2, u32::MAX)).is_err()); 2028 2029 assert_eq!( 2030 I8Vec3::new(1, 2, 3), 2031 I8Vec3::try_from(I64Vec3::new(1, 2, 3)).unwrap() 2032 ); 2033 assert!(I8Vec3::try_from(I64Vec3::new(i64::MAX, 2, 3)).is_err()); 2034 assert!(I8Vec3::try_from(I64Vec3::new(1, i64::MAX, 3)).is_err()); 2035 assert!(I8Vec3::try_from(I64Vec3::new(1, 2, i64::MAX)).is_err()); 2036 2037 assert_eq!( 2038 I8Vec3::new(1, 2, 3), 2039 I8Vec3::try_from(U64Vec3::new(1, 2, 3)).unwrap() 2040 ); 2041 assert!(I8Vec3::try_from(U64Vec3::new(u64::MAX, 2, 3)).is_err()); 2042 assert!(I8Vec3::try_from(U64Vec3::new(1, u64::MAX, 3)).is_err()); 2043 assert!(I8Vec3::try_from(U64Vec3::new(1, 2, u64::MAX)).is_err()); 2044 }); 2045 2046 glam_test!(test_wrapping_add, { 2047 assert_eq!( 2048 I8Vec3::new(i8::MAX, 5, i8::MIN).wrapping_add(I8Vec3::new(1, 3, i8::MAX)), 2049 I8Vec3::new(i8::MIN, 8, -1), 2050 ); 2051 }); 2052 2053 glam_test!(test_wrapping_sub, { 2054 assert_eq!( 2055 I8Vec3::new(i8::MAX, 5, i8::MIN).wrapping_sub(I8Vec3::new(1, 3, i8::MAX)), 2056 I8Vec3::new(126, 2, 1), 2057 ); 2058 }); 2059 2060 glam_test!(test_wrapping_mul, { 2061 assert_eq!( 2062 I8Vec3::new(i8::MAX, 5, i8::MIN).wrapping_mul(I8Vec3::new(3, 3, 5)), 2063 I8Vec3::new(125, 15, -128) 2064 ); 2065 }); 2066 2067 glam_test!(test_wrapping_div, { 2068 assert_eq!( 2069 I8Vec3::new(i8::MAX, 5, i8::MIN).wrapping_div(I8Vec3::new(3, 3, 5)), 2070 I8Vec3::new(42, 1, -25) 2071 ); 2072 }); 2073 2074 glam_test!(test_saturating_add, { 2075 assert_eq!( 2076 I8Vec3::new(i8::MAX, i8::MIN, 0).saturating_add(I8Vec3::new(1, -1, 2)), 2077 I8Vec3::new(i8::MAX, i8::MIN, 2) 2078 ); 2079 }); 2080 2081 glam_test!(test_saturating_sub, { 2082 assert_eq!( 2083 I8Vec3::new(i8::MIN, i8::MAX, 0).saturating_sub(I8Vec3::new(1, -1, 2)), 2084 I8Vec3::new(i8::MIN, i8::MAX, -2) 2085 ); 2086 }); 2087 2088 glam_test!(test_saturating_mul, { 2089 assert_eq!( 2090 I8Vec3::new(i8::MAX, i8::MIN, 0).saturating_mul(I8Vec3::new(2, 2, 0)), 2091 I8Vec3::new(i8::MAX, i8::MIN, 0) 2092 ); 2093 }); 2094 2095 glam_test!(test_saturating_div, { 2096 assert_eq!( 2097 I8Vec3::new(i8::MAX, i8::MIN, 0).saturating_div(I8Vec3::new(2, 2, 3)), 2098 I8Vec3::new(63, -64, 0) 2099 ); 2100 }); 2101 2102 glam_test!(test_checked_add_unsigned, { 2103 assert_eq!(I8Vec3::MAX.checked_add_unsigned(U8Vec3::ONE), None); 2104 assert_eq!( 2105 I8Vec3::NEG_ONE.checked_add_unsigned(U8Vec3::ONE), 2106 Some(I8Vec3::ZERO) 2107 ); 2108 }); 2109 2110 glam_test!(test_checked_sub_unsigned, { 2111 assert_eq!(I8Vec3::MIN.checked_sub_unsigned(U8Vec3::ONE), None); 2112 assert_eq!( 2113 I8Vec3::ZERO.checked_sub_unsigned(U8Vec3::ONE), 2114 Some(I8Vec3::NEG_ONE) 2115 ); 2116 }); 2117 2118 glam_test!(test_wrapping_add_unsigned, { 2119 assert_eq!( 2120 I8Vec3::new(i8::MAX, i8::MAX, i8::MAX).wrapping_add_unsigned(U8Vec3::new(1, 1, 1)), 2121 I8Vec3::new(i8::MIN, i8::MIN, i8::MIN) 2122 ); 2123 }); 2124 2125 glam_test!(test_wrapping_sub_unsigned, { 2126 assert_eq!( 2127 I8Vec3::new(i8::MIN, i8::MIN, i8::MIN).wrapping_sub_unsigned(U8Vec3::new(1, 1, 1)), 2128 I8Vec3::new(i8::MAX, i8::MAX, i8::MAX) 2129 ); 2130 }); 2131 2132 glam_test!(test_saturating_add_unsigned, { 2133 assert_eq!( 2134 I8Vec3::new(i8::MAX, i8::MAX, i8::MAX).saturating_add_unsigned(U8Vec3::new(1, 1, 1)), 2135 I8Vec3::new(i8::MAX, i8::MAX, i8::MAX) 2136 ); 2137 }); 2138 2139 glam_test!(test_saturating_sub_unsigned, { 2140 assert_eq!( 2141 I8Vec3::new(i8::MIN, i8::MIN, i8::MIN).saturating_sub_unsigned(U8Vec3::new(1, 1, 1)), 2142 I8Vec3::new(i8::MIN, i8::MIN, i8::MIN) 2143 ); 2144 }); 2145 2146 impl_vec3_signed_integer_tests!(i8, i8vec3, I8Vec3, BVec3, bvec3); 2147 impl_vec3_eq_hash_tests!(i8, i8vec3); 2148 2149 impl_vec3_scalar_shift_op_tests!(I8Vec3, -2, 2); 2150 impl_vec3_shift_op_tests!(I8Vec3); 2151 2152 impl_vec3_scalar_bit_op_tests!(I8Vec3, -2, 2); 2153 impl_vec3_bit_op_tests!(I8Vec3, -2, 2); 2154 } 2155 2156 mod u8vec3 { 2157 use glam::{ 2158 bvec3, u8vec3, BVec3, I16Vec3, I64Vec3, I8Vec3, IVec3, U16Vec3, U64Vec3, U8Vec3, UVec3, 2159 }; 2160 2161 glam_test!(test_align, { 2162 use std::mem; 2163 assert_eq!(3, mem::size_of::<U8Vec3>()); 2164 assert_eq!(1, mem::align_of::<U8Vec3>()); 2165 }); 2166 2167 glam_test!(test_try_from, { 2168 assert_eq!( 2169 U8Vec3::new(1, 2, 3), 2170 U8Vec3::try_from(I8Vec3::new(1, 2, 3)).unwrap() 2171 ); 2172 assert!(U8Vec3::try_from(I8Vec3::new(-1, 2, 3)).is_err()); 2173 assert!(U8Vec3::try_from(I8Vec3::new(1, -2, 3)).is_err()); 2174 assert!(U8Vec3::try_from(I8Vec3::new(1, 2, -3)).is_err()); 2175 2176 assert_eq!( 2177 U8Vec3::new(1, 2, 3), 2178 U8Vec3::try_from(I16Vec3::new(1, 2, 3)).unwrap() 2179 ); 2180 assert!(U8Vec3::try_from(I16Vec3::new(-1, 2, 3)).is_err()); 2181 assert!(U8Vec3::try_from(I16Vec3::new(1, -2, 3)).is_err()); 2182 assert!(U8Vec3::try_from(I16Vec3::new(1, 2, -3)).is_err()); 2183 2184 assert!(U8Vec3::try_from(I16Vec3::new(i16::MAX, 2, 3)).is_err()); 2185 assert!(U8Vec3::try_from(I16Vec3::new(1, i16::MAX, 3)).is_err()); 2186 assert!(U8Vec3::try_from(I16Vec3::new(1, 2, i16::MAX)).is_err()); 2187 2188 assert_eq!( 2189 U8Vec3::new(1, 2, 3), 2190 U8Vec3::try_from(U16Vec3::new(1, 2, 3)).unwrap() 2191 ); 2192 assert!(U8Vec3::try_from(U16Vec3::new(u16::MAX, 2, 3)).is_err()); 2193 assert!(U8Vec3::try_from(U16Vec3::new(1, u16::MAX, 3)).is_err()); 2194 assert!(U8Vec3::try_from(U16Vec3::new(1, 2, u16::MAX)).is_err()); 2195 2196 assert_eq!( 2197 U8Vec3::new(1, 2, 3), 2198 U8Vec3::try_from(IVec3::new(1, 2, 3)).unwrap() 2199 ); 2200 assert!(U8Vec3::try_from(IVec3::new(-1, 2, 3)).is_err()); 2201 assert!(U8Vec3::try_from(IVec3::new(1, -2, 3)).is_err()); 2202 assert!(U8Vec3::try_from(IVec3::new(1, 2, -3)).is_err()); 2203 2204 assert!(U8Vec3::try_from(IVec3::new(i32::MAX, 2, 3)).is_err()); 2205 assert!(U8Vec3::try_from(IVec3::new(1, i32::MAX, 3)).is_err()); 2206 assert!(U8Vec3::try_from(IVec3::new(1, 2, i32::MAX)).is_err()); 2207 2208 assert_eq!( 2209 U8Vec3::new(1, 2, 3), 2210 U8Vec3::try_from(UVec3::new(1, 2, 3)).unwrap() 2211 ); 2212 assert!(U8Vec3::try_from(UVec3::new(u32::MAX, 2, 3)).is_err()); 2213 assert!(U8Vec3::try_from(UVec3::new(1, u32::MAX, 3)).is_err()); 2214 assert!(U8Vec3::try_from(UVec3::new(1, 2, u32::MAX)).is_err()); 2215 2216 assert_eq!( 2217 U8Vec3::new(1, 2, 3), 2218 U8Vec3::try_from(I64Vec3::new(1, 2, 3)).unwrap() 2219 ); 2220 assert!(U8Vec3::try_from(I64Vec3::new(-1, 2, 3)).is_err()); 2221 assert!(U8Vec3::try_from(I64Vec3::new(1, -2, 3)).is_err()); 2222 assert!(U8Vec3::try_from(I64Vec3::new(1, 2, -3)).is_err()); 2223 2224 assert!(U8Vec3::try_from(I64Vec3::new(i64::MAX, 2, 3)).is_err()); 2225 assert!(U8Vec3::try_from(I64Vec3::new(1, i64::MAX, 3)).is_err()); 2226 assert!(U8Vec3::try_from(I64Vec3::new(1, 2, i64::MAX)).is_err()); 2227 2228 assert_eq!( 2229 U8Vec3::new(1, 2, 3), 2230 U8Vec3::try_from(U64Vec3::new(1, 2, 3)).unwrap() 2231 ); 2232 assert!(U8Vec3::try_from(U64Vec3::new(u64::MAX, 2, 3)).is_err()); 2233 assert!(U8Vec3::try_from(U64Vec3::new(1, u64::MAX, 3)).is_err()); 2234 assert!(U8Vec3::try_from(U64Vec3::new(1, 2, u64::MAX)).is_err()); 2235 }); 2236 2237 glam_test!(test_wrapping_add, { 2238 assert_eq!( 2239 U8Vec3::new(u8::MAX, 5, u8::MAX).wrapping_add(U8Vec3::new(1, 3, u8::MAX)), 2240 U8Vec3::new(0, 8, 254), 2241 ); 2242 }); 2243 2244 glam_test!(test_wrapping_sub, { 2245 assert_eq!( 2246 U8Vec3::new(u8::MAX, 5, u8::MAX - 1).wrapping_sub(U8Vec3::new(1, 3, u8::MAX)), 2247 U8Vec3::new(254, 2, 255) 2248 ); 2249 }); 2250 2251 glam_test!(test_wrapping_mul, { 2252 assert_eq!( 2253 U8Vec3::new(u8::MAX, 5, u8::MAX).wrapping_mul(U8Vec3::new(3, 3, 5)), 2254 U8Vec3::new(253, 15, 251) 2255 ); 2256 }); 2257 2258 glam_test!(test_wrapping_div, { 2259 assert_eq!( 2260 U8Vec3::new(u8::MAX, 5, u8::MAX).wrapping_div(U8Vec3::new(3, 3, 5)), 2261 U8Vec3::new(85, 1, 51) 2262 ); 2263 }); 2264 2265 glam_test!(test_saturating_add, { 2266 assert_eq!( 2267 U8Vec3::new(u8::MAX, u8::MAX, 0).saturating_add(U8Vec3::new(1, u8::MAX, 2)), 2268 U8Vec3::new(u8::MAX, u8::MAX, 2) 2269 ); 2270 }); 2271 2272 glam_test!(test_saturating_sub, { 2273 assert_eq!( 2274 U8Vec3::new(0, u8::MAX, 0).saturating_sub(U8Vec3::new(1, 1, 2)), 2275 U8Vec3::new(0, 254, 0) 2276 ); 2277 }); 2278 2279 glam_test!(test_saturating_mul, { 2280 assert_eq!( 2281 U8Vec3::new(u8::MAX, u8::MAX, 0).saturating_mul(U8Vec3::new(2, u8::MAX, 0)), 2282 U8Vec3::new(u8::MAX, u8::MAX, 0) 2283 ); 2284 }); 2285 2286 glam_test!(test_saturating_div, { 2287 assert_eq!( 2288 U8Vec3::new(u8::MAX, u8::MAX, 0).saturating_div(U8Vec3::new(2, u8::MAX, 3)), 2289 U8Vec3::new(127, 1, 0) 2290 ); 2291 }); 2292 2293 glam_test!(test_wrapping_add_signed, { 2294 assert_eq!( 2295 U8Vec3::new(u8::MAX, u8::MAX, u8::MAX).wrapping_add_signed(I8Vec3::new(1, 1, 1)), 2296 U8Vec3::new(u8::MIN, u8::MIN, u8::MIN) 2297 ); 2298 }); 2299 2300 glam_test!(test_saturating_add_signed, { 2301 assert_eq!( 2302 U8Vec3::new(u8::MAX, u8::MAX, u8::MAX).saturating_add_signed(I8Vec3::new(1, 1, 1)), 2303 U8Vec3::new(u8::MAX, u8::MAX, u8::MAX) 2304 ); 2305 }); 2306 2307 impl_vec3_unsigned_integer_tests!(u8, u8vec3, U8Vec3, BVec3, bvec3); 2308 impl_vec3_eq_hash_tests!(u8, u8vec3); 2309 2310 impl_vec3_scalar_shift_op_tests!(U8Vec3, 0, 2); 2311 impl_vec3_shift_op_tests!(U8Vec3); 2312 2313 impl_vec3_scalar_bit_op_tests!(U8Vec3, 0, 2); 2314 impl_vec3_bit_op_tests!(U8Vec3, 0, 2); 2315 } 2316 2317 mod i16vec3 { 2318 use glam::{ 2319 bvec3, i16vec3, BVec3, I16Vec3, I64Vec3, I8Vec3, IVec3, U16Vec3, U64Vec3, U8Vec3, UVec3, 2320 }; 2321 2322 glam_test!(test_align, { 2323 use std::mem; 2324 assert_eq!(6, mem::size_of::<I16Vec3>()); 2325 assert_eq!(2, mem::align_of::<I16Vec3>()); 2326 }); 2327 2328 glam_test!(test_try_from, { 2329 assert_eq!(I16Vec3::new(1, 2, 3), I16Vec3::from(U8Vec3::new(1, 2, 3))); 2330 assert_eq!(I16Vec3::new(1, 2, 3), I16Vec3::from(I8Vec3::new(1, 2, 3))); 2331 2332 assert_eq!( 2333 I16Vec3::new(1, 2, 3), 2334 I16Vec3::try_from(U16Vec3::new(1, 2, 3)).unwrap() 2335 ); 2336 assert!(I16Vec3::try_from(U16Vec3::new(u16::MAX, 2, 3)).is_err()); 2337 assert!(I16Vec3::try_from(U16Vec3::new(1, u16::MAX, 3)).is_err()); 2338 assert!(I16Vec3::try_from(U16Vec3::new(1, 2, u16::MAX)).is_err()); 2339 2340 assert_eq!( 2341 I16Vec3::new(1, 2, 3), 2342 I16Vec3::try_from(IVec3::new(1, 2, 3)).unwrap() 2343 ); 2344 assert!(I16Vec3::try_from(IVec3::new(i32::MAX, 2, 3)).is_err()); 2345 assert!(I16Vec3::try_from(IVec3::new(1, i32::MAX, 3)).is_err()); 2346 assert!(I16Vec3::try_from(IVec3::new(1, 2, i32::MAX)).is_err()); 2347 2348 assert_eq!( 2349 I16Vec3::new(1, 2, 3), 2350 I16Vec3::try_from(UVec3::new(1, 2, 3)).unwrap() 2351 ); 2352 assert!(I16Vec3::try_from(UVec3::new(u32::MAX, 2, 3)).is_err()); 2353 assert!(I16Vec3::try_from(UVec3::new(1, u32::MAX, 3)).is_err()); 2354 assert!(I16Vec3::try_from(UVec3::new(1, 2, u32::MAX)).is_err()); 2355 2356 assert_eq!( 2357 I16Vec3::new(1, 2, 3), 2358 I16Vec3::try_from(I64Vec3::new(1, 2, 3)).unwrap() 2359 ); 2360 assert!(I16Vec3::try_from(I64Vec3::new(i64::MAX, 2, 3)).is_err()); 2361 assert!(I16Vec3::try_from(I64Vec3::new(1, i64::MAX, 3)).is_err()); 2362 assert!(I16Vec3::try_from(I64Vec3::new(1, 2, i64::MAX)).is_err()); 2363 2364 assert_eq!( 2365 I16Vec3::new(1, 2, 3), 2366 I16Vec3::try_from(U64Vec3::new(1, 2, 3)).unwrap() 2367 ); 2368 assert!(I16Vec3::try_from(U64Vec3::new(u64::MAX, 2, 3)).is_err()); 2369 assert!(I16Vec3::try_from(U64Vec3::new(1, u64::MAX, 3)).is_err()); 2370 assert!(I16Vec3::try_from(U64Vec3::new(1, 2, u64::MAX)).is_err()); 2371 }); 2372 2373 glam_test!(test_wrapping_add, { 2374 assert_eq!( 2375 I16Vec3::new(i16::MAX, 5, i16::MIN).wrapping_add(I16Vec3::new(1, 3, i16::MAX)), 2376 I16Vec3::new(i16::MIN, 8, -1), 2377 ); 2378 }); 2379 2380 glam_test!(test_wrapping_sub, { 2381 assert_eq!( 2382 I16Vec3::new(i16::MAX, 5, i16::MIN).wrapping_sub(I16Vec3::new(1, 3, i16::MAX)), 2383 I16Vec3::new(32766, 2, 1), 2384 ); 2385 }); 2386 2387 glam_test!(test_wrapping_mul, { 2388 assert_eq!( 2389 I16Vec3::new(i16::MAX, 5, i16::MIN).wrapping_mul(I16Vec3::new(3, 3, 5)), 2390 I16Vec3::new(32765, 15, -32768) 2391 ); 2392 }); 2393 2394 glam_test!(test_wrapping_div, { 2395 assert_eq!( 2396 I16Vec3::new(i16::MAX, 5, i16::MIN).wrapping_div(I16Vec3::new(3, 3, 5)), 2397 I16Vec3::new(10922, 1, -6553) 2398 ); 2399 }); 2400 2401 glam_test!(test_saturating_add, { 2402 assert_eq!( 2403 I16Vec3::new(i16::MAX, i16::MIN, 0).saturating_add(I16Vec3::new(1, -1, 2)), 2404 I16Vec3::new(i16::MAX, i16::MIN, 2) 2405 ); 2406 }); 2407 2408 glam_test!(test_saturating_sub, { 2409 assert_eq!( 2410 I16Vec3::new(i16::MIN, i16::MAX, 0).saturating_sub(I16Vec3::new(1, -1, 2)), 2411 I16Vec3::new(i16::MIN, i16::MAX, -2) 2412 ); 2413 }); 2414 2415 glam_test!(test_saturating_mul, { 2416 assert_eq!( 2417 I16Vec3::new(i16::MAX, i16::MIN, 0).saturating_mul(I16Vec3::new(2, 2, 0)), 2418 I16Vec3::new(i16::MAX, i16::MIN, 0) 2419 ); 2420 }); 2421 2422 glam_test!(test_saturating_div, { 2423 assert_eq!( 2424 I16Vec3::new(i16::MAX, i16::MIN, 0).saturating_div(I16Vec3::new(2, 2, 3)), 2425 I16Vec3::new(16383, -16384, 0) 2426 ); 2427 }); 2428 2429 glam_test!(test_checked_add_unsigned, { 2430 assert_eq!(I16Vec3::MAX.checked_add_unsigned(U16Vec3::ONE), None); 2431 assert_eq!( 2432 I16Vec3::NEG_ONE.checked_add_unsigned(U16Vec3::ONE), 2433 Some(I16Vec3::ZERO) 2434 ); 2435 }); 2436 2437 glam_test!(test_checked_sub_unsigned, { 2438 assert_eq!(I16Vec3::MIN.checked_sub_unsigned(U16Vec3::ONE), None); 2439 assert_eq!( 2440 I16Vec3::ZERO.checked_sub_unsigned(U16Vec3::ONE), 2441 Some(I16Vec3::NEG_ONE) 2442 ); 2443 }); 2444 2445 glam_test!(test_wrapping_add_unsigned, { 2446 assert_eq!( 2447 I16Vec3::new(i16::MAX, i16::MAX, i16::MAX).wrapping_add_unsigned(U16Vec3::new(1, 1, 1)), 2448 I16Vec3::new(i16::MIN, i16::MIN, i16::MIN) 2449 ); 2450 }); 2451 2452 glam_test!(test_wrapping_sub_unsigned, { 2453 assert_eq!( 2454 I16Vec3::new(i16::MIN, i16::MIN, i16::MIN).wrapping_sub_unsigned(U16Vec3::new(1, 1, 1)), 2455 I16Vec3::new(i16::MAX, i16::MAX, i16::MAX) 2456 ); 2457 }); 2458 2459 glam_test!(test_saturating_add_unsigned, { 2460 assert_eq!( 2461 I16Vec3::new(i16::MAX, i16::MAX, i16::MAX) 2462 .saturating_add_unsigned(U16Vec3::new(1, 1, 1)), 2463 I16Vec3::new(i16::MAX, i16::MAX, i16::MAX) 2464 ); 2465 }); 2466 2467 glam_test!(test_saturating_sub_unsigned, { 2468 assert_eq!( 2469 I16Vec3::new(i16::MIN, i16::MIN, i16::MIN) 2470 .saturating_sub_unsigned(U16Vec3::new(1, 1, 1)), 2471 I16Vec3::new(i16::MIN, i16::MIN, i16::MIN) 2472 ); 2473 }); 2474 2475 impl_vec3_signed_integer_tests!(i16, i16vec3, I16Vec3, BVec3, bvec3); 2476 impl_vec3_eq_hash_tests!(i16, i16vec3); 2477 2478 impl_vec3_scalar_shift_op_tests!(I16Vec3, -2, 2); 2479 impl_vec3_shift_op_tests!(I16Vec3); 2480 2481 impl_vec3_scalar_bit_op_tests!(I16Vec3, -2, 2); 2482 impl_vec3_bit_op_tests!(I16Vec3, -2, 2); 2483 } 2484 2485 mod u16vec3 { 2486 use glam::{ 2487 bvec3, u16vec3, BVec3, I16Vec3, I64Vec3, I8Vec3, IVec3, U16Vec3, U64Vec3, U8Vec3, UVec3, 2488 }; 2489 2490 glam_test!(test_align, { 2491 use std::mem; 2492 assert_eq!(6, mem::size_of::<U16Vec3>()); 2493 assert_eq!(2, mem::align_of::<U16Vec3>()); 2494 }); 2495 2496 glam_test!(test_try_from, { 2497 assert_eq!( 2498 U16Vec3::new(1, 2, 3), 2499 U16Vec3::try_from(I8Vec3::new(1, 2, 3)).unwrap() 2500 ); 2501 assert!(U16Vec3::try_from(I8Vec3::new(-1, 2, 3)).is_err()); 2502 assert!(U16Vec3::try_from(I8Vec3::new(1, -2, 3)).is_err()); 2503 assert!(U16Vec3::try_from(I8Vec3::new(1, 2, -3)).is_err()); 2504 2505 assert_eq!(U16Vec3::new(1, 2, 3), U16Vec3::from(U8Vec3::new(1, 2, 3))); 2506 2507 assert_eq!( 2508 U16Vec3::new(1, 2, 3), 2509 U16Vec3::try_from(I16Vec3::new(1, 2, 3)).unwrap() 2510 ); 2511 assert!(U16Vec3::try_from(I16Vec3::new(-1, 2, 3)).is_err()); 2512 assert!(U16Vec3::try_from(I16Vec3::new(1, -2, 3)).is_err()); 2513 assert!(U16Vec3::try_from(I16Vec3::new(1, 2, -3)).is_err()); 2514 2515 assert_eq!( 2516 U16Vec3::new(1, 2, 3), 2517 U16Vec3::try_from(IVec3::new(1, 2, 3)).unwrap() 2518 ); 2519 assert!(U16Vec3::try_from(IVec3::new(-1, 2, 3)).is_err()); 2520 assert!(U16Vec3::try_from(IVec3::new(1, -2, 3)).is_err()); 2521 assert!(U16Vec3::try_from(IVec3::new(1, 2, -3)).is_err()); 2522 2523 assert!(U16Vec3::try_from(IVec3::new(i32::MAX, 2, 3)).is_err()); 2524 assert!(U16Vec3::try_from(IVec3::new(1, i32::MAX, 3)).is_err()); 2525 assert!(U16Vec3::try_from(IVec3::new(1, 2, i32::MAX)).is_err()); 2526 2527 assert_eq!( 2528 U16Vec3::new(1, 2, 3), 2529 U16Vec3::try_from(UVec3::new(1, 2, 3)).unwrap() 2530 ); 2531 assert!(U16Vec3::try_from(UVec3::new(u32::MAX, 2, 3)).is_err()); 2532 assert!(U16Vec3::try_from(UVec3::new(1, u32::MAX, 3)).is_err()); 2533 assert!(U16Vec3::try_from(UVec3::new(1, 2, u32::MAX)).is_err()); 2534 2535 assert_eq!( 2536 U16Vec3::new(1, 2, 3), 2537 U16Vec3::try_from(I64Vec3::new(1, 2, 3)).unwrap() 2538 ); 2539 assert!(U16Vec3::try_from(I64Vec3::new(-1, 2, 3)).is_err()); 2540 assert!(U16Vec3::try_from(I64Vec3::new(1, -2, 3)).is_err()); 2541 assert!(U16Vec3::try_from(I64Vec3::new(1, 2, -3)).is_err()); 2542 2543 assert!(U16Vec3::try_from(I64Vec3::new(i64::MAX, 2, 3)).is_err()); 2544 assert!(U16Vec3::try_from(I64Vec3::new(1, i64::MAX, 3)).is_err()); 2545 assert!(U16Vec3::try_from(I64Vec3::new(1, 2, i64::MAX)).is_err()); 2546 2547 assert_eq!( 2548 U16Vec3::new(1, 2, 3), 2549 U16Vec3::try_from(U64Vec3::new(1, 2, 3)).unwrap() 2550 ); 2551 assert!(U16Vec3::try_from(U64Vec3::new(u64::MAX, 2, 3)).is_err()); 2552 assert!(U16Vec3::try_from(U64Vec3::new(1, u64::MAX, 3)).is_err()); 2553 assert!(U16Vec3::try_from(U64Vec3::new(1, 2, u64::MAX)).is_err()); 2554 }); 2555 2556 glam_test!(test_wrapping_add, { 2557 assert_eq!( 2558 U16Vec3::new(u16::MAX, 5, u16::MAX).wrapping_add(U16Vec3::new(1, 3, u16::MAX)), 2559 U16Vec3::new(0, 8, 65534), 2560 ); 2561 }); 2562 2563 glam_test!(test_wrapping_sub, { 2564 assert_eq!( 2565 U16Vec3::new(u16::MAX, 5, u16::MAX - 1).wrapping_sub(U16Vec3::new(1, 3, u16::MAX)), 2566 U16Vec3::new(65534, 2, 65535) 2567 ); 2568 }); 2569 2570 glam_test!(test_wrapping_mul, { 2571 assert_eq!( 2572 U16Vec3::new(u16::MAX, 5, u16::MAX).wrapping_mul(U16Vec3::new(3, 3, 5)), 2573 U16Vec3::new(65533, 15, 65531) 2574 ); 2575 }); 2576 2577 glam_test!(test_wrapping_div, { 2578 assert_eq!( 2579 U16Vec3::new(u16::MAX, 5, u16::MAX).wrapping_div(U16Vec3::new(3, 3, 5)), 2580 U16Vec3::new(21845, 1, 13107) 2581 ); 2582 }); 2583 2584 glam_test!(test_saturating_add, { 2585 assert_eq!( 2586 U16Vec3::new(u16::MAX, u16::MAX, 0).saturating_add(U16Vec3::new(1, u16::MAX, 2)), 2587 U16Vec3::new(u16::MAX, u16::MAX, 2) 2588 ); 2589 }); 2590 2591 glam_test!(test_saturating_sub, { 2592 assert_eq!( 2593 U16Vec3::new(0, u16::MAX, 0).saturating_sub(U16Vec3::new(1, 1, 2)), 2594 U16Vec3::new(0, 65534, 0) 2595 ); 2596 }); 2597 2598 glam_test!(test_saturating_mul, { 2599 assert_eq!( 2600 U16Vec3::new(u16::MAX, u16::MAX, 0).saturating_mul(U16Vec3::new(2, u16::MAX, 0)), 2601 U16Vec3::new(u16::MAX, u16::MAX, 0) 2602 ); 2603 }); 2604 2605 glam_test!(test_saturating_div, { 2606 assert_eq!( 2607 U16Vec3::new(u16::MAX, u16::MAX, 0).saturating_div(U16Vec3::new(2, u16::MAX, 3)), 2608 U16Vec3::new(32767, 1, 0) 2609 ); 2610 }); 2611 2612 glam_test!(test_wrapping_add_signed, { 2613 assert_eq!( 2614 U16Vec3::new(u16::MAX, u16::MAX, u16::MAX).wrapping_add_signed(I16Vec3::new(1, 1, 1)), 2615 U16Vec3::new(u16::MIN, u16::MIN, u16::MIN) 2616 ); 2617 }); 2618 2619 glam_test!(test_saturating_add_signed, { 2620 assert_eq!( 2621 U16Vec3::new(u16::MAX, u16::MAX, u16::MAX).saturating_add_signed(I16Vec3::new(1, 1, 1)), 2622 U16Vec3::new(u16::MAX, u16::MAX, u16::MAX) 2623 ); 2624 }); 2625 2626 impl_vec3_unsigned_integer_tests!(u16, u16vec3, U16Vec3, BVec3, bvec3); 2627 impl_vec3_eq_hash_tests!(u16, u16vec3); 2628 2629 impl_vec3_scalar_shift_op_tests!(U16Vec3, 0, 2); 2630 impl_vec3_shift_op_tests!(U16Vec3); 2631 2632 impl_vec3_scalar_bit_op_tests!(U16Vec3, 0, 2); 2633 impl_vec3_bit_op_tests!(U16Vec3, 0, 2); 2634 } 2635 2636 mod ivec3 { 2637 use glam::{ 2638 bvec3, ivec3, BVec3, I16Vec3, I64Vec3, I8Vec3, IVec3, U16Vec3, U64Vec3, U8Vec3, UVec3, 2639 }; 2640 2641 glam_test!(test_align, { 2642 use std::mem; 2643 assert_eq!(12, mem::size_of::<IVec3>()); 2644 assert_eq!(4, mem::align_of::<IVec3>()); 2645 assert_eq!(3, mem::size_of::<BVec3>()); 2646 assert_eq!(1, mem::align_of::<BVec3>()); 2647 }); 2648 2649 glam_test!(test_try_from, { 2650 assert_eq!(IVec3::new(1, 2, 3), IVec3::from(U8Vec3::new(1, 2, 3))); 2651 assert_eq!(IVec3::new(1, 2, 3), IVec3::from(I8Vec3::new(1, 2, 3))); 2652 2653 assert_eq!(IVec3::new(1, 2, 3), IVec3::from(U16Vec3::new(1, 2, 3))); 2654 assert_eq!(IVec3::new(1, 2, 3), IVec3::from(I16Vec3::new(1, 2, 3))); 2655 2656 assert_eq!( 2657 IVec3::new(1, 2, 3), 2658 IVec3::try_from(UVec3::new(1, 2, 3)).unwrap() 2659 ); 2660 assert!(IVec3::try_from(UVec3::new(u32::MAX, 2, 3)).is_err()); 2661 assert!(IVec3::try_from(UVec3::new(1, u32::MAX, 3)).is_err()); 2662 assert!(IVec3::try_from(UVec3::new(1, 2, u32::MAX)).is_err()); 2663 2664 assert_eq!( 2665 IVec3::new(1, 2, 3), 2666 IVec3::try_from(I64Vec3::new(1, 2, 3)).unwrap() 2667 ); 2668 assert!(IVec3::try_from(I64Vec3::new(i64::MAX, 2, 3)).is_err()); 2669 assert!(IVec3::try_from(I64Vec3::new(1, i64::MAX, 3)).is_err()); 2670 assert!(IVec3::try_from(I64Vec3::new(1, 2, i64::MAX)).is_err()); 2671 2672 assert_eq!( 2673 IVec3::new(1, 2, 3), 2674 IVec3::try_from(U64Vec3::new(1, 2, 3)).unwrap() 2675 ); 2676 assert!(IVec3::try_from(U64Vec3::new(u64::MAX, 2, 3)).is_err()); 2677 assert!(IVec3::try_from(U64Vec3::new(1, u64::MAX, 3)).is_err()); 2678 assert!(IVec3::try_from(U64Vec3::new(1, 2, u64::MAX)).is_err()); 2679 }); 2680 2681 glam_test!(test_wrapping_add, { 2682 assert_eq!( 2683 IVec3::new(i32::MAX, 5, i32::MIN).wrapping_add(IVec3::new(1, 3, i32::MAX)), 2684 IVec3::new(i32::MIN, 8, -1), 2685 ); 2686 }); 2687 2688 glam_test!(test_wrapping_sub, { 2689 assert_eq!( 2690 IVec3::new(i32::MAX, 5, i32::MIN).wrapping_sub(IVec3::new(1, 3, i32::MAX)), 2691 IVec3::new(2147483646, 2, 1), 2692 ); 2693 }); 2694 2695 glam_test!(test_wrapping_mul, { 2696 assert_eq!( 2697 IVec3::new(i32::MAX, 5, i32::MIN).wrapping_mul(IVec3::new(3, 3, 5)), 2698 IVec3::new(2147483645, 15, -2147483648) 2699 ); 2700 }); 2701 2702 glam_test!(test_wrapping_div, { 2703 assert_eq!( 2704 IVec3::new(i32::MAX, 5, i32::MIN).wrapping_div(IVec3::new(3, 3, 5)), 2705 IVec3::new(715827882, 1, -429496729) 2706 ); 2707 }); 2708 2709 glam_test!(test_saturating_add, { 2710 assert_eq!( 2711 IVec3::new(i32::MAX, i32::MIN, 0).saturating_add(IVec3::new(1, -1, 2)), 2712 IVec3::new(i32::MAX, i32::MIN, 2) 2713 ); 2714 }); 2715 2716 glam_test!(test_saturating_sub, { 2717 assert_eq!( 2718 IVec3::new(i32::MIN, i32::MAX, 0).saturating_sub(IVec3::new(1, -1, 2)), 2719 IVec3::new(i32::MIN, i32::MAX, -2) 2720 ); 2721 }); 2722 2723 glam_test!(test_saturating_mul, { 2724 assert_eq!( 2725 IVec3::new(i32::MAX, i32::MIN, 0).saturating_mul(IVec3::new(2, 2, 0)), 2726 IVec3::new(i32::MAX, i32::MIN, 0) 2727 ); 2728 }); 2729 2730 glam_test!(test_saturating_div, { 2731 assert_eq!( 2732 IVec3::new(i32::MAX, i32::MIN, 0).saturating_div(IVec3::new(2, 2, 3)), 2733 IVec3::new(1073741823, -1073741824, 0) 2734 ); 2735 }); 2736 2737 glam_test!(test_checked_add_unsigned, { 2738 assert_eq!(IVec3::MAX.checked_add_unsigned(UVec3::ONE), None); 2739 assert_eq!( 2740 IVec3::NEG_ONE.checked_add_unsigned(UVec3::ONE), 2741 Some(IVec3::ZERO) 2742 ); 2743 }); 2744 2745 glam_test!(test_checked_sub_unsigned, { 2746 assert_eq!(IVec3::MIN.checked_sub_unsigned(UVec3::ONE), None); 2747 assert_eq!( 2748 IVec3::ZERO.checked_sub_unsigned(UVec3::ONE), 2749 Some(IVec3::NEG_ONE) 2750 ); 2751 }); 2752 2753 glam_test!(test_wrapping_add_unsigned, { 2754 assert_eq!( 2755 IVec3::new(i32::MAX, i32::MAX, i32::MAX).wrapping_add_unsigned(UVec3::new(1, 1, 1)), 2756 IVec3::new(i32::MIN, i32::MIN, i32::MIN) 2757 ); 2758 }); 2759 2760 glam_test!(test_wrapping_sub_unsigned, { 2761 assert_eq!( 2762 IVec3::new(i32::MIN, i32::MIN, i32::MIN).wrapping_sub_unsigned(UVec3::new(1, 1, 1)), 2763 IVec3::new(i32::MAX, i32::MAX, i32::MAX) 2764 ); 2765 }); 2766 2767 glam_test!(test_saturating_add_unsigned, { 2768 assert_eq!( 2769 IVec3::new(i32::MAX, i32::MAX, i32::MAX).saturating_add_unsigned(UVec3::new(1, 1, 1)), 2770 IVec3::new(i32::MAX, i32::MAX, i32::MAX) 2771 ); 2772 }); 2773 2774 glam_test!(test_saturating_sub_unsigned, { 2775 assert_eq!( 2776 IVec3::new(i32::MIN, i32::MIN, i32::MIN).saturating_sub_unsigned(UVec3::new(1, 1, 1)), 2777 IVec3::new(i32::MIN, i32::MIN, i32::MIN) 2778 ); 2779 }); 2780 2781 impl_vec3_signed_integer_tests!(i32, ivec3, IVec3, BVec3, bvec3); 2782 impl_vec3_eq_hash_tests!(i32, ivec3); 2783 2784 impl_vec3_scalar_shift_op_tests!(IVec3, -2, 2); 2785 impl_vec3_shift_op_tests!(IVec3); 2786 2787 impl_vec3_scalar_bit_op_tests!(IVec3, -2, 2); 2788 impl_vec3_bit_op_tests!(IVec3, -2, 2); 2789 } 2790 2791 mod uvec3 { 2792 use glam::{ 2793 bvec3, uvec3, BVec3, I16Vec3, I64Vec3, I8Vec3, IVec3, U16Vec3, U64Vec3, U8Vec3, UVec3, 2794 }; 2795 2796 glam_test!(test_align, { 2797 use std::mem; 2798 assert_eq!(12, mem::size_of::<UVec3>()); 2799 assert_eq!(4, mem::align_of::<UVec3>()); 2800 assert_eq!(3, mem::size_of::<BVec3>()); 2801 assert_eq!(1, mem::align_of::<BVec3>()); 2802 }); 2803 2804 glam_test!(test_try_from, { 2805 assert_eq!( 2806 UVec3::new(1, 2, 3), 2807 UVec3::try_from(I8Vec3::new(1, 2, 3)).unwrap() 2808 ); 2809 assert!(UVec3::try_from(I8Vec3::new(-1, 2, 3)).is_err()); 2810 assert!(UVec3::try_from(I8Vec3::new(1, -2, 3)).is_err()); 2811 assert!(UVec3::try_from(I8Vec3::new(1, 2, -3)).is_err()); 2812 2813 assert_eq!(UVec3::new(1, 2, 3), UVec3::from(U8Vec3::new(1, 2, 3))); 2814 2815 assert_eq!( 2816 UVec3::new(1, 2, 3), 2817 UVec3::try_from(I16Vec3::new(1, 2, 3)).unwrap() 2818 ); 2819 assert!(UVec3::try_from(I16Vec3::new(-1, 2, 3)).is_err()); 2820 assert!(UVec3::try_from(I16Vec3::new(1, -2, 3)).is_err()); 2821 assert!(UVec3::try_from(I16Vec3::new(1, 2, -3)).is_err()); 2822 2823 assert_eq!(UVec3::new(1, 2, 3), UVec3::from(U16Vec3::new(1, 2, 3))); 2824 2825 assert_eq!( 2826 UVec3::new(1, 2, 3), 2827 UVec3::try_from(IVec3::new(1, 2, 3)).unwrap() 2828 ); 2829 assert!(UVec3::try_from(IVec3::new(-1, 2, 3)).is_err()); 2830 assert!(UVec3::try_from(IVec3::new(1, -2, 3)).is_err()); 2831 assert!(UVec3::try_from(IVec3::new(1, 2, -3)).is_err()); 2832 2833 assert_eq!( 2834 UVec3::new(1, 2, 3), 2835 UVec3::try_from(I64Vec3::new(1, 2, 3)).unwrap() 2836 ); 2837 assert!(UVec3::try_from(I64Vec3::new(-1, 2, 3)).is_err()); 2838 assert!(UVec3::try_from(I64Vec3::new(1, -2, 3)).is_err()); 2839 assert!(UVec3::try_from(I64Vec3::new(1, 2, -3)).is_err()); 2840 2841 assert!(UVec3::try_from(I64Vec3::new(i64::MAX, 2, 3)).is_err()); 2842 assert!(UVec3::try_from(I64Vec3::new(1, i64::MAX, 3)).is_err()); 2843 assert!(UVec3::try_from(I64Vec3::new(1, 2, i64::MAX)).is_err()); 2844 2845 assert_eq!( 2846 UVec3::new(1, 2, 3), 2847 UVec3::try_from(U64Vec3::new(1, 2, 3)).unwrap() 2848 ); 2849 assert!(UVec3::try_from(U64Vec3::new(u64::MAX, 2, 3)).is_err()); 2850 assert!(UVec3::try_from(U64Vec3::new(1, u64::MAX, 3)).is_err()); 2851 assert!(UVec3::try_from(U64Vec3::new(1, 2, u64::MAX)).is_err()); 2852 }); 2853 2854 glam_test!(test_wrapping_add, { 2855 assert_eq!( 2856 UVec3::new(u32::MAX, 5, u32::MAX).wrapping_add(UVec3::new(1, 3, u32::MAX)), 2857 UVec3::new(0, 8, 4294967294), 2858 ); 2859 }); 2860 2861 glam_test!(test_wrapping_sub, { 2862 assert_eq!( 2863 UVec3::new(u32::MAX, 5, u32::MAX - 1).wrapping_sub(UVec3::new(1, 3, u32::MAX)), 2864 UVec3::new(4294967294, 2, 4294967295) 2865 ); 2866 }); 2867 2868 glam_test!(test_wrapping_mul, { 2869 assert_eq!( 2870 UVec3::new(u32::MAX, 5, u32::MAX).wrapping_mul(UVec3::new(3, 3, 5)), 2871 UVec3::new(4294967293, 15, 4294967291) 2872 ); 2873 }); 2874 2875 glam_test!(test_wrapping_div, { 2876 assert_eq!( 2877 UVec3::new(u32::MAX, 5, u32::MAX).wrapping_div(UVec3::new(3, 3, 5)), 2878 UVec3::new(1431655765, 1, 858993459) 2879 ); 2880 }); 2881 2882 glam_test!(test_saturating_add, { 2883 assert_eq!( 2884 UVec3::new(u32::MAX, u32::MAX, 0).saturating_add(UVec3::new(1, u32::MAX, 2)), 2885 UVec3::new(u32::MAX, u32::MAX, 2) 2886 ); 2887 }); 2888 2889 glam_test!(test_saturating_sub, { 2890 assert_eq!( 2891 UVec3::new(0, u32::MAX, 0).saturating_sub(UVec3::new(1, 1, 2)), 2892 UVec3::new(0, 4294967294, 0) 2893 ); 2894 }); 2895 2896 glam_test!(test_saturating_mul, { 2897 assert_eq!( 2898 UVec3::new(u32::MAX, u32::MAX, 0).saturating_mul(UVec3::new(2, u32::MAX, 0)), 2899 UVec3::new(u32::MAX, u32::MAX, 0) 2900 ); 2901 }); 2902 2903 glam_test!(test_saturating_div, { 2904 assert_eq!( 2905 UVec3::new(u32::MAX, u32::MAX, 0).saturating_div(UVec3::new(2, u32::MAX, 3)), 2906 UVec3::new(2147483647, 1, 0) 2907 ); 2908 }); 2909 2910 glam_test!(test_wrapping_add_signed, { 2911 assert_eq!( 2912 UVec3::new(u32::MAX, u32::MAX, u32::MAX).wrapping_add_signed(IVec3::new(1, 1, 1)), 2913 UVec3::new(u32::MIN, u32::MIN, u32::MIN) 2914 ); 2915 }); 2916 2917 glam_test!(test_saturating_add_signed, { 2918 assert_eq!( 2919 UVec3::new(u32::MAX, u32::MAX, u32::MAX).saturating_add_signed(IVec3::new(1, 1, 1)), 2920 UVec3::new(u32::MAX, u32::MAX, u32::MAX) 2921 ); 2922 }); 2923 2924 impl_vec3_unsigned_integer_tests!(u32, uvec3, UVec3, BVec3, bvec3); 2925 impl_vec3_eq_hash_tests!(u32, uvec3); 2926 2927 impl_vec3_scalar_shift_op_tests!(UVec3, 0, 2); 2928 impl_vec3_shift_op_tests!(UVec3); 2929 2930 impl_vec3_scalar_bit_op_tests!(UVec3, 0, 2); 2931 impl_vec3_bit_op_tests!(UVec3, 0, 2); 2932 } 2933 2934 mod i64vec3 { 2935 use glam::{ 2936 bvec3, i64vec3, BVec3, I16Vec3, I64Vec3, I8Vec3, IVec3, U16Vec3, U64Vec3, U8Vec3, UVec3, 2937 }; 2938 2939 glam_test!(test_align, { 2940 use std::mem; 2941 assert_eq!(24, mem::size_of::<I64Vec3>()); 2942 assert_eq!(8, mem::align_of::<I64Vec3>()); 2943 assert_eq!(3, mem::size_of::<BVec3>()); 2944 assert_eq!(1, mem::align_of::<BVec3>()); 2945 }); 2946 2947 glam_test!(test_try_from, { 2948 assert_eq!(I64Vec3::new(1, 2, 3), I64Vec3::from(I8Vec3::new(1, 2, 3))); 2949 assert_eq!(I64Vec3::new(1, 2, 3), I64Vec3::from(U8Vec3::new(1, 2, 3))); 2950 assert_eq!(I64Vec3::new(1, 2, 3), I64Vec3::from(I16Vec3::new(1, 2, 3))); 2951 assert_eq!(I64Vec3::new(1, 2, 3), I64Vec3::from(U16Vec3::new(1, 2, 3))); 2952 assert_eq!(I64Vec3::new(1, 2, 3), I64Vec3::from(IVec3::new(1, 2, 3))); 2953 assert_eq!(I64Vec3::new(1, 2, 3), I64Vec3::from(UVec3::new(1, 2, 3))); 2954 2955 assert_eq!( 2956 I64Vec3::new(1, 2, 3), 2957 I64Vec3::try_from(U64Vec3::new(1, 2, 3)).unwrap() 2958 ); 2959 assert!(I64Vec3::try_from(U64Vec3::new(u64::MAX, 2, 3)).is_err()); 2960 assert!(I64Vec3::try_from(U64Vec3::new(1, u64::MAX, 3)).is_err()); 2961 assert!(I64Vec3::try_from(U64Vec3::new(1, 2, u64::MAX)).is_err()); 2962 }); 2963 2964 glam_test!(test_checked_add_unsigned, { 2965 assert_eq!(I64Vec3::MAX.checked_add_unsigned(U64Vec3::ONE), None); 2966 assert_eq!( 2967 I64Vec3::NEG_ONE.checked_add_unsigned(U64Vec3::ONE), 2968 Some(I64Vec3::ZERO) 2969 ); 2970 }); 2971 2972 glam_test!(test_checked_sub_unsigned, { 2973 assert_eq!(I64Vec3::MIN.checked_sub_unsigned(U64Vec3::ONE), None); 2974 assert_eq!( 2975 I64Vec3::ZERO.checked_sub_unsigned(U64Vec3::ONE), 2976 Some(I64Vec3::NEG_ONE) 2977 ); 2978 }); 2979 2980 glam_test!(test_wrapping_add_unsigned, { 2981 assert_eq!( 2982 I64Vec3::new(i64::MAX, i64::MAX, i64::MAX).wrapping_add_unsigned(U64Vec3::new(1, 1, 1)), 2983 I64Vec3::new(i64::MIN, i64::MIN, i64::MIN) 2984 ); 2985 }); 2986 2987 glam_test!(test_wrapping_sub_unsigned, { 2988 assert_eq!( 2989 I64Vec3::new(i64::MIN, i64::MIN, i64::MIN).wrapping_sub_unsigned(U64Vec3::new(1, 1, 1)), 2990 I64Vec3::new(i64::MAX, i64::MAX, i64::MAX) 2991 ); 2992 }); 2993 2994 glam_test!(test_saturating_add_unsigned, { 2995 assert_eq!( 2996 I64Vec3::new(i64::MAX, i64::MAX, i64::MAX) 2997 .saturating_add_unsigned(U64Vec3::new(1, 1, 1)), 2998 I64Vec3::new(i64::MAX, i64::MAX, i64::MAX) 2999 ); 3000 }); 3001 3002 glam_test!(test_saturating_sub_unsigned, { 3003 assert_eq!( 3004 I64Vec3::new(i64::MIN, i64::MIN, i64::MIN) 3005 .saturating_sub_unsigned(U64Vec3::new(1, 1, 1)), 3006 I64Vec3::new(i64::MIN, i64::MIN, i64::MIN) 3007 ); 3008 }); 3009 3010 impl_vec3_signed_integer_tests!(i64, i64vec3, I64Vec3, BVec3, bvec3); 3011 impl_vec3_eq_hash_tests!(i64, i64vec3); 3012 3013 impl_vec3_scalar_shift_op_tests!(I64Vec3, -2, 2); 3014 impl_vec3_shift_op_tests!(I64Vec3); 3015 3016 impl_vec3_scalar_bit_op_tests!(I64Vec3, -2, 2); 3017 impl_vec3_bit_op_tests!(I64Vec3, -2, 2); 3018 } 3019 3020 mod u64vec3 { 3021 use glam::{ 3022 bvec3, u64vec3, BVec3, I16Vec3, I64Vec3, I8Vec3, IVec3, U16Vec3, U64Vec3, U8Vec3, UVec3, 3023 }; 3024 3025 glam_test!(test_align, { 3026 use std::mem; 3027 assert_eq!(24, mem::size_of::<U64Vec3>()); 3028 assert_eq!(8, mem::align_of::<U64Vec3>()); 3029 assert_eq!(3, mem::size_of::<BVec3>()); 3030 assert_eq!(1, mem::align_of::<BVec3>()); 3031 }); 3032 3033 glam_test!(test_try_from, { 3034 assert_eq!( 3035 U64Vec3::new(1, 2, 3), 3036 U64Vec3::try_from(I8Vec3::new(1, 2, 3)).unwrap() 3037 ); 3038 assert!(U64Vec3::try_from(I8Vec3::new(-1, 2, 3)).is_err()); 3039 assert!(U64Vec3::try_from(I8Vec3::new(1, -2, 3)).is_err()); 3040 assert!(U64Vec3::try_from(I8Vec3::new(1, 2, -3)).is_err()); 3041 3042 assert_eq!(U64Vec3::new(1, 2, 3), U64Vec3::from(U8Vec3::new(1, 2, 3))); 3043 3044 assert_eq!( 3045 U64Vec3::new(1, 2, 3), 3046 U64Vec3::try_from(I16Vec3::new(1, 2, 3)).unwrap() 3047 ); 3048 assert!(U64Vec3::try_from(I16Vec3::new(-1, 2, 3)).is_err()); 3049 assert!(U64Vec3::try_from(I16Vec3::new(1, -2, 3)).is_err()); 3050 assert!(U64Vec3::try_from(I16Vec3::new(1, 2, -3)).is_err()); 3051 3052 assert_eq!(U64Vec3::new(1, 2, 3), U64Vec3::from(U16Vec3::new(1, 2, 3))); 3053 3054 assert_eq!( 3055 U64Vec3::new(1, 2, 3), 3056 U64Vec3::try_from(IVec3::new(1, 2, 3)).unwrap() 3057 ); 3058 assert!(U64Vec3::try_from(IVec3::new(-1, 2, 3)).is_err()); 3059 assert!(U64Vec3::try_from(IVec3::new(1, -2, 3)).is_err()); 3060 assert!(U64Vec3::try_from(IVec3::new(1, 2, -3)).is_err()); 3061 3062 assert_eq!(U64Vec3::new(1, 2, 3), U64Vec3::from(UVec3::new(1, 2, 3))); 3063 3064 assert_eq!( 3065 U64Vec3::new(1, 2, 3), 3066 U64Vec3::try_from(I64Vec3::new(1, 2, 3)).unwrap() 3067 ); 3068 assert!(U64Vec3::try_from(I64Vec3::new(-1, 2, 3)).is_err()); 3069 assert!(U64Vec3::try_from(I64Vec3::new(1, -2, 3)).is_err()); 3070 assert!(U64Vec3::try_from(I64Vec3::new(1, 2, -3)).is_err()); 3071 }); 3072 3073 glam_test!(test_wrapping_add_signed, { 3074 assert_eq!( 3075 U64Vec3::new(u64::MAX, u64::MAX, u64::MAX).wrapping_add_signed(I64Vec3::new(1, 1, 1)), 3076 U64Vec3::new(u64::MIN, u64::MIN, u64::MIN) 3077 ); 3078 }); 3079 3080 glam_test!(test_saturating_add_signed, { 3081 assert_eq!( 3082 U64Vec3::new(u64::MAX, u64::MAX, u64::MAX).saturating_add_signed(I64Vec3::new(1, 1, 1)), 3083 U64Vec3::new(u64::MAX, u64::MAX, u64::MAX) 3084 ); 3085 }); 3086 3087 impl_vec3_unsigned_integer_tests!(u64, u64vec3, U64Vec3, BVec3, bvec3); 3088 impl_vec3_eq_hash_tests!(u64, u64vec3); 3089 3090 impl_vec3_scalar_shift_op_tests!(U64Vec3, 0, 2); 3091 impl_vec3_shift_op_tests!(U64Vec3); 3092 3093 impl_vec3_scalar_bit_op_tests!(U64Vec3, 0, 2); 3094 impl_vec3_bit_op_tests!(U64Vec3, 0, 2); 3095 } 3096