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) => { 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!($vec4::new(1 as $t, 0 as $t, 0 as $t, 0 as $t), $vec4::X); 56 assert_eq!($vec4::new(0 as $t, 1 as $t, 0 as $t, 0 as $t), $vec4::Y); 57 assert_eq!($vec4::new(0 as $t, 0 as $t, 1 as $t, 0 as $t), $vec4::Z); 58 assert_eq!($vec4::new(0 as $t, 0 as $t, 0 as $t, 1 as $t), $vec4::W); 59 60 assert_eq!( 61 v, 62 $vec4::from(($vec3::new(1 as $t, 2 as $t, 3 as $t), 4 as $t)) 63 ); 64 65 assert_eq!( 66 v, 67 $vec4::from((1 as $t, $vec3::new(2 as $t, 3 as $t, 4 as $t))) 68 ); 69 70 assert_eq!( 71 v, 72 $vec4::from(($vec2::new(1 as $t, 2 as $t), 3 as $t, 4 as $t)) 73 ); 74 assert_eq!( 75 v, 76 $vec4::from(($vec2::new(1 as $t, 2 as $t), $vec2::new(3 as $t, 4 as $t))) 77 ); 78 }); 79 80 glam_test!(test_fmt, { 81 let a = $vec4::new(1 as $t, 2 as $t, 3 as $t, 4 as $t); 82 assert_eq!( 83 format!("{:?}", a), 84 format!( 85 "{}({:?}, {:?}, {:?}, {:?})", 86 stringify!($vec4), 87 a.x, 88 a.y, 89 a.z, 90 a.w 91 ) 92 ); 93 assert_eq!( 94 format!("{:#?}", a), 95 format!( 96 "{}(\n {:#?},\n {:#?},\n {:#?},\n {:#?},\n)", 97 stringify!($vec4), 98 a.x, 99 a.y, 100 a.z, 101 a.w 102 ) 103 ); 104 assert_eq!(format!("{}", a), "[1, 2, 3, 4]"); 105 }); 106 107 glam_test!(test_zero, { 108 let v = $vec4::ZERO; 109 assert_eq!((0 as $t, 0 as $t, 0 as $t, 0 as $t), v.into()); 110 assert_eq!(v, $vec4::default()); 111 }); 112 113 glam_test!(test_splat, { 114 let v = $vec4::splat(1 as $t); 115 assert_eq!($vec4::ONE, v); 116 }); 117 118 glam_test!(test_accessors, { 119 let mut a = $vec4::ZERO; 120 a.x = 1 as $t; 121 a.y = 2 as $t; 122 a.z = 3 as $t; 123 a.w = 4 as $t; 124 assert_eq!(1 as $t, a.x); 125 assert_eq!(2 as $t, a.y); 126 assert_eq!(3 as $t, a.z); 127 assert_eq!(4 as $t, a.w); 128 assert_eq!((1 as $t, 2 as $t, 3 as $t, 4 as $t), a.into()); 129 130 let mut a = $vec4::ZERO; 131 a[0] = 1 as $t; 132 a[1] = 2 as $t; 133 a[2] = 3 as $t; 134 a[3] = 4 as $t; 135 assert_eq!(1 as $t, a[0]); 136 assert_eq!(2 as $t, a[1]); 137 assert_eq!(3 as $t, a[2]); 138 assert_eq!(4 as $t, a[3]); 139 assert_eq!((1 as $t, 2 as $t, 3 as $t, 4 as $t), a.into()); 140 }); 141 142 glam_test!(test_dot_unsigned, { 143 let x = $new(1 as $t, 0 as $t, 0 as $t, 0 as $t); 144 let y = $new(0 as $t, 1 as $t, 0 as $t, 0 as $t); 145 let z = $new(0 as $t, 0 as $t, 1 as $t, 0 as $t); 146 let w = $new(0 as $t, 0 as $t, 0 as $t, 1 as $t); 147 assert_eq!(1 as $t, x.dot(x)); 148 assert_eq!(0 as $t, x.dot(y)); 149 assert_eq!(0 as $t, y.dot(z)); 150 assert_eq!(0 as $t, z.dot(w)); 151 152 assert_eq!( 153 $new(28 as $t, 28 as $t, 28 as $t, 28 as $t), 154 $new(0 as $t, 5 as $t, 3 as $t, 6 as $t) 155 .dot_into_vec($new(7 as $t, 2 as $t, 4 as $t, 1 as $t)) 156 ); 157 }); 158 159 glam_test!(test_length_squared_unsigned, { 160 let x = $new(1 as $t, 0 as $t, 0 as $t, 0 as $t); 161 let z = $new(0 as $t, 0 as $t, 1 as $t, 0 as $t); 162 let w = $new(0 as $t, 0 as $t, 0 as $t, 1 as $t); 163 assert_eq!(4 as $t, (2 as $t * x).length_squared()); 164 assert_eq!(16 as $t, (4 as $t * z).length_squared()); 165 assert_eq!(64 as $t, (8 as $t * w).length_squared()); 166 assert_eq!( 167 2 as $t * 2 as $t + 3 as $t * 3 as $t + 4 as $t * 4 as $t + 5 as $t * 5 as $t, 168 $new(2 as $t, 3 as $t, 4 as $t, 5 as $t).length_squared() 169 ); 170 }); 171 172 glam_test!(test_ops, { 173 let a = $new(2 as $t, 4 as $t, 8 as $t, 16 as $t); 174 assert_eq!($new(4 as $t, 8 as $t, 16 as $t, 32 as $t), a + a); 175 assert_eq!($new(2 as $t, 4 as $t, 8 as $t, 16 as $t), 0 as $t + a); 176 assert_eq!($new(0 as $t, 0 as $t, 0 as $t, 0 as $t), a - a); 177 assert_eq!($new(14 as $t, 12 as $t, 8 as $t, 0 as $t), 16 as $t - a); 178 assert_eq!($new(4 as $t, 16 as $t, 64 as $t, 256 as $t), a * a); 179 assert_eq!($new(4 as $t, 8 as $t, 16 as $t, 32 as $t), a * 2 as $t); 180 assert_eq!($new(4 as $t, 8 as $t, 16 as $t, 32 as $t), 2 as $t * a); 181 assert_eq!($new(1 as $t, 1 as $t, 1 as $t, 1 as $t), a / a); 182 assert_eq!($new(1 as $t, 2 as $t, 4 as $t, 8 as $t), a / 2 as $t); 183 assert_eq!($new(8 as $t, 4 as $t, 2 as $t, 1 as $t), 16 as $t / a); 184 assert_eq!($new(0 as $t, 0 as $t, 0 as $t, 0 as $t), a % a); 185 assert_eq!($new(0 as $t, 1 as $t, 1 as $t, 1 as $t), a % (a - 1 as $t)); 186 assert_eq!($new(0 as $t, 0 as $t, 0 as $t, 0 as $t), a % 1 as $t); 187 assert_eq!($new(2 as $t, 1 as $t, 2 as $t, 1 as $t), a % 3 as $t); 188 assert_eq!($new(1 as $t, 1 as $t, 1 as $t, 1 as $t), 17 as $t % a); 189 assert_eq!($new(2 as $t, 4 as $t, 0 as $t, 0 as $t), a % 8 as $t); 190 }); 191 192 glam_test!(test_assign_ops, { 193 let a = $new(1 as $t, 2 as $t, 3 as $t, 4 as $t); 194 let mut b = a; 195 196 b += 2 as $t; 197 assert_eq!($new(3 as $t, 4 as $t, 5 as $t, 6 as $t), b); 198 b -= 2 as $t; 199 assert_eq!($new(1 as $t, 2 as $t, 3 as $t, 4 as $t), b); 200 b *= 2 as $t; 201 assert_eq!($new(2 as $t, 4 as $t, 6 as $t, 8 as $t), b); 202 b /= 2 as $t; 203 assert_eq!($new(1 as $t, 2 as $t, 3 as $t, 4 as $t), b); 204 b %= 2 as $t; 205 assert_eq!($new(1 as $t, 0 as $t, 1 as $t, 0 as $t), b); 206 207 b = a; 208 b += a; 209 assert_eq!($new(2 as $t, 4 as $t, 6 as $t, 8 as $t), b); 210 b -= a; 211 assert_eq!($new(1 as $t, 2 as $t, 3 as $t, 4 as $t), b); 212 b *= a; 213 assert_eq!($new(1 as $t, 4 as $t, 9 as $t, 16 as $t), b); 214 b /= a; 215 assert_eq!($new(1 as $t, 2 as $t, 3 as $t, 4 as $t), b); 216 b *= 2 as $t; 217 assert_eq!($new(2 as $t, 4 as $t, 6 as $t, 8 as $t), b); 218 b /= 2 as $t; 219 assert_eq!($new(1 as $t, 2 as $t, 3 as $t, 4 as $t), b); 220 b %= (b + 1 as $t); 221 assert_eq!($new(1 as $t, 2 as $t, 3 as $t, 4 as $t), b); 222 b %= b; 223 assert_eq!($new(0 as $t, 0 as $t, 0 as $t, 0 as $t), b); 224 }); 225 226 glam_test!(test_min_max, { 227 let a = $new(4 as $t, 6 as $t, 2 as $t, 8 as $t); 228 let b = $new(5 as $t, 3 as $t, 7 as $t, 1 as $t); 229 assert_eq!((4 as $t, 3 as $t, 2 as $t, 1 as $t), a.min(b).into()); 230 assert_eq!((4 as $t, 3 as $t, 2 as $t, 1 as $t), b.min(a).into()); 231 assert_eq!((5 as $t, 6 as $t, 7 as $t, 8 as $t), a.max(b).into()); 232 assert_eq!((5 as $t, 6 as $t, 7 as $t, 8 as $t), b.max(a).into()); 233 }); 234 235 glam_test!(test_clamp, { 236 fn vec(x: i32, y: i32, z: i32, w: i32) -> $vec4 { 237 $vec4::new(x as $t, y as $t, z as $t, w as $t) 238 } 239 let min = vec(1, 1, 3, 3); 240 let max = vec(6, 6, 8, 8); 241 assert_eq!(vec(0, 0, 0, 0).clamp(min, max), vec(1, 1, 3, 3)); 242 assert_eq!(vec(2, 2, 2, 2).clamp(min, max), vec(2, 2, 3, 3)); 243 assert_eq!(vec(4, 4, 5, 5).clamp(min, max), vec(4, 4, 5, 5)); 244 assert_eq!(vec(6, 6, 6, 6).clamp(min, max), vec(6, 6, 6, 6)); 245 assert_eq!(vec(7, 7, 7, 7).clamp(min, max), vec(6, 6, 7, 7)); 246 assert_eq!(vec(9, 9, 9, 9).clamp(min, max), vec(6, 6, 8, 8)); 247 248 should_glam_assert!({ $vec4::clamp($vec4::ZERO, $vec4::ONE, $vec4::ZERO) }); 249 }); 250 251 glam_test!(test_hmin_hmax, { 252 assert_eq!( 253 1 as $t, 254 $new(1 as $t, 2 as $t, 3 as $t, 4 as $t).min_element() 255 ); 256 assert_eq!( 257 1 as $t, 258 $new(4 as $t, 1 as $t, 2 as $t, 3 as $t).min_element() 259 ); 260 assert_eq!( 261 1 as $t, 262 $new(3 as $t, 4 as $t, 1 as $t, 2 as $t).min_element() 263 ); 264 assert_eq!( 265 1 as $t, 266 $new(2 as $t, 3 as $t, 4 as $t, 1 as $t).min_element() 267 ); 268 assert_eq!( 269 4 as $t, 270 $new(1 as $t, 2 as $t, 3 as $t, 4 as $t).max_element() 271 ); 272 assert_eq!( 273 4 as $t, 274 $new(4 as $t, 1 as $t, 2 as $t, 3 as $t).max_element() 275 ); 276 assert_eq!( 277 4 as $t, 278 $new(3 as $t, 4 as $t, 1 as $t, 2 as $t).max_element() 279 ); 280 assert_eq!( 281 4 as $t, 282 $new(2 as $t, 3 as $t, 4 as $t, 1 as $t).max_element() 283 ); 284 assert_eq!( 285 3 as $t, 286 $new(1 as $t, 2 as $t, 3 as $t, 4 as $t) 287 .truncate() 288 .max_element() 289 ); 290 assert_eq!( 291 2 as $t, 292 $new(4 as $t, 3 as $t, 2 as $t, 1 as $t) 293 .truncate() 294 .min_element() 295 ); 296 }); 297 298 glam_test!(test_eq, { 299 let a = $new(1 as $t, 1 as $t, 1 as $t, 1 as $t); 300 let b = $new(1 as $t, 2 as $t, 3 as $t, 4 as $t); 301 assert!(a.cmpeq(a).all()); 302 assert!(b.cmpeq(b).all()); 303 assert!(a.cmpne(b).any()); 304 assert!(b.cmpne(a).any()); 305 assert!(b.cmpeq(a).any()); 306 }); 307 308 glam_test!(test_cmp, { 309 assert!(!$mask::default().any()); 310 assert!(!$mask::default().all()); 311 assert_eq!($mask::default().bitmask(), 0x0); 312 let a = $new(1 as $t, 1 as $t, 1 as $t, 1 as $t); 313 let b = $new(2 as $t, 2 as $t, 2 as $t, 2 as $t); 314 let c = $new(1 as $t, 1 as $t, 2 as $t, 2 as $t); 315 let d = $new(2 as $t, 1 as $t, 1 as $t, 2 as $t); 316 assert_eq!(a.cmplt(a).bitmask(), 0x0); 317 assert_eq!(a.cmplt(b).bitmask(), 0xf); 318 assert_eq!(a.cmplt(c).bitmask(), 0xc); 319 assert_eq!(c.cmple(a).bitmask(), 0x3); 320 assert_eq!(a.cmplt(d).bitmask(), 0x9); 321 assert!(a.cmplt(b).all()); 322 assert!(a.cmplt(c).any()); 323 assert!(a.cmple(b).all()); 324 assert!(a.cmple(a).all()); 325 assert!(b.cmpgt(a).all()); 326 assert!(b.cmpge(a).all()); 327 assert!(b.cmpge(b).all()); 328 assert!(!(a.cmpge(c).all())); 329 assert!(c.cmple(c).all()); 330 assert!(c.cmpge(c).all()); 331 assert!(a.cmpeq(a).all()); 332 assert!(!a.cmpeq(b).all()); 333 assert!(a.cmpeq(c).any()); 334 assert!(!a.cmpne(a).all()); 335 assert!(a.cmpne(b).all()); 336 assert!(a.cmpne(c).any()); 337 assert!(a == a); 338 }); 339 340 glam_test!(test_slice, { 341 let a = [1 as $t, 2 as $t, 3 as $t, 4 as $t]; 342 let b = $vec4::from_slice(&a); 343 let c: [$t; 4] = b.into(); 344 assert_eq!(a, c); 345 let mut d = [0 as $t, 0 as $t, 0 as $t, 0 as $t]; 346 b.write_to_slice(&mut d[..]); 347 assert_eq!(a, d); 348 349 should_panic!({ $vec4::ONE.write_to_slice(&mut [0 as $t; 3]) }); 350 should_panic!({ $vec4::from_slice(&[0 as $t; 3]) }); 351 }); 352 353 glam_test!(test_mask_into_array_u32, { 354 assert_eq!( 355 Into::<[u32; 4]>::into($mask::new(false, false, false, false)), 356 [0, 0, 0, 0] 357 ); 358 assert_eq!( 359 Into::<[u32; 4]>::into($mask::new(false, false, true, true)), 360 [0, 0, !0, !0] 361 ); 362 assert_eq!( 363 Into::<[u32; 4]>::into($mask::new(true, true, false, false)), 364 [!0, !0, 0, 0] 365 ); 366 assert_eq!( 367 Into::<[u32; 4]>::into($mask::new(false, true, false, true)), 368 [0, !0, 0, !0] 369 ); 370 assert_eq!( 371 Into::<[u32; 4]>::into($mask::new(true, false, true, false)), 372 [!0, 0, !0, 0] 373 ); 374 assert_eq!( 375 Into::<[u32; 4]>::into($mask::new(true, true, true, true)), 376 [!0, !0, !0, !0] 377 ); 378 }); 379 380 glam_test!(test_mask_into_array_bool, { 381 assert_eq!( 382 Into::<[bool; 4]>::into($mask::new(false, false, false, false)), 383 [false, false, false, false] 384 ); 385 assert_eq!( 386 Into::<[bool; 4]>::into($mask::new(false, false, true, true)), 387 [false, false, true, true] 388 ); 389 assert_eq!( 390 Into::<[bool; 4]>::into($mask::new(true, true, false, false)), 391 [true, true, false, false] 392 ); 393 assert_eq!( 394 Into::<[bool; 4]>::into($mask::new(false, true, false, true)), 395 [false, true, false, true] 396 ); 397 assert_eq!( 398 Into::<[bool; 4]>::into($mask::new(true, false, true, false)), 399 [true, false, true, false] 400 ); 401 assert_eq!( 402 Into::<[bool; 4]>::into($mask::new(true, true, true, true)), 403 [true, true, true, true] 404 ); 405 }); 406 407 glam_test!(test_mask_splat, { 408 assert_eq!($mask::splat(false), $mask::new(false, false, false, false)); 409 assert_eq!($mask::splat(true), $mask::new(true, true, true, true)); 410 }); 411 412 glam_test!(test_mask_bitmask, { 413 assert_eq!($mask::new(false, false, false, false).bitmask(), 0b0000); 414 assert_eq!($mask::new(false, false, true, true).bitmask(), 0b1100); 415 assert_eq!($mask::new(true, true, false, false).bitmask(), 0b0011); 416 assert_eq!($mask::new(false, true, false, true).bitmask(), 0b1010); 417 assert_eq!($mask::new(true, false, true, false).bitmask(), 0b0101); 418 assert_eq!($mask::new(true, true, true, true).bitmask(), 0b1111); 419 }); 420 421 glam_test!(test_mask_any, { 422 assert_eq!($mask::new(false, false, false, false).any(), false); 423 assert_eq!($mask::new(true, false, false, false).any(), true); 424 assert_eq!($mask::new(false, true, false, false).any(), true); 425 assert_eq!($mask::new(false, false, true, false).any(), true); 426 assert_eq!($mask::new(false, false, false, true).any(), true); 427 }); 428 429 glam_test!(test_mask_all, { 430 assert_eq!($mask::new(true, true, true, true).all(), true); 431 assert_eq!($mask::new(false, true, true, true).all(), false); 432 assert_eq!($mask::new(true, false, true, true).all(), false); 433 assert_eq!($mask::new(true, true, false, true).all(), false); 434 assert_eq!($mask::new(true, true, true, false).all(), false); 435 }); 436 437 glam_test!(test_mask_select, { 438 let a = $vec4::new(1 as $t, 2 as $t, 3 as $t, 4 as $t); 439 let b = $vec4::new(5 as $t, 6 as $t, 7 as $t, 8 as $t); 440 assert_eq!( 441 $vec4::select($mask::new(true, true, true, true), a, b), 442 $vec4::new(1 as $t, 2 as $t, 3 as $t, 4 as $t), 443 ); 444 assert_eq!( 445 $vec4::select($mask::new(true, false, true, false), a, b), 446 $vec4::new(1 as $t, 6 as $t, 3 as $t, 8 as $t), 447 ); 448 assert_eq!( 449 $vec4::select($mask::new(false, true, false, true), a, b), 450 $vec4::new(5 as $t, 2 as $t, 7 as $t, 4 as $t), 451 ); 452 assert_eq!( 453 $vec4::select($mask::new(false, false, false, false), a, b), 454 $vec4::new(5 as $t, 6 as $t, 7 as $t, 8 as $t), 455 ); 456 }); 457 458 glam_test!(test_mask_and, { 459 assert_eq!( 460 ($mask::new(false, false, false, false) & $mask::new(false, false, false, false)) 461 .bitmask(), 462 0b0000, 463 ); 464 assert_eq!( 465 ($mask::new(true, true, true, true) & $mask::new(true, true, true, true)).bitmask(), 466 0b1111, 467 ); 468 assert_eq!( 469 ($mask::new(true, false, true, false) & $mask::new(false, true, false, true)) 470 .bitmask(), 471 0b0000, 472 ); 473 assert_eq!( 474 ($mask::new(true, false, true, true) & $mask::new(true, true, true, false)) 475 .bitmask(), 476 0b0101, 477 ); 478 479 let mut mask = $mask::new(true, true, false, false); 480 mask &= $mask::new(true, false, true, false); 481 assert_eq!(mask.bitmask(), 0b0001); 482 }); 483 484 glam_test!(test_mask_or, { 485 assert_eq!( 486 ($mask::new(false, false, false, false) | $mask::new(false, false, false, false)) 487 .bitmask(), 488 0b0000, 489 ); 490 assert_eq!( 491 ($mask::new(true, true, true, true) | $mask::new(true, true, true, true)).bitmask(), 492 0b1111, 493 ); 494 assert_eq!( 495 ($mask::new(true, false, true, false) | $mask::new(false, true, false, true)) 496 .bitmask(), 497 0b1111, 498 ); 499 assert_eq!( 500 ($mask::new(true, false, true, false) | $mask::new(true, false, true, false)) 501 .bitmask(), 502 0b0101, 503 ); 504 505 let mut mask = $mask::new(true, true, false, false); 506 mask |= $mask::new(true, false, true, false); 507 assert_eq!(mask.bitmask(), 0b0111); 508 }); 509 510 glam_test!(test_mask_xor, { 511 assert_eq!( 512 ($mask::new(false, false, false, false) ^ $mask::new(false, false, false, false)) 513 .bitmask(), 514 0b0000, 515 ); 516 assert_eq!( 517 ($mask::new(true, true, true, true) ^ $mask::new(true, true, true, true)).bitmask(), 518 0b0000, 519 ); 520 assert_eq!( 521 ($mask::new(true, false, true, false) ^ $mask::new(false, true, false, true)) 522 .bitmask(), 523 0b1111, 524 ); 525 assert_eq!( 526 ($mask::new(true, false, true, false) ^ $mask::new(true, false, true, false)) 527 .bitmask(), 528 0b0000, 529 ); 530 531 let mut mask = $mask::new(true, true, false, false); 532 mask ^= $mask::new(true, false, true, false); 533 assert_eq!(mask.bitmask(), 0b0110); 534 }); 535 536 glam_test!(test_mask_not, { 537 assert_eq!((!$mask::new(false, false, false, false)).bitmask(), 0b1111); 538 assert_eq!((!$mask::new(true, true, true, true)).bitmask(), 0b0000); 539 assert_eq!((!$mask::new(true, false, true, false)).bitmask(), 0b1010); 540 assert_eq!((!$mask::new(false, true, false, true)).bitmask(), 0b0101); 541 }); 542 543 glam_test!(test_mask_fmt, { 544 let a = $mask::new(true, false, true, false); 545 546 assert_eq!(format!("{}", a), "[true, false, true, false]"); 547 assert_eq!( 548 format!("{:?}", a), 549 format!("{}(0xffffffff, 0x0, 0xffffffff, 0x0)", stringify!($mask)) 550 ); 551 }); 552 553 glam_test!(test_mask_eq, { 554 let a = $mask::new(true, false, true, false); 555 let b = $mask::new(true, false, true, false); 556 let c = $mask::new(false, true, true, false); 557 558 assert_eq!(a, b); 559 assert_eq!(b, a); 560 assert_ne!(a, c); 561 assert_ne!(b, c); 562 }); 563 564 glam_test!(test_mask_test, { 565 let a = $mask::new(true, false, true, false); 566 assert_eq!(a.test(0), true); 567 assert_eq!(a.test(1), false); 568 assert_eq!(a.test(2), true); 569 assert_eq!(a.test(3), false); 570 571 let b = $mask::new(false, true, false, true); 572 assert_eq!(b.test(0), false); 573 assert_eq!(b.test(1), true); 574 assert_eq!(b.test(2), false); 575 assert_eq!(b.test(3), true); 576 }); 577 578 glam_test!(test_mask_set, { 579 let mut a = $mask::new(false, true, false, true); 580 a.set(0, true); 581 assert_eq!(a.test(0), true); 582 a.set(1, false); 583 assert_eq!(a.test(1), false); 584 a.set(2, true); 585 assert_eq!(a.test(2), true); 586 a.set(3, false); 587 assert_eq!(a.test(3), false); 588 589 let mut b = $mask::new(true, false, true, false); 590 b.set(0, false); 591 assert_eq!(b.test(0), false); 592 b.set(1, true); 593 assert_eq!(b.test(1), true); 594 b.set(2, false); 595 assert_eq!(b.test(2), false); 596 b.set(3, true); 597 assert_eq!(b.test(3), true); 598 }); 599 600 glam_test!(test_mask_hash, { 601 use std::collections::hash_map::DefaultHasher; 602 use std::hash::Hash; 603 use std::hash::Hasher; 604 605 let a = $mask::new(true, false, true, false); 606 let b = $mask::new(true, false, true, false); 607 let c = $mask::new(false, true, true, false); 608 609 let mut hasher = DefaultHasher::new(); 610 a.hash(&mut hasher); 611 let a_hashed = hasher.finish(); 612 613 let mut hasher = DefaultHasher::new(); 614 b.hash(&mut hasher); 615 let b_hashed = hasher.finish(); 616 617 let mut hasher = DefaultHasher::new(); 618 c.hash(&mut hasher); 619 let c_hashed = hasher.finish(); 620 621 assert_eq!(a, b); 622 assert_eq!(a_hashed, b_hashed); 623 assert_ne!(a, c); 624 assert_ne!(a_hashed, c_hashed); 625 }); 626 627 glam_test!(test_to_from_slice, { 628 let v = $vec4::new(1 as $t, 2 as $t, 3 as $t, 4 as $t); 629 let mut a = [0 as $t, 0 as $t, 0 as $t, 0 as $t]; 630 v.write_to_slice(&mut a); 631 assert_eq!(v, $vec4::from_slice(&a)); 632 }); 633 634 glam_test!(test_sum, { 635 let one = $vec4::ONE; 636 assert_eq!([one, one].iter().sum::<$vec4>(), one + one); 637 assert_eq!([one, one].into_iter().sum::<$vec4>(), one + one); 638 }); 639 640 glam_test!(test_product, { 641 let two = $vec4::new(2 as $t, 2 as $t, 2 as $t, 2 as $t); 642 assert_eq!([two, two].iter().product::<$vec4>(), two * two); 643 assert_eq!([two, two].into_iter().product::<$vec4>(), two * two); 644 }); 645 }; 646 } 647 648 macro_rules! impl_vec4_signed_tests { 649 ($t:ident, $new:ident, $vec4:ident, $vec3:ident, $vec2:ident, $mask:ident) => { 650 impl_vec4_tests!($t, $new, $vec4, $vec3, $vec2, $mask); 651 652 glam_test!(test_neg, { 653 let a = $new(1 as $t, 2 as $t, 3 as $t, 4 as $t); 654 assert_eq!((-1 as $t, -2 as $t, -3 as $t, -4 as $t), (-a).into()); 655 assert_eq!( 656 $new(-0 as $t, -0 as $t, -0 as $t, -0 as $t), 657 -$new(0 as $t, 0 as $t, 0 as $t, 0 as $t) 658 ); 659 assert_eq!( 660 $new(0 as $t, -0 as $t, -0 as $t, -0 as $t), 661 -$new(-0 as $t, 0 as $t, 0 as $t, 0 as $t) 662 ); 663 }); 664 665 glam_test!(test_is_negative_bitmask, { 666 assert_eq!($vec4::ZERO.is_negative_bitmask(), 0b0000); 667 assert_eq!($vec4::ONE.is_negative_bitmask(), 0b0000); 668 assert_eq!((-$vec4::ONE).is_negative_bitmask(), 0b1111); 669 assert_eq!( 670 $vec4::new(-1 as $t, 2 as $t, 3 as $t, -4 as $t).is_negative_bitmask(), 671 0b1001 672 ); 673 assert_eq!( 674 $vec4::new(1 as $t, 5 as $t, -3 as $t, 7 as $t).is_negative_bitmask(), 675 0b0100 676 ); 677 assert_eq!( 678 $vec4::new(3 as $t, -4 as $t, 1 as $t, 6 as $t).is_negative_bitmask(), 679 0b0010 680 ); 681 assert_eq!( 682 $vec4::new(2 as $t, -6 as $t, 5 as $t, -3 as $t).is_negative_bitmask(), 683 0b1010 684 ); 685 }); 686 687 glam_test!(test_abs, { 688 assert_eq!($vec4::ZERO.abs(), $vec4::ZERO); 689 assert_eq!($vec4::ONE.abs(), $vec4::ONE); 690 assert_eq!((-$vec4::ONE).abs(), $vec4::ONE); 691 }); 692 693 glam_test!(test_dot_signed, { 694 let x = $new(1 as $t, 0 as $t, 0 as $t, 0 as $t); 695 let y = $new(0 as $t, 1 as $t, 0 as $t, 0 as $t); 696 let z = $new(0 as $t, 0 as $t, 1 as $t, 0 as $t); 697 let w = $new(0 as $t, 0 as $t, 0 as $t, 1 as $t); 698 assert_eq!(1 as $t, x.dot(x)); 699 assert_eq!(0 as $t, x.dot(y)); 700 assert_eq!(0 as $t, x.dot(-z)); 701 assert_eq!(-1 as $t, w.dot(-w)); 702 }); 703 704 glam_test!(test_length_squared_signed, { 705 let x = $new(1 as $t, 0 as $t, 0 as $t, 0 as $t); 706 let y = $new(0 as $t, 1 as $t, 0 as $t, 0 as $t); 707 let z = $new(0 as $t, 0 as $t, 1 as $t, 0 as $t); 708 let w = $new(0 as $t, 0 as $t, 0 as $t, 1 as $t); 709 assert_eq!(4 as $t, (2 as $t * x).length_squared()); 710 assert_eq!(9 as $t, (-3 as $t * y).length_squared()); 711 assert_eq!(16 as $t, (4 as $t * z).length_squared()); 712 assert_eq!(64 as $t, (8 as $t * w).length_squared()); 713 assert_eq!( 714 2 as $t * 2 as $t + 3 as $t * 3 as $t + 4 as $t * 4 as $t + 5 as $t * 5 as $t, 715 $new(2 as $t, 3 as $t, 4 as $t, 5 as $t).length_squared() 716 ); 717 assert_eq!(2 as $t, x.distance_squared(y)); 718 assert_eq!(13 as $t, (2 as $t * x).distance_squared(-3 as $t * z)); 719 }); 720 721 glam_test!(test_div_euclid, { 722 let one = $vec4::ONE; 723 let two = one + one; 724 let three = two + one; 725 assert_eq!(three.div_euclid(two), one); 726 assert_eq!((-three).div_euclid(two), -two); 727 assert_eq!(three.div_euclid(-two), -one); 728 assert_eq!((-three).div_euclid(-two), two); 729 }); 730 731 glam_test!(test_rem_euclid, { 732 let one = $vec4::ONE; 733 let two = one + one; 734 let three = two + one; 735 let four = three + one; 736 assert_eq!(four.rem_euclid(three), one); 737 assert_eq!((-four).rem_euclid(three), two); 738 assert_eq!(four.rem_euclid(-three), one); 739 assert_eq!((-four).rem_euclid(-three), two); 740 }); 741 }; 742 } 743 744 macro_rules! impl_vec4_signed_integer_tests { 745 ($t:ident, $new:ident, $vec4:ident, $vec3:ident, $vec2:ident, $mask:ident) => { 746 impl_vec4_signed_tests!($t, $new, $vec4, $vec3, $vec2, $mask); 747 748 glam_test!(test_signum, { 749 assert_eq!($vec4::ZERO.signum(), $vec4::ZERO); 750 assert_eq!($vec4::ONE.signum(), $vec4::ONE); 751 assert_eq!((-$vec4::ONE).signum(), -$vec4::ONE); 752 }); 753 }; 754 } 755 756 macro_rules! impl_vec4_eq_hash_tests { 757 ($t:ident, $new:ident) => { 758 glam_test!(test_ve2_hash, { 759 use std::collections::hash_map::DefaultHasher; 760 use std::hash::Hash; 761 use std::hash::Hasher; 762 763 let a = $new(1 as $t, 2 as $t, 3 as $t, 4 as $t); 764 let b = $new(1 as $t, 2 as $t, 3 as $t, 4 as $t); 765 let c = $new(3 as $t, 2 as $t, 1 as $t, 4 as $t); 766 767 let mut hasher = DefaultHasher::new(); 768 a.hash(&mut hasher); 769 let a_hashed = hasher.finish(); 770 771 let mut hasher = DefaultHasher::new(); 772 b.hash(&mut hasher); 773 let b_hashed = hasher.finish(); 774 775 let mut hasher = DefaultHasher::new(); 776 c.hash(&mut hasher); 777 let c_hashed = hasher.finish(); 778 779 assert_eq!(a, b); 780 assert_eq!(a_hashed, b_hashed); 781 assert_ne!(a, c); 782 assert_ne!(a_hashed, c_hashed); 783 }); 784 }; 785 } 786 787 macro_rules! impl_vec4_float_tests { 788 ($t:ident, $new:ident, $vec4:ident, $vec3:ident, $vec2:ident, $mask:ident) => { 789 impl_vec4_signed_tests!($t, $new, $vec4, $vec3, $vec2, $mask); 790 impl_vec_float_normalize_tests!($t, $vec4); 791 792 use core::$t::INFINITY; 793 use core::$t::NAN; 794 use core::$t::NEG_INFINITY; 795 796 glam_test!(test_vec4_nan, { 797 assert!($vec4::NAN.is_nan()); 798 assert!(!$vec4::NAN.is_finite()); 799 }); 800 801 glam_test!(test_funcs, { 802 let x = $new(1.0, 0.0, 0.0, 0.0); 803 let y = $new(0.0, 1.0, 0.0, 0.0); 804 let z = $new(0.0, 0.0, 1.0, 0.0); 805 let w = $new(0.0, 0.0, 0.0, 1.0); 806 assert_eq!(2.0, (-2.0 * x).length()); 807 assert_eq!(3.0, (3.0 * y).length()); 808 assert_eq!(4.0, (-4.0 * z).length()); 809 assert_eq!(5.0, (-5.0 * w).length()); 810 assert_eq!((2.0 as $t).sqrt(), w.distance(y)); 811 assert_eq!(5.0, (3.0 * x).distance(-4.0 * y)); 812 assert_eq!(13.0, (-5.0 * w).distance(12.0 * y)); 813 assert_eq!(x, (2.0 * x).normalize()); 814 assert_eq!( 815 1.0 * 5.0 + 2.0 * 6.0 + 3.0 * 7.0 + 4.0 * 8.0, 816 $new(1.0, 2.0, 3.0, 4.0).dot($new(5.0, 6.0, 7.0, 8.0)) 817 ); 818 assert_eq!( 819 (2.0 as $t * 2.0 + 3.0 * 3.0 + 4.0 * 4.0 + 5.0 * 5.0).sqrt(), 820 $new(2.0, 3.0, 4.0, 5.0).length() 821 ); 822 assert_eq!( 823 1.0 / (2.0 as $t * 2.0 + 3.0 * 3.0 + 4.0 * 4.0 + 5.0 * 5.0).sqrt(), 824 $new(2.0, 3.0, 4.0, 5.0).length_recip() 825 ); 826 assert!($new(2.0, 3.0, 4.0, 5.0).normalize().is_normalized()); 827 assert_approx_eq!( 828 $new(2.0, 3.0, 4.0, 5.0) 829 / (2.0 as $t * 2.0 + 3.0 * 3.0 + 4.0 * 4.0 + 5.0 * 5.0).sqrt(), 830 $new(2.0, 3.0, 4.0, 5.0).normalize() 831 ); 832 assert_eq!( 833 $new(0.5, 0.25, 0.125, 0.0625), 834 $new(2.0, 4.0, 8.0, 16.0).recip() 835 ); 836 }); 837 838 glam_test!(test_project_reject, { 839 assert_eq!( 840 $new(0.0, 0.0, 0.0, 1.0), 841 $new(0.0, 1.0, 0.0, 1.0).project_onto($new(0.0, 0.0, 0.0, 2.0)) 842 ); 843 assert_eq!( 844 $new(0.0, 1.0, 0.0, 0.0), 845 $new(0.0, 1.0, 0.0, 1.0).reject_from($new(0.0, 0.0, 0.0, 2.0)) 846 ); 847 assert_eq!( 848 $new(0.0, 0.0, 0.0, 1.0), 849 $new(0.0, 1.0, 0.0, 1.0).project_onto_normalized($new(0.0, 0.0, 0.0, 1.0)) 850 ); 851 assert_eq!( 852 $new(0.0, 1.0, 0.0, 0.0), 853 $new(0.0, 1.0, 0.0, 1.0).reject_from_normalized($new(0.0, 0.0, 0.0, 1.0)) 854 ); 855 should_glam_assert!({ $vec4::ONE.project_onto($vec4::ZERO) }); 856 should_glam_assert!({ $vec4::ONE.reject_from($vec4::ZERO) }); 857 should_glam_assert!({ $vec4::ONE.project_onto_normalized($vec4::ONE) }); 858 should_glam_assert!({ $vec4::ONE.reject_from_normalized($vec4::ONE) }); 859 }); 860 861 glam_test!(test_signum, { 862 assert_eq!($vec4::ZERO.signum(), $vec4::ONE); 863 assert_eq!((-$vec4::ZERO).signum(), -$vec4::ONE); 864 assert_eq!($vec4::ONE.signum(), $vec4::ONE); 865 assert_eq!((-$vec4::ONE).signum(), -$vec4::ONE); 866 assert_eq!($vec4::INFINITY.signum(), $vec4::ONE); 867 assert_eq!($vec4::NEG_INFINITY.signum(), -$vec4::ONE); 868 assert!($vec4::NAN.signum().is_nan_mask().all()); 869 }); 870 871 glam_test!(test_copysign, { 872 assert_eq!($vec4::ZERO.copysign(-$vec4::ZERO), -$vec4::ZERO); 873 assert_eq!((-$vec4::ZERO).copysign(-$vec4::ZERO), -$vec4::ZERO); 874 assert_eq!($vec4::ZERO.copysign($vec4::ZERO), $vec4::ZERO); 875 assert_eq!((-$vec4::ZERO).copysign($vec4::ZERO), $vec4::ZERO); 876 assert_eq!($vec4::ONE.copysign(-$vec4::ZERO), -$vec4::ONE); 877 assert_eq!((-$vec4::ONE).copysign(-$vec4::ZERO), -$vec4::ONE); 878 assert_eq!($vec4::ONE.copysign($vec4::ZERO), $vec4::ONE); 879 assert_eq!((-$vec4::ONE).copysign($vec4::ZERO), $vec4::ONE); 880 assert_eq!($vec4::ZERO.copysign(-$vec4::ONE), -$vec4::ZERO); 881 assert_eq!((-$vec4::ZERO).copysign(-$vec4::ONE), -$vec4::ZERO); 882 assert_eq!($vec4::ZERO.copysign($vec4::ONE), $vec4::ZERO); 883 assert_eq!((-$vec4::ZERO).copysign($vec4::ONE), $vec4::ZERO); 884 assert_eq!($vec4::ONE.copysign(-$vec4::ONE), -$vec4::ONE); 885 assert_eq!((-$vec4::ONE).copysign(-$vec4::ONE), -$vec4::ONE); 886 assert_eq!($vec4::ONE.copysign($vec4::ONE), $vec4::ONE); 887 assert_eq!((-$vec4::ONE).copysign($vec4::ONE), $vec4::ONE); 888 assert_eq!($vec4::INFINITY.copysign($vec4::ONE), $vec4::INFINITY); 889 assert_eq!($vec4::INFINITY.copysign(-$vec4::ONE), $vec4::NEG_INFINITY); 890 assert_eq!($vec4::NEG_INFINITY.copysign($vec4::ONE), $vec4::INFINITY); 891 assert_eq!( 892 $vec4::NEG_INFINITY.copysign(-$vec4::ONE), 893 $vec4::NEG_INFINITY 894 ); 895 assert!($vec4::NAN.copysign($vec4::ONE).is_nan_mask().all()); 896 assert!($vec4::NAN.copysign(-$vec4::ONE).is_nan_mask().all()); 897 }); 898 899 glam_test!(test_float_is_negative_bitmask, { 900 assert_eq!($vec4::ZERO.is_negative_bitmask(), 0b0000); 901 assert_eq!((-$vec4::ZERO).is_negative_bitmask(), 0b1111); 902 assert_eq!($vec4::ONE.is_negative_bitmask(), 0b0000); 903 assert_eq!((-$vec4::ONE).is_negative_bitmask(), 0b1111); 904 assert_eq!( 905 $vec4::new(-1.0, 2.0, 3.0, -4.0).is_negative_bitmask(), 906 0b1001 907 ); 908 assert_eq!( 909 $vec4::new(8.0, 3.0, 1.0, -0.0).is_negative_bitmask(), 910 0b1000 911 ); 912 assert_eq!( 913 $vec4::new(1.0, 5.0, -3.0, 7.0).is_negative_bitmask(), 914 0b0100 915 ); 916 assert_eq!( 917 $vec4::new(3.0, -4.0, 1.0, 6.0).is_negative_bitmask(), 918 0b0010 919 ); 920 assert_eq!( 921 $vec4::new(2.0, -6.0, 5.0, -3.0).is_negative_bitmask(), 922 0b1010 923 ); 924 }); 925 926 glam_test!(test_round, { 927 assert_eq!($vec4::new(1.35, 0.0, 0.0, 0.0).round().x, 1.0); 928 assert_eq!($vec4::new(0.0, 1.5, 0.0, 0.0).round().y, 2.0); 929 assert_eq!($vec4::new(0.0, 0.0, -15.5, 0.0).round().z, -16.0); 930 assert_eq!($vec4::new(0.0, 0.0, 0.0, 0.0).round().z, 0.0); 931 assert_eq!($vec4::new(0.0, 21.1, 0.0, 0.0).round().y, 21.0); 932 assert_eq!($vec4::new(0.0, 0.0, 0.0, 11.123).round().w, 11.0); 933 assert_eq!($vec4::new(0.0, 0.0, 11.501, 0.0).round().z, 12.0); 934 assert_eq!( 935 $vec4::new(NEG_INFINITY, INFINITY, 1.0, -1.0).round(), 936 $vec4::new(NEG_INFINITY, INFINITY, 1.0, -1.0) 937 ); 938 assert!($vec4::new(NAN, 0.0, 0.0, 1.0).round().x.is_nan()); 939 }); 940 941 glam_test!(test_floor, { 942 assert_eq!( 943 $vec4::new(1.35, 1.5, -1.5, 1.999).floor(), 944 $vec4::new(1.0, 1.0, -2.0, 1.0) 945 ); 946 assert_eq!( 947 $vec4::new(INFINITY, NEG_INFINITY, 0.0, 0.0).floor(), 948 $vec4::new(INFINITY, NEG_INFINITY, 0.0, 0.0) 949 ); 950 assert!($vec4::new(0.0, NAN, 0.0, 0.0).floor().y.is_nan()); 951 assert_eq!( 952 $vec4::new(-0.0, -2000000.123, 10000000.123, 1000.9).floor(), 953 $vec4::new(-0.0, -2000001.0, 10000000.0, 1000.0) 954 ); 955 }); 956 957 glam_test!(test_fract, { 958 assert_approx_eq!( 959 $vec4::new(1.35, 1.5, -1.5, 1.999).fract(), 960 $vec4::new(0.35, 0.5, 0.5, 0.999) 961 ); 962 assert_approx_eq!( 963 $vec4::new(-0.0, -200000.123, 1000000.123, 1000.9).fract(), 964 $vec4::new(0.0, 0.877, 0.123, 0.9), 965 0.002 966 ); 967 }); 968 969 glam_test!(test_ceil, { 970 assert_eq!( 971 $vec4::new(1.35, 1.5, -1.5, 1234.1234).ceil(), 972 $vec4::new(2.0, 2.0, -1.0, 1235.0) 973 ); 974 assert_eq!( 975 $vec4::new(INFINITY, NEG_INFINITY, 0.0, 0.0).ceil(), 976 $vec4::new(INFINITY, NEG_INFINITY, 0.0, 0.0) 977 ); 978 assert!($vec4::new(0.0, 0.0, NAN, 0.0).ceil().z.is_nan()); 979 assert_eq!( 980 $vec4::new(-1234.1234, -2000000.123, 1000000.123, 1000.9).ceil(), 981 $vec4::new(-1234.0, -2000000.0, 1000001.0, 1001.0) 982 ); 983 }); 984 985 glam_test!(test_trunc, { 986 assert_eq!( 987 $vec4::new(1.35, 1.5, -1.5, 1.999).trunc(), 988 $vec4::new(1.0, 1.0, -1.0, 1.0) 989 ); 990 assert_eq!( 991 $vec4::new(INFINITY, NEG_INFINITY, 0.0, 0.0).trunc(), 992 $vec4::new(INFINITY, NEG_INFINITY, 0.0, 0.0) 993 ); 994 assert!($vec4::new(0.0, NAN, 0.0, 0.0).trunc().y.is_nan()); 995 assert_eq!( 996 $vec4::new(-0.0, -2000000.123, 10000000.123, 1000.9).trunc(), 997 $vec4::new(-0.0, -2000000.0, 10000000.0, 1000.0) 998 ); 999 }); 1000 1001 glam_test!(test_lerp, { 1002 let v0 = $vec4::new(-1.0, -1.0, -1.0, -1.0); 1003 let v1 = $vec4::new(1.0, 1.0, 1.0, 1.0); 1004 assert_approx_eq!(v0, v0.lerp(v1, 0.0)); 1005 assert_approx_eq!(v1, v0.lerp(v1, 1.0)); 1006 assert_approx_eq!($vec4::ZERO, v0.lerp(v1, 0.5)); 1007 }); 1008 1009 glam_test!(test_is_finite, { 1010 assert!($vec4::new(0.0, 0.0, 0.0, 0.0).is_finite()); 1011 assert!($vec4::new(-1e-10, 1.0, 1e10, 42.0).is_finite()); 1012 assert!(!$vec4::new(INFINITY, 0.0, 0.0, 0.0).is_finite()); 1013 assert!(!$vec4::new(0.0, NAN, 0.0, 0.0).is_finite()); 1014 assert!(!$vec4::new(0.0, 0.0, NEG_INFINITY, 0.0).is_finite()); 1015 assert!(!$vec4::new(0.0, 0.0, 0.0, NAN).is_finite()); 1016 assert!(!$vec4::INFINITY.is_finite()); 1017 assert!(!$vec4::NEG_INFINITY.is_finite()); 1018 }); 1019 1020 glam_test!(test_powf, { 1021 assert_eq!( 1022 $vec4::new(2.0, 4.0, 8.0, 16.0).powf(2.0), 1023 $vec4::new(4.0, 16.0, 64.0, 256.0) 1024 ); 1025 }); 1026 1027 glam_test!(test_exp, { 1028 assert_approx_eq!( 1029 $vec4::new(1.0, 2.0, 3.0, 4.0).exp(), 1030 $vec4::new( 1031 (1.0 as $t).exp(), 1032 (2.0 as $t).exp(), 1033 (3.0 as $t).exp(), 1034 (4.0 as $t).exp() 1035 ), 1036 1e-5 1037 ); 1038 }); 1039 1040 glam_test!(test_clamp_length, { 1041 // Too long gets shortened 1042 assert_eq!( 1043 $vec4::new(12.0, 16.0, 0.0, 0.0).clamp_length(7.0, 10.0), 1044 $vec4::new(6.0, 8.0, 0.0, 0.0) // shortened to length 10.0 1045 ); 1046 // In the middle is unchanged 1047 assert_eq!( 1048 $vec4::new(2.0, 1.0, 0.0, 0.0).clamp_length(0.5, 5.0), 1049 $vec4::new(2.0, 1.0, 0.0, 0.0) // unchanged 1050 ); 1051 // Too short gets lengthened 1052 assert_eq!( 1053 $vec4::new(0.6, 0.8, 0.0, 0.0).clamp_length(10.0, 20.0), 1054 $vec4::new(6.0, 8.0, 0.0, 0.0) // lengthened to length 10.0 1055 ); 1056 should_glam_assert!({ $vec4::ONE.clamp_length(1.0, 0.0) }); 1057 }); 1058 1059 glam_test!(test_clamp_length_max, { 1060 // Too long gets shortened 1061 assert_eq!( 1062 $vec4::new(12.0, 16.0, 0.0, 0.0).clamp_length_max(10.0), 1063 $vec4::new(6.0, 8.0, 0.0, 0.0) // shortened to length 10.0 1064 ); 1065 // Not too long is unchanged 1066 assert_eq!( 1067 $vec4::new(2.0, 1.0, 0.0, 0.0).clamp_length_max(5.0), 1068 $vec4::new(2.0, 1.0, 0.0, 0.0) // unchanged 1069 ); 1070 }); 1071 1072 glam_test!(test_clamp_length_min, { 1073 // Not too short is unchanged 1074 assert_eq!( 1075 $vec4::new(2.0, 1.0, 0.0, 0.0).clamp_length_min(0.5), 1076 $vec4::new(2.0, 1.0, 0.0, 0.0) // unchanged 1077 ); 1078 // Too short gets lengthened 1079 assert_eq!( 1080 $vec4::new(0.6, 0.8, 0.0, 0.0).clamp_length_min(10.0), 1081 $vec4::new(6.0, 8.0, 0.0, 0.0) // lengthened to length 10.0 1082 ); 1083 }); 1084 1085 glam_test!(test_mul_add, { 1086 assert_eq!( 1087 $vec4::new(1.0, 1.0, 1.0, 1.0).mul_add( 1088 $vec4::new(0.5, 2.0, -4.0, 0.0), 1089 $vec4::new(-1.0, -1.0, -1.0, -1.0) 1090 ), 1091 $vec4::new(-0.5, 1.0, -5.0, -1.0) 1092 ); 1093 }); 1094 }; 1095 } 1096 1097 macro_rules! impl_vec4_scalar_shift_op_test { 1098 ($vec4:ident, $t_min:literal, $t_max:literal, $rhs_min:literal, $rhs_max:literal) => { 1099 glam_test!(test_vec4_scalar_shift_ops, { 1100 for x in $t_min..$t_max { 1101 for y in $t_min..$t_max { 1102 for z in $t_min..$t_max { 1103 for w in $t_min..$t_max { 1104 for rhs in $rhs_min..$rhs_max { 1105 assert_eq!( 1106 $vec4::new(x, y, z, w) << rhs, 1107 $vec4::new(x << rhs, y << rhs, z << rhs, w << rhs) 1108 ); 1109 assert_eq!( 1110 $vec4::new(x, y, z, w) >> rhs, 1111 $vec4::new(x >> rhs, y >> rhs, z >> rhs, w >> rhs) 1112 ); 1113 } 1114 } 1115 } 1116 } 1117 } 1118 }); 1119 }; 1120 } 1121 1122 macro_rules! impl_vec4_scalar_shift_op_tests { 1123 ($vec4:ident, $t_min:literal, $t_max:literal) => { 1124 mod shift_by_i8 { 1125 use glam::$vec4; 1126 impl_vec4_scalar_shift_op_test!($vec4, $t_min, $t_max, 0i8, 2); 1127 } 1128 mod shift_by_i16 { 1129 use glam::$vec4; 1130 impl_vec4_scalar_shift_op_test!($vec4, $t_min, $t_max, 0i16, 2); 1131 } 1132 mod shift_by_i32 { 1133 use glam::$vec4; 1134 impl_vec4_scalar_shift_op_test!($vec4, $t_min, $t_max, 0i32, 2); 1135 } 1136 mod shift_by_i64 { 1137 use glam::$vec4; 1138 impl_vec4_scalar_shift_op_test!($vec4, $t_min, $t_max, 0i64, 2); 1139 } 1140 mod shift_by_u8 { 1141 use glam::$vec4; 1142 impl_vec4_scalar_shift_op_test!($vec4, $t_min, $t_max, 0u8, 2); 1143 } 1144 mod shift_by_u16 { 1145 use glam::$vec4; 1146 impl_vec4_scalar_shift_op_test!($vec4, $t_min, $t_max, 0u16, 2); 1147 } 1148 mod shift_by_u32 { 1149 use glam::$vec4; 1150 impl_vec4_scalar_shift_op_test!($vec4, $t_min, $t_max, 0u32, 2); 1151 } 1152 mod shift_by_u64 { 1153 use glam::$vec4; 1154 impl_vec4_scalar_shift_op_test!($vec4, $t_min, $t_max, 0u64, 2); 1155 } 1156 }; 1157 } 1158 1159 macro_rules! impl_vec4_shift_op_test { 1160 ($vec4:ident, $rhs:ident, $t_min:literal, $t_max:literal) => { 1161 glam_test!(test_vec4_shift_ops, { 1162 for x1 in $t_min..$t_max { 1163 for y1 in $t_min..$t_max { 1164 for z1 in $t_min..$t_max { 1165 for w1 in $t_min..$t_max { 1166 for x2 in $t_min..$t_max { 1167 for y2 in $t_min..$t_max { 1168 for z2 in $t_min..$t_max { 1169 for w2 in $t_min..$t_max { 1170 assert_eq!( 1171 $vec4::new(x1, y1, z1, w1) 1172 << $rhs::new(x2, y2, z2, w2), 1173 $vec4::new(x1 << x2, y1 << y2, z1 << z2, w1 << w2) 1174 ); 1175 assert_eq!( 1176 $vec4::new(x1, y1, z1, w1) 1177 >> $rhs::new(x2, y2, z2, w2), 1178 $vec4::new(x1 >> x2, y1 >> y2, z1 >> z2, w1 >> w2) 1179 ); 1180 } 1181 } 1182 } 1183 } 1184 } 1185 } 1186 } 1187 } 1188 }); 1189 }; 1190 } 1191 1192 macro_rules! impl_vec4_shift_op_tests { 1193 ($vec4:ident) => { 1194 mod shift_ivec4_by_ivec4 { 1195 use super::*; 1196 impl_vec4_shift_op_test!($vec4, IVec4, 0, 2); 1197 } 1198 mod shift_ivec4_by_uvec4 { 1199 use super::*; 1200 impl_vec4_shift_op_test!($vec4, UVec4, 0, 2); 1201 } 1202 }; 1203 } 1204 1205 macro_rules! impl_vec4_scalar_bit_op_tests { 1206 ($vec4:ident, $t_min:literal, $t_max:literal) => { 1207 glam_test!(test_vec4_scalar_bit_ops, { 1208 for x in $t_min..$t_max { 1209 for y in $t_min..$t_max { 1210 for z in $t_min..$t_max { 1211 for w in $t_min..$t_max { 1212 for rhs in $t_min..$t_max { 1213 assert_eq!( 1214 $vec4::new(x, y, z, w) & rhs, 1215 $vec4::new(x & rhs, y & rhs, z & rhs, w & rhs) 1216 ); 1217 assert_eq!( 1218 $vec4::new(x, y, z, w) | rhs, 1219 $vec4::new(x | rhs, y | rhs, z | rhs, w | rhs) 1220 ); 1221 assert_eq!( 1222 $vec4::new(x, y, z, w) ^ rhs, 1223 $vec4::new(x ^ rhs, y ^ rhs, z ^ rhs, w ^ rhs) 1224 ); 1225 } 1226 } 1227 } 1228 } 1229 } 1230 }); 1231 }; 1232 } 1233 1234 macro_rules! impl_vec4_bit_op_tests { 1235 ($vec4:ident, $t_min:literal, $t_max:literal) => { 1236 glam_test!(test_vec4_bit_ops, { 1237 for x1 in $t_min..$t_max { 1238 for y1 in $t_min..$t_max { 1239 for z1 in $t_min..$t_max { 1240 for w1 in $t_min..$t_max { 1241 assert_eq!(!$vec4::new(x1, y1, z1, w1), $vec4::new(!x1, !y1, !z1, !w1)); 1242 1243 for x2 in $t_min..$t_max { 1244 for y2 in $t_min..$t_max { 1245 for z2 in $t_min..$t_max { 1246 for w2 in $t_min..$t_max { 1247 assert_eq!( 1248 $vec4::new(x1, y1, z1, w1) 1249 & $vec4::new(x2, y2, z2, w2), 1250 $vec4::new(x1 & x2, y1 & y2, z1 & z2, w1 & w2) 1251 ); 1252 assert_eq!( 1253 $vec4::new(x1, y1, z1, w1) 1254 | $vec4::new(x2, y2, z2, w2), 1255 $vec4::new(x1 | x2, y1 | y2, z1 | z2, w1 | w2) 1256 ); 1257 assert_eq!( 1258 $vec4::new(x1, y1, z1, w1) 1259 ^ $vec4::new(x2, y2, z2, w2), 1260 $vec4::new(x1 ^ x2, y1 ^ y2, z1 ^ z2, w1 ^ w2) 1261 ); 1262 } 1263 } 1264 } 1265 } 1266 } 1267 } 1268 } 1269 } 1270 }); 1271 }; 1272 } 1273 1274 mod vec4 { 1275 #[cfg(any( 1276 not(any(target_feature = "sse2", target_feature = "simd128")), 1277 feature = "scalar-math" 1278 ))] 1279 use glam::BVec4; 1280 #[cfg(not(feature = "scalar-math"))] 1281 use glam::BVec4A; 1282 use glam::{vec4, Vec2, Vec3, Vec4}; 1283 1284 glam_test!(test_align, { 1285 use std::mem; 1286 assert_eq!(16, mem::size_of::<Vec4>()); 1287 if cfg!(any(not(feature = "scalar-math"), feature = "cuda")) { 1288 assert_eq!(16, mem::align_of::<Vec4>()); 1289 } else { 1290 assert_eq!(4, mem::align_of::<Vec4>()); 1291 } 1292 #[cfg(not(feature = "scalar-math"))] 1293 { 1294 assert_eq!(16, mem::size_of::<BVec4A>()); 1295 assert_eq!(16, mem::align_of::<BVec4A>()); 1296 } 1297 #[cfg(feature = "scalar-math")] 1298 { 1299 assert_eq!(4, mem::size_of::<BVec4>()); 1300 assert_eq!(1, mem::align_of::<BVec4>()); 1301 } 1302 }); 1303 1304 #[cfg(all( 1305 target_feature = "sse2", 1306 not(any(feature = "core-simd", feature = "scalar-math")) 1307 ))] 1308 #[test] test_m128()1309 fn test_m128() { 1310 #[cfg(target_arch = "x86")] 1311 use core::arch::x86::*; 1312 #[cfg(target_arch = "x86_64")] 1313 use core::arch::x86_64::*; 1314 1315 #[repr(C, align(16))] 1316 struct F32x4_A16([f32; 4]); 1317 1318 let v0 = Vec4::new(1.0, 2.0, 3.0, 4.0); 1319 let m0: __m128 = v0.into(); 1320 let mut a0 = F32x4_A16([0.0, 0.0, 0.0, 0.0]); 1321 unsafe { 1322 _mm_store_ps(a0.0.as_mut_ptr(), m0); 1323 } 1324 assert_eq!([1.0, 2.0, 3.0, 4.0], a0.0); 1325 let v1 = Vec4::from(m0); 1326 assert_eq!(v0, v1); 1327 1328 #[repr(C, align(16))] 1329 struct U32x4_A16([u32; 4]); 1330 1331 let v0 = BVec4A::new(true, false, true, false); 1332 let m0: __m128 = v0.into(); 1333 let mut a0 = U32x4_A16([1, 2, 3, 4]); 1334 unsafe { 1335 _mm_store_ps(a0.0.as_mut_ptr() as *mut f32, m0); 1336 } 1337 assert_eq!([0xffffffff, 0, 0xffffffff, 0], a0.0); 1338 } 1339 1340 glam_test!(test_as, { 1341 use glam::{DVec4, I16Vec4, I64Vec4, IVec4, U16Vec4, U64Vec4, UVec4, Vec4}; 1342 assert_eq!( 1343 DVec4::new(-1.0, -2.0, -3.0, -4.0), 1344 Vec4::new(-1.0, -2.0, -3.0, -4.0).as_dvec4() 1345 ); 1346 assert_eq!( 1347 I16Vec4::new(-1, -2, -3, -4), 1348 Vec4::new(-1.0, -2.0, -3.0, -4.0).as_i16vec4() 1349 ); 1350 assert_eq!( 1351 U16Vec4::new(1, 2, 3, 4), 1352 Vec4::new(1.0, 2.0, 3.0, 4.0).as_u16vec4() 1353 ); 1354 assert_eq!( 1355 IVec4::new(-1, -2, -3, -4), 1356 Vec4::new(-1.0, -2.0, -3.0, -4.0).as_ivec4() 1357 ); 1358 assert_eq!( 1359 UVec4::new(1, 2, 3, 4), 1360 Vec4::new(1.0, 2.0, 3.0, 4.0).as_uvec4() 1361 ); 1362 assert_eq!( 1363 I64Vec4::new(-1, -2, -3, -4), 1364 Vec4::new(-1.0, -2.0, -3.0, -4.0).as_i64vec4() 1365 ); 1366 assert_eq!( 1367 U64Vec4::new(1, 2, 3, 4), 1368 Vec4::new(1.0, 2.0, 3.0, 4.0).as_u64vec4() 1369 ); 1370 1371 assert_eq!( 1372 Vec4::new(-1.0, -2.0, -3.0, -4.0), 1373 DVec4::new(-1.0, -2.0, -3.0, -4.0).as_vec4() 1374 ); 1375 assert_eq!( 1376 I16Vec4::new(-1, -2, -3, -4), 1377 DVec4::new(-1.0, -2.0, -3.0, -4.0).as_i16vec4() 1378 ); 1379 assert_eq!( 1380 U16Vec4::new(1, 2, 3, 4), 1381 DVec4::new(1.0, 2.0, 3.0, 4.0).as_u16vec4() 1382 ); 1383 assert_eq!( 1384 IVec4::new(-1, -2, -3, -4), 1385 DVec4::new(-1.0, -2.0, -3.0, -4.0).as_ivec4() 1386 ); 1387 assert_eq!( 1388 UVec4::new(1, 2, 3, 4), 1389 DVec4::new(1.0, 2.0, 3.0, 4.0).as_uvec4() 1390 ); 1391 assert_eq!( 1392 I64Vec4::new(-1, -2, -3, -4), 1393 DVec4::new(-1.0, -2.0, -3.0, -4.0).as_i64vec4() 1394 ); 1395 assert_eq!( 1396 U64Vec4::new(1, 2, 3, 4), 1397 DVec4::new(1.0, 2.0, 3.0, 4.0).as_u64vec4() 1398 ); 1399 1400 assert_eq!( 1401 Vec4::new(-1.0, -2.0, -3.0, -4.0), 1402 I16Vec4::new(-1, -2, -3, -4).as_vec4() 1403 ); 1404 assert_eq!( 1405 DVec4::new(-1.0, -2.0, -3.0, -4.0), 1406 I16Vec4::new(-1, -2, -3, -4).as_dvec4() 1407 ); 1408 assert_eq!( 1409 U16Vec4::new(1, 2, 3, 4), 1410 I16Vec4::new(1, 2, 3, 4).as_u16vec4() 1411 ); 1412 assert_eq!( 1413 IVec4::new(-1, -2, -3, -4), 1414 I16Vec4::new(-1, -2, -3, -4).as_ivec4() 1415 ); 1416 assert_eq!(UVec4::new(1, 2, 3, 4), I16Vec4::new(1, 2, 3, 4).as_uvec4()); 1417 assert_eq!( 1418 I64Vec4::new(-1, -2, -3, -4), 1419 I16Vec4::new(-1, -2, -3, -4).as_i64vec4() 1420 ); 1421 assert_eq!( 1422 U64Vec4::new(1, 2, 3, 4), 1423 I16Vec4::new(1, 2, 3, 4).as_u64vec4() 1424 ); 1425 1426 assert_eq!( 1427 Vec4::new(1.0, 2.0, 3.0, 4.0), 1428 U16Vec4::new(1, 2, 3, 4).as_vec4() 1429 ); 1430 assert_eq!( 1431 DVec4::new(1.0, 2.0, 3.0, 4.0), 1432 U16Vec4::new(1, 2, 3, 4).as_dvec4() 1433 ); 1434 assert_eq!( 1435 I16Vec4::new(1, 2, 3, 4), 1436 U16Vec4::new(1, 2, 3, 4).as_i16vec4() 1437 ); 1438 assert_eq!(IVec4::new(1, 2, 3, 4), U16Vec4::new(1, 2, 3, 4).as_ivec4()); 1439 assert_eq!(UVec4::new(1, 2, 3, 4), U16Vec4::new(1, 2, 3, 4).as_uvec4()); 1440 assert_eq!( 1441 I64Vec4::new(1, 2, 3, 4), 1442 U16Vec4::new(1, 2, 3, 4).as_i64vec4() 1443 ); 1444 assert_eq!( 1445 U64Vec4::new(1, 2, 3, 4), 1446 U16Vec4::new(1, 2, 3, 4).as_u64vec4() 1447 ); 1448 1449 assert_eq!( 1450 Vec4::new(-1.0, -2.0, -3.0, -4.0), 1451 IVec4::new(-1, -2, -3, -4).as_vec4() 1452 ); 1453 assert_eq!( 1454 DVec4::new(-1.0, -2.0, -3.0, -4.0), 1455 IVec4::new(-1, -2, -3, -4).as_dvec4() 1456 ); 1457 assert_eq!(UVec4::new(1, 2, 3, 4), IVec4::new(1, 2, 3, 4).as_uvec4()); 1458 assert_eq!( 1459 I16Vec4::new(-1, -2, -3, -4), 1460 IVec4::new(-1, -2, -3, -4).as_i16vec4() 1461 ); 1462 assert_eq!( 1463 U16Vec4::new(1, 2, 3, 4), 1464 IVec4::new(1, 2, 3, 4).as_u16vec4() 1465 ); 1466 assert_eq!( 1467 I64Vec4::new(-1, -2, -3, -4), 1468 IVec4::new(-1, -2, -3, -4).as_i64vec4() 1469 ); 1470 assert_eq!( 1471 U64Vec4::new(1, 2, 3, 4), 1472 IVec4::new(1, 2, 3, 4).as_u64vec4() 1473 ); 1474 1475 assert_eq!( 1476 Vec4::new(1.0, 2.0, 3.0, 4.0), 1477 UVec4::new(1, 2, 3, 4).as_vec4() 1478 ); 1479 assert_eq!( 1480 DVec4::new(1.0, 2.0, 3.0, 4.0), 1481 UVec4::new(1, 2, 3, 4).as_dvec4() 1482 ); 1483 assert_eq!( 1484 I16Vec4::new(1, 2, 3, 4), 1485 UVec4::new(1, 2, 3, 4).as_i16vec4() 1486 ); 1487 assert_eq!( 1488 U16Vec4::new(1, 2, 3, 4), 1489 UVec4::new(1, 2, 3, 4).as_u16vec4() 1490 ); 1491 assert_eq!(IVec4::new(1, 2, 3, 4), UVec4::new(1, 2, 3, 4).as_ivec4()); 1492 assert_eq!( 1493 I64Vec4::new(1, 2, 3, 4), 1494 UVec4::new(1, 2, 3, 4).as_i64vec4() 1495 ); 1496 assert_eq!( 1497 U64Vec4::new(1, 2, 3, 4), 1498 UVec4::new(1, 2, 3, 4).as_u64vec4() 1499 ); 1500 1501 assert_eq!( 1502 Vec4::new(-1.0, -2.0, -3.0, -4.0), 1503 I64Vec4::new(-1, -2, -3, -4).as_vec4() 1504 ); 1505 assert_eq!( 1506 DVec4::new(-1.0, -2.0, -3.0, -4.0), 1507 I64Vec4::new(-1, -2, -3, -4).as_dvec4() 1508 ); 1509 assert_eq!( 1510 U16Vec4::new(1, 2, 3, 4), 1511 I64Vec4::new(1, 2, 3, 4).as_u16vec4() 1512 ); 1513 assert_eq!( 1514 I16Vec4::new(-1, -2, -3, -4), 1515 I64Vec4::new(-1, -2, -3, -4).as_i16vec4() 1516 ); 1517 assert_eq!(UVec4::new(1, 2, 3, 4), I64Vec4::new(1, 2, 3, 4).as_uvec4()); 1518 assert_eq!( 1519 IVec4::new(-1, -2, -3, -4), 1520 I64Vec4::new(-1, -2, -3, -4).as_ivec4() 1521 ); 1522 assert_eq!( 1523 U64Vec4::new(1, 2, 3, 4), 1524 I64Vec4::new(1, 2, 3, 4).as_u64vec4() 1525 ); 1526 1527 assert_eq!( 1528 Vec4::new(1.0, 2.0, 3.0, 4.0), 1529 U64Vec4::new(1, 2, 3, 4).as_vec4() 1530 ); 1531 assert_eq!( 1532 DVec4::new(1.0, 2.0, 3.0, 4.0), 1533 U64Vec4::new(1, 2, 3, 4).as_dvec4() 1534 ); 1535 assert_eq!( 1536 I16Vec4::new(1, 2, 3, 4), 1537 U64Vec4::new(1, 2, 3, 4).as_i16vec4() 1538 ); 1539 assert_eq!( 1540 U16Vec4::new(1, 2, 3, 4), 1541 U64Vec4::new(1, 2, 3, 4).as_u16vec4() 1542 ); 1543 assert_eq!(IVec4::new(1, 2, 3, 4), U64Vec4::new(1, 2, 3, 4).as_ivec4()); 1544 assert_eq!(UVec4::new(1, 2, 3, 4), U64Vec4::new(1, 2, 3, 4).as_uvec4()); 1545 assert_eq!( 1546 I64Vec4::new(1, 2, 3, 4), 1547 U64Vec4::new(1, 2, 3, 4).as_i64vec4() 1548 ); 1549 }); 1550 1551 glam_test!(test_vec3a, { 1552 use glam::Vec3A; 1553 assert_eq!( 1554 Vec4::new(1.0, 2.0, 3.0, 4.0), 1555 Vec4::from((Vec3A::new(1.0, 2.0, 3.0), 4.0)) 1556 ); 1557 assert_eq!( 1558 Vec4::new(1.0, 2.0, 3.0, 4.0), 1559 Vec4::from((1.0, Vec3A::new(2.0, 3.0, 4.0))) 1560 ); 1561 }); 1562 1563 #[cfg(not(feature = "scalar-math"))] 1564 impl_vec4_float_tests!(f32, vec4, Vec4, Vec3, Vec2, BVec4A); 1565 1566 #[cfg(feature = "scalar-math")] 1567 impl_vec4_float_tests!(f32, vec4, Vec4, Vec3, Vec2, BVec4); 1568 } 1569 1570 mod dvec4 { 1571 use glam::{dvec4, BVec4, DVec2, DVec3, DVec4, IVec4, UVec4, Vec4}; 1572 1573 glam_test!(test_align, { 1574 use std::mem; 1575 assert_eq!(32, mem::size_of::<DVec4>()); 1576 #[cfg(not(feature = "cuda"))] 1577 assert_eq!(mem::align_of::<f64>(), mem::align_of::<DVec4>()); 1578 #[cfg(feature = "cuda")] 1579 assert_eq!(16, mem::align_of::<DVec4>()); 1580 assert_eq!(4, mem::size_of::<BVec4>()); 1581 assert_eq!(1, mem::align_of::<BVec4>()); 1582 }); 1583 1584 glam_test!(test_try_from, { 1585 assert_eq!( 1586 DVec4::new(1.0, 2.0, 3.0, 4.0), 1587 DVec4::from(Vec4::new(1.0, 2.0, 3.0, 4.0)) 1588 ); 1589 assert_eq!( 1590 DVec4::new(1.0, 2.0, 3.0, 4.0), 1591 DVec4::from(IVec4::new(1, 2, 3, 4)) 1592 ); 1593 assert_eq!( 1594 DVec4::new(1.0, 2.0, 3.0, 4.0), 1595 DVec4::from(UVec4::new(1, 2, 3, 4)) 1596 ); 1597 }); 1598 1599 impl_vec4_float_tests!(f64, dvec4, DVec4, DVec3, DVec2, BVec4); 1600 } 1601 1602 mod i16vec4 { 1603 use glam::{ 1604 i16vec4, BVec4, I16Vec2, I16Vec3, I16Vec4, I64Vec4, IVec4, U16Vec4, U64Vec4, UVec4, 1605 }; 1606 1607 glam_test!(test_align, { 1608 use std::mem; 1609 assert_eq!(8, mem::size_of::<I16Vec4>()); 1610 #[cfg(not(feature = "cuda"))] 1611 assert_eq!(2, mem::align_of::<I16Vec4>()); 1612 #[cfg(feature = "cuda")] 1613 assert_eq!(8, mem::align_of::<I16Vec4>()); 1614 }); 1615 1616 glam_test!(test_try_from, { 1617 assert_eq!( 1618 I16Vec4::new(1, 2, 3, 4), 1619 I16Vec4::try_from(U16Vec4::new(1, 2, 3, 4)).unwrap() 1620 ); 1621 assert!(I16Vec4::try_from(U16Vec4::new(u16::MAX, 2, 3, 4)).is_err()); 1622 assert!(I16Vec4::try_from(U16Vec4::new(1, u16::MAX, 3, 4)).is_err()); 1623 assert!(I16Vec4::try_from(U16Vec4::new(1, 2, u16::MAX, 4)).is_err()); 1624 assert!(I16Vec4::try_from(U16Vec4::new(1, 2, 3, u16::MAX)).is_err()); 1625 1626 assert_eq!( 1627 I16Vec4::new(1, 2, 3, 4), 1628 I16Vec4::try_from(IVec4::new(1, 2, 3, 4)).unwrap() 1629 ); 1630 assert!(I16Vec4::try_from(IVec4::new(i32::MAX, 2, 3, 4)).is_err()); 1631 assert!(I16Vec4::try_from(IVec4::new(1, i32::MAX, 3, 4)).is_err()); 1632 assert!(I16Vec4::try_from(IVec4::new(1, 2, i32::MAX, 4)).is_err()); 1633 assert!(I16Vec4::try_from(IVec4::new(1, 2, 3, i32::MAX)).is_err()); 1634 1635 assert_eq!( 1636 I16Vec4::new(1, 2, 3, 4), 1637 I16Vec4::try_from(UVec4::new(1, 2, 3, 4)).unwrap() 1638 ); 1639 assert!(I16Vec4::try_from(UVec4::new(u32::MAX, 2, 3, 4)).is_err()); 1640 assert!(I16Vec4::try_from(UVec4::new(1, u32::MAX, 3, 4)).is_err()); 1641 assert!(I16Vec4::try_from(UVec4::new(1, 2, u32::MAX, 4)).is_err()); 1642 assert!(I16Vec4::try_from(UVec4::new(1, 2, 3, u32::MAX)).is_err()); 1643 1644 assert_eq!( 1645 I16Vec4::new(1, 2, 3, 4), 1646 I16Vec4::try_from(I64Vec4::new(1, 2, 3, 4)).unwrap() 1647 ); 1648 assert!(I16Vec4::try_from(I64Vec4::new(i64::MAX, 2, 3, 4)).is_err()); 1649 assert!(I16Vec4::try_from(I64Vec4::new(1, i64::MAX, 3, 4)).is_err()); 1650 assert!(I16Vec4::try_from(I64Vec4::new(1, 2, i64::MAX, 4)).is_err()); 1651 assert!(I16Vec4::try_from(I64Vec4::new(1, 2, 3, i64::MAX)).is_err()); 1652 1653 assert_eq!( 1654 I16Vec4::new(1, 2, 3, 4), 1655 I16Vec4::try_from(U64Vec4::new(1, 2, 3, 4)).unwrap() 1656 ); 1657 assert!(I16Vec4::try_from(U64Vec4::new(u64::MAX, 2, 3, 4)).is_err()); 1658 assert!(I16Vec4::try_from(U64Vec4::new(1, u64::MAX, 3, 4)).is_err()); 1659 assert!(I16Vec4::try_from(U64Vec4::new(1, 2, u64::MAX, 4)).is_err()); 1660 assert!(I16Vec4::try_from(U64Vec4::new(1, 2, 3, u64::MAX)).is_err()); 1661 }); 1662 1663 glam_test!(test_wrapping_add, { 1664 assert_eq!( 1665 I16Vec4::new(i16::MAX, 5, i16::MIN, 0).wrapping_add(I16Vec4::new(1, 3, i16::MAX, 0)), 1666 I16Vec4::new(i16::MIN, 8, -1, 0), 1667 ); 1668 }); 1669 1670 glam_test!(test_wrapping_sub, { 1671 assert_eq!( 1672 I16Vec4::new(i16::MAX, 5, i16::MIN, 0).wrapping_sub(I16Vec4::new(1, 3, i16::MAX, 0)), 1673 I16Vec4::new(32766, 2, 1, 0) 1674 ); 1675 }); 1676 1677 glam_test!(test_wrapping_mul, { 1678 assert_eq!( 1679 I16Vec4::new(i16::MAX, 5, i16::MIN, 0).wrapping_mul(I16Vec4::new(3, 3, 5, 1)), 1680 I16Vec4::new(32765, 15, -32768, 0) 1681 ); 1682 }); 1683 1684 glam_test!(test_wrapping_div, { 1685 assert_eq!( 1686 I16Vec4::new(i16::MAX, 5, i16::MIN, 0).wrapping_div(I16Vec4::new(3, 3, 5, 1)), 1687 I16Vec4::new(10922, 1, -6553, 0) 1688 ); 1689 }); 1690 1691 glam_test!(test_saturating_add, { 1692 assert_eq!( 1693 I16Vec4::new(i16::MAX, i16::MIN, 0, 0).saturating_add(I16Vec4::new(1, -1, 2, 3)), 1694 I16Vec4::new(i16::MAX, i16::MIN, 2, 3) 1695 ); 1696 }); 1697 1698 glam_test!(test_saturating_sub, { 1699 assert_eq!( 1700 I16Vec4::new(i16::MIN, i16::MAX, 0, 0).saturating_sub(I16Vec4::new(1, -1, 2, 3)), 1701 I16Vec4::new(i16::MIN, i16::MAX, -2, -3) 1702 ); 1703 }); 1704 1705 glam_test!(test_saturating_mul, { 1706 assert_eq!( 1707 I16Vec4::new(i16::MAX, i16::MIN, 0, 0).saturating_mul(I16Vec4::new(2, 2, 0, 0)), 1708 I16Vec4::new(i16::MAX, i16::MIN, 0, 0) 1709 ); 1710 }); 1711 1712 glam_test!(test_saturating_div, { 1713 assert_eq!( 1714 I16Vec4::new(i16::MAX, i16::MIN, 0, 0).saturating_div(I16Vec4::new(2, 2, 3, 4)), 1715 I16Vec4::new(16383, -16384, 0, 0) 1716 ); 1717 }); 1718 1719 impl_vec4_signed_integer_tests!(i16, i16vec4, I16Vec4, I16Vec3, I16Vec2, BVec4); 1720 impl_vec4_eq_hash_tests!(i16, i16vec4); 1721 1722 impl_vec4_scalar_shift_op_tests!(I16Vec4, -2, 2); 1723 impl_vec4_shift_op_tests!(I16Vec4); 1724 1725 impl_vec4_scalar_bit_op_tests!(I16Vec4, -2, 2); 1726 impl_vec4_bit_op_tests!(I16Vec4, -2, 2); 1727 } 1728 1729 mod u16vec4 { 1730 use glam::{ 1731 u16vec4, BVec4, I16Vec4, I64Vec4, IVec4, U16Vec2, U16Vec3, U16Vec4, U64Vec4, UVec4, 1732 }; 1733 1734 glam_test!(test_align, { 1735 use std::mem; 1736 assert_eq!(8, mem::size_of::<U16Vec4>()); 1737 #[cfg(not(feature = "cuda"))] 1738 assert_eq!(2, mem::align_of::<U16Vec4>()); 1739 #[cfg(feature = "cuda")] 1740 assert_eq!(8, mem::align_of::<U16Vec4>()); 1741 }); 1742 1743 glam_test!(test_try_from, { 1744 assert_eq!( 1745 U16Vec4::new(1, 2, 3, 4), 1746 U16Vec4::try_from(I16Vec4::new(1, 2, 3, 4)).unwrap() 1747 ); 1748 assert!(U16Vec4::try_from(I16Vec4::new(-1, 2, 3, 4)).is_err()); 1749 assert!(U16Vec4::try_from(I16Vec4::new(1, -2, 3, 4)).is_err()); 1750 assert!(U16Vec4::try_from(I16Vec4::new(1, 2, -3, 4)).is_err()); 1751 assert!(U16Vec4::try_from(I16Vec4::new(1, 2, 3, -4)).is_err()); 1752 1753 assert_eq!( 1754 U16Vec4::new(1, 2, 3, 4), 1755 U16Vec4::try_from(IVec4::new(1, 2, 3, 4)).unwrap() 1756 ); 1757 assert!(U16Vec4::try_from(IVec4::new(-1, 2, 3, 4)).is_err()); 1758 assert!(U16Vec4::try_from(IVec4::new(1, -2, 3, 4)).is_err()); 1759 assert!(U16Vec4::try_from(IVec4::new(1, 2, -3, 4)).is_err()); 1760 assert!(U16Vec4::try_from(IVec4::new(1, 2, 3, -4)).is_err()); 1761 1762 assert!(U16Vec4::try_from(IVec4::new(i32::MAX, 2, 3, 4)).is_err()); 1763 assert!(U16Vec4::try_from(IVec4::new(1, i32::MAX, 3, 4)).is_err()); 1764 assert!(U16Vec4::try_from(IVec4::new(1, 2, i32::MAX, 4)).is_err()); 1765 assert!(U16Vec4::try_from(IVec4::new(1, 2, 3, i32::MAX)).is_err()); 1766 1767 assert_eq!( 1768 U16Vec4::new(1, 2, 3, 4), 1769 U16Vec4::try_from(UVec4::new(1, 2, 3, 4)).unwrap() 1770 ); 1771 assert!(U16Vec4::try_from(UVec4::new(u32::MAX, 2, 3, 4)).is_err()); 1772 assert!(U16Vec4::try_from(UVec4::new(1, u32::MAX, 3, 4)).is_err()); 1773 assert!(U16Vec4::try_from(UVec4::new(1, 2, u32::MAX, 4)).is_err()); 1774 assert!(U16Vec4::try_from(UVec4::new(1, 2, 3, u32::MAX)).is_err()); 1775 1776 assert_eq!( 1777 U16Vec4::new(1, 2, 3, 4), 1778 U16Vec4::try_from(I64Vec4::new(1, 2, 3, 4)).unwrap() 1779 ); 1780 assert!(U16Vec4::try_from(I64Vec4::new(-1, 2, 3, 4)).is_err()); 1781 assert!(U16Vec4::try_from(I64Vec4::new(1, -2, 3, 4)).is_err()); 1782 assert!(U16Vec4::try_from(I64Vec4::new(1, 2, -3, 4)).is_err()); 1783 assert!(U16Vec4::try_from(I64Vec4::new(1, 2, 3, -4)).is_err()); 1784 1785 assert!(U16Vec4::try_from(I64Vec4::new(i64::MAX, 2, 3, 4)).is_err()); 1786 assert!(U16Vec4::try_from(I64Vec4::new(1, i64::MAX, 3, 4)).is_err()); 1787 assert!(U16Vec4::try_from(I64Vec4::new(1, 2, i64::MAX, 4)).is_err()); 1788 assert!(U16Vec4::try_from(I64Vec4::new(1, 2, 3, i64::MAX)).is_err()); 1789 1790 assert_eq!( 1791 U16Vec4::new(1, 2, 3, 4), 1792 U16Vec4::try_from(U64Vec4::new(1, 2, 3, 4)).unwrap() 1793 ); 1794 assert!(U16Vec4::try_from(U64Vec4::new(u64::MAX, 2, 3, 4)).is_err()); 1795 assert!(U16Vec4::try_from(U64Vec4::new(1, u64::MAX, 3, 4)).is_err()); 1796 assert!(U16Vec4::try_from(U64Vec4::new(1, 2, u64::MAX, 4)).is_err()); 1797 assert!(U16Vec4::try_from(U64Vec4::new(1, 2, 3, u64::MAX)).is_err()); 1798 }); 1799 1800 glam_test!(test_wrapping_add, { 1801 assert_eq!( 1802 U16Vec4::new(u16::MAX, 5, u16::MAX, 0).wrapping_add(U16Vec4::new(1, 3, u16::MAX, 0)), 1803 U16Vec4::new(0, 8, 65534, 0), 1804 ); 1805 }); 1806 1807 glam_test!(test_wrapping_sub, { 1808 assert_eq!( 1809 U16Vec4::new(u16::MAX, 5, u16::MAX - 1, 0).wrapping_sub(U16Vec4::new( 1810 1, 1811 3, 1812 u16::MAX, 1813 0 1814 )), 1815 U16Vec4::new(65534, 2, 65535, 0) 1816 ); 1817 }); 1818 1819 glam_test!(test_wrapping_mul, { 1820 assert_eq!( 1821 U16Vec4::new(u16::MAX, 5, u16::MAX, 0).wrapping_mul(U16Vec4::new(3, 3, 5, 1)), 1822 U16Vec4::new(65533, 15, 65531, 0) 1823 ); 1824 }); 1825 1826 glam_test!(test_wrapping_div, { 1827 assert_eq!( 1828 U16Vec4::new(u16::MAX, 5, u16::MAX, 0).wrapping_div(U16Vec4::new(3, 3, 5, 1)), 1829 U16Vec4::new(21845, 1, 13107, 0) 1830 ); 1831 }); 1832 1833 glam_test!(test_saturating_add, { 1834 assert_eq!( 1835 U16Vec4::new(u16::MAX, u16::MAX, 0, 0).saturating_add(U16Vec4::new(1, u16::MAX, 2, 3)), 1836 U16Vec4::new(u16::MAX, u16::MAX, 2, 3) 1837 ); 1838 }); 1839 1840 glam_test!(test_saturating_sub, { 1841 assert_eq!( 1842 U16Vec4::new(0, u16::MAX, 0, 0).saturating_sub(U16Vec4::new(1, 1, 2, 3)), 1843 U16Vec4::new(0, 65534, 0, 0) 1844 ); 1845 }); 1846 1847 glam_test!(test_saturating_mul, { 1848 assert_eq!( 1849 U16Vec4::new(u16::MAX, u16::MAX, 0, 0).saturating_mul(U16Vec4::new(2, u16::MAX, 0, 0)), 1850 U16Vec4::new(u16::MAX, u16::MAX, 0, 0) 1851 ); 1852 }); 1853 1854 glam_test!(test_saturating_div, { 1855 assert_eq!( 1856 U16Vec4::new(u16::MAX, u16::MAX, 0, 0).saturating_div(U16Vec4::new(2, u16::MAX, 3, 4)), 1857 U16Vec4::new(32767, 1, 0, 0) 1858 ); 1859 }); 1860 1861 impl_vec4_tests!(u16, u16vec4, U16Vec4, U16Vec3, U16Vec2, BVec4); 1862 impl_vec4_eq_hash_tests!(u16, u16vec4); 1863 1864 impl_vec4_scalar_shift_op_tests!(U16Vec4, 0, 2); 1865 impl_vec4_shift_op_tests!(U16Vec4); 1866 1867 impl_vec4_scalar_bit_op_tests!(U16Vec4, 0, 2); 1868 impl_vec4_bit_op_tests!(U16Vec4, 0, 2); 1869 } 1870 1871 mod ivec4 { 1872 use glam::{ivec4, BVec4, I16Vec4, I64Vec4, IVec2, IVec3, IVec4, U16Vec4, U64Vec4, UVec4}; 1873 1874 glam_test!(test_align, { 1875 use std::mem; 1876 assert_eq!(16, mem::size_of::<IVec4>()); 1877 #[cfg(not(feature = "cuda"))] 1878 assert_eq!(4, mem::align_of::<IVec4>()); 1879 #[cfg(feature = "cuda")] 1880 assert_eq!(16, mem::align_of::<IVec4>()); 1881 assert_eq!(4, mem::size_of::<BVec4>()); 1882 assert_eq!(1, mem::align_of::<BVec4>()); 1883 }); 1884 1885 glam_test!(test_try_from, { 1886 assert_eq!( 1887 IVec4::new(1, 2, 3, 4), 1888 IVec4::from(U16Vec4::new(1, 2, 3, 4)) 1889 ); 1890 assert_eq!( 1891 IVec4::new(1, 2, 3, 4), 1892 IVec4::from(I16Vec4::new(1, 2, 3, 4)) 1893 ); 1894 1895 assert_eq!( 1896 IVec4::new(1, 2, 3, 4), 1897 IVec4::try_from(UVec4::new(1, 2, 3, 4)).unwrap() 1898 ); 1899 assert!(IVec4::try_from(UVec4::new(u32::MAX, 2, 3, 4)).is_err()); 1900 assert!(IVec4::try_from(UVec4::new(1, u32::MAX, 3, 4)).is_err()); 1901 assert!(IVec4::try_from(UVec4::new(1, 2, u32::MAX, 4)).is_err()); 1902 assert!(IVec4::try_from(UVec4::new(1, 2, 3, u32::MAX)).is_err()); 1903 1904 assert_eq!( 1905 IVec4::new(1, 2, 3, 4), 1906 IVec4::try_from(I64Vec4::new(1, 2, 3, 4)).unwrap() 1907 ); 1908 assert!(IVec4::try_from(I64Vec4::new(i64::MAX, 2, 3, 4)).is_err()); 1909 assert!(IVec4::try_from(I64Vec4::new(1, i64::MAX, 3, 4)).is_err()); 1910 assert!(IVec4::try_from(I64Vec4::new(1, 2, i64::MAX, 4)).is_err()); 1911 assert!(IVec4::try_from(I64Vec4::new(1, 2, 3, i64::MAX)).is_err()); 1912 1913 assert_eq!( 1914 IVec4::new(1, 2, 3, 4), 1915 IVec4::try_from(U64Vec4::new(1, 2, 3, 4)).unwrap() 1916 ); 1917 assert!(IVec4::try_from(U64Vec4::new(u64::MAX, 2, 3, 4)).is_err()); 1918 assert!(IVec4::try_from(U64Vec4::new(1, u64::MAX, 3, 4)).is_err()); 1919 assert!(IVec4::try_from(U64Vec4::new(1, 2, u64::MAX, 4)).is_err()); 1920 assert!(IVec4::try_from(U64Vec4::new(1, 2, 3, u64::MAX)).is_err()); 1921 }); 1922 1923 glam_test!(test_wrapping_add, { 1924 assert_eq!( 1925 IVec4::new(i32::MAX, 5, i32::MIN, 0).wrapping_add(IVec4::new(1, 3, i32::MAX, 0)), 1926 IVec4::new(i32::MIN, 8, -1, 0), 1927 ); 1928 }); 1929 1930 glam_test!(test_wrapping_sub, { 1931 assert_eq!( 1932 IVec4::new(i32::MAX, 5, i32::MIN, 0).wrapping_sub(IVec4::new(1, 3, i32::MAX, 0)), 1933 IVec4::new(2147483646, 2, 1, 0) 1934 ); 1935 }); 1936 1937 glam_test!(test_wrapping_mul, { 1938 assert_eq!( 1939 IVec4::new(i32::MAX, 5, i32::MIN, 0).wrapping_mul(IVec4::new(3, 3, 5, 1)), 1940 IVec4::new(2147483645, 15, -2147483648, 0) 1941 ); 1942 }); 1943 1944 glam_test!(test_wrapping_div, { 1945 assert_eq!( 1946 IVec4::new(i32::MAX, 5, i32::MIN, 0).wrapping_div(IVec4::new(3, 3, 5, 1)), 1947 IVec4::new(715827882, 1, -429496729, 0) 1948 ); 1949 }); 1950 1951 glam_test!(test_saturating_add, { 1952 assert_eq!( 1953 IVec4::new(i32::MAX, i32::MIN, 0, 0).saturating_add(IVec4::new(1, -1, 2, 3)), 1954 IVec4::new(i32::MAX, i32::MIN, 2, 3) 1955 ); 1956 }); 1957 1958 glam_test!(test_saturating_sub, { 1959 assert_eq!( 1960 IVec4::new(i32::MIN, i32::MAX, 0, 0).saturating_sub(IVec4::new(1, -1, 2, 3)), 1961 IVec4::new(i32::MIN, i32::MAX, -2, -3) 1962 ); 1963 }); 1964 1965 glam_test!(test_saturating_mul, { 1966 assert_eq!( 1967 IVec4::new(i32::MAX, i32::MIN, 0, 0).saturating_mul(IVec4::new(2, 2, 0, 0)), 1968 IVec4::new(i32::MAX, i32::MIN, 0, 0) 1969 ); 1970 }); 1971 1972 glam_test!(test_saturating_div, { 1973 assert_eq!( 1974 IVec4::new(i32::MAX, i32::MIN, 0, 0).saturating_div(IVec4::new(2, 2, 3, 4)), 1975 IVec4::new(1073741823, -1073741824, 0, 0) 1976 ); 1977 }); 1978 1979 impl_vec4_signed_integer_tests!(i32, ivec4, IVec4, IVec3, IVec2, BVec4); 1980 impl_vec4_eq_hash_tests!(i32, ivec4); 1981 1982 impl_vec4_scalar_shift_op_tests!(IVec4, -2, 2); 1983 impl_vec4_shift_op_tests!(IVec4); 1984 1985 impl_vec4_scalar_bit_op_tests!(IVec4, -2, 2); 1986 impl_vec4_bit_op_tests!(IVec4, -2, 2); 1987 } 1988 1989 mod uvec4 { 1990 use glam::{uvec4, BVec4, I16Vec4, I64Vec4, IVec4, U16Vec4, U64Vec4, UVec2, UVec3, UVec4}; 1991 1992 glam_test!(test_align, { 1993 use std::mem; 1994 assert_eq!(16, mem::size_of::<UVec4>()); 1995 #[cfg(not(feature = "cuda"))] 1996 assert_eq!(4, mem::align_of::<UVec4>()); 1997 #[cfg(feature = "cuda")] 1998 assert_eq!(16, mem::align_of::<UVec4>()); 1999 assert_eq!(4, mem::size_of::<BVec4>()); 2000 assert_eq!(1, mem::align_of::<BVec4>()); 2001 }); 2002 2003 glam_test!(test_try_from, { 2004 assert_eq!( 2005 UVec4::new(1, 2, 3, 4), 2006 UVec4::try_from(I16Vec4::new(1, 2, 3, 4)).unwrap() 2007 ); 2008 assert!(UVec4::try_from(I16Vec4::new(-1, 2, 3, 4)).is_err()); 2009 assert!(UVec4::try_from(I16Vec4::new(1, -2, 3, 4)).is_err()); 2010 assert!(UVec4::try_from(I16Vec4::new(1, 2, -3, 4)).is_err()); 2011 assert!(UVec4::try_from(I16Vec4::new(1, 2, 3, -4)).is_err()); 2012 2013 assert_eq!( 2014 UVec4::new(1, 2, 3, 4), 2015 UVec4::from(U16Vec4::new(1, 2, 3, 4)) 2016 ); 2017 2018 assert_eq!( 2019 UVec4::new(1, 2, 3, 4), 2020 UVec4::try_from(IVec4::new(1, 2, 3, 4)).unwrap() 2021 ); 2022 assert!(UVec4::try_from(IVec4::new(-1, 2, 3, 4)).is_err()); 2023 assert!(UVec4::try_from(IVec4::new(1, -2, 3, 4)).is_err()); 2024 assert!(UVec4::try_from(IVec4::new(1, 2, -3, 4)).is_err()); 2025 assert!(UVec4::try_from(IVec4::new(1, 2, 3, -4)).is_err()); 2026 2027 assert_eq!( 2028 UVec4::new(1, 2, 3, 4), 2029 UVec4::try_from(I64Vec4::new(1, 2, 3, 4)).unwrap() 2030 ); 2031 assert!(UVec4::try_from(I64Vec4::new(-1, 2, 3, 4)).is_err()); 2032 assert!(UVec4::try_from(I64Vec4::new(1, -2, 3, 4)).is_err()); 2033 assert!(UVec4::try_from(I64Vec4::new(1, 2, -3, 4)).is_err()); 2034 assert!(UVec4::try_from(I64Vec4::new(1, 2, 3, -4)).is_err()); 2035 2036 assert!(UVec4::try_from(I64Vec4::new(i64::MAX, 2, 3, 4)).is_err()); 2037 assert!(UVec4::try_from(I64Vec4::new(1, i64::MAX, 3, 4)).is_err()); 2038 assert!(UVec4::try_from(I64Vec4::new(1, 2, i64::MAX, 4)).is_err()); 2039 assert!(UVec4::try_from(I64Vec4::new(1, 2, 3, i64::MAX)).is_err()); 2040 2041 assert_eq!( 2042 UVec4::new(1, 2, 3, 4), 2043 UVec4::try_from(U64Vec4::new(1, 2, 3, 4)).unwrap() 2044 ); 2045 assert!(UVec4::try_from(U64Vec4::new(u64::MAX, 2, 3, 4)).is_err()); 2046 assert!(UVec4::try_from(U64Vec4::new(1, u64::MAX, 3, 4)).is_err()); 2047 assert!(UVec4::try_from(U64Vec4::new(1, 2, u64::MAX, 4)).is_err()); 2048 assert!(UVec4::try_from(U64Vec4::new(1, 2, 3, u64::MAX)).is_err()); 2049 }); 2050 2051 glam_test!(test_wrapping_add, { 2052 assert_eq!( 2053 UVec4::new(u32::MAX, 5, u32::MAX, 0).wrapping_add(UVec4::new(1, 3, u32::MAX, 0)), 2054 UVec4::new(0, 8, 4294967294, 0), 2055 ); 2056 }); 2057 2058 glam_test!(test_wrapping_sub, { 2059 assert_eq!( 2060 UVec4::new(u32::MAX, 5, u32::MAX - 1, 0).wrapping_sub(UVec4::new(1, 3, u32::MAX, 0)), 2061 UVec4::new(4294967294, 2, 4294967295, 0) 2062 ); 2063 }); 2064 2065 glam_test!(test_wrapping_mul, { 2066 assert_eq!( 2067 UVec4::new(u32::MAX, 5, u32::MAX, 0).wrapping_mul(UVec4::new(3, 3, 5, 1)), 2068 UVec4::new(4294967293, 15, 4294967291, 0) 2069 ); 2070 }); 2071 2072 glam_test!(test_wrapping_div, { 2073 assert_eq!( 2074 UVec4::new(u32::MAX, 5, u32::MAX, 0).wrapping_div(UVec4::new(3, 3, 5, 1)), 2075 UVec4::new(1431655765, 1, 858993459, 0) 2076 ); 2077 }); 2078 2079 glam_test!(test_saturating_add, { 2080 assert_eq!( 2081 UVec4::new(u32::MAX, u32::MAX, 0, 0).saturating_add(UVec4::new(1, u32::MAX, 2, 3)), 2082 UVec4::new(u32::MAX, u32::MAX, 2, 3) 2083 ); 2084 }); 2085 2086 glam_test!(test_saturating_sub, { 2087 assert_eq!( 2088 UVec4::new(0, u32::MAX, 0, 0).saturating_sub(UVec4::new(1, 1, 2, 3)), 2089 UVec4::new(0, 4294967294, 0, 0) 2090 ); 2091 }); 2092 2093 glam_test!(test_saturating_mul, { 2094 assert_eq!( 2095 UVec4::new(u32::MAX, u32::MAX, 0, 0).saturating_mul(UVec4::new(2, u32::MAX, 0, 0)), 2096 UVec4::new(u32::MAX, u32::MAX, 0, 0) 2097 ); 2098 }); 2099 2100 glam_test!(test_saturating_div, { 2101 assert_eq!( 2102 UVec4::new(u32::MAX, u32::MAX, 0, 0).saturating_div(UVec4::new(2, u32::MAX, 3, 4)), 2103 UVec4::new(2147483647, 1, 0, 0) 2104 ); 2105 }); 2106 2107 impl_vec4_tests!(u32, uvec4, UVec4, UVec3, UVec2, BVec4); 2108 impl_vec4_eq_hash_tests!(u32, uvec4); 2109 2110 impl_vec4_scalar_shift_op_tests!(UVec4, 0, 2); 2111 impl_vec4_shift_op_tests!(UVec4); 2112 2113 impl_vec4_scalar_bit_op_tests!(UVec4, 0, 2); 2114 impl_vec4_bit_op_tests!(UVec4, 0, 2); 2115 } 2116 2117 mod i64vec4 { 2118 use glam::{ 2119 i64vec4, BVec4, I16Vec4, I64Vec2, I64Vec3, I64Vec4, IVec4, U16Vec4, U64Vec4, UVec4, 2120 }; 2121 2122 glam_test!(test_align, { 2123 use std::mem; 2124 assert_eq!(32, mem::size_of::<I64Vec4>()); 2125 #[cfg(not(feature = "cuda"))] 2126 assert_eq!(8, mem::align_of::<I64Vec4>()); 2127 #[cfg(feature = "cuda")] 2128 assert_eq!(16, mem::align_of::<I64Vec4>()); 2129 assert_eq!(4, mem::size_of::<BVec4>()); 2130 assert_eq!(1, mem::align_of::<BVec4>()); 2131 }); 2132 2133 glam_test!(test_try_from, { 2134 assert_eq!( 2135 I64Vec4::new(1, 2, 3, 4), 2136 I64Vec4::from(I16Vec4::new(1, 2, 3, 4)) 2137 ); 2138 assert_eq!( 2139 I64Vec4::new(1, 2, 3, 4), 2140 I64Vec4::from(U16Vec4::new(1, 2, 3, 4)) 2141 ); 2142 assert_eq!( 2143 I64Vec4::new(1, 2, 3, 4), 2144 I64Vec4::from(IVec4::new(1, 2, 3, 4)) 2145 ); 2146 assert_eq!( 2147 I64Vec4::new(1, 2, 3, 4), 2148 I64Vec4::from(UVec4::new(1, 2, 3, 4)) 2149 ); 2150 2151 assert_eq!( 2152 I64Vec4::new(1, 2, 3, 4), 2153 I64Vec4::try_from(U64Vec4::new(1, 2, 3, 4)).unwrap() 2154 ); 2155 assert!(I64Vec4::try_from(U64Vec4::new(u64::MAX, 2, 3, 4)).is_err()); 2156 assert!(I64Vec4::try_from(U64Vec4::new(1, u64::MAX, 3, 4)).is_err()); 2157 assert!(I64Vec4::try_from(U64Vec4::new(1, 2, u64::MAX, 4)).is_err()); 2158 assert!(I64Vec4::try_from(U64Vec4::new(1, 2, 3, u64::MAX)).is_err()); 2159 }); 2160 2161 impl_vec4_signed_integer_tests!(i64, i64vec4, I64Vec4, I64Vec3, I64Vec2, BVec4); 2162 impl_vec4_eq_hash_tests!(i64, i64vec4); 2163 2164 impl_vec4_scalar_shift_op_tests!(I64Vec4, -2, 2); 2165 impl_vec4_shift_op_tests!(I64Vec4); 2166 2167 impl_vec4_scalar_bit_op_tests!(I64Vec4, -2, 2); 2168 impl_vec4_bit_op_tests!(I64Vec4, -2, 2); 2169 } 2170 2171 mod u64vec4 { 2172 use glam::{ 2173 u64vec4, BVec4, I16Vec4, I64Vec4, IVec4, U16Vec4, U64Vec2, U64Vec3, U64Vec4, UVec4, 2174 }; 2175 2176 glam_test!(test_align, { 2177 use std::mem; 2178 assert_eq!(32, mem::size_of::<U64Vec4>()); 2179 #[cfg(not(feature = "cuda"))] 2180 assert_eq!(8, mem::align_of::<U64Vec4>()); 2181 #[cfg(feature = "cuda")] 2182 assert_eq!(16, mem::align_of::<U64Vec4>()); 2183 assert_eq!(4, mem::size_of::<BVec4>()); 2184 assert_eq!(1, mem::align_of::<BVec4>()); 2185 }); 2186 2187 glam_test!(test_try_from, { 2188 assert_eq!( 2189 U64Vec4::new(1, 2, 3, 4), 2190 U64Vec4::try_from(I16Vec4::new(1, 2, 3, 4)).unwrap() 2191 ); 2192 assert!(U64Vec4::try_from(I16Vec4::new(-1, 2, 3, 4)).is_err()); 2193 assert!(U64Vec4::try_from(I16Vec4::new(1, -2, 3, 4)).is_err()); 2194 assert!(U64Vec4::try_from(I16Vec4::new(1, 2, -3, 4)).is_err()); 2195 assert!(U64Vec4::try_from(I16Vec4::new(1, 2, 3, -4)).is_err()); 2196 2197 assert_eq!( 2198 U64Vec4::new(1, 2, 3, 4), 2199 U64Vec4::from(U16Vec4::new(1, 2, 3, 4)) 2200 ); 2201 2202 assert_eq!( 2203 U64Vec4::new(1, 2, 3, 4), 2204 U64Vec4::try_from(IVec4::new(1, 2, 3, 4)).unwrap() 2205 ); 2206 assert!(U64Vec4::try_from(IVec4::new(-1, 2, 3, 4)).is_err()); 2207 assert!(U64Vec4::try_from(IVec4::new(1, -2, 3, 4)).is_err()); 2208 assert!(U64Vec4::try_from(IVec4::new(1, 2, -3, 4)).is_err()); 2209 assert!(U64Vec4::try_from(IVec4::new(1, 2, 3, -4)).is_err()); 2210 2211 assert_eq!( 2212 U64Vec4::new(1, 2, 3, 4), 2213 U64Vec4::from(UVec4::new(1, 2, 3, 4)) 2214 ); 2215 2216 assert_eq!( 2217 U64Vec4::new(1, 2, 3, 4), 2218 U64Vec4::try_from(I64Vec4::new(1, 2, 3, 4)).unwrap() 2219 ); 2220 assert!(U64Vec4::try_from(I64Vec4::new(-1, 2, 3, 4)).is_err()); 2221 assert!(U64Vec4::try_from(I64Vec4::new(1, -2, 3, 4)).is_err()); 2222 assert!(U64Vec4::try_from(I64Vec4::new(1, 2, -3, 4)).is_err()); 2223 assert!(U64Vec4::try_from(I64Vec4::new(1, 2, 3, -4)).is_err()); 2224 }); 2225 2226 impl_vec4_tests!(u64, u64vec4, U64Vec4, U64Vec3, U64Vec2, BVec4); 2227 impl_vec4_eq_hash_tests!(u64, u64vec4); 2228 2229 impl_vec4_scalar_shift_op_tests!(U64Vec4, 0, 2); 2230 impl_vec4_shift_op_tests!(U64Vec4); 2231 2232 impl_vec4_scalar_bit_op_tests!(U64Vec4, 0, 2); 2233 impl_vec4_bit_op_tests!(U64Vec4, 0, 2); 2234 } 2235