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