1 #![allow(clippy::excessive_precision)] 2 3 #[macro_use] 4 mod support; 5 6 macro_rules! impl_vec2_tests { 7 ($t:ident, $new:ident, $vec2:ident, $vec3:ident, $mask:ident) => { 8 glam_test!(test_const, { 9 const V0: $vec2 = $vec2::splat(1 as $t); 10 const V1: $vec2 = $vec2::new(1 as $t, 2 as $t); 11 const V2: $vec2 = $vec2::from_array([1 as $t, 2 as $t]); 12 assert_eq!([1 as $t, 1 as $t], *V0.as_ref()); 13 assert_eq!([1 as $t, 2 as $t], *V1.as_ref()); 14 assert_eq!([1 as $t, 2 as $t], *V2.as_ref()); 15 }); 16 17 glam_test!(test_vec2_consts, { 18 assert_eq!($vec2::ZERO, $new(0 as $t, 0 as $t)); 19 assert_eq!($vec2::ONE, $new(1 as $t, 1 as $t)); 20 assert_eq!($vec2::X, $new(1 as $t, 0 as $t)); 21 assert_eq!($vec2::Y, $new(0 as $t, 1 as $t)); 22 assert_eq!($vec2::MIN, $new($t::MIN, $t::MIN)); 23 assert_eq!($vec2::MAX, $new($t::MAX, $t::MAX)); 24 }); 25 26 glam_test!(test_new, { 27 let v = $new(1 as $t, 2 as $t); 28 29 assert_eq!(v.x, 1 as $t); 30 assert_eq!(v.y, 2 as $t); 31 32 let t = (1 as $t, 2 as $t); 33 let v = $vec2::from(t); 34 assert_eq!(t, v.into()); 35 36 let a = [1 as $t, 2 as $t]; 37 let v = $vec2::from(a); 38 let a1: [$t; 2] = v.into(); 39 assert_eq!(a, a1); 40 41 assert_eq!(a, v.to_array()); 42 assert_eq!(a, *v.as_ref()); 43 44 let mut v2 = $vec2::default(); 45 *v2.as_mut() = a; 46 assert_eq!(a, v2.to_array()); 47 48 let v = $vec2::new(t.0, t.1); 49 assert_eq!(t, v.into()); 50 51 assert_eq!($vec2::new(1 as $t, 0 as $t), $vec2::X); 52 assert_eq!($vec2::new(0 as $t, 1 as $t), $vec2::Y); 53 }); 54 55 glam_test!(test_fmt, { 56 let a = $vec2::new(1 as $t, 2 as $t); 57 assert_eq!( 58 format!("{:?}", a), 59 format!("{}({:?}, {:?})", stringify!($vec2), a.x, a.y) 60 ); 61 assert_eq!( 62 format!("{:#?}", a), 63 format!( 64 "{}(\n {:#?},\n {:#?},\n)", 65 stringify!($vec2), 66 a.x, 67 a.y 68 ) 69 ); 70 assert_eq!(format!("{}", a), "[1, 2]"); 71 }); 72 73 glam_test!(test_zero, { 74 let v = $vec2::ZERO; 75 assert_eq!($new(0 as $t, 0 as $t), v); 76 assert_eq!(v, $vec2::default()); 77 }); 78 79 glam_test!(test_splat, { 80 let v = $vec2::splat(1 as $t); 81 assert_eq!($vec2::ONE, v); 82 }); 83 84 glam_test!(test_accessors, { 85 let mut a = $vec2::ZERO; 86 a.x = 1 as $t; 87 a.y = 2 as $t; 88 assert_eq!(1 as $t, a.x); 89 assert_eq!(2 as $t, a.y); 90 assert_eq!($vec2::new(1 as $t, 2 as $t), a); 91 92 let mut a = $vec2::ZERO; 93 a[0] = 1 as $t; 94 a[1] = 2 as $t; 95 assert_eq!(1 as $t, a[0]); 96 assert_eq!(2 as $t, a[1]); 97 assert_eq!($vec2::new(1 as $t, 2 as $t), a); 98 }); 99 100 glam_test!(test_dot_unsigned, { 101 let x = $new(1 as $t, 0 as $t); 102 let y = $new(0 as $t, 1 as $t); 103 assert_eq!(1 as $t, x.dot(x)); 104 assert_eq!(0 as $t, x.dot(y)); 105 106 assert_eq!( 107 $new(8 as $t, 8 as $t), 108 $new(1 as $t, 2 as $t).dot_into_vec($new(4 as $t, 2 as $t)) 109 ); 110 }); 111 112 glam_test!(test_length_squared_unsigned, { 113 let x = $new(1 as $t, 0 as $t); 114 assert_eq!(4 as $t, (2 as $t * x).length_squared()); 115 assert_eq!( 116 2 as $t * 2 as $t + 3 as $t * 3 as $t, 117 $new(2 as $t, 3 as $t).length_squared() 118 ); 119 }); 120 121 glam_test!(test_ops, { 122 let a = $new(2 as $t, 4 as $t); 123 assert_eq!($new(4 as $t, 8 as $t), (a + a)); 124 assert_eq!($new(2 as $t, 4 as $t), 0 as $t + a); 125 assert_eq!($new(0 as $t, 0 as $t), (a - a)); 126 assert_eq!($new(14 as $t, 12 as $t), 16 as $t - a); 127 assert_eq!($new(4 as $t, 16 as $t), (a * a)); 128 assert_eq!($new(4 as $t, 8 as $t), (a * 2 as $t)); 129 assert_eq!($new(4 as $t, 8 as $t), (2 as $t * a)); 130 assert_eq!($new(1 as $t, 1 as $t), (a / a)); 131 assert_eq!($new(1 as $t, 2 as $t), (a / 2 as $t)); 132 assert_eq!($new(2 as $t, 1 as $t), (4 as $t / a)); 133 assert_eq!($new(0 as $t, 0 as $t), a % a); 134 assert_eq!($new(0 as $t, 1 as $t), a % (a - 1 as $t)); 135 assert_eq!($new(0 as $t, 0 as $t), a % 1 as $t); 136 assert_eq!($new(2 as $t, 1 as $t), a % 3 as $t); 137 assert_eq!($new(1 as $t, 1 as $t), 17 as $t % a); 138 assert_eq!($new(2 as $t, 4 as $t), a % 8 as $t); 139 }); 140 141 glam_test!(test_assign_ops, { 142 let a = $new(1 as $t, 2 as $t); 143 let mut b = a; 144 145 b += 2 as $t; 146 assert_eq!($new(3 as $t, 4 as $t), b); 147 b -= 2 as $t; 148 assert_eq!($new(1 as $t, 2 as $t), b); 149 b *= 2 as $t; 150 assert_eq!($new(2 as $t, 4 as $t), b); 151 b /= 2 as $t; 152 assert_eq!($new(1 as $t, 2 as $t), b); 153 b %= 2 as $t; 154 assert_eq!($new(1 as $t, 0 as $t), b); 155 156 b = a; 157 b += a; 158 assert_eq!($new(2 as $t, 4 as $t), b); 159 b -= a; 160 assert_eq!($new(1 as $t, 2 as $t), b); 161 b *= a; 162 assert_eq!($new(1 as $t, 4 as $t), b); 163 b /= a; 164 assert_eq!($new(1 as $t, 2 as $t), b); 165 b *= 2 as $t; 166 assert_eq!($new(2 as $t, 4 as $t), b); 167 b /= 2 as $t; 168 assert_eq!($new(1 as $t, 2 as $t), b); 169 b %= (b + 1 as $t); 170 assert_eq!($new(1 as $t, 2 as $t), b); 171 b %= b; 172 assert_eq!($new(0 as $t, 0 as $t), b); 173 }); 174 175 glam_test!(test_min_max, { 176 let a = $new(0 as $t, 2 as $t); 177 let b = $new(1 as $t, 1 as $t); 178 assert_eq!($new(0 as $t, 1 as $t), a.min(b)); 179 assert_eq!($new(0 as $t, 1 as $t), b.min(a)); 180 assert_eq!($new(1 as $t, 2 as $t), a.max(b)); 181 assert_eq!($new(1 as $t, 2 as $t), b.max(a)); 182 }); 183 184 glam_test!(test_clamp, { 185 fn vec(x: i32, y: i32) -> $vec2 { 186 $vec2::new(x as $t, y as $t) 187 } 188 let min = vec(1, 3); 189 let max = vec(6, 8); 190 assert_eq!(vec(0, 0).clamp(min, max), vec(1, 3)); 191 assert_eq!(vec(2, 2).clamp(min, max), vec(2, 3)); 192 assert_eq!(vec(4, 5).clamp(min, max), vec(4, 5)); 193 assert_eq!(vec(6, 6).clamp(min, max), vec(6, 6)); 194 assert_eq!(vec(7, 7).clamp(min, max), vec(6, 7)); 195 assert_eq!(vec(9, 9).clamp(min, max), vec(6, 8)); 196 197 should_glam_assert!({ $vec2::clamp($vec2::ZERO, $vec2::ONE, $vec2::ZERO) }); 198 }); 199 200 glam_test!(test_hmin_hmax, { 201 assert_eq!(1 as $t, $new(1 as $t, 2 as $t).min_element()); 202 assert_eq!(1 as $t, $new(2 as $t, 1 as $t).min_element()); 203 assert_eq!(2 as $t, $new(1 as $t, 2 as $t).max_element()); 204 assert_eq!(2 as $t, $new(2 as $t, 1 as $t).max_element()); 205 }); 206 207 glam_test!(test_eq, { 208 let a = $new(1 as $t, 1 as $t); 209 let b = $new(1 as $t, 2 as $t); 210 assert!(a.cmpeq(a).all()); 211 assert!(b.cmpeq(b).all()); 212 assert!(a.cmpne(b).any()); 213 assert!(b.cmpne(a).any()); 214 assert!(b.cmpeq(a).any()); 215 }); 216 217 glam_test!(test_cmp, { 218 assert!(!$mask::default().any()); 219 assert!(!$mask::default().all()); 220 assert_eq!($mask::default().bitmask(), 0x0); 221 let a = $new(1 as $t, 1 as $t); 222 let b = $new(2 as $t, 2 as $t); 223 let c = $new(1 as $t, 1 as $t); 224 let d = $new(2 as $t, 1 as $t); 225 assert_eq!(a.cmplt(a).bitmask(), 0x0); 226 assert_eq!(a.cmplt(b).bitmask(), 0x3); 227 assert_eq!(a.cmplt(d).bitmask(), 0x1); 228 assert_eq!(c.cmple(a).bitmask(), 0x3); 229 assert!(a.cmplt(b).all()); 230 assert!(a.cmplt(d).any()); 231 assert!(a.cmple(b).all()); 232 assert!(a.cmple(a).all()); 233 assert!(b.cmpgt(a).all()); 234 assert!(b.cmpge(a).all()); 235 assert!(b.cmpge(b).all()); 236 assert!(!(a.cmpge(d).all())); 237 assert!(c.cmple(c).all()); 238 assert!(c.cmpge(c).all()); 239 assert!(a == a); 240 }); 241 242 glam_test!(test_extend_truncate, { 243 let a = $new(1 as $t, 2 as $t); 244 let b = a.extend(3 as $t); 245 assert_eq!($vec3::new(1 as $t, 2 as $t, 3 as $t), b); 246 }); 247 248 glam_test!(test_vec2mask, { 249 // make sure the unused 'z' value doesn't break $vec2 behaviour 250 let a = $vec3::ZERO; 251 let mut b = a.truncate(); 252 b.x = 1 as $t; 253 b.y = 1 as $t; 254 assert!(!b.cmpeq($vec2::ZERO).any()); 255 assert!(b.cmpeq($vec2::splat(1 as $t)).all()); 256 }); 257 258 glam_test!(test_mask_into_array_u32, { 259 assert_eq!(Into::<[u32; 2]>::into($mask::new(false, false)), [0, 0]); 260 assert_eq!(Into::<[u32; 2]>::into($mask::new(true, false)), [!0, 0]); 261 assert_eq!(Into::<[u32; 2]>::into($mask::new(false, true)), [0, !0]); 262 assert_eq!(Into::<[u32; 2]>::into($mask::new(true, true)), [!0, !0]); 263 }); 264 265 glam_test!(test_mask_into_array_bool, { 266 assert_eq!( 267 Into::<[bool; 2]>::into($mask::new(false, false)), 268 [false, false] 269 ); 270 assert_eq!( 271 Into::<[bool; 2]>::into($mask::new(true, false)), 272 [true, false] 273 ); 274 assert_eq!( 275 Into::<[bool; 2]>::into($mask::new(false, true)), 276 [false, true] 277 ); 278 assert_eq!( 279 Into::<[bool; 2]>::into($mask::new(true, true)), 280 [true, true] 281 ); 282 }); 283 284 glam_test!(test_mask_splat, { 285 assert_eq!($mask::splat(false), $mask::new(false, false)); 286 assert_eq!($mask::splat(true), $mask::new(true, true)); 287 }); 288 289 glam_test!(test_mask_bitmask, { 290 assert_eq!($mask::new(false, false).bitmask(), 0b00); 291 assert_eq!($mask::new(true, false).bitmask(), 0b01); 292 assert_eq!($mask::new(false, true).bitmask(), 0b10); 293 assert_eq!($mask::new(true, true).bitmask(), 0b11); 294 }); 295 296 glam_test!(test_mask_any, { 297 assert_eq!($mask::new(false, false).any(), false); 298 assert_eq!($mask::new(true, false).any(), true); 299 assert_eq!($mask::new(false, true).any(), true); 300 assert_eq!($mask::new(true, true).any(), true); 301 }); 302 303 glam_test!(test_mask_all, { 304 assert_eq!($mask::new(false, false).all(), false); 305 assert_eq!($mask::new(true, false).all(), false); 306 assert_eq!($mask::new(false, true).all(), false); 307 assert_eq!($mask::new(true, true).all(), true); 308 }); 309 310 glam_test!(test_mask_select, { 311 let a = $vec2::new(1 as $t, 2 as $t); 312 let b = $vec2::new(3 as $t, 4 as $t); 313 assert_eq!( 314 $vec2::select($mask::new(true, true), a, b), 315 $vec2::new(1 as $t, 2 as $t), 316 ); 317 assert_eq!( 318 $vec2::select($mask::new(true, false), a, b), 319 $vec2::new(1 as $t, 4 as $t), 320 ); 321 assert_eq!( 322 $vec2::select($mask::new(false, true), a, b), 323 $vec2::new(3 as $t, 2 as $t), 324 ); 325 assert_eq!( 326 $vec2::select($mask::new(false, false), a, b), 327 $vec2::new(3 as $t, 4 as $t), 328 ); 329 }); 330 331 glam_test!(test_mask_and, { 332 assert_eq!( 333 ($mask::new(false, false) & $mask::new(false, false)).bitmask(), 334 0b00, 335 ); 336 assert_eq!( 337 ($mask::new(true, true) & $mask::new(true, false)).bitmask(), 338 0b01, 339 ); 340 assert_eq!( 341 ($mask::new(true, false) & $mask::new(false, true)).bitmask(), 342 0b00, 343 ); 344 assert_eq!( 345 ($mask::new(true, true) & $mask::new(true, true)).bitmask(), 346 0b11, 347 ); 348 349 let mut mask = $mask::new(true, true); 350 mask &= $mask::new(true, false); 351 assert_eq!(mask.bitmask(), 0b01); 352 }); 353 354 glam_test!(test_mask_or, { 355 assert_eq!( 356 ($mask::new(false, false) | $mask::new(false, false)).bitmask(), 357 0b00, 358 ); 359 assert_eq!( 360 ($mask::new(false, false) | $mask::new(false, true)).bitmask(), 361 0b10, 362 ); 363 assert_eq!( 364 ($mask::new(true, false) | $mask::new(false, true)).bitmask(), 365 0b11, 366 ); 367 assert_eq!( 368 ($mask::new(true, true) | $mask::new(true, true)).bitmask(), 369 0b11, 370 ); 371 372 let mut mask = $mask::new(true, true); 373 mask |= $mask::new(true, false); 374 assert_eq!(mask.bitmask(), 0b11); 375 }); 376 377 glam_test!(test_mask_xor, { 378 assert_eq!( 379 ($mask::new(false, false) ^ $mask::new(false, false)).bitmask(), 380 0b00, 381 ); 382 assert_eq!( 383 ($mask::new(false, false) ^ $mask::new(false, true)).bitmask(), 384 0b10, 385 ); 386 assert_eq!( 387 ($mask::new(true, false) ^ $mask::new(false, true)).bitmask(), 388 0b11, 389 ); 390 assert_eq!( 391 ($mask::new(true, true) ^ $mask::new(true, true)).bitmask(), 392 0b00, 393 ); 394 395 let mut mask = $mask::new(false, true); 396 mask ^= $mask::new(true, false); 397 assert_eq!(mask.bitmask(), 0b11); 398 }); 399 400 glam_test!(test_mask_not, { 401 assert_eq!((!$mask::new(false, false)).bitmask(), 0b11); 402 assert_eq!((!$mask::new(true, false)).bitmask(), 0b10); 403 assert_eq!((!$mask::new(false, true)).bitmask(), 0b01); 404 assert_eq!((!$mask::new(true, true)).bitmask(), 0b00); 405 }); 406 407 glam_test!(test_mask_fmt, { 408 let a = $mask::new(true, false); 409 410 assert_eq!( 411 format!("{:?}", a), 412 format!("{}(0xffffffff, 0x0)", stringify!($mask)) 413 ); 414 assert_eq!(format!("{}", a), "[true, false]"); 415 }); 416 417 glam_test!(test_mask_eq, { 418 let a = $mask::new(true, false); 419 let b = $mask::new(true, false); 420 let c = $mask::new(false, true); 421 422 assert_eq!(a, b); 423 assert_eq!(b, a); 424 assert_ne!(a, c); 425 assert_ne!(b, c); 426 }); 427 428 glam_test!(test_mask_test, { 429 let a = $mask::new(true, false); 430 assert_eq!(a.test(0), true); 431 assert_eq!(a.test(1), false); 432 433 let b = $mask::new(false, true); 434 assert_eq!(b.test(0), false); 435 assert_eq!(b.test(1), true); 436 }); 437 438 glam_test!(test_mask_set, { 439 let mut a = $mask::new(false, true); 440 a.set(0, true); 441 assert_eq!(a.test(0), true); 442 a.set(1, false); 443 assert_eq!(a.test(1), false); 444 445 let mut b = $mask::new(true, false); 446 b.set(0, false); 447 assert_eq!(b.test(0), false); 448 b.set(1, true); 449 assert_eq!(b.test(1), true); 450 }); 451 452 glam_test!(test_mask_hash, { 453 use std::collections::hash_map::DefaultHasher; 454 use std::hash::Hash; 455 use std::hash::Hasher; 456 457 let a = $mask::new(true, false); 458 let b = $mask::new(true, false); 459 let c = $mask::new(false, true); 460 461 let mut hasher = DefaultHasher::new(); 462 a.hash(&mut hasher); 463 let a_hashed = hasher.finish(); 464 465 let mut hasher = DefaultHasher::new(); 466 b.hash(&mut hasher); 467 let b_hashed = hasher.finish(); 468 469 let mut hasher = DefaultHasher::new(); 470 c.hash(&mut hasher); 471 let c_hashed = hasher.finish(); 472 473 assert_eq!(a, b); 474 assert_eq!(a_hashed, b_hashed); 475 assert_ne!(a, c); 476 assert_ne!(a_hashed, c_hashed); 477 }); 478 479 glam_test!(test_to_from_slice, { 480 let v = $vec2::new(1 as $t, 2 as $t); 481 let mut a = [0 as $t, 0 as $t]; 482 v.write_to_slice(&mut a); 483 assert_eq!(v, $vec2::from_slice(&a)); 484 485 should_panic!({ $vec2::ONE.write_to_slice(&mut [0 as $t]) }); 486 should_panic!({ $vec2::from_slice(&[0 as $t]) }); 487 }); 488 489 glam_test!(test_sum, { 490 let one = $vec2::ONE; 491 assert_eq!([one, one].iter().sum::<$vec2>(), one + one); 492 assert_eq!([one, one].into_iter().sum::<$vec2>(), one + one); 493 }); 494 495 glam_test!(test_product, { 496 let two = $vec2::new(2 as $t, 2 as $t); 497 assert_eq!([two, two].iter().product::<$vec2>(), two * two); 498 assert_eq!([two, two].into_iter().product::<$vec2>(), two * two); 499 }); 500 }; 501 } 502 503 macro_rules! impl_vec2_signed_tests { 504 ($t:ident, $new:ident, $vec2:ident, $vec3:ident, $mask:ident) => { 505 impl_vec2_tests!($t, $new, $vec2, $vec3, $mask); 506 507 glam_test!(test_is_negative_bitmask, { 508 assert_eq!($vec2::ZERO.is_negative_bitmask(), 0b00); 509 assert_eq!($vec2::ONE.is_negative_bitmask(), 0b00); 510 assert_eq!((-$vec2::ONE).is_negative_bitmask(), 0b11); 511 assert_eq!($vec2::new(-1 as $t, 2 as $t).is_negative_bitmask(), 0b01); 512 assert_eq!($vec2::new(8 as $t, 3 as $t).is_negative_bitmask(), 0b00); 513 assert_eq!($vec2::new(3 as $t, -4 as $t).is_negative_bitmask(), 0b10); 514 assert_eq!($vec2::new(-2 as $t, -6 as $t).is_negative_bitmask(), 0b11); 515 }); 516 517 glam_test!(test_abs, { 518 assert_eq!($vec2::ZERO.abs(), $vec2::ZERO); 519 assert_eq!($vec2::ONE.abs(), $vec2::ONE); 520 assert_eq!((-$vec2::ONE).abs(), $vec2::ONE); 521 }); 522 523 glam_test!(test_dot_signed, { 524 let x = $new(1 as $t, 0 as $t); 525 let y = $new(0 as $t, 1 as $t); 526 assert_eq!(1 as $t, x.dot(x)); 527 assert_eq!(0 as $t, x.dot(y)); 528 assert_eq!(-1 as $t, x.dot(-x)); 529 }); 530 531 glam_test!(test_length_squared_signed, { 532 let x = $new(1 as $t, 0 as $t); 533 let y = $new(0 as $t, 1 as $t); 534 assert_eq!(9 as $t, (-3 as $t * y).length_squared()); 535 assert_eq!(2 as $t, x.distance_squared(y)); 536 assert_eq!(13 as $t, (2 as $t * x).distance_squared(-3 as $t * y)); 537 }); 538 539 glam_test!(test_neg, { 540 let a = $new(1 as $t, 2 as $t); 541 assert_eq!($new(-1 as $t, -2 as $t), (-a)); 542 assert_eq!($new(-0.0 as $t, -0.0 as $t), -$new(0.0 as $t, 0.0 as $t)); 543 assert_eq!($new(0.0 as $t, -0.0 as $t), -$new(-0.0 as $t, 0.0 as $t)); 544 }); 545 546 glam_test!(test_perp, { 547 let v1 = $vec2::new(1 as $t, 2 as $t); 548 let v2 = $vec2::new(1 as $t, 1 as $t); 549 let v1_perp = $vec2::new(-2 as $t, 1 as $t); 550 551 assert_eq!(v1_perp, v1.perp()); 552 assert_eq!(v1.perp().dot(v1), 0 as $t); 553 assert_eq!(v2.perp().dot(v2), 0 as $t); 554 assert_eq!(v1.perp().dot(v2), v1.perp_dot(v2)); 555 }); 556 557 glam_test!(test_rotate, { 558 assert_eq!( 559 $vec2::new(0 as $t, 1 as $t).rotate($vec2::new(1 as $t, 1 as $t)), 560 $vec2::new(-1 as $t, 1 as $t) 561 ); 562 }); 563 564 glam_test!(test_div_euclid, { 565 let one = $vec2::ONE; 566 let two = one + one; 567 let three = two + one; 568 assert_eq!(three.div_euclid(two), one); 569 assert_eq!((-three).div_euclid(two), -two); 570 assert_eq!(three.div_euclid(-two), -one); 571 assert_eq!((-three).div_euclid(-two), two); 572 }); 573 574 glam_test!(test_rem_euclid, { 575 let one = $vec2::ONE; 576 let two = one + one; 577 let three = two + one; 578 let four = three + one; 579 assert_eq!(four.rem_euclid(three), one); 580 assert_eq!((-four).rem_euclid(three), two); 581 assert_eq!(four.rem_euclid(-three), one); 582 assert_eq!((-four).rem_euclid(-three), two); 583 }); 584 }; 585 } 586 587 macro_rules! impl_vec2_signed_integer_tests { 588 ($t:ident, $new:ident, $vec2:ident, $vec3:ident, $mask:ident) => { 589 impl_vec2_signed_tests!($t, $new, $vec2, $vec3, $mask); 590 591 glam_test!(test_signum, { 592 assert_eq!($vec3::ZERO.signum(), $vec3::ZERO); 593 assert_eq!($vec3::ONE.signum(), $vec3::ONE); 594 assert_eq!((-$vec3::ONE).signum(), -$vec3::ONE); 595 }); 596 }; 597 } 598 599 macro_rules! impl_vec2_eq_hash_tests { 600 ($t:ident, $new:ident) => { 601 glam_test!(test_ve2_hash, { 602 use std::collections::hash_map::DefaultHasher; 603 use std::hash::Hash; 604 use std::hash::Hasher; 605 606 let a = $new(1 as $t, 2 as $t); 607 let b = $new(1 as $t, 2 as $t); 608 let c = $new(3 as $t, 2 as $t); 609 610 let mut hasher = DefaultHasher::new(); 611 a.hash(&mut hasher); 612 let a_hashed = hasher.finish(); 613 614 let mut hasher = DefaultHasher::new(); 615 b.hash(&mut hasher); 616 let b_hashed = hasher.finish(); 617 618 let mut hasher = DefaultHasher::new(); 619 c.hash(&mut hasher); 620 let c_hashed = hasher.finish(); 621 622 assert_eq!(a, b); 623 assert_eq!(a_hashed, b_hashed); 624 assert_ne!(a, c); 625 assert_ne!(a_hashed, c_hashed); 626 }); 627 }; 628 } 629 630 macro_rules! impl_vec2_float_tests { 631 ($t:ident, $new:ident, $vec2:ident, $vec3:ident, $mask:ident) => { 632 impl_vec2_signed_tests!($t, $new, $vec2, $vec3, $mask); 633 impl_vec_float_normalize_tests!($t, $vec2); 634 635 use core::$t::INFINITY; 636 use core::$t::NAN; 637 use core::$t::NEG_INFINITY; 638 639 glam_test!(test_vec2_nan, { 640 assert!($vec2::NAN.is_nan()); 641 assert!(!$vec2::NAN.is_finite()); 642 }); 643 644 glam_test!(test_length, { 645 let x = $new(1.0, 0.0); 646 let y = $new(0.0, 1.0); 647 assert_eq!(2.0, (-2.0 * x).length()); 648 assert_eq!(3.0, (3.0 * y).length()); 649 assert_eq!((2.0 as $t).sqrt(), x.distance(y)); 650 assert_eq!(5.0, (3.0 * x).distance(-4.0 * y)); 651 assert_eq!(13.0, (-5.0 * x).distance(12.0 * y)); 652 assert_eq!(x, (2.0 * x).normalize()); 653 assert_eq!(1.0 * 3.0 + 2.0 * 4.0, $new(1.0, 2.0).dot($new(3.0, 4.0))); 654 assert_eq!( 655 (2.0 as $t * 2.0 + 3.0 * 3.0).sqrt(), 656 $new(2.0, 3.0).length() 657 ); 658 assert_eq!( 659 1.0 / (2.0 as $t * 2.0 + 3.0 * 3.0).sqrt(), 660 $new(2.0, 3.0).length_recip() 661 ); 662 assert!($new(2.0, 3.0).normalize().is_normalized()); 663 assert_eq!( 664 $new(2.0, 3.0) / (2.0 as $t * 2.0 + 3.0 * 3.0).sqrt(), 665 $new(2.0, 3.0).normalize() 666 ); 667 assert_eq!($new(0.5, 0.25), $new(2.0, 4.0).recip()); 668 }); 669 670 glam_test!(test_project_reject, { 671 assert_eq!($new(0.0, 1.0), $new(1.0, 1.0).project_onto($new(0.0, 2.0))); 672 assert_eq!($new(1.0, 0.0), $new(1.0, 1.0).reject_from($new(0.0, 2.0))); 673 assert_eq!( 674 $new(0.0, 1.0), 675 $new(1.0, 1.0).project_onto_normalized($new(0.0, 1.0)) 676 ); 677 assert_eq!( 678 $new(1.0, 0.0), 679 $new(1.0, 1.0).reject_from_normalized($new(0.0, 1.0)) 680 ); 681 should_glam_assert!({ $vec2::ONE.project_onto($vec2::ZERO) }); 682 should_glam_assert!({ $vec2::ONE.reject_from($vec2::ZERO) }); 683 should_glam_assert!({ $vec2::ONE.project_onto_normalized($vec2::ONE) }); 684 should_glam_assert!({ $vec2::ONE.reject_from_normalized($vec2::ONE) }); 685 }); 686 687 glam_test!(test_signum, { 688 assert_eq!($vec2::ZERO.signum(), $vec2::ONE); 689 assert_eq!((-$vec2::ZERO).signum(), -$vec2::ONE); 690 assert_eq!($vec2::ONE.signum(), $vec2::ONE); 691 assert_eq!((-$vec2::ONE).signum(), -$vec2::ONE); 692 assert_eq!($vec2::INFINITY.signum(), $vec2::ONE); 693 assert_eq!($vec2::NEG_INFINITY.signum(), -$vec2::ONE); 694 assert!($vec2::NAN.signum().is_nan_mask().all()); 695 }); 696 697 glam_test!(test_copysign, { 698 assert_eq!($vec2::ZERO.copysign(-$vec2::ZERO), -$vec2::ZERO); 699 assert_eq!((-$vec2::ZERO).copysign(-$vec2::ZERO), -$vec2::ZERO); 700 assert_eq!($vec2::ZERO.copysign($vec2::ZERO), $vec2::ZERO); 701 assert_eq!((-$vec2::ZERO).copysign($vec2::ZERO), $vec2::ZERO); 702 assert_eq!($vec2::ONE.copysign(-$vec2::ZERO), -$vec2::ONE); 703 assert_eq!((-$vec2::ONE).copysign(-$vec2::ZERO), -$vec2::ONE); 704 assert_eq!($vec2::ONE.copysign($vec2::ZERO), $vec2::ONE); 705 assert_eq!((-$vec2::ONE).copysign($vec2::ZERO), $vec2::ONE); 706 assert_eq!($vec2::ZERO.copysign(-$vec2::ONE), -$vec2::ZERO); 707 assert_eq!((-$vec2::ZERO).copysign(-$vec2::ONE), -$vec2::ZERO); 708 assert_eq!($vec2::ZERO.copysign($vec2::ONE), $vec2::ZERO); 709 assert_eq!((-$vec2::ZERO).copysign($vec2::ONE), $vec2::ZERO); 710 assert_eq!($vec2::ONE.copysign(-$vec2::ONE), -$vec2::ONE); 711 assert_eq!((-$vec2::ONE).copysign(-$vec2::ONE), -$vec2::ONE); 712 assert_eq!($vec2::ONE.copysign($vec2::ONE), $vec2::ONE); 713 assert_eq!((-$vec2::ONE).copysign($vec2::ONE), $vec2::ONE); 714 assert_eq!($vec2::INFINITY.copysign($vec2::ONE), $vec2::INFINITY); 715 assert_eq!($vec2::INFINITY.copysign(-$vec2::ONE), $vec2::NEG_INFINITY); 716 assert_eq!($vec2::NEG_INFINITY.copysign($vec2::ONE), $vec2::INFINITY); 717 assert_eq!( 718 $vec2::NEG_INFINITY.copysign(-$vec2::ONE), 719 $vec2::NEG_INFINITY 720 ); 721 assert!($vec2::NAN.copysign($vec2::ONE).is_nan_mask().all()); 722 assert!($vec2::NAN.copysign(-$vec2::ONE).is_nan_mask().all()); 723 }); 724 725 glam_test!(test_float_is_negative_bitmask, { 726 assert_eq!($vec2::ZERO.is_negative_bitmask(), 0b00); 727 assert_eq!((-$vec2::ZERO).is_negative_bitmask(), 0b11); 728 assert_eq!($vec2::ONE.is_negative_bitmask(), 0b00); 729 assert_eq!((-$vec2::ONE).is_negative_bitmask(), 0b11); 730 assert_eq!($vec2::new(-1.0, 2.0).is_negative_bitmask(), 0b01); 731 assert_eq!($vec2::new(8.0, 3.0).is_negative_bitmask(), 0b00); 732 assert_eq!($vec2::new(3.0, -4.0).is_negative_bitmask(), 0b10); 733 assert_eq!($vec2::new(-2.0, -6.0).is_negative_bitmask(), 0b11); 734 }); 735 736 glam_test!(test_round, { 737 assert_eq!($vec2::new(1.35, 0.0).round().x, 1.0); 738 assert_eq!($vec2::new(0.0, 1.5).round().y, 2.0); 739 assert_eq!($vec2::new(0.0, -15.5).round().y, -16.0); 740 assert_eq!($vec2::new(0.0, 0.0).round().y, 0.0); 741 assert_eq!($vec2::new(0.0, 21.1).round().y, 21.0); 742 assert_eq!($vec2::new(0.0, 11.123).round().y, 11.0); 743 assert_eq!($vec2::new(0.0, 11.499).round().y, 11.0); 744 assert_eq!( 745 $vec2::new(NEG_INFINITY, INFINITY).round(), 746 $vec2::new(NEG_INFINITY, INFINITY) 747 ); 748 assert!($vec2::new(NAN, 0.0).round().x.is_nan()); 749 }); 750 751 glam_test!(test_floor, { 752 assert_eq!($vec2::new(1.35, -1.5).floor(), $vec2::new(1.0, -2.0)); 753 assert_eq!( 754 $vec2::new(INFINITY, NEG_INFINITY).floor(), 755 $vec2::new(INFINITY, NEG_INFINITY) 756 ); 757 assert!($vec2::new(NAN, 0.0).floor().x.is_nan()); 758 assert_eq!( 759 $vec2::new(-2000000.123, 10000000.123).floor(), 760 $vec2::new(-2000001.0, 10000000.0) 761 ); 762 }); 763 764 glam_test!(test_fract, { 765 assert_approx_eq!($vec2::new(1.35, -1.5).fract(), $vec2::new(0.35, 0.5)); 766 assert_approx_eq!( 767 $vec2::new(-2000000.123, 1000000.123).fract(), 768 $vec2::new(0.877, 0.123), 769 0.002 770 ); 771 }); 772 773 glam_test!(test_ceil, { 774 assert_eq!($vec2::new(1.35, -1.5).ceil(), $vec2::new(2.0, -1.0)); 775 assert_eq!( 776 $vec2::new(INFINITY, NEG_INFINITY).ceil(), 777 $vec2::new(INFINITY, NEG_INFINITY) 778 ); 779 assert!($vec2::new(NAN, 0.0).ceil().x.is_nan()); 780 assert_eq!( 781 $vec2::new(-2000000.123, 1000000.123).ceil(), 782 $vec2::new(-2000000.0, 1000001.0) 783 ); 784 }); 785 786 glam_test!(test_trunc, { 787 assert_eq!($vec2::new(1.35, -1.5).trunc(), $vec2::new(1.0, -1.0)); 788 assert_eq!( 789 $vec2::new(INFINITY, NEG_INFINITY).trunc(), 790 $vec2::new(INFINITY, NEG_INFINITY) 791 ); 792 assert!($vec2::new(0.0, NAN).trunc().y.is_nan()); 793 assert_eq!( 794 $vec2::new(-0.0, -2000000.123).trunc(), 795 $vec2::new(-0.0, -2000000.0) 796 ); 797 }); 798 799 glam_test!(test_lerp, { 800 let v0 = $vec2::new(-1.0, -1.0); 801 let v1 = $vec2::new(1.0, 1.0); 802 assert_approx_eq!(v0, v0.lerp(v1, 0.0)); 803 assert_approx_eq!(v1, v0.lerp(v1, 1.0)); 804 assert_approx_eq!($vec2::ZERO, v0.lerp(v1, 0.5)); 805 }); 806 807 glam_test!(test_is_finite, { 808 assert!($vec2::new(0.0, 0.0).is_finite()); 809 assert!($vec2::new(-1e-10, 1e10).is_finite()); 810 assert!(!$vec2::new(INFINITY, 0.0).is_finite()); 811 assert!(!$vec2::new(0.0, NAN).is_finite()); 812 assert!(!$vec2::new(0.0, NEG_INFINITY).is_finite()); 813 assert!(!$vec2::new(INFINITY, NEG_INFINITY).is_finite()); 814 assert!(!$vec2::INFINITY.is_finite()); 815 assert!(!$vec2::NEG_INFINITY.is_finite()); 816 }); 817 818 glam_test!(test_powf, { 819 assert_eq!($vec2::new(2.0, 4.0).powf(2.0), $vec2::new(4.0, 16.0)); 820 }); 821 822 glam_test!(test_exp, { 823 assert_approx_eq!( 824 $vec2::new(1.0, 2.0).exp(), 825 $vec2::new((1.0 as $t).exp(), (2.0 as $t).exp()) 826 ); 827 }); 828 829 glam_test!(test_angle_between, { 830 let angle = $vec2::new(1.0, 0.0).angle_between($vec2::new(0.0, 1.0)); 831 assert_approx_eq!(core::$t::consts::FRAC_PI_2, angle, 1e-6); 832 833 let angle = $vec2::new(10.0, 0.0).angle_between($vec2::new(0.0, 5.0)); 834 assert_approx_eq!(core::$t::consts::FRAC_PI_2, angle, 1e-6); 835 836 let angle = $vec2::new(-1.0, 0.0).angle_between($vec2::new(0.0, 1.0)); 837 assert_approx_eq!(-core::$t::consts::FRAC_PI_2, angle, 1e-6); 838 }); 839 840 glam_test!(test_clamp_length, { 841 // Too long gets shortened 842 assert_eq!( 843 $vec2::new(12.0, 16.0).clamp_length(7.0, 10.0), 844 $vec2::new(6.0, 8.0) // shortened to length 10.0 845 ); 846 // In the middle is unchanged 847 assert_eq!( 848 $vec2::new(2.0, 1.0).clamp_length(0.5, 5.0), 849 $vec2::new(2.0, 1.0) // unchanged 850 ); 851 // Too short gets lengthened 852 assert_eq!( 853 $vec2::new(0.6, 0.8).clamp_length(10.0, 20.0), 854 $vec2::new(6.0, 8.0) // lengthened to length 10.0 855 ); 856 should_glam_assert!({ $vec2::ONE.clamp_length(1.0, 0.0) }); 857 }); 858 859 glam_test!(test_clamp_length_max, { 860 // Too long gets shortened 861 assert_eq!( 862 $vec2::new(12.0, 16.0).clamp_length_max(10.0), 863 $vec2::new(6.0, 8.0) // shortened to length 10.0 864 ); 865 // Not too long is unchanged 866 assert_eq!( 867 $vec2::new(2.0, 1.0).clamp_length_max(5.0), 868 $vec2::new(2.0, 1.0) // unchanged 869 ); 870 }); 871 872 glam_test!(test_clamp_length_min, { 873 // Not too short is unchanged 874 assert_eq!( 875 $vec2::new(2.0, 1.0).clamp_length_min(0.5), 876 $vec2::new(2.0, 1.0) // unchanged 877 ); 878 // Too short gets lengthened 879 assert_eq!( 880 $vec2::new(0.6, 0.8).clamp_length_min(10.0), 881 $vec2::new(6.0, 8.0) // lengthened to length 10.0 882 ); 883 }); 884 885 #[cfg(any(feature = "glam-assert", feature = "debug-glam-assert"))] 886 glam_test!(test_float_glam_assert, { 887 use std::panic::catch_unwind; 888 889 assert!(catch_unwind(|| $vec2::ZERO.normalize()).is_err()); 890 }); 891 892 glam_test!(test_mul_add, { 893 assert_eq!( 894 $vec2::new(1.0, 1.0).mul_add($vec2::new(0.5, 2.0), $vec2::new(-1.0, -1.0)), 895 $vec2::new(-0.5, 1.0) 896 ); 897 }); 898 899 glam_test!(test_angle_conversion, { 900 let angle = 0.; 901 let vec = $vec2::from_angle(angle); 902 assert_approx_eq!(vec, $vec2::new(1.0, 0.0)); 903 assert_approx_eq!(vec.to_angle(), angle); 904 905 let angle = core::$t::consts::FRAC_PI_2; 906 let vec = $vec2::from_angle(angle); 907 assert_approx_eq!(vec, $vec2::new(0.0, 1.0)); 908 assert_approx_eq!(vec.to_angle(), angle); 909 910 let angle = core::$t::consts::PI; 911 let vec = $vec2::from_angle(angle); 912 assert_approx_eq!(vec, $vec2::new(-1.0, 0.0)); 913 // The sign of the angle PI gets flipped and is slightly less precise but correct 914 assert_approx_eq!(vec.to_angle().abs(), angle, 1e-6); 915 916 let angle = -core::$t::consts::FRAC_PI_2; 917 let vec = $vec2::from_angle(angle); 918 assert_approx_eq!(vec, $vec2::new(0.0, -1.0)); 919 assert_approx_eq!(vec.to_angle(), angle); 920 }); 921 }; 922 } 923 924 macro_rules! impl_vec2_scalar_shift_op_test { 925 ($vec2:ident, $t_min:literal, $t_max:literal, $rhs_min:literal, $rhs_max:literal) => { 926 glam_test!(test_vec2_scalar_shift_ops, { 927 for x in $t_min..$t_max { 928 for y in $t_min..$t_max { 929 for rhs in $rhs_min..$rhs_max { 930 assert_eq!($vec2::new(x, y) << rhs, $vec2::new(x << rhs, y << rhs)); 931 assert_eq!($vec2::new(x, y) >> rhs, $vec2::new(x >> rhs, y >> rhs)); 932 } 933 } 934 } 935 }); 936 }; 937 } 938 939 macro_rules! impl_vec2_scalar_shift_op_tests { 940 ($vec2:ident, $t_min:literal, $t_max:literal) => { 941 mod shift_by_i8 { 942 use glam::$vec2; 943 impl_vec2_scalar_shift_op_test!($vec2, $t_min, $t_max, 0i8, 2); 944 } 945 mod shift_by_i16 { 946 use glam::$vec2; 947 impl_vec2_scalar_shift_op_test!($vec2, $t_min, $t_max, 0i16, 2); 948 } 949 mod shift_by_i32 { 950 use glam::$vec2; 951 impl_vec2_scalar_shift_op_test!($vec2, $t_min, $t_max, 0i32, 2); 952 } 953 mod shift_by_i64 { 954 use glam::$vec2; 955 impl_vec2_scalar_shift_op_test!($vec2, $t_min, $t_max, 0i64, 2); 956 } 957 mod shift_by_u8 { 958 use glam::$vec2; 959 impl_vec2_scalar_shift_op_test!($vec2, $t_min, $t_max, 0u8, 2); 960 } 961 mod shift_by_u16 { 962 use glam::$vec2; 963 impl_vec2_scalar_shift_op_test!($vec2, $t_min, $t_max, 0u16, 2); 964 } 965 mod shift_by_u32 { 966 use glam::$vec2; 967 impl_vec2_scalar_shift_op_test!($vec2, $t_min, $t_max, 0u32, 2); 968 } 969 mod shift_by_u64 { 970 use glam::$vec2; 971 impl_vec2_scalar_shift_op_test!($vec2, $t_min, $t_max, 0u64, 2); 972 } 973 }; 974 } 975 976 macro_rules! impl_vec2_shift_op_test { 977 ($vec2:ident, $rhs:ident, $t_min:literal, $t_max:literal) => { 978 glam_test!(test_vec2_shift_ops, { 979 for x1 in $t_min..$t_max { 980 for y1 in $t_min..$t_max { 981 for x2 in $t_min..$t_max { 982 for y2 in $t_min..$t_max { 983 assert_eq!( 984 $vec2::new(x1, y1) << $rhs::new(x2, y2), 985 $vec2::new(x1 << x2, y1 << y2) 986 ); 987 assert_eq!( 988 $vec2::new(x1, y1) >> $rhs::new(x2, y2), 989 $vec2::new(x1 >> x2, y1 >> y2) 990 ); 991 } 992 } 993 } 994 } 995 }); 996 }; 997 } 998 999 macro_rules! impl_vec2_shift_op_tests { 1000 ($vec2:ident) => { 1001 mod shift_ivec2_by_ivec2 { 1002 use super::*; 1003 impl_vec2_shift_op_test!($vec2, IVec2, 0, 2); 1004 } 1005 mod shift_ivec2_by_uvec2 { 1006 use super::*; 1007 impl_vec2_shift_op_test!($vec2, UVec2, 0, 2); 1008 } 1009 }; 1010 } 1011 1012 macro_rules! impl_vec2_scalar_bit_op_tests { 1013 ($vec2:ident, $t_min:literal, $t_max:literal) => { 1014 glam_test!(test_vec2_scalar_bit_ops, { 1015 for x in $t_min..$t_max { 1016 for y in $t_min..$t_max { 1017 for rhs in $t_min..$t_max { 1018 assert_eq!($vec2::new(x, y) & rhs, $vec2::new(x & rhs, y & rhs)); 1019 assert_eq!($vec2::new(x, y) | rhs, $vec2::new(x | rhs, y | rhs)); 1020 assert_eq!($vec2::new(x, y) ^ rhs, $vec2::new(x ^ rhs, y ^ rhs)); 1021 } 1022 } 1023 } 1024 }); 1025 }; 1026 } 1027 1028 macro_rules! impl_vec2_bit_op_tests { 1029 ($vec2:ident, $t_min:literal, $t_max:literal) => { 1030 glam_test!(test_vec2_bit_ops, { 1031 for x1 in $t_min..$t_max { 1032 for y1 in $t_min..$t_max { 1033 assert_eq!(!$vec2::new(x1, y1), $vec2::new(!x1, !y1)); 1034 1035 for x2 in $t_min..$t_max { 1036 for y2 in $t_min..$t_max { 1037 assert_eq!( 1038 $vec2::new(x1, y1) & $vec2::new(x2, y2), 1039 $vec2::new(x1 & x2, y1 & y2) 1040 ); 1041 assert_eq!( 1042 $vec2::new(x1, y1) | $vec2::new(x2, y2), 1043 $vec2::new(x1 | x2, y1 | y2) 1044 ); 1045 assert_eq!( 1046 $vec2::new(x1, y1) ^ $vec2::new(x2, y2), 1047 $vec2::new(x1 ^ x2, y1 ^ y2) 1048 ); 1049 } 1050 } 1051 } 1052 } 1053 }); 1054 }; 1055 } 1056 1057 mod vec2 { 1058 use glam::{vec2, BVec2, Vec2, Vec3}; 1059 1060 glam_test!(test_align, { 1061 use core::mem; 1062 assert_eq!(8, mem::size_of::<Vec2>()); 1063 #[cfg(not(feature = "cuda"))] 1064 assert_eq!(4, mem::align_of::<Vec2>()); 1065 #[cfg(feature = "cuda")] 1066 assert_eq!(8, mem::align_of::<Vec2>()); 1067 assert_eq!(2, mem::size_of::<BVec2>()); 1068 assert_eq!(1, mem::align_of::<BVec2>()); 1069 }); 1070 1071 glam_test!(test_as, { 1072 use glam::{DVec2, I16Vec2, I64Vec2, IVec2, U16Vec2, U64Vec2, UVec2}; 1073 assert_eq!(DVec2::new(-1.0, -2.0), Vec2::new(-1.0, -2.0).as_dvec2()); 1074 assert_eq!(I16Vec2::new(-1, -2), Vec2::new(-1.0, -2.0).as_i16vec2()); 1075 assert_eq!(U16Vec2::new(1, 2), Vec2::new(1.0, 2.0).as_u16vec2()); 1076 assert_eq!(IVec2::new(-1, -2), Vec2::new(-1.0, -2.0).as_ivec2()); 1077 assert_eq!(UVec2::new(1, 2), Vec2::new(1.0, 2.0).as_uvec2()); 1078 assert_eq!(I64Vec2::new(-1, -2), Vec2::new(-1.0, -2.0).as_i64vec2()); 1079 assert_eq!(U64Vec2::new(1, 2), Vec2::new(1.0, 2.0).as_u64vec2()); 1080 1081 assert_eq!(Vec2::new(-1.0, -2.0), DVec2::new(-1.0, -2.0).as_vec2()); 1082 assert_eq!(I16Vec2::new(-1, -2), DVec2::new(-1.0, -2.0).as_i16vec2()); 1083 assert_eq!(U16Vec2::new(1, 2), DVec2::new(1.0, 2.0).as_u16vec2()); 1084 assert_eq!(IVec2::new(-1, -2), DVec2::new(-1.0, -2.0).as_ivec2()); 1085 assert_eq!(UVec2::new(1, 2), DVec2::new(1.0, 2.0).as_uvec2()); 1086 assert_eq!(I64Vec2::new(-1, -2), DVec2::new(-1.0, -2.0).as_i64vec2()); 1087 assert_eq!(U64Vec2::new(1, 2), DVec2::new(1.0, 2.0).as_u64vec2()); 1088 1089 assert_eq!(Vec2::new(-1.0, -2.0), I16Vec2::new(-1, -2).as_vec2()); 1090 assert_eq!(DVec2::new(-1.0, -2.0), I16Vec2::new(-1, -2).as_dvec2()); 1091 assert_eq!(U16Vec2::new(1, 2), I16Vec2::new(1, 2).as_u16vec2()); 1092 assert_eq!(IVec2::new(-1, -2), I16Vec2::new(-1, -2).as_ivec2()); 1093 assert_eq!(UVec2::new(1, 2), I16Vec2::new(1, 2).as_uvec2()); 1094 assert_eq!(I64Vec2::new(-1, -2), I16Vec2::new(-1, -2).as_i64vec2()); 1095 assert_eq!(U64Vec2::new(1, 2), I16Vec2::new(1, 2).as_u64vec2()); 1096 1097 assert_eq!(Vec2::new(1.0, 2.0), U16Vec2::new(1, 2).as_vec2()); 1098 assert_eq!(DVec2::new(1.0, 2.0), U16Vec2::new(1, 2).as_dvec2()); 1099 assert_eq!(I16Vec2::new(1, 2), U16Vec2::new(1, 2).as_i16vec2()); 1100 assert_eq!(IVec2::new(1, 2), U16Vec2::new(1, 2).as_ivec2()); 1101 assert_eq!(UVec2::new(1, 2), U16Vec2::new(1, 2).as_uvec2()); 1102 assert_eq!(I64Vec2::new(1, 2), U16Vec2::new(1, 2).as_i64vec2()); 1103 assert_eq!(U64Vec2::new(1, 2), U16Vec2::new(1, 2).as_u64vec2()); 1104 1105 assert_eq!(Vec2::new(-1.0, -2.0), IVec2::new(-1, -2).as_vec2()); 1106 assert_eq!(DVec2::new(-1.0, -2.0), IVec2::new(-1, -2).as_dvec2()); 1107 assert_eq!(UVec2::new(1, 2), IVec2::new(1, 2).as_uvec2()); 1108 assert_eq!(I16Vec2::new(-1, -2), IVec2::new(-1, -2).as_i16vec2()); 1109 assert_eq!(U16Vec2::new(1, 2), IVec2::new(1, 2).as_u16vec2()); 1110 assert_eq!(I64Vec2::new(-1, -2), IVec2::new(-1, -2).as_i64vec2()); 1111 assert_eq!(U64Vec2::new(1, 2), IVec2::new(1, 2).as_u64vec2()); 1112 1113 assert_eq!(Vec2::new(1.0, 2.0), UVec2::new(1, 2).as_vec2()); 1114 assert_eq!(DVec2::new(1.0, 2.0), UVec2::new(1, 2).as_dvec2()); 1115 assert_eq!(I16Vec2::new(1, 2), UVec2::new(1, 2).as_i16vec2()); 1116 assert_eq!(U16Vec2::new(1, 2), UVec2::new(1, 2).as_u16vec2()); 1117 assert_eq!(IVec2::new(1, 2), UVec2::new(1, 2).as_ivec2()); 1118 assert_eq!(I64Vec2::new(1, 2), UVec2::new(1, 2).as_i64vec2()); 1119 assert_eq!(U64Vec2::new(1, 2), UVec2::new(1, 2).as_u64vec2()); 1120 1121 assert_eq!(Vec2::new(-1.0, -2.0), I64Vec2::new(-1, -2).as_vec2()); 1122 assert_eq!(DVec2::new(-1.0, -2.0), I64Vec2::new(-1, -2).as_dvec2()); 1123 assert_eq!(U16Vec2::new(1, 2), I64Vec2::new(1, 2).as_u16vec2()); 1124 assert_eq!(I16Vec2::new(-1, -2), I64Vec2::new(-1, -2).as_i16vec2()); 1125 assert_eq!(UVec2::new(1, 2), I64Vec2::new(1, 2).as_uvec2()); 1126 assert_eq!(IVec2::new(-1, -2), I64Vec2::new(-1, -2).as_ivec2()); 1127 assert_eq!(U64Vec2::new(1, 2), I64Vec2::new(1, 2).as_u64vec2()); 1128 1129 assert_eq!(Vec2::new(1.0, 2.0), U64Vec2::new(1, 2).as_vec2()); 1130 assert_eq!(DVec2::new(1.0, 2.0), U64Vec2::new(1, 2).as_dvec2()); 1131 assert_eq!(I16Vec2::new(1, 2), U64Vec2::new(1, 2).as_i16vec2()); 1132 assert_eq!(U16Vec2::new(1, 2), U64Vec2::new(1, 2).as_u16vec2()); 1133 assert_eq!(IVec2::new(1, 2), U64Vec2::new(1, 2).as_ivec2()); 1134 assert_eq!(UVec2::new(1, 2), U64Vec2::new(1, 2).as_uvec2()); 1135 assert_eq!(I64Vec2::new(1, 2), U64Vec2::new(1, 2).as_i64vec2()); 1136 }); 1137 1138 impl_vec2_float_tests!(f32, vec2, Vec2, Vec3, BVec2); 1139 } 1140 1141 mod dvec2 { 1142 use glam::{dvec2, BVec2, DVec2, DVec3, IVec2, UVec2, Vec2}; 1143 1144 glam_test!(test_align, { 1145 use core::mem; 1146 assert_eq!(16, mem::size_of::<DVec2>()); 1147 #[cfg(not(feature = "cuda"))] 1148 assert_eq!(mem::align_of::<f64>(), mem::align_of::<DVec2>()); 1149 #[cfg(feature = "cuda")] 1150 assert_eq!(16, mem::align_of::<DVec2>()); 1151 assert_eq!(2, mem::size_of::<BVec2>()); 1152 assert_eq!(1, mem::align_of::<BVec2>()); 1153 }); 1154 1155 glam_test!(test_try_from, { 1156 assert_eq!(DVec2::new(1.0, 2.0), DVec2::from(Vec2::new(1.0, 2.0))); 1157 assert_eq!(DVec2::new(1.0, 2.0), DVec2::from(IVec2::new(1, 2))); 1158 assert_eq!(DVec2::new(1.0, 2.0), DVec2::from(UVec2::new(1, 2))); 1159 }); 1160 1161 impl_vec2_float_tests!(f64, dvec2, DVec2, DVec3, BVec2); 1162 } 1163 1164 mod i16vec2 { 1165 use glam::{i16vec2, BVec2, I16Vec2, I16Vec3, I64Vec2, IVec2, U16Vec2, U64Vec2, UVec2}; 1166 1167 glam_test!(test_align, { 1168 use core::mem; 1169 assert_eq!(4, mem::size_of::<I16Vec2>()); 1170 #[cfg(not(feature = "cuda"))] 1171 assert_eq!(2, mem::align_of::<I16Vec2>()); 1172 #[cfg(feature = "cuda")] 1173 assert_eq!(4, mem::align_of::<I16Vec2>()); 1174 }); 1175 1176 glam_test!(test_try_from, { 1177 assert_eq!( 1178 I16Vec2::new(1, 2), 1179 I16Vec2::try_from(U16Vec2::new(1, 2)).unwrap() 1180 ); 1181 assert!(I16Vec2::try_from(U16Vec2::new(u16::MAX, 2)).is_err()); 1182 assert!(I16Vec2::try_from(U16Vec2::new(1, u16::MAX)).is_err()); 1183 1184 assert_eq!( 1185 I16Vec2::new(1, 2), 1186 I16Vec2::try_from(IVec2::new(1, 2)).unwrap() 1187 ); 1188 assert!(I16Vec2::try_from(IVec2::new(i32::MAX, 2)).is_err()); 1189 assert!(I16Vec2::try_from(IVec2::new(1, i32::MAX)).is_err()); 1190 1191 assert_eq!( 1192 I16Vec2::new(1, 2), 1193 I16Vec2::try_from(UVec2::new(1, 2)).unwrap() 1194 ); 1195 assert!(I16Vec2::try_from(UVec2::new(u32::MAX, 2)).is_err()); 1196 assert!(I16Vec2::try_from(UVec2::new(1, u32::MAX)).is_err()); 1197 1198 assert_eq!( 1199 I16Vec2::new(1, 2), 1200 I16Vec2::try_from(I64Vec2::new(1, 2)).unwrap() 1201 ); 1202 assert!(I16Vec2::try_from(I64Vec2::new(i64::MAX, 2)).is_err()); 1203 assert!(I16Vec2::try_from(I64Vec2::new(1, i64::MAX)).is_err()); 1204 1205 assert_eq!( 1206 I16Vec2::new(1, 2), 1207 I16Vec2::try_from(U64Vec2::new(1, 2)).unwrap() 1208 ); 1209 assert!(I16Vec2::try_from(U64Vec2::new(u64::MAX, 2)).is_err()); 1210 assert!(I16Vec2::try_from(U64Vec2::new(1, u64::MAX)).is_err()); 1211 }); 1212 1213 glam_test!(test_wrapping_add, { 1214 assert_eq!( 1215 I16Vec2::new(i16::MAX, 5).wrapping_add(I16Vec2::new(1, 3)), 1216 I16Vec2::new(i16::MIN, 8), 1217 ); 1218 }); 1219 1220 glam_test!(test_wrapping_sub, { 1221 assert_eq!( 1222 I16Vec2::new(i16::MAX, 5).wrapping_sub(I16Vec2::new(1, 3)), 1223 I16Vec2::new(32766, 2) 1224 ); 1225 }); 1226 1227 glam_test!(test_wrapping_mul, { 1228 assert_eq!( 1229 I16Vec2::new(i16::MAX, 5).wrapping_mul(I16Vec2::new(3, 3)), 1230 I16Vec2::new(32765, 15) 1231 ); 1232 }); 1233 1234 glam_test!(test_wrapping_div, { 1235 assert_eq!( 1236 I16Vec2::new(i16::MAX, 5).wrapping_div(I16Vec2::new(3, 3)), 1237 I16Vec2::new(10922, 1) 1238 ); 1239 }); 1240 1241 glam_test!(test_saturating_add, { 1242 assert_eq!( 1243 I16Vec2::new(i16::MAX, i16::MIN,).saturating_add(I16Vec2::new(1, -1)), 1244 I16Vec2::new(i16::MAX, i16::MIN) 1245 ); 1246 }); 1247 1248 glam_test!(test_saturating_sub, { 1249 assert_eq!( 1250 I16Vec2::new(i16::MIN, i16::MAX).saturating_sub(I16Vec2::new(1, -1)), 1251 I16Vec2::new(i16::MIN, i16::MAX) 1252 ); 1253 }); 1254 1255 glam_test!(test_saturating_mul, { 1256 assert_eq!( 1257 I16Vec2::new(i16::MAX, i16::MIN).saturating_mul(I16Vec2::new(2, 2)), 1258 I16Vec2::new(i16::MAX, i16::MIN) 1259 ); 1260 }); 1261 1262 glam_test!(test_saturating_div, { 1263 assert_eq!( 1264 I16Vec2::new(i16::MAX, i16::MIN).saturating_div(I16Vec2::new(2, 2)), 1265 I16Vec2::new(16383, -16384) 1266 ); 1267 }); 1268 1269 impl_vec2_signed_integer_tests!(i16, i16vec2, I16Vec2, I16Vec3, BVec2); 1270 impl_vec2_eq_hash_tests!(i16, i16vec2); 1271 1272 impl_vec2_scalar_shift_op_tests!(I16Vec2, -2, 2); 1273 impl_vec2_shift_op_tests!(I16Vec2); 1274 1275 impl_vec2_scalar_bit_op_tests!(I16Vec2, -2, 2); 1276 impl_vec2_bit_op_tests!(I16Vec2, -2, 2); 1277 } 1278 1279 mod u16vec2 { 1280 use glam::{u16vec2, BVec2, I16Vec2, I64Vec2, IVec2, U16Vec2, U16Vec3, U64Vec2, UVec2}; 1281 1282 glam_test!(test_align, { 1283 use core::mem; 1284 assert_eq!(4, mem::size_of::<U16Vec2>()); 1285 #[cfg(not(feature = "cuda"))] 1286 assert_eq!(2, mem::align_of::<U16Vec2>()); 1287 #[cfg(feature = "cuda")] 1288 assert_eq!(4, mem::align_of::<U16Vec2>()); 1289 }); 1290 1291 glam_test!(test_try_from, { 1292 assert_eq!( 1293 U16Vec2::new(1, 2), 1294 U16Vec2::try_from(I16Vec2::new(1, 2)).unwrap() 1295 ); 1296 assert!(U16Vec2::try_from(I16Vec2::new(-1, 2)).is_err()); 1297 assert!(U16Vec2::try_from(I16Vec2::new(1, -2)).is_err()); 1298 1299 assert_eq!( 1300 U16Vec2::new(1, 2), 1301 U16Vec2::try_from(IVec2::new(1, 2)).unwrap() 1302 ); 1303 assert!(U16Vec2::try_from(IVec2::new(-1, 2)).is_err()); 1304 assert!(U16Vec2::try_from(IVec2::new(1, -2)).is_err()); 1305 1306 assert!(U16Vec2::try_from(IVec2::new(i32::MAX, 2)).is_err()); 1307 assert!(U16Vec2::try_from(IVec2::new(1, i32::MAX)).is_err()); 1308 1309 assert_eq!( 1310 U16Vec2::new(1, 2), 1311 U16Vec2::try_from(UVec2::new(1, 2)).unwrap() 1312 ); 1313 assert!(U16Vec2::try_from(UVec2::new(u32::MAX, 2)).is_err()); 1314 assert!(U16Vec2::try_from(UVec2::new(1, u32::MAX)).is_err()); 1315 1316 assert_eq!( 1317 U16Vec2::new(1, 2), 1318 U16Vec2::try_from(I64Vec2::new(1, 2)).unwrap() 1319 ); 1320 assert!(U16Vec2::try_from(I64Vec2::new(-1, 2)).is_err()); 1321 assert!(U16Vec2::try_from(I64Vec2::new(1, -2)).is_err()); 1322 1323 assert!(U16Vec2::try_from(I64Vec2::new(i64::MAX, 2)).is_err()); 1324 assert!(U16Vec2::try_from(I64Vec2::new(1, i64::MAX)).is_err()); 1325 1326 assert_eq!( 1327 U16Vec2::new(1, 2), 1328 U16Vec2::try_from(U64Vec2::new(1, 2)).unwrap() 1329 ); 1330 assert!(U16Vec2::try_from(U64Vec2::new(u64::MAX, 2)).is_err()); 1331 assert!(U16Vec2::try_from(U64Vec2::new(1, u64::MAX)).is_err()); 1332 }); 1333 1334 glam_test!(test_wrapping_add, { 1335 assert_eq!( 1336 U16Vec2::new(u16::MAX, 5).wrapping_add(U16Vec2::new(1, 3)), 1337 U16Vec2::new(0, 8), 1338 ); 1339 }); 1340 1341 glam_test!(test_wrapping_sub, { 1342 assert_eq!( 1343 U16Vec2::new(u16::MAX, 5).wrapping_sub(U16Vec2::new(1, 3)), 1344 U16Vec2::new(65534, 2) 1345 ); 1346 }); 1347 1348 glam_test!(test_wrapping_mul, { 1349 assert_eq!( 1350 U16Vec2::new(u16::MAX, 5).wrapping_mul(U16Vec2::new(3, 3)), 1351 U16Vec2::new(65533, 15) 1352 ); 1353 }); 1354 1355 glam_test!(test_wrapping_div, { 1356 assert_eq!( 1357 U16Vec2::new(u16::MAX, 5).wrapping_div(U16Vec2::new(3, 3)), 1358 U16Vec2::new(21845, 1) 1359 ); 1360 }); 1361 1362 glam_test!(test_saturating_add, { 1363 assert_eq!( 1364 U16Vec2::new(u16::MAX, u16::MAX).saturating_add(U16Vec2::new(1, u16::MAX)), 1365 U16Vec2::new(u16::MAX, u16::MAX) 1366 ); 1367 }); 1368 1369 glam_test!(test_saturating_sub, { 1370 assert_eq!( 1371 U16Vec2::new(0, u16::MAX).saturating_sub(U16Vec2::new(1, 1)), 1372 U16Vec2::new(0, 65534) 1373 ); 1374 }); 1375 1376 glam_test!(test_saturating_mul, { 1377 assert_eq!( 1378 U16Vec2::new(u16::MAX, u16::MAX).saturating_mul(U16Vec2::new(2, u16::MAX)), 1379 U16Vec2::new(u16::MAX, u16::MAX) 1380 ); 1381 }); 1382 1383 glam_test!(test_saturating_div, { 1384 assert_eq!( 1385 U16Vec2::new(u16::MAX, u16::MAX).saturating_div(U16Vec2::new(2, u16::MAX)), 1386 U16Vec2::new(32767, 1) 1387 ); 1388 }); 1389 1390 impl_vec2_tests!(u16, u16vec2, U16Vec2, U16Vec3, BVec2); 1391 impl_vec2_eq_hash_tests!(u16, u16vec2); 1392 1393 impl_vec2_scalar_shift_op_tests!(U16Vec2, 0, 2); 1394 impl_vec2_shift_op_tests!(U16Vec2); 1395 1396 impl_vec2_scalar_bit_op_tests!(U16Vec2, 0, 2); 1397 impl_vec2_bit_op_tests!(U16Vec2, 0, 2); 1398 } 1399 1400 mod ivec2 { 1401 use glam::{ivec2, BVec2, I16Vec2, I64Vec2, IVec2, IVec3, U16Vec2, U64Vec2, UVec2}; 1402 1403 glam_test!(test_align, { 1404 use core::mem; 1405 assert_eq!(8, mem::size_of::<IVec2>()); 1406 #[cfg(not(feature = "cuda"))] 1407 assert_eq!(4, mem::align_of::<IVec2>()); 1408 #[cfg(feature = "cuda")] 1409 assert_eq!(8, mem::align_of::<IVec2>()); 1410 assert_eq!(2, mem::size_of::<BVec2>()); 1411 assert_eq!(1, mem::align_of::<BVec2>()); 1412 }); 1413 1414 glam_test!(test_try_from, { 1415 assert_eq!(IVec2::new(1, 2), IVec2::from(U16Vec2::new(1, 2))); 1416 assert_eq!(IVec2::new(1, 2), IVec2::from(I16Vec2::new(1, 2))); 1417 1418 assert_eq!(IVec2::new(1, 2), IVec2::try_from(UVec2::new(1, 2)).unwrap()); 1419 assert!(IVec2::try_from(UVec2::new(u32::MAX, 2)).is_err()); 1420 assert!(IVec2::try_from(UVec2::new(1, u32::MAX)).is_err()); 1421 1422 assert_eq!( 1423 IVec2::new(1, 2), 1424 IVec2::try_from(I64Vec2::new(1, 2)).unwrap() 1425 ); 1426 assert!(IVec2::try_from(I64Vec2::new(i64::MAX, 2)).is_err()); 1427 assert!(IVec2::try_from(I64Vec2::new(1, i64::MAX)).is_err()); 1428 1429 assert_eq!( 1430 IVec2::new(1, 2), 1431 IVec2::try_from(U64Vec2::new(1, 2)).unwrap() 1432 ); 1433 assert!(IVec2::try_from(U64Vec2::new(u64::MAX, 2)).is_err()); 1434 assert!(IVec2::try_from(U64Vec2::new(1, u64::MAX)).is_err()); 1435 }); 1436 1437 glam_test!(test_wrapping_add, { 1438 assert_eq!( 1439 IVec2::new(i32::MAX, 5).wrapping_add(IVec2::new(1, 3)), 1440 IVec2::new(i32::MIN, 8), 1441 ); 1442 }); 1443 1444 glam_test!(test_wrapping_sub, { 1445 assert_eq!( 1446 IVec2::new(i32::MAX, 5).wrapping_sub(IVec2::new(1, 3)), 1447 IVec2::new(2147483646, 2) 1448 ); 1449 }); 1450 1451 glam_test!(test_wrapping_mul, { 1452 assert_eq!( 1453 IVec2::new(i32::MAX, 5).wrapping_mul(IVec2::new(3, 3)), 1454 IVec2::new(2147483645, 15) 1455 ); 1456 }); 1457 1458 glam_test!(test_wrapping_div, { 1459 assert_eq!( 1460 IVec2::new(i32::MAX, 5).wrapping_div(IVec2::new(3, 3)), 1461 IVec2::new(715827882, 1) 1462 ); 1463 }); 1464 1465 glam_test!(test_saturating_add, { 1466 assert_eq!( 1467 IVec2::new(i32::MAX, i32::MIN,).saturating_add(IVec2::new(1, -1)), 1468 IVec2::new(i32::MAX, i32::MIN) 1469 ); 1470 }); 1471 1472 glam_test!(test_saturating_sub, { 1473 assert_eq!( 1474 IVec2::new(i32::MIN, i32::MAX).saturating_sub(IVec2::new(1, -1)), 1475 IVec2::new(i32::MIN, i32::MAX) 1476 ); 1477 }); 1478 1479 glam_test!(test_saturating_mul, { 1480 assert_eq!( 1481 IVec2::new(i32::MAX, i32::MIN).saturating_mul(IVec2::new(2, 2)), 1482 IVec2::new(i32::MAX, i32::MIN) 1483 ); 1484 }); 1485 1486 glam_test!(test_saturating_div, { 1487 assert_eq!( 1488 IVec2::new(i32::MAX, i32::MIN).saturating_div(IVec2::new(2, 2)), 1489 IVec2::new(1073741823, -1073741824) 1490 ); 1491 }); 1492 1493 impl_vec2_signed_integer_tests!(i32, ivec2, IVec2, IVec3, BVec2); 1494 impl_vec2_eq_hash_tests!(i32, ivec2); 1495 1496 impl_vec2_scalar_shift_op_tests!(IVec2, -2, 2); 1497 impl_vec2_shift_op_tests!(IVec2); 1498 1499 impl_vec2_scalar_bit_op_tests!(IVec2, -2, 2); 1500 impl_vec2_bit_op_tests!(IVec2, -2, 2); 1501 } 1502 1503 mod uvec2 { 1504 use glam::{uvec2, BVec2, I16Vec2, I64Vec2, IVec2, U16Vec2, U64Vec2, UVec2, UVec3}; 1505 1506 glam_test!(test_align, { 1507 use core::mem; 1508 assert_eq!(8, mem::size_of::<UVec2>()); 1509 #[cfg(not(feature = "cuda"))] 1510 assert_eq!(4, mem::align_of::<UVec2>()); 1511 #[cfg(feature = "cuda")] 1512 assert_eq!(8, mem::align_of::<UVec2>()); 1513 assert_eq!(2, mem::size_of::<BVec2>()); 1514 assert_eq!(1, mem::align_of::<BVec2>()); 1515 }); 1516 1517 glam_test!(test_try_from, { 1518 assert_eq!( 1519 UVec2::new(1, 2), 1520 UVec2::try_from(I16Vec2::new(1, 2)).unwrap() 1521 ); 1522 assert!(UVec2::try_from(I16Vec2::new(-1, 2)).is_err()); 1523 assert!(UVec2::try_from(I16Vec2::new(1, -2)).is_err()); 1524 1525 assert_eq!(UVec2::new(1, 2), UVec2::from(U16Vec2::new(1, 2))); 1526 1527 assert_eq!(UVec2::new(1, 2), UVec2::try_from(IVec2::new(1, 2)).unwrap()); 1528 assert!(UVec2::try_from(IVec2::new(-1, 2)).is_err()); 1529 assert!(UVec2::try_from(IVec2::new(1, -2)).is_err()); 1530 1531 assert_eq!( 1532 UVec2::new(1, 2), 1533 UVec2::try_from(I64Vec2::new(1, 2)).unwrap() 1534 ); 1535 assert!(UVec2::try_from(I64Vec2::new(-1, 2)).is_err()); 1536 assert!(UVec2::try_from(I64Vec2::new(1, -2)).is_err()); 1537 1538 assert!(UVec2::try_from(I64Vec2::new(i64::MAX, 2)).is_err()); 1539 assert!(UVec2::try_from(I64Vec2::new(1, i64::MAX)).is_err()); 1540 1541 assert_eq!( 1542 UVec2::new(1, 2), 1543 UVec2::try_from(U64Vec2::new(1, 2)).unwrap() 1544 ); 1545 assert!(UVec2::try_from(U64Vec2::new(u64::MAX, 2)).is_err()); 1546 assert!(UVec2::try_from(U64Vec2::new(1, u64::MAX)).is_err()); 1547 }); 1548 1549 glam_test!(test_wrapping_add, { 1550 assert_eq!( 1551 UVec2::new(u32::MAX, 5).wrapping_add(UVec2::new(1, 3)), 1552 UVec2::new(0, 8), 1553 ); 1554 }); 1555 1556 glam_test!(test_wrapping_sub, { 1557 assert_eq!( 1558 UVec2::new(u32::MAX, 5).wrapping_sub(UVec2::new(1, 3)), 1559 UVec2::new(4294967294, 2) 1560 ); 1561 }); 1562 1563 glam_test!(test_wrapping_mul, { 1564 assert_eq!( 1565 UVec2::new(u32::MAX, 5).wrapping_mul(UVec2::new(3, 3)), 1566 UVec2::new(4294967293, 15) 1567 ); 1568 }); 1569 1570 glam_test!(test_wrapping_div, { 1571 assert_eq!( 1572 UVec2::new(u32::MAX, 5).wrapping_div(UVec2::new(3, 3)), 1573 UVec2::new(1431655765, 1) 1574 ); 1575 }); 1576 1577 glam_test!(test_saturating_add, { 1578 assert_eq!( 1579 UVec2::new(u32::MAX, u32::MAX).saturating_add(UVec2::new(1, u32::MAX)), 1580 UVec2::new(u32::MAX, u32::MAX) 1581 ); 1582 }); 1583 1584 glam_test!(test_saturating_sub, { 1585 assert_eq!( 1586 UVec2::new(0, u32::MAX).saturating_sub(UVec2::new(1, 1)), 1587 UVec2::new(0, 4294967294) 1588 ); 1589 }); 1590 1591 glam_test!(test_saturating_mul, { 1592 assert_eq!( 1593 UVec2::new(u32::MAX, u32::MAX).saturating_mul(UVec2::new(2, u32::MAX)), 1594 UVec2::new(u32::MAX, u32::MAX) 1595 ); 1596 }); 1597 1598 glam_test!(test_saturating_div, { 1599 assert_eq!( 1600 UVec2::new(u32::MAX, u32::MAX).saturating_div(UVec2::new(2, u32::MAX)), 1601 UVec2::new(2147483647, 1) 1602 ); 1603 }); 1604 1605 impl_vec2_tests!(u32, uvec2, UVec2, UVec3, BVec2); 1606 impl_vec2_eq_hash_tests!(u32, uvec2); 1607 1608 impl_vec2_scalar_shift_op_tests!(UVec2, 0, 2); 1609 impl_vec2_shift_op_tests!(UVec2); 1610 1611 impl_vec2_scalar_bit_op_tests!(UVec2, 0, 2); 1612 impl_vec2_bit_op_tests!(UVec2, 0, 2); 1613 } 1614 1615 mod i64vec2 { 1616 use glam::{i64vec2, BVec2, I16Vec2, I64Vec2, I64Vec3, IVec2, U16Vec2, U64Vec2, UVec2}; 1617 1618 glam_test!(test_align, { 1619 use core::mem; 1620 assert_eq!(16, mem::size_of::<I64Vec2>()); 1621 #[cfg(not(feature = "cuda"))] 1622 assert_eq!(8, mem::align_of::<I64Vec2>()); 1623 #[cfg(feature = "cuda")] 1624 assert_eq!(16, mem::align_of::<I64Vec2>()); 1625 assert_eq!(2, mem::size_of::<BVec2>()); 1626 assert_eq!(1, mem::align_of::<BVec2>()); 1627 }); 1628 1629 glam_test!(test_try_from, { 1630 assert_eq!(I64Vec2::new(1, 2), I64Vec2::from(I16Vec2::new(1, 2))); 1631 assert_eq!(I64Vec2::new(1, 2), I64Vec2::from(U16Vec2::new(1, 2))); 1632 assert_eq!(I64Vec2::new(1, 2), I64Vec2::from(IVec2::new(1, 2))); 1633 assert_eq!(I64Vec2::new(1, 2), I64Vec2::from(UVec2::new(1, 2))); 1634 1635 assert_eq!( 1636 I64Vec2::new(1, 2), 1637 I64Vec2::try_from(U64Vec2::new(1, 2)).unwrap() 1638 ); 1639 assert!(I64Vec2::try_from(U64Vec2::new(u64::MAX, 2)).is_err()); 1640 assert!(I64Vec2::try_from(U64Vec2::new(1, u64::MAX)).is_err()); 1641 }); 1642 1643 impl_vec2_signed_integer_tests!(i64, i64vec2, I64Vec2, I64Vec3, BVec2); 1644 impl_vec2_eq_hash_tests!(i64, i64vec2); 1645 1646 impl_vec2_scalar_shift_op_tests!(I64Vec2, -2, 2); 1647 impl_vec2_shift_op_tests!(I64Vec2); 1648 1649 impl_vec2_scalar_bit_op_tests!(I64Vec2, -2, 2); 1650 impl_vec2_bit_op_tests!(I64Vec2, -2, 2); 1651 } 1652 1653 mod u64vec2 { 1654 use glam::{u64vec2, BVec2, I16Vec2, I64Vec2, IVec2, U16Vec2, U64Vec2, U64Vec3, UVec2}; 1655 1656 glam_test!(test_align, { 1657 use core::mem; 1658 assert_eq!(16, mem::size_of::<U64Vec2>()); 1659 #[cfg(not(feature = "cuda"))] 1660 assert_eq!(8, mem::align_of::<U64Vec2>()); 1661 #[cfg(feature = "cuda")] 1662 assert_eq!(16, mem::align_of::<U64Vec2>()); 1663 assert_eq!(2, mem::size_of::<BVec2>()); 1664 assert_eq!(1, mem::align_of::<BVec2>()); 1665 }); 1666 1667 glam_test!(test_try_from, { 1668 assert_eq!( 1669 U64Vec2::new(1, 2), 1670 U64Vec2::try_from(I16Vec2::new(1, 2)).unwrap() 1671 ); 1672 assert!(U64Vec2::try_from(I16Vec2::new(-1, 2)).is_err()); 1673 assert!(U64Vec2::try_from(I16Vec2::new(1, -2)).is_err()); 1674 1675 assert_eq!(U64Vec2::new(1, 2), U64Vec2::from(U16Vec2::new(1, 2))); 1676 1677 assert_eq!( 1678 U64Vec2::new(1, 2), 1679 U64Vec2::try_from(IVec2::new(1, 2)).unwrap() 1680 ); 1681 assert!(U64Vec2::try_from(IVec2::new(-1, 2)).is_err()); 1682 assert!(U64Vec2::try_from(IVec2::new(1, -2)).is_err()); 1683 1684 assert_eq!(U64Vec2::new(1, 2), U64Vec2::from(UVec2::new(1, 2))); 1685 1686 assert_eq!( 1687 U64Vec2::new(1, 2), 1688 U64Vec2::try_from(I64Vec2::new(1, 2)).unwrap() 1689 ); 1690 assert!(U64Vec2::try_from(I64Vec2::new(-1, 2)).is_err()); 1691 assert!(U64Vec2::try_from(I64Vec2::new(1, -2)).is_err()); 1692 }); 1693 1694 impl_vec2_tests!(u64, u64vec2, U64Vec2, U64Vec3, BVec2); 1695 impl_vec2_eq_hash_tests!(u64, u64vec2); 1696 1697 impl_vec2_scalar_shift_op_tests!(U64Vec2, 0, 2); 1698 impl_vec2_shift_op_tests!(U64Vec2); 1699 1700 impl_vec2_scalar_bit_op_tests!(U64Vec2, 0, 2); 1701 impl_vec2_bit_op_tests!(U64Vec2, 0, 2); 1702 } 1703