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