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