Vendor dependencies for 0.3.0 release

vendor/glam/tests/affine2.rs

@@ -0,0 +1,343 @@
+#[macro_use]
+mod support;
+
+macro_rules! impl_affine2_tests {
+    ($t:ident, $affine2:ident, $vec2:ident, $mat2:ident, $mat3:ident) => {
+        const MATRIX1D: [$t; 6] = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0];
+        const MATRIX2D: [[$t; 2]; 3] = [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]];
+
+        glam_test!(test_affine2_identity, {
+            assert_eq!($affine2::IDENTITY, $affine2::IDENTITY * $affine2::IDENTITY);
+            assert_eq!($affine2::IDENTITY, $affine2::default());
+        });
+
+        glam_test!(test_affine2_zero, {
+            assert_eq!(
+                $affine2::ZERO.transform_point2($vec2::new(1., 2.)),
+                $vec2::ZERO
+            );
+        });
+
+        glam_test!(test_affine2_nan, {
+            assert!($affine2::NAN.is_nan());
+            assert!(!$affine2::NAN.is_finite());
+        });
+
+        glam_test!(test_affine2_from_cols, {
+            let a = $affine2::from_cols(
+                $vec2::from_array(MATRIX2D[0]),
+                $vec2::from_array(MATRIX2D[1]),
+                $vec2::from_array(MATRIX2D[2]),
+            );
+            assert_eq!(MATRIX2D, a.to_cols_array_2d());
+
+            let a = $affine2::from_cols_array(&MATRIX1D);
+            assert_eq!(MATRIX1D, a.to_cols_array());
+
+            let a = $affine2::from_cols_array_2d(&MATRIX2D);
+            assert_eq!(MATRIX2D, a.to_cols_array_2d());
+        });
+
+        glam_test!(test_affine2_deref, {
+            let a = $affine2::from_cols_array_2d(&MATRIX2D);
+            assert_eq!(MATRIX2D[0], a.x_axis.to_array());
+            assert_eq!(MATRIX2D[1], a.y_axis.to_array());
+            assert_eq!(MATRIX2D[2], a.z_axis.to_array());
+
+            let mut b = a;
+            b.x_axis *= 0.0;
+            b.y_axis *= 0.0;
+            b.z_axis *= 0.0;
+            assert_eq!($affine2::ZERO, b);
+        });
+
+        glam_test!(test_affine2_from_mat2, {
+            let m = $mat2::from_cols_array_2d(&[MATRIX2D[0], MATRIX2D[1]]);
+            let a = $affine2::from_mat2(m);
+            assert_eq!(m, a.matrix2);
+            assert_eq!($vec2::ZERO, a.translation);
+
+            let t = $vec2::from_array(MATRIX2D[2]);
+            let a = $affine2::from_mat2_translation(m, t);
+            assert_eq!(MATRIX2D, a.to_cols_array_2d());
+        });
+
+        glam_test!(test_affine2_from_mat3, {
+            let m = $mat3::from_cols_array_2d(&[[1.0, 2.0, 0.0], [3.0, 4.0, 0.0], [5.0, 6.0, 1.0]]);
+            let a = $affine2::from_mat3(m);
+            assert_eq!(MATRIX2D, a.to_cols_array_2d());
+
+            assert_eq!(m, $mat3::from(a));
+        });
+
+        glam_test!(test_affine2_translation, {
+            let translate = $affine2::from_translation($vec2::new(1.0, 2.0));
+            assert_eq!(translate.translation, $vec2::new(1.0, 2.0).into());
+            assert_eq!(
+                translate.transform_point2($vec2::new(2.0, 3.0)),
+                $vec2::new(3.0, 5.0),
+            );
+        });
+
+        glam_test!(test_affine2_mul, {
+            let m = $affine2::from_angle(deg(90.0));
+            let result3 = m.transform_vector2($vec2::Y);
+            assert_approx_eq!($vec2::new(-1.0, 0.0), result3);
+
+            let m = $affine2::from_angle_translation(deg(90.0), $vec2::new(1.0, 2.0));
+            let result3 = m.transform_vector2($vec2::Y);
+            assert_approx_eq!($vec2::new(-1.0, 0.0), result3, 1.0e-6);
+
+            let m = $affine2::from_scale_angle_translation(
+                $vec2::new(0.5, 1.5),
+                deg(90.0),
+                $vec2::new(1.0, 2.0),
+            );
+            let result3 = m.transform_vector2($vec2::Y);
+            assert_approx_eq!($vec2::new(-1.5, 0.0), result3, 1.0e-6);
+
+            let result3 = m.transform_point2($vec2::Y);
+            assert_approx_eq!($vec2::new(-0.5, 2.0), result3, 1.0e-6);
+        });
+
+        glam_test!(test_from_scale, {
+            let m = $affine2::from_scale($vec2::new(2.0, 4.0));
+            assert_approx_eq!(
+                m.transform_point2($vec2::new(1.0, 1.0)),
+                $vec2::new(2.0, 4.0)
+            );
+        });
+
+        glam_test!(test_affine2_inverse, {
+            let inv = $affine2::IDENTITY.inverse();
+            assert_approx_eq!($affine2::IDENTITY, inv);
+
+            let rot = $affine2::from_angle(deg(90.0));
+            let rot_inv = rot.inverse();
+            assert_approx_eq!($affine2::IDENTITY, rot * rot_inv);
+            assert_approx_eq!($affine2::IDENTITY, rot_inv * rot);
+
+            let trans = $affine2::from_translation($vec2::new(1.0, 2.0));
+            let trans_inv = trans.inverse();
+            assert_approx_eq!($affine2::IDENTITY, trans * trans_inv);
+            assert_approx_eq!($affine2::IDENTITY, trans_inv * trans);
+
+            let scale = $affine2::from_scale($vec2::new(4.0, 5.0));
+            let scale_inv = scale.inverse();
+            assert_approx_eq!($affine2::IDENTITY, scale * scale_inv);
+            assert_approx_eq!($affine2::IDENTITY, scale_inv * scale);
+
+            let m = scale * rot * trans;
+            let m_inv = m.inverse();
+            assert_approx_eq!($affine2::IDENTITY, m * m_inv, 1.0e-5);
+            assert_approx_eq!($affine2::IDENTITY, m_inv * m, 1.0e-5);
+            assert_approx_eq!(m_inv, trans_inv * rot_inv * scale_inv, 1.0e-6);
+
+            // Make sure we can invert a shear matrix:
+            let m = $affine2::from_angle(0.5)
+                * $affine2::from_scale($vec2::new(1.0, 0.5))
+                * $affine2::from_angle(-0.5);
+            let m_inv = m.inverse();
+            assert_approx_eq!($affine2::IDENTITY, m * m_inv, 1.0e-5);
+            assert_approx_eq!($affine2::IDENTITY, m_inv * m, 1.0e-5);
+
+            should_glam_assert!({ $affine2::ZERO.inverse() });
+        });
+
+        glam_test!(test_affine2_decompose, {
+            // identity
+            let (out_scale, out_rotation, out_translation) =
+                $affine2::IDENTITY.to_scale_angle_translation();
+            assert_approx_eq!($vec2::ONE, out_scale);
+            assert_eq!(out_rotation, 0.0);
+            assert_approx_eq!($vec2::ZERO, out_translation);
+
+            // no scale
+            let in_scale = $vec2::ONE;
+            let in_translation = $vec2::new(-2.0, 4.0);
+            let in_rotation = $t::to_radians(-45.0);
+            let in_mat =
+                $affine2::from_scale_angle_translation(in_scale, in_rotation, in_translation);
+            let (out_scale, out_rotation, out_translation) = in_mat.to_scale_angle_translation();
+            assert_approx_eq!(in_scale, out_scale, 1e-6);
+            assert_approx_eq!(in_rotation, out_rotation);
+            assert_approx_eq!(in_translation, out_translation);
+            assert_approx_eq!(
+                in_mat,
+                $affine2::from_scale_angle_translation(out_scale, out_rotation, out_translation),
+                1e-6
+            );
+
+            // positive scale
+            let in_scale = $vec2::new(1.0, 2.0);
+            let in_mat =
+                $affine2::from_scale_angle_translation(in_scale, in_rotation, in_translation);
+            let (out_scale, out_rotation, out_translation) = in_mat.to_scale_angle_translation();
+            assert_approx_eq!(in_scale, out_scale, 1e-6);
+            assert_approx_eq!(in_rotation, out_rotation);
+            assert_approx_eq!(in_translation, out_translation);
+            assert_approx_eq!(
+                in_mat,
+                $affine2::from_scale_angle_translation(out_scale, out_rotation, out_translation),
+                1e-5
+            );
+
+            // negative scale
+            let in_scale = $vec2::new(-4.0, 1.0);
+            let in_mat =
+                $affine2::from_scale_angle_translation(in_scale, in_rotation, in_translation);
+            let (out_scale, out_rotation, out_translation) = in_mat.to_scale_angle_translation();
+            assert_approx_eq!(in_scale, out_scale, 1e-6);
+            assert_approx_eq!(in_rotation, out_rotation);
+            assert_approx_eq!(in_translation, out_translation);
+            assert_approx_eq!(
+                in_mat,
+                $affine2::from_scale_angle_translation(out_scale, out_rotation, out_translation),
+                1e-5
+            );
+
+            // negative scale
+            let in_scale = $vec2::new(4.0, -1.0);
+            let in_mat =
+                $affine2::from_scale_angle_translation(in_scale, in_rotation, in_translation);
+            let (out_scale, out_rotation, out_translation) = in_mat.to_scale_angle_translation();
+            // out_scale and out_rotation are different but they produce the same matrix
+            // assert_approx_eq!(in_scale, out_scale, 1e-6);
+            // assert_approx_eq!(in_rotation, out_rotation);
+            assert_approx_eq!(in_translation, out_translation);
+            assert_approx_eq!(
+                in_mat,
+                $affine2::from_scale_angle_translation(out_scale, out_rotation, out_translation),
+                1e-6
+            );
+        });
+
+        glam_test!(test_affine2_ops, {
+            let m0 = $affine2::from_cols_array_2d(&MATRIX2D);
+            assert_approx_eq!(m0, m0 * $affine2::IDENTITY);
+            assert_approx_eq!(m0, $affine2::IDENTITY * m0);
+
+            let mut m1 = m0;
+            m1 *= $affine2::IDENTITY;
+            assert_approx_eq!(m1, m0);
+
+            let mat3 = $mat3::from(m0);
+            assert_approx_eq!(mat3, $affine2::IDENTITY * mat3);
+            assert_approx_eq!(mat3, mat3 * $affine2::IDENTITY);
+        });
+
+        glam_test!(test_affine2_fmt, {
+            let a = $affine2::from_cols_array_2d(&MATRIX2D);
+            assert_eq!(format!("{}", a), "[[1, 2], [3, 4], [5, 6]]");
+            assert_eq!(format!("{:.1}", a), "[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]");
+        });
+
+        glam_test!(test_affine2_to_from_slice, {
+            let m = $affine2::from_cols_slice(&MATRIX1D);
+            assert_eq!($affine2::from_cols_array(&MATRIX1D), m);
+            assert_eq!(MATRIX1D, m.to_cols_array());
+            assert_eq!(MATRIX2D, m.to_cols_array_2d());
+            let mut out: [$t; 6] = Default::default();
+            m.write_cols_to_slice(&mut out);
+            assert_eq!(MATRIX1D, out);
+            assert_eq!(
+                m,
+                $affine2::from_cols(MATRIX2D[0].into(), MATRIX2D[1].into(), MATRIX2D[2].into())
+            );
+
+            should_panic!({ $affine2::from_cols_slice(&[0.0; 5]) });
+            should_panic!({ $affine2::IDENTITY.write_cols_to_slice(&mut [0.0; 5]) });
+        });
+
+        glam_test!(test_product, {
+            let ident = $affine2::IDENTITY;
+            assert_eq!([ident, ident].iter().product::<$affine2>(), ident * ident);
+        });
+
+        glam_test!(test_affine2_is_finite, {
+            assert!($affine2::from_scale($vec2::new(1.0, 1.0)).is_finite());
+            assert!($affine2::from_scale($vec2::new(0.0, 1.0)).is_finite());
+            assert!(!$affine2::from_scale($vec2::new(1.0, $t::NAN)).is_finite());
+            assert!(!$affine2::from_scale($vec2::new(1.0, $t::NEG_INFINITY)).is_finite());
+        });
+    };
+}
+
+mod affine2 {
+    use super::support::{deg, FloatCompare};
+    use glam::{Affine2, Mat2, Mat3, Vec2};
+
+    impl FloatCompare for Affine2 {
+        #[inline]
+        fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
+            self.abs_diff_eq(*other, max_abs_diff)
+        }
+        #[inline]
+        fn abs_diff(&self, other: &Self) -> Self {
+            Self {
+                matrix2: self.matrix2.abs_diff(&other.matrix2),
+                translation: self.translation.abs_diff(&other.translation),
+            }
+        }
+    }
+
+    glam_test!(test_align, {
+        use std::mem;
+        if cfg!(not(feature = "scalar-math")) {
+            assert_eq!(32, mem::size_of::<Affine2>());
+            assert_eq!(16, mem::align_of::<Affine2>());
+        } else if cfg!(feature = "cuda") {
+            assert_eq!(24, mem::size_of::<Affine2>());
+            assert_eq!(8, mem::align_of::<Affine2>());
+        } else {
+            assert_eq!(24, mem::size_of::<Affine2>());
+            assert_eq!(4, mem::align_of::<Affine2>());
+        }
+    });
+
+    glam_test!(test_affine2_from_mat3a, {
+        use glam::Mat3A;
+        let m = Mat3A::from_cols_array_2d(&[[1.0, 2.0, 0.0], [3.0, 4.0, 0.0], [5.0, 6.0, 1.0]]);
+        let a = Affine2::from_mat3a(m);
+        assert_eq!(MATRIX2D, a.to_cols_array_2d());
+
+        assert_eq!(m, Mat3A::from(a));
+    });
+
+    impl_affine2_tests!(f32, Affine2, Vec2, Mat2, Mat3);
+}
+
+mod daffine2 {
+    use super::support::{deg, FloatCompare};
+    use glam::{DAffine2, DMat2, DMat3, DVec2};
+
+    impl FloatCompare for DAffine2 {
+        #[inline]
+        fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
+            self.abs_diff_eq(*other, max_abs_diff as f64)
+        }
+        #[inline]
+        fn abs_diff(&self, other: &Self) -> Self {
+            Self {
+                matrix2: self.matrix2.abs_diff(&other.matrix2),
+                translation: self.translation.abs_diff(&other.translation),
+            }
+        }
+    }
+
+    #[cfg(not(feature = "cuda"))]
+    glam_test!(test_align, {
+        use std::mem;
+        assert_eq!(48, mem::size_of::<DAffine2>());
+        assert_eq!(mem::align_of::<f64>(), mem::align_of::<DAffine2>());
+    });
+
+    #[cfg(feature = "cuda")]
+    glam_test!(test_align, {
+        use std::mem;
+        assert_eq!(48, mem::size_of::<DAffine2>());
+        assert_eq!(16, mem::align_of::<DAffine2>());
+    });
+
+    impl_affine2_tests!(f64, DAffine2, DVec2, DMat2, DMat3);
+}

vendor/glam/tests/affine3.rs

@@ -0,0 +1,420 @@
+#[macro_use]
+mod support;
+
+macro_rules! impl_affine3_tests {
+    ($t:ident, $affine3:ident, $quat:ident, $vec3:ident, $mat3:ident, $mat4:ident) => {
+        const MATRIX1D: [$t; 12] = [
+            1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0,
+        ];
+        const MATRIX2D: [[$t; 3]; 4] = [
+            [1.0, 2.0, 3.0],
+            [4.0, 5.0, 6.0],
+            [7.0, 8.0, 9.0],
+            [10.0, 11.0, 12.0],
+        ];
+
+        glam_test!(test_affine3_identity, {
+            assert_eq!($affine3::IDENTITY, $affine3::IDENTITY * $affine3::IDENTITY);
+            assert_eq!($affine3::IDENTITY, $affine3::default());
+        });
+
+        glam_test!(test_affine3_zero, {
+            assert_eq!(
+                $affine3::ZERO.transform_point3($vec3::new(1., 2., 3.)),
+                $vec3::ZERO
+            );
+        });
+
+        glam_test!(test_affine3_nan, {
+            assert!($affine3::NAN.is_nan());
+            assert!(!$affine3::NAN.is_finite());
+        });
+
+        glam_test!(test_affine3_from_cols, {
+            let a = $affine3::from_cols(
+                $vec3::from_array(MATRIX2D[0]).into(),
+                $vec3::from_array(MATRIX2D[1]).into(),
+                $vec3::from_array(MATRIX2D[2]).into(),
+                $vec3::from_array(MATRIX2D[3]).into(),
+            );
+            assert_eq!(MATRIX2D, a.to_cols_array_2d());
+
+            let a = $affine3::from_cols_array(&MATRIX1D);
+            assert_eq!(MATRIX1D, a.to_cols_array());
+
+            let a = $affine3::from_cols_array_2d(&MATRIX2D);
+            assert_eq!(MATRIX2D, a.to_cols_array_2d());
+        });
+
+        glam_test!(test_affine3_deref, {
+            let a = $affine3::from_cols_array_2d(&MATRIX2D);
+            assert_eq!(MATRIX2D[0], a.x_axis.to_array());
+            assert_eq!(MATRIX2D[1], a.y_axis.to_array());
+            assert_eq!(MATRIX2D[2], a.z_axis.to_array());
+            assert_eq!(MATRIX2D[3], a.w_axis.to_array());
+
+            let mut b = a;
+            b.x_axis *= 0.0;
+            b.y_axis *= 0.0;
+            b.z_axis *= 0.0;
+            b.w_axis *= 0.0;
+            assert_eq!($affine3::ZERO, b);
+        });
+
+        glam_test!(test_affine3_from_mat3, {
+            let m = $mat3::from_cols_array_2d(&[MATRIX2D[0], MATRIX2D[1], MATRIX2D[2]]);
+            let a = $affine3::from_mat3(m);
+            assert_eq!(m, a.matrix3.into());
+            assert_eq!($vec3::ZERO, a.translation.into());
+
+            let t = $vec3::from_array(MATRIX2D[3]);
+            let a = $affine3::from_mat3_translation(m, t);
+            assert_eq!(MATRIX2D, a.to_cols_array_2d());
+        });
+
+        glam_test!(test_affine2_from_mat4, {
+            let m = $mat4::from_cols_array_2d(&[
+                [1.0, 2.0, 3.0, 0.0],
+                [4.0, 5.0, 6.0, 0.0],
+                [7.0, 8.0, 9.0, 0.0],
+                [10.0, 11.0, 12.0, 1.0],
+            ]);
+            let a = $affine3::from_mat4(m);
+            assert_eq!(MATRIX2D, a.to_cols_array_2d());
+
+            assert_eq!(m, $mat4::from(a));
+        });
+
+        glam_test!(test_affine3_translation, {
+            let translate = $affine3::from_translation($vec3::new(1.0, 2.0, 3.0));
+            assert_eq!(translate.translation, $vec3::new(1.0, 2.0, 3.0).into());
+            assert_eq!(
+                translate.transform_point3($vec3::new(2.0, 3.0, 4.0)),
+                $vec3::new(3.0, 5.0, 7.0),
+            );
+        });
+
+        glam_test!(test_from_rotation, {
+            let eps = 2.0 * f32::EPSILON;
+            let rot_x1 = $affine3::from_rotation_x(deg(180.0));
+            let rot_x2 = $affine3::from_axis_angle($vec3::X, deg(180.0));
+            assert_approx_eq!(rot_x1, rot_x2, eps);
+            let rot_y1 = $affine3::from_rotation_y(deg(180.0));
+            let rot_y2 = $affine3::from_axis_angle($vec3::Y, deg(180.0));
+            assert_approx_eq!(rot_y1, rot_y2, eps);
+            let rot_z1 = $affine3::from_rotation_z(deg(180.0));
+            let rot_z2 = $affine3::from_axis_angle($vec3::Z, deg(180.0));
+            assert_approx_eq!(rot_z1, rot_z2, eps);
+
+            assert_approx_eq!(
+                $affine3::from_rotation_x(deg(180.0)),
+                $affine3::from_quat($quat::from_rotation_x(deg(180.0)))
+            );
+
+            assert_approx_eq!(
+                $quat::from_affine3(&$affine3::from_rotation_x(deg(180.0))),
+                $quat::from_rotation_x(deg(180.0))
+            );
+
+            let m = $affine3::from_rotation_translation(
+                $quat::from_rotation_x(deg(90.0)),
+                $vec3::new(1.0, 2.0, 3.0),
+            );
+            let result3 = m.transform_vector3($vec3::Y);
+            assert_approx_eq!($vec3::new(0.0, 0.0, 1.0), result3, 1.0e-6);
+
+            should_glam_assert!({ $affine3::from_axis_angle($vec3::ZERO, 0.0) });
+            should_glam_assert!({ $affine3::from_quat($quat::IDENTITY * 2.0) });
+        });
+
+        glam_test!(test_affine3_mul, {
+            let m = $affine3::from_axis_angle($vec3::Z, deg(90.0));
+            let result3 = m.transform_vector3($vec3::Y);
+            assert_approx_eq!($vec3::new(-1.0, 0.0, 0.0), result3);
+
+            let m = $affine3::from_scale_rotation_translation(
+                $vec3::new(0.5, 1.5, 2.0),
+                $quat::from_rotation_x(deg(90.0)),
+                $vec3::new(1.0, 2.0, 3.0),
+            );
+            let result3 = m.transform_vector3($vec3::Y);
+            assert_approx_eq!($vec3::new(0.0, 0.0, 1.5), result3, 1.0e-6);
+
+            let result3 = m.transform_point3($vec3::Y);
+            assert_approx_eq!($vec3::new(1.0, 2.0, 4.5), result3, 1.0e-6);
+        });
+
+        glam_test!(test_from_scale, {
+            let m = $affine3::from_scale($vec3::new(2.0, 4.0, 8.0));
+            assert_approx_eq!(
+                m.transform_point3($vec3::new(1.0, 1.0, 1.0)),
+                $vec3::new(2.0, 4.0, 8.0)
+            );
+        });
+
+        glam_test!(test_affine3_inverse, {
+            let inv = $affine3::IDENTITY.inverse();
+            assert_approx_eq!($affine3::IDENTITY, inv);
+
+            let rotz = $affine3::from_rotation_z(deg(90.0));
+            let rotz_inv = rotz.inverse();
+            assert_approx_eq!($affine3::IDENTITY, rotz * rotz_inv);
+            assert_approx_eq!($affine3::IDENTITY, rotz_inv * rotz);
+
+            let trans = $affine3::from_translation($vec3::new(1.0, 2.0, 3.0));
+            let trans_inv = trans.inverse();
+            assert_approx_eq!($affine3::IDENTITY, trans * trans_inv);
+            assert_approx_eq!($affine3::IDENTITY, trans_inv * trans);
+
+            let scale = $affine3::from_scale($vec3::new(4.0, 5.0, 6.0));
+            let scale_inv = scale.inverse();
+            assert_approx_eq!($affine3::IDENTITY, scale * scale_inv);
+            assert_approx_eq!($affine3::IDENTITY, scale_inv * scale);
+
+            let m = scale * rotz * trans;
+            let m_inv = m.inverse();
+            assert_approx_eq!($affine3::IDENTITY, m * m_inv, 1.0e-5);
+            assert_approx_eq!($affine3::IDENTITY, m_inv * m, 1.0e-5);
+            assert_approx_eq!(m_inv, trans_inv * rotz_inv * scale_inv, 1.0e-6);
+
+            // Make sure we can invert a shear matrix:
+            let m = $affine3::from_axis_angle($vec3::X, 0.5)
+                * $affine3::from_scale($vec3::new(1.0, 0.5, 2.0))
+                * $affine3::from_axis_angle($vec3::X, -0.5);
+            let m_inv = m.inverse();
+            assert_approx_eq!($affine3::IDENTITY, m * m_inv, 1.0e-5);
+            assert_approx_eq!($affine3::IDENTITY, m_inv * m, 1.0e-5);
+
+            should_glam_assert!({ $affine3::ZERO.inverse() });
+        });
+
+        glam_test!(test_affine3_decompose, {
+            // identity
+            let (out_scale, out_rotation, out_translation) =
+                $affine3::IDENTITY.to_scale_rotation_translation();
+            assert_approx_eq!($vec3::ONE, out_scale);
+            assert!(out_rotation.is_near_identity());
+            assert_approx_eq!($vec3::ZERO, out_translation);
+
+            // no scale
+            let in_scale = $vec3::ONE;
+            let in_translation = $vec3::new(-2.0, 4.0, -0.125);
+            let in_rotation = $quat::from_euler(
+                glam::EulerRot::YXZ,
+                $t::to_radians(-45.0),
+                $t::to_radians(180.0),
+                $t::to_radians(270.0),
+            );
+            let in_mat =
+                $affine3::from_scale_rotation_translation(in_scale, in_rotation, in_translation);
+            let (out_scale, out_rotation, out_translation) = in_mat.to_scale_rotation_translation();
+            assert_approx_eq!(in_scale, out_scale, 1e-6);
+            // out_rotation is different but produces the same matrix
+            // assert_approx_eq!(in_rotation, out_rotation);
+            assert_approx_eq!(in_translation, out_translation);
+            assert_approx_eq!(
+                in_mat,
+                $affine3::from_scale_rotation_translation(out_scale, out_rotation, out_translation),
+                1e-6
+            );
+
+            // positive scale
+            let in_scale = $vec3::new(1.0, 2.0, 4.0);
+            let in_mat =
+                $affine3::from_scale_rotation_translation(in_scale, in_rotation, in_translation);
+            let (out_scale, out_rotation, out_translation) = in_mat.to_scale_rotation_translation();
+            assert_approx_eq!(in_scale, out_scale, 1e-6);
+            // out_rotation is different but produces the same matrix
+            // assert_approx_eq!(in_rotation, out_rotation);
+            assert_approx_eq!(in_translation, out_translation);
+            assert_approx_eq!(
+                in_mat,
+                $affine3::from_scale_rotation_translation(out_scale, out_rotation, out_translation),
+                1e-5
+            );
+
+            // negative scale
+            let in_scale = $vec3::new(-4.0, 1.0, 2.0);
+            let in_mat =
+                $affine3::from_scale_rotation_translation(in_scale, in_rotation, in_translation);
+            let (out_scale, out_rotation, out_translation) = in_mat.to_scale_rotation_translation();
+            assert_approx_eq!(in_scale, out_scale, 1e-6);
+            // out_rotation is different but produces the same matrix
+            // assert_approx_eq!(in_rotation, out_rotation);
+            assert_approx_eq!(in_translation, out_translation);
+            assert_approx_eq!(
+                in_mat,
+                $affine3::from_scale_rotation_translation(out_scale, out_rotation, out_translation),
+                1e-5
+            );
+
+            // negative scale
+            let in_scale = $vec3::new(4.0, -1.0, -2.0);
+            let in_mat =
+                $affine3::from_scale_rotation_translation(in_scale, in_rotation, in_translation);
+            let (out_scale, out_rotation, out_translation) = in_mat.to_scale_rotation_translation();
+            // out_scale and out_rotation are different but they produce the same matrix
+            // assert_approx_eq!(in_scale, out_scale, 1e-6);
+            // assert_approx_eq!(in_rotation, out_rotation);
+            assert_approx_eq!(in_translation, out_translation);
+            assert_approx_eq!(
+                in_mat,
+                $affine3::from_scale_rotation_translation(out_scale, out_rotation, out_translation),
+                1e-6
+            );
+        });
+
+        glam_test!(test_affine3_look_at, {
+            let eye = $vec3::new(0.0, 0.0, -5.0);
+            let center = $vec3::new(0.0, 0.0, 0.0);
+            let up = $vec3::new(1.0, 0.0, 0.0);
+
+            let point = $vec3::new(1.0, 0.0, 0.0);
+
+            let lh = $affine3::look_at_lh(eye, center, up);
+            let rh = $affine3::look_at_rh(eye, center, up);
+            assert_approx_eq!(lh.transform_point3(point), $vec3::new(0.0, 1.0, 5.0));
+            assert_approx_eq!(rh.transform_point3(point), $vec3::new(0.0, 1.0, -5.0));
+
+            let dir = center - eye;
+            let lh = $affine3::look_to_lh(eye, dir, up);
+            let rh = $affine3::look_to_rh(eye, dir, up);
+            assert_approx_eq!(lh.transform_point3(point), $vec3::new(0.0, 1.0, 5.0));
+            assert_approx_eq!(rh.transform_point3(point), $vec3::new(0.0, 1.0, -5.0));
+
+            should_glam_assert!({ $affine3::look_at_lh($vec3::ONE, $vec3::ZERO, $vec3::ZERO) });
+            should_glam_assert!({ $affine3::look_at_rh($vec3::ONE, $vec3::ZERO, $vec3::ZERO) });
+        });
+
+        glam_test!(test_affine3_ops, {
+            let m0 = $affine3::from_cols_array_2d(&MATRIX2D);
+            assert_approx_eq!(m0, m0 * $affine3::IDENTITY);
+            assert_approx_eq!(m0, $affine3::IDENTITY * m0);
+
+            let mut m1 = m0;
+            m1 *= $affine3::IDENTITY;
+            assert_approx_eq!(m1, m0);
+
+            let mat4 = $mat4::from(m0);
+            assert_approx_eq!(mat4, $affine3::IDENTITY * mat4);
+            assert_approx_eq!(mat4, mat4 * $affine3::IDENTITY);
+        });
+
+        glam_test!(test_affine3_fmt, {
+            let a = $affine3::from_cols_array_2d(&MATRIX2D);
+            assert_eq!(
+                format!("{}", a),
+                "[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]"
+            );
+            assert_eq!(
+                format!("{:.1}", a),
+                "[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0], [10.0, 11.0, 12.0]]"
+            );
+        });
+
+        glam_test!(test_affine3_to_from_slice, {
+            let m = $affine3::from_cols_slice(&MATRIX1D);
+            assert_eq!($affine3::from_cols_array(&MATRIX1D), m);
+            assert_eq!(MATRIX1D, m.to_cols_array());
+            assert_eq!(MATRIX2D, m.to_cols_array_2d());
+            let mut out: [$t; 12] = Default::default();
+            m.write_cols_to_slice(&mut out);
+            assert_eq!(MATRIX1D, out);
+            assert_eq!(
+                m,
+                $affine3::from_cols(
+                    MATRIX2D[0].into(),
+                    MATRIX2D[1].into(),
+                    MATRIX2D[2].into(),
+                    MATRIX2D[3].into()
+                )
+            );
+
+            should_panic!({ $affine3::from_cols_slice(&[0.0; 11]) });
+            should_panic!({ $affine3::IDENTITY.write_cols_to_slice(&mut [0.0; 11]) });
+        });
+
+        glam_test!(test_product, {
+            let ident = $affine3::IDENTITY;
+            assert_eq!([ident, ident].iter().product::<$affine3>(), ident * ident);
+        });
+
+        glam_test!(test_affine3_is_finite, {
+            assert!($affine3::from_scale($vec3::new(1.0, 1.0, 1.0)).is_finite());
+            assert!($affine3::from_scale($vec3::new(0.0, 1.0, 1.0)).is_finite());
+            assert!(!$affine3::from_scale($vec3::new(1.0, $t::NAN, 1.0)).is_finite());
+            assert!(!$affine3::from_scale($vec3::new(1.0, 1.0, $t::NEG_INFINITY)).is_finite());
+        });
+    };
+}
+
+mod affine3a {
+    use super::support::{deg, FloatCompare};
+    use glam::{Affine3A, Mat3, Mat4, Quat, Vec3, Vec3A};
+
+    impl FloatCompare for Affine3A {
+        #[inline]
+        fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
+            self.abs_diff_eq(*other, max_abs_diff)
+        }
+        #[inline]
+        fn abs_diff(&self, other: &Self) -> Self {
+            Self {
+                matrix3: self.matrix3.abs_diff(&other.matrix3),
+                translation: self.translation.abs_diff(&other.translation),
+            }
+        }
+    }
+
+    glam_test!(test_align, {
+        use std::mem;
+        assert_eq!(64, mem::size_of::<Affine3A>());
+        assert_eq!(mem::align_of::<Vec3A>(), mem::align_of::<Affine3A>());
+    });
+
+    glam_test!(test_affine3_mul_vec3a, {
+        let m = Affine3A::from_axis_angle(Vec3::Z, deg(90.0));
+        let result3 = m.transform_vector3a(Vec3A::Y);
+        assert_approx_eq!(Vec3A::new(-1.0, 0.0, 0.0), result3);
+
+        let m = Affine3A::from_scale_rotation_translation(
+            Vec3::new(0.5, 1.5, 2.0),
+            Quat::from_rotation_x(deg(90.0)),
+            Vec3::new(1.0, 2.0, 3.0),
+        );
+        let result3 = m.transform_vector3a(Vec3A::Y);
+        assert_approx_eq!(Vec3A::new(0.0, 0.0, 1.5), result3, 1.0e-6);
+
+        let result3 = m.transform_point3a(Vec3A::Y);
+        assert_approx_eq!(Vec3A::new(1.0, 2.0, 4.5), result3, 1.0e-6);
+    });
+
+    impl_affine3_tests!(f32, Affine3A, Quat, Vec3, Mat3, Mat4);
+}
+
+mod daffine3 {
+    use super::support::{deg, FloatCompare};
+    use glam::{DAffine3, DMat3, DMat4, DQuat, DVec3};
+
+    impl FloatCompare for DAffine3 {
+        #[inline]
+        fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
+            self.abs_diff_eq(*other, max_abs_diff as f64)
+        }
+        #[inline]
+        fn abs_diff(&self, other: &Self) -> Self {
+            Self {
+                matrix3: self.matrix3.abs_diff(&other.matrix3),
+                translation: self.translation.abs_diff(&other.translation),
+            }
+        }
+    }
+
+    glam_test!(test_align, {
+        use std::mem;
+        assert_eq!(96, mem::size_of::<DAffine3>());
+        assert_eq!(mem::align_of::<f64>(), mem::align_of::<DAffine3>());
+    });
+
+    impl_affine3_tests!(f64, DAffine3, DQuat, DVec3, DMat3, DMat4);
+}

vendor/glam/tests/euler.rs

@@ -0,0 +1,287 @@
+#[macro_use]
+mod support;
+
+mod euler {
+    use glam::*;
+    use std::ops::RangeInclusive;
+
+    /// Helper to get the 'canonical' version of a `Quat`. We define the canonical of quat `q` as:
+    ///
+    /// * `q`, if q.w > epsilon
+    /// * `-q`, if q.w < -epsilon
+    /// * `(0, 0, 0, 1)` otherwise
+    ///
+    /// The rationale is that q and -q represent the same rotation, and any (_, _, _, 0) represent no rotation at all.
+    trait CanonicalQuat: Copy {
+        fn canonical(self) -> Self;
+    }
+
+    /// Helper to set some alternative epsilons based on the floating point type used
+    trait EulerEpsilon {
+        /// epsilon for comparing quaternion round-tripped through eulers (quat -> euler -> quat)
+        const E_EPS: f32;
+    }
+
+    impl EulerEpsilon for f32 {
+        const E_EPS: f32 = 2e-6;
+    }
+
+    impl EulerEpsilon for f64 {
+        const E_EPS: f32 = 1e-8;
+    }
+
+    fn axis_order(order: EulerRot) -> (usize, usize, usize) {
+        match order {
+            EulerRot::XYZ => (0, 1, 2),
+            EulerRot::XYX => (0, 1, 0),
+            EulerRot::XZY => (0, 2, 1),
+            EulerRot::XZX => (0, 2, 0),
+            EulerRot::YZX => (1, 2, 0),
+            EulerRot::YZY => (1, 2, 1),
+            EulerRot::YXZ => (1, 0, 2),
+            EulerRot::YXY => (1, 0, 1),
+            EulerRot::ZXY => (2, 0, 1),
+            EulerRot::ZXZ => (2, 0, 2),
+            EulerRot::ZYX => (2, 1, 0),
+            EulerRot::ZYZ => (2, 1, 2),
+            EulerRot::ZYXEx => (2, 1, 0),
+            EulerRot::XYXEx => (0, 1, 0),
+            EulerRot::YZXEx => (1, 2, 0),
+            EulerRot::XZXEx => (0, 2, 0),
+            EulerRot::XZYEx => (0, 2, 1),
+            EulerRot::YZYEx => (1, 2, 1),
+            EulerRot::ZXYEx => (2, 0, 1),
+            EulerRot::YXYEx => (1, 0, 1),
+            EulerRot::YXZEx => (1, 0, 2),
+            EulerRot::ZXZEx => (2, 0, 2),
+            EulerRot::XYZEx => (0, 1, 2),
+            EulerRot::ZYZEx => (2, 1, 2),
+        }
+    }
+
+    fn is_intrinsic(order: EulerRot) -> bool {
+        match order {
+            EulerRot::XYZ
+            | EulerRot::XYX
+            | EulerRot::XZY
+            | EulerRot::XZX
+            | EulerRot::YZX
+            | EulerRot::YZY
+            | EulerRot::YXZ
+            | EulerRot::YXY
+            | EulerRot::ZXY
+            | EulerRot::ZXZ
+            | EulerRot::ZYX
+            | EulerRot::ZYZ => true,
+            EulerRot::ZYXEx
+            | EulerRot::XYXEx
+            | EulerRot::YZXEx
+            | EulerRot::XZXEx
+            | EulerRot::XZYEx
+            | EulerRot::YZYEx
+            | EulerRot::ZXYEx
+            | EulerRot::YXYEx
+            | EulerRot::YXZEx
+            | EulerRot::ZXZEx
+            | EulerRot::XYZEx
+            | EulerRot::ZYZEx => false,
+        }
+    }
+
+    mod f32 {
+        pub fn deg_to_rad(a: i32, b: i32, c: i32) -> (f32, f32, f32) {
+            (
+                (a as f32).to_radians(),
+                (b as f32).to_radians(),
+                (c as f32).to_radians(),
+            )
+        }
+    }
+
+    mod f64 {
+        pub fn deg_to_rad(a: i32, b: i32, c: i32) -> (f64, f64, f64) {
+            (
+                (a as f64).to_radians(),
+                (b as f64).to_radians(),
+                (c as f64).to_radians(),
+            )
+        }
+    }
+
+    fn test_order_angles<F: Fn(EulerRot, i32, i32, i32)>(order: EulerRot, test: &F) {
+        const RANGE: RangeInclusive<i32> = -180..=180;
+        const STEP: usize = 15;
+        for i in RANGE.step_by(STEP) {
+            for j in RANGE.step_by(STEP) {
+                for k in RANGE.step_by(STEP) {
+                    test(order, i, j, k);
+                }
+            }
+        }
+    }
+
+    fn test_all_orders<F: Fn(EulerRot)>(test: &F) {
+        test(EulerRot::XYZ);
+        test(EulerRot::XZY);
+        test(EulerRot::YZX);
+        test(EulerRot::YXZ);
+        test(EulerRot::ZXY);
+        test(EulerRot::ZYX);
+
+        test(EulerRot::XZX);
+        test(EulerRot::XYX);
+        test(EulerRot::YXY);
+        test(EulerRot::YZY);
+        test(EulerRot::ZYZ);
+        test(EulerRot::ZXZ);
+
+        test(EulerRot::XYZEx);
+        test(EulerRot::XZYEx);
+        test(EulerRot::YZXEx);
+        test(EulerRot::YXZEx);
+        test(EulerRot::ZXYEx);
+        test(EulerRot::ZYXEx);
+
+        test(EulerRot::XZXEx);
+        test(EulerRot::XYXEx);
+        test(EulerRot::YXYEx);
+        test(EulerRot::YZYEx);
+        test(EulerRot::ZYZEx);
+        test(EulerRot::ZXZEx);
+    }
+
+    macro_rules! impl_quat_euler_test {
+        ($quat:ident, $t:ident) => {
+            use super::{
+                axis_order, is_intrinsic, test_all_orders, test_order_angles, $t::deg_to_rad,
+                CanonicalQuat, EulerEpsilon,
+            };
+            use glam::{$quat, EulerRot};
+
+            const AXIS_ANGLE: [fn($t) -> $quat; 3] = [
+                $quat::from_rotation_x,
+                $quat::from_rotation_y,
+                $quat::from_rotation_z,
+            ];
+
+            impl CanonicalQuat for $quat {
+                fn canonical(self) -> Self {
+                    match self {
+                        _ if self.w >= 1e-5 => self,
+                        _ if self.w <= -1e-5 => -self,
+                        _ => $quat::from_xyzw(0.0, 0.0, 0.0, 1.0),
+                    }
+                }
+            }
+
+            fn test_euler(order: EulerRot, a: i32, b: i32, c: i32) {
+                println!(
+                    "test_euler: {} {order:?} ({a}, {b}, {c})",
+                    stringify!($quat)
+                );
+
+                let (a, b, c) = deg_to_rad(a, b, c);
+                let m = $quat::from_euler(order, a, b, c);
+
+                let n = {
+                    let (i, j, k) = m.to_euler(order);
+                    $quat::from_euler(order, i, j, k)
+                };
+                assert_approx_eq!(m.canonical(), n.canonical(), $t::E_EPS);
+
+                let o = {
+                    let (i, j, k) = axis_order(order);
+                    if is_intrinsic(order) {
+                        AXIS_ANGLE[i](a) * AXIS_ANGLE[j](b) * AXIS_ANGLE[k](c)
+                    } else {
+                        AXIS_ANGLE[k](c) * AXIS_ANGLE[j](b) * AXIS_ANGLE[i](a)
+                    }
+                };
+                assert_approx_eq!(m.canonical(), o.canonical(), $t::E_EPS);
+            }
+
+            #[test]
+            fn test_all_euler_orders() {
+                let test = |order| test_order_angles(order, &test_euler);
+                test_all_orders(&test);
+            }
+        };
+    }
+
+    macro_rules! impl_mat_euler_test {
+        ($mat:ident, $t:ident) => {
+            use super::{
+                axis_order, is_intrinsic, test_all_orders, test_order_angles, $t::deg_to_rad,
+                EulerEpsilon,
+            };
+            use glam::{$mat, EulerRot};
+
+            const AXIS_ANGLE: [fn($t) -> $mat; 3] = [
+                $mat::from_rotation_x,
+                $mat::from_rotation_y,
+                $mat::from_rotation_z,
+            ];
+
+            fn test_euler(order: EulerRot, a: i32, b: i32, c: i32) {
+                println!("test_euler: {} {order:?} ({a}, {b}, {c})", stringify!($mat));
+
+                let (a, b, c) = deg_to_rad(a, b, c);
+                let m = $mat::from_euler(order, a, b, c);
+                let n = {
+                    let (i, j, k) = m.to_euler(order);
+                    $mat::from_euler(order, i, j, k)
+                };
+                assert_approx_eq!(m, n, $t::E_EPS);
+
+                let o = {
+                    let (i, j, k) = axis_order(order);
+                    if is_intrinsic(order) {
+                        AXIS_ANGLE[i](a) * AXIS_ANGLE[j](b) * AXIS_ANGLE[k](c)
+                    } else {
+                        AXIS_ANGLE[k](c) * AXIS_ANGLE[j](b) * AXIS_ANGLE[i](a)
+                    }
+                };
+                assert_approx_eq!(m, o, $t::E_EPS);
+            }
+
+            #[test]
+            fn test_all_euler_orders() {
+                let test = |order| test_order_angles(order, &test_euler);
+                test_all_orders(&test);
+            }
+        };
+    }
+
+    #[test]
+    fn test_euler_default() {
+        assert_eq!(EulerRot::YXZ, EulerRot::default());
+    }
+
+    mod quat {
+        impl_quat_euler_test!(Quat, f32);
+    }
+
+    mod mat3 {
+        impl_mat_euler_test!(Mat3, f32);
+    }
+
+    mod mat3a {
+        impl_mat_euler_test!(Mat3A, f32);
+    }
+
+    mod mat4 {
+        impl_mat_euler_test!(Mat4, f32);
+    }
+
+    mod dquat {
+        impl_quat_euler_test!(DQuat, f64);
+    }
+
+    mod dmat3 {
+        impl_mat_euler_test!(DMat3, f64);
+    }
+
+    mod dmat4 {
+        impl_mat_euler_test!(DMat4, f64);
+    }
+}

vendor/glam/tests/float.rs

@@ -0,0 +1,48 @@
+#[macro_use]
+mod support;
+
+macro_rules! impl_float_tests {
+    ($t:ident) => {
+        glam_test!(test_lerp, {
+            let a = 0.;
+            let b = 10.;
+            assert_eq!($t::lerp(a, b, 0.), a);
+            assert_eq!($t::lerp(a, b, 0.5), 5.);
+            assert_eq!($t::lerp(a, b, 1.), b);
+            assert_eq!($t::lerp(a, a, 0.), a);
+            assert_eq!($t::lerp(a, a, 1.), a);
+        });
+
+        glam_test!(test_inverse_lerp, {
+            let a = 0.;
+            let b = 10.;
+            assert_eq!($t::inverse_lerp(a, b, 0.), 0.);
+            assert_eq!($t::inverse_lerp(a, b, 5.), 0.5);
+            assert_eq!($t::inverse_lerp(a, b, 10.), 1.);
+            assert_eq!($t::inverse_lerp(a, b, 15.), 1.5);
+            assert!($t::inverse_lerp(a, a, 0.).is_nan());
+            assert!($t::inverse_lerp(a, a, 1.).is_infinite());
+        });
+
+        glam_test!(test_remap, {
+            assert_eq!($t::remap(0., 0., 2., 0., 20.), 0.);
+            assert_eq!($t::remap(1., 0., 2., 0., 20.), 10.);
+            assert_eq!($t::remap(2., 0., 2., 0., 20.), 20.);
+            assert_eq!($t::remap(-5., -10., 30., 60., 20.), 55.);
+            assert!($t::remap(0., 0., 0., 0., 1.).is_nan());
+            assert!($t::remap(1., 0., 0., 0., 1.).is_infinite());
+        });
+    };
+}
+
+mod float32 {
+    use glam::FloatExt;
+
+    impl_float_tests!(f32);
+}
+
+mod float64 {
+    use glam::FloatExt;
+
+    impl_float_tests!(f64);
+}

vendor/glam/tests/mat2.rs

@@ -0,0 +1,315 @@
+#[macro_use]
+mod support;
+
+macro_rules! impl_mat2_tests {
+    ($t:ident, $newmat2:ident, $mat2:ident, $mat3:ident, $newvec2:ident, $vec2:ident) => {
+        const IDENTITY: [[$t; 2]; 2] = [[1.0, 0.0], [0.0, 1.0]];
+        const ARRAY2X2: [[$t; 2]; 2] = [[1.0, 2.0], [3.0, 4.0]];
+        const ARRAY1X4: [$t; 4] = [1.0, 2.0, 3.0, 4.0];
+        const ARRAY3X3: [[$t; 3]; 3] = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]];
+
+        glam_test!(test_const, {
+            const M0: $mat2 = $mat2::from_cols($newvec2(1.0, 2.0), $newvec2(3.0, 4.0));
+            const M1: $mat2 = $mat2::from_cols_array(&ARRAY1X4);
+            const M2: $mat2 = $mat2::from_cols_array_2d(&ARRAY2X2);
+
+            assert_eq!(ARRAY1X4, M0.to_cols_array());
+            assert_eq!(ARRAY1X4, M1.to_cols_array());
+            assert_eq!(ARRAY1X4, M2.to_cols_array());
+        });
+
+        glam_test!(test_mat2_identity, {
+            assert_eq!($mat2::IDENTITY, $mat2::from_cols_array(&[1., 0., 0., 1.]));
+            let identity = $mat2::IDENTITY;
+            assert_eq!(IDENTITY, identity.to_cols_array_2d());
+            assert_eq!($mat2::from_cols_array_2d(&IDENTITY), identity);
+            assert_eq!(identity, identity * identity);
+            assert_eq!(identity, $mat2::default());
+            assert_eq!(identity, $mat2::from_diagonal($vec2::ONE));
+        });
+
+        glam_test!(test_mat2_zero, {
+            assert_eq!($mat2::ZERO, $mat2::from_cols_array(&[0., 0., 0., 0.]));
+        });
+
+        glam_test!(test_mat2_nan, {
+            assert!($mat2::NAN.is_nan());
+            assert!(!$mat2::NAN.is_finite());
+        });
+
+        glam_test!(test_mat2_accessors, {
+            let mut m = $mat2::ZERO;
+            m.x_axis = $vec2::new(1.0, 2.0);
+            m.y_axis = $vec2::new(3.0, 4.0);
+            assert_eq!($mat2::from_cols_array_2d(&ARRAY2X2), m);
+            assert_eq!($vec2::new(1.0, 2.0), m.x_axis);
+            assert_eq!($vec2::new(3.0, 4.0), m.y_axis);
+
+            assert_eq!($vec2::new(1.0, 2.0), m.col(0));
+            assert_eq!($vec2::new(3.0, 4.0), m.col(1));
+
+            assert_eq!($newvec2(1.0, 3.0), m.row(0));
+            assert_eq!($newvec2(2.0, 4.0), m.row(1));
+
+            *m.col_mut(0) = m.col(0).yx();
+            *m.col_mut(1) = m.col(1).yx();
+            assert_eq!($vec2::new(2.0, 1.0), m.col(0));
+            assert_eq!($vec2::new(4.0, 3.0), m.col(1));
+
+            should_panic!({ $mat2::ZERO.col(2) });
+            should_panic!({
+                let mut m = $mat2::ZERO;
+                m.col_mut(2);
+            });
+            should_panic!({ $mat2::ZERO.row(2) });
+        });
+
+        glam_test!(test_mat2_from_axes, {
+            let a = $mat2::from_cols_array_2d(&ARRAY2X2);
+            assert_eq!(ARRAY2X2, a.to_cols_array_2d());
+            let b = $mat2::from_cols($newvec2(1.0, 2.0), $newvec2(3.0, 4.0));
+            assert_eq!(a, b);
+            let c = $newmat2($newvec2(1.0, 2.0), $newvec2(3.0, 4.0));
+            assert_eq!(a, c);
+            let d = b.to_cols_array();
+            let f = $mat2::from_cols_array(&d);
+            assert_eq!(b, f);
+        });
+
+        glam_test!(test_mat2_mul, {
+            let mat_a = $mat2::from_angle(deg(90.0));
+            let res_a = mat_a * $vec2::Y;
+            assert_approx_eq!($newvec2(-1.0, 0.0), res_a);
+            let res_b = mat_a * $vec2::X;
+            assert_approx_eq!($newvec2(0.0, 1.0), res_b);
+        });
+
+        glam_test!(test_from_scale_angle, {
+            let rot = $mat2::from_scale_angle($vec2::new(4.0, 2.0), deg(180.0));
+            assert_approx_eq!($vec2::X * -4.0, rot * $vec2::X, 1.0e-6);
+            assert_approx_eq!($vec2::Y * -2.0, rot * $vec2::Y, 1.0e-6);
+        });
+
+        glam_test!(test_from_diagonal, {
+            let m = $mat2::from_diagonal($vec2::new(2 as $t, 4 as $t));
+            assert_eq!(
+                $mat2::from_cols_array_2d(&[[2 as $t, 0 as $t], [0 as $t, 4 as $t]]),
+                m
+            );
+            assert_approx_eq!(m * $vec2::new(1.0, 1.0), $vec2::new(2.0, 4.0));
+            assert_approx_eq!($vec2::X * 2.0, m.x_axis);
+            assert_approx_eq!($vec2::Y * 4.0, m.y_axis);
+        });
+
+        glam_test!(test_from_mat3, {
+            let m3 = $mat3::from_cols_array_2d(&ARRAY3X3);
+            let m2 = $mat2::from_mat3(m3);
+            assert_eq!($mat2::from_cols_array_2d(&[[1.0, 2.0], [4.0, 5.0]]), m2);
+        });
+
+        glam_test!(test_from_mat3_minor, {
+            let m3 = $mat3::from_cols_array_2d(&ARRAY3X3);
+            for i in 0..3 {
+                for j in 0..3 {
+                    let m2 = $mat2::from_mat3_minor(m3, i, j);
+                    test_matrix_minor!(3, m2, m3, i, j);
+                }
+            }
+            should_panic!({ $mat2::from_mat3_minor(m3, 3, 0) });
+            should_panic!({ $mat2::from_mat3_minor(m3, 0, 3) });
+        });
+
+        glam_test!(test_mat2_transpose, {
+            let m = $newmat2($newvec2(1.0, 2.0), $newvec2(3.0, 4.0));
+            let mt = m.transpose();
+            assert_eq!($newvec2(1.0, 3.0), mt.x_axis);
+            assert_eq!($newvec2(2.0, 4.0), mt.y_axis);
+        });
+
+        glam_test!(test_mat2_det, {
+            assert_eq!(0.0, $mat2::ZERO.determinant());
+            assert_eq!(1.0, $mat2::IDENTITY.determinant());
+            assert_eq!(1.0, $mat2::from_angle(deg(90.0)).determinant());
+            assert_eq!(1.0, $mat2::from_angle(deg(180.0)).determinant());
+            assert_eq!(1.0, $mat2::from_angle(deg(270.0)).determinant());
+            assert_eq!(
+                2.0 * 2.0,
+                $mat2::from_diagonal($newvec2(2.0, 2.0)).determinant()
+            );
+            assert_eq!(
+                1.0 * 4.0 - 2.0 * 3.0,
+                $mat2::from_cols_array(&ARRAY1X4).determinant()
+            );
+        });
+
+        glam_test!(test_mat2_inverse, {
+            let inv = $mat2::IDENTITY.inverse();
+            assert_approx_eq!($mat2::IDENTITY, inv);
+
+            let rot = $mat2::from_angle(deg(90.0));
+            let rot_inv = rot.inverse();
+            assert_approx_eq!($mat2::IDENTITY, rot * rot_inv);
+            assert_approx_eq!($mat2::IDENTITY, rot_inv * rot);
+
+            let scale = $mat2::from_diagonal($newvec2(4.0, 5.0));
+            let scale_inv = scale.inverse();
+            assert_approx_eq!($mat2::IDENTITY, scale * scale_inv);
+            assert_approx_eq!($mat2::IDENTITY, scale_inv * scale);
+
+            let m = scale * rot;
+            let m_inv = m.inverse();
+            assert_approx_eq!($mat2::IDENTITY, m * m_inv);
+            assert_approx_eq!($mat2::IDENTITY, m_inv * m);
+            assert_approx_eq!(m_inv, rot_inv * scale_inv);
+
+            should_glam_assert!({ $mat2::ZERO.inverse() });
+        });
+
+        glam_test!(test_mat2_ops, {
+            let m0 = $mat2::from_cols_array_2d(&ARRAY2X2);
+            let m0x2 = $mat2::from_cols_array_2d(&[[2.0, 4.0], [6.0, 8.0]]);
+            let m0_neg = $mat2::from_cols_array_2d(&[[-1.0, -2.0], [-3.0, -4.0]]);
+            assert_eq!(m0x2, m0 * 2.0);
+            assert_eq!(m0x2, 2.0 * m0);
+            assert_eq!(m0, m0x2 / 2.0);
+            assert_eq!(m0, 2.0 / m0x2);
+            assert_eq!(m0x2, m0 + m0);
+            assert_eq!($mat2::ZERO, m0 - m0);
+            assert_eq!(m0_neg, -m0);
+            assert_approx_eq!(m0, m0 * $mat2::IDENTITY);
+            assert_approx_eq!(m0, $mat2::IDENTITY * m0);
+
+            let mut m1 = m0;
+            m1 *= 2.0;
+            assert_eq!(m0x2, m1);
+
+            let mut m1 = m0x2;
+            m1 /= 2.0;
+            assert_eq!(m0, m1);
+
+            let mut m1 = m0;
+            m1 += m0;
+            assert_eq!(m0x2, m1);
+
+            let mut m1 = m0;
+            m1 -= m0;
+            assert_eq!($mat2::ZERO, m1);
+
+            let mut m1 = $mat2::IDENTITY;
+            m1 *= m0;
+            assert_approx_eq!(m0, m1);
+        });
+
+        glam_test!(test_mat2_fmt, {
+            let a = $mat2::from_cols_array_2d(&ARRAY2X2);
+            assert_eq!(format!("{}", a), "[[1, 2], [3, 4]]");
+            assert_eq!(format!("{:.2}", a), "[[1.00, 2.00], [3.00, 4.00]]");
+        });
+
+        glam_test!(test_mat2_to_from_slice, {
+            let m = $mat2::from_cols_slice(&ARRAY1X4);
+            assert_eq!($mat2::from_cols_array(&ARRAY1X4), m);
+            let mut out: [$t; 4] = Default::default();
+            m.write_cols_to_slice(&mut out);
+            assert_eq!(ARRAY1X4, out);
+
+            should_panic!({ $mat2::from_cols_slice(&[0.0; 3]) });
+            should_panic!({ $mat2::IDENTITY.write_cols_to_slice(&mut [0.0; 3]) });
+        });
+
+        glam_test!(test_sum, {
+            let id = $mat2::IDENTITY;
+            assert_eq!([id, id].iter().sum::<$mat2>(), id + id);
+            assert_eq!([id, id].into_iter().sum::<$mat2>(), id + id);
+        });
+
+        glam_test!(test_product, {
+            let two = $mat2::IDENTITY + $mat2::IDENTITY;
+            assert_eq!([two, two].iter().product::<$mat2>(), two * two);
+            assert_eq!([two, two].into_iter().product::<$mat2>(), two * two);
+        });
+
+        glam_test!(test_mat2_is_finite, {
+            assert!($mat2::IDENTITY.is_finite());
+            assert!(!($mat2::IDENTITY * $t::INFINITY).is_finite());
+            assert!(!($mat2::IDENTITY * $t::NEG_INFINITY).is_finite());
+            assert!(!($mat2::IDENTITY * $t::NAN).is_finite());
+        });
+    };
+}
+
+macro_rules! impl_as_ref_tests {
+    ($mat:ident) => {
+        glam_test!(test_as_ref, {
+            let m = $mat::from_cols_array_2d(&ARRAY2X2);
+            assert_eq!(ARRAY1X4, *m.as_ref());
+        });
+        glam_test!(test_as_mut, {
+            let mut m = $mat::ZERO;
+            *m.as_mut() = ARRAY1X4;
+            assert_eq!($mat::from_cols_array_2d(&ARRAY2X2), m);
+        });
+    };
+}
+
+mod mat2 {
+    use super::support::deg;
+    use glam::{mat2, swizzles::*, vec2, Mat2, Mat3, Mat3A, Vec2};
+
+    glam_test!(test_align, {
+        use std::mem;
+        assert_eq!(16, mem::size_of::<Mat2>());
+        if cfg!(feature = "scalar-math") {
+            assert_eq!(mem::align_of::<Vec2>(), mem::align_of::<Mat2>());
+        } else {
+            assert_eq!(16, mem::align_of::<Mat2>());
+        }
+    });
+
+    glam_test!(test_from_mat3a, {
+        let m3 = Mat3A::from_cols_array_2d(&ARRAY3X3);
+        let m2 = Mat2::from_mat3a(m3);
+        assert_eq!(Mat2::from_cols_array_2d(&[[1.0, 2.0], [4.0, 5.0]]), m2);
+    });
+
+    glam_test!(test_from_mat3a_minor, {
+        let m3 = Mat3A::from_cols_array_2d(&ARRAY3X3);
+        for i in 0..3 {
+            for j in 0..3 {
+                let m2 = Mat2::from_mat3a_minor(m3, i, j);
+                test_matrix_minor!(3, m2, m3, i, j);
+            }
+        }
+        should_panic!({ Mat2::from_mat3a_minor(m3, 3, 0) });
+        should_panic!({ Mat2::from_mat3a_minor(m3, 0, 3) });
+    });
+
+    glam_test!(test_as, {
+        use glam::DMat2;
+        assert_eq!(
+            DMat2::from_cols_array(&[1.0, 2.0, 3.0, 4.0]),
+            Mat2::from_cols_array(&[1.0, 2.0, 3.0, 4.0]).as_dmat2()
+        );
+        assert_eq!(
+            Mat2::from_cols_array(&[1.0, 2.0, 3.0, 4.0]),
+            DMat2::from_cols_array(&[1.0, 2.0, 3.0, 4.0]).as_mat2()
+        );
+    });
+
+    impl_mat2_tests!(f32, mat2, Mat2, Mat3, vec2, Vec2);
+    impl_as_ref_tests!(Mat2);
+}
+
+mod dmat2 {
+    use super::support::deg;
+    use glam::{dmat2, dvec2, swizzles::*, DMat2, DMat3, DVec2};
+
+    glam_test!(test_align, {
+        use std::mem;
+        assert_eq!(32, mem::size_of::<DMat2>());
+        assert_eq!(mem::align_of::<DVec2>(), mem::align_of::<DMat2>());
+    });
+
+    impl_mat2_tests!(f64, dmat2, DMat2, DMat3, dvec2, DVec2);
+    impl_as_ref_tests!(DMat2);
+}

vendor/glam/tests/mat3.rs

@@ -0,0 +1,465 @@
+#[macro_use]
+mod support;
+
+macro_rules! impl_mat3_tests {
+    ($t:ident, $newmat3:ident, $mat3:ident, $mat2:ident, $mat4:ident, $quat:ident, $newvec3:ident, $vec3:ident, $vec2:ident) => {
+        const IDENTITY: [[$t; 3]; 3] = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]];
+        const ARRAY3X3: [[$t; 3]; 3] = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]];
+        const ARRAY1X9: [$t; 9] = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0];
+        const ARRAY4X4: [[$t; 4]; 4] = [
+            [1.0, 2.0, 3.0, 4.0],
+            [5.0, 6.0, 7.0, 8.0],
+            [9.0, 10.0, 11.0, 12.0],
+            [13.0, 14.0, 15.0, 16.0],
+        ];
+
+        glam_test!(test_const, {
+            const M0: $mat3 = $mat3::from_cols(
+                $newvec3(1.0, 2.0, 3.0),
+                $newvec3(4.0, 5.0, 6.0),
+                $newvec3(7.0, 8.0, 9.0),
+            );
+            const M1: $mat3 = $mat3::from_cols_array(&ARRAY1X9);
+            const M2: $mat3 = $mat3::from_cols_array_2d(&ARRAY3X3);
+
+            assert_eq!(ARRAY1X9, M0.to_cols_array());
+            assert_eq!(ARRAY1X9, M1.to_cols_array());
+            assert_eq!(ARRAY1X9, M2.to_cols_array());
+        });
+
+        glam_test!(test_mat3_identity, {
+            assert_eq!(
+                $mat3::IDENTITY,
+                $mat3::from_cols_array(&[
+                    1., 0., 0., //
+                    0., 1., 0., //
+                    0., 0., 1., //
+                ])
+            );
+            let identity = $mat3::IDENTITY;
+            assert_eq!(IDENTITY, identity.to_cols_array_2d());
+            assert_eq!($mat3::from_cols_array_2d(&IDENTITY), identity);
+            assert_eq!(identity, identity * identity);
+            assert_eq!(identity, $mat3::default());
+            assert_eq!(identity, $mat3::from_diagonal($vec3::ONE));
+        });
+
+        glam_test!(test_mat3_zero, {
+            assert_eq!(
+                $mat3::ZERO,
+                $mat3::from_cols_array(&[0., 0., 0., 0., 0., 0., 0., 0., 0.])
+            );
+        });
+
+        glam_test!(test_mat3_nan, {
+            assert!($mat3::NAN.is_nan());
+            assert!(!$mat3::NAN.is_finite());
+        });
+
+        glam_test!(test_mat3_accessors, {
+            let mut m = $mat3::ZERO;
+            m.x_axis = $newvec3(1.0, 2.0, 3.0);
+            m.y_axis = $newvec3(4.0, 5.0, 6.0);
+            m.z_axis = $newvec3(7.0, 8.0, 9.0);
+            assert_eq!($mat3::from_cols_array_2d(&ARRAY3X3), m);
+            assert_eq!($newvec3(1.0, 2.0, 3.0), m.x_axis);
+            assert_eq!($newvec3(4.0, 5.0, 6.0), m.y_axis);
+            assert_eq!($newvec3(7.0, 8.0, 9.0), m.z_axis);
+
+            assert_eq!($newvec3(1.0, 2.0, 3.0), m.col(0));
+            assert_eq!($newvec3(4.0, 5.0, 6.0), m.col(1));
+            assert_eq!($newvec3(7.0, 8.0, 9.0), m.col(2));
+
+            assert_eq!($newvec3(1.0, 4.0, 7.0), m.row(0));
+            assert_eq!($newvec3(2.0, 5.0, 8.0), m.row(1));
+            assert_eq!($newvec3(3.0, 6.0, 9.0), m.row(2));
+
+            *m.col_mut(0) = m.col(0).zyx();
+            *m.col_mut(1) = m.col(1).zyx();
+            *m.col_mut(2) = m.col(2).zyx();
+            assert_eq!($newvec3(3.0, 2.0, 1.0), m.col(0));
+            assert_eq!($newvec3(6.0, 5.0, 4.0), m.col(1));
+            assert_eq!($newvec3(9.0, 8.0, 7.0), m.col(2));
+
+            should_panic!({ $mat3::ZERO.col(3) });
+            should_panic!({
+                let mut m = $mat3::ZERO;
+                m.col_mut(3);
+            });
+            should_panic!({ $mat3::ZERO.row(3) });
+        });
+
+        glam_test!(test_mat3_from_axes, {
+            let a = $mat3::from_cols_array_2d(&[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]);
+            assert_eq!(ARRAY3X3, a.to_cols_array_2d());
+            let b = $mat3::from_cols(
+                $newvec3(1.0, 2.0, 3.0),
+                $newvec3(4.0, 5.0, 6.0),
+                $newvec3(7.0, 8.0, 9.0),
+            );
+            assert_eq!(a, b);
+            let c = $newmat3(
+                $newvec3(1.0, 2.0, 3.0),
+                $newvec3(4.0, 5.0, 6.0),
+                $newvec3(7.0, 8.0, 9.0),
+            );
+            assert_eq!(a, c);
+            let d = b.to_cols_array();
+            let f = $mat3::from_cols_array(&d);
+            assert_eq!(b, f);
+        });
+
+        glam_test!(test_from_rotation, {
+            let rot_x1 = $mat3::from_rotation_x(deg(180.0));
+            let rot_x2 = $mat3::from_axis_angle($vec3::X, deg(180.0));
+            assert_approx_eq!(rot_x1, rot_x2);
+            let rot_x3 = $mat3::from_quat($quat::from_rotation_x(deg(180.0)));
+            assert_approx_eq!(rot_x1, rot_x3);
+
+            let rot_y1 = $mat3::from_rotation_y(deg(180.0));
+            let rot_y2 = $mat3::from_axis_angle($vec3::Y, deg(180.0));
+            assert_approx_eq!(rot_y1, rot_y2);
+            let rot_y3 = $mat3::from_quat($quat::from_rotation_y(deg(180.0)));
+            assert_approx_eq!(rot_y1, rot_y3);
+
+            let rot_z1 = $mat3::from_rotation_z(deg(180.0));
+            let rot_z2 = $mat3::from_axis_angle($vec3::Z, deg(180.0));
+            assert_approx_eq!(rot_z1, rot_z2);
+            let rot_z3 = $mat3::from_quat($quat::from_rotation_z(deg(180.0)));
+            assert_approx_eq!(rot_z1, rot_z3);
+
+            should_glam_assert!({ $mat3::from_axis_angle($vec3::ZERO, 0.0) });
+            should_glam_assert!({ $mat3::from_quat($quat::from_xyzw(0.0, 0.0, 0.0, 0.0)) });
+        });
+
+        glam_test!(test_mat3_mul, {
+            let mat_a = $mat3::from_axis_angle($vec3::Z, deg(90.0));
+            assert_approx_eq!($newvec3(-1.0, 0.0, 0.0), mat_a * $newvec3(0.0, 1.0, 0.0));
+            assert_approx_eq!(
+                $vec3::new(-1.0, 0.0, 0.0),
+                mat_a.mul_vec3($vec3::new(0.0, 1.0, 0.0))
+            );
+        });
+
+        glam_test!(test_mat3_transform2d, {
+            let m = $mat3::from_translation($vec2::new(2.0, 4.0));
+            assert_eq!($vec2::ZERO, m.transform_vector2($vec2::ZERO));
+            assert_eq!($vec2::new(2.0, 4.0), m.transform_point2($vec2::ZERO));
+            assert_eq!($vec2::ZERO, m.transform_point2($vec2::new(-2.0, -4.0)));
+
+            let m = $mat3::from_angle($t::to_radians(90.0));
+            assert_approx_eq!($vec2::Y, m.transform_vector2($vec2::X), 1e-7);
+            assert_approx_eq!($vec2::Y, m.transform_point2($vec2::X), 1e-7);
+
+            let m = $mat3::from_scale($vec2::new(2.0, 4.0));
+            assert_eq!($vec2::new(2.0, 0.0), m.transform_vector2($vec2::X));
+            assert_eq!($vec2::new(0.0, 4.0), m.transform_vector2($vec2::Y));
+            assert_eq!($vec2::new(2.0, 0.0), m.transform_point2($vec2::X));
+            assert_eq!($vec2::new(0.0, 4.0), m.transform_point2($vec2::Y));
+
+            should_glam_assert!({ $mat3::from_scale($vec2::ZERO) });
+
+            let m = $mat3::from_scale_angle_translation(
+                $vec2::new(0.5, 1.5),
+                $t::to_radians(90.0),
+                $vec2::new(1.0, 2.0),
+            );
+            let result2 = m.transform_vector2($vec2::Y);
+            assert_approx_eq!($vec2::new(-1.5, 0.0), result2, 1.0e-6);
+            assert_approx_eq!(result2, (m * $vec2::Y.extend(0.0)).truncate());
+
+            let result2 = m.transform_point2($vec2::Y);
+            assert_approx_eq!($vec2::new(-0.5, 2.0), result2, 1.0e-6);
+            assert_approx_eq!(result2, (m * $vec2::Y.extend(1.0)).truncate());
+        });
+
+        glam_test!(test_from_ypr, {
+            use glam::EulerRot;
+            let zero = deg(0.0);
+            let yaw = deg(30.0);
+            let pitch = deg(60.0);
+            let roll = deg(90.0);
+            let y0 = $mat3::from_rotation_y(yaw);
+            let y1 = $mat3::from_euler(EulerRot::YXZ, yaw, zero, zero);
+            assert_approx_eq!(y0, y1);
+
+            let x0 = $mat3::from_rotation_x(pitch);
+            let x1 = $mat3::from_euler(EulerRot::YXZ, zero, pitch, zero);
+            assert_approx_eq!(x0, x1);
+
+            let z0 = $mat3::from_rotation_z(roll);
+            let z1 = $mat3::from_euler(EulerRot::YXZ, zero, zero, roll);
+            assert_approx_eq!(z0, z1);
+
+            let yx0 = y0 * x0;
+            let yx1 = $mat3::from_euler(EulerRot::YXZ, yaw, pitch, zero);
+            assert_approx_eq!(yx0, yx1, 1e-6);
+
+            let yxz0 = y0 * x0 * z0;
+            let yxz1 = $mat3::from_euler(EulerRot::YXZ, yaw, pitch, roll);
+            assert_approx_eq!(yxz0, yxz1, 1e-6);
+        });
+
+        glam_test!(test_from_diagonal, {
+            let m = $mat3::from_diagonal($vec3::new(2.0, 4.0, 8.0));
+            assert_approx_eq!(m * $vec3::new(1.0, 1.0, 1.0), $vec3::new(2.0, 4.0, 8.0));
+            assert_approx_eq!($newvec3(2.0, 0.0, 0.0), m.x_axis);
+            assert_approx_eq!($newvec3(0.0, 4.0, 0.0), m.y_axis);
+            assert_approx_eq!($newvec3(0.0, 0.0, 8.0), m.z_axis);
+        });
+
+        glam_test!(test_from_mat2, {
+            let m2 = $mat2::from_cols_array_2d(&[[1.0, 2.0], [3.0, 4.0]]);
+            let m3 = $mat3::from_mat2(m2);
+            assert_eq!(
+                $mat3::from_cols_array_2d(&[[1.0, 2.0, 0.0], [3.0, 4.0, 0.0], [0.0, 0.0, 1.0]]),
+                m3
+            );
+        });
+
+        glam_test!(test_from_mat4, {
+            let m4 = $mat4::from_cols_array_2d(&ARRAY4X4);
+            let m3 = $mat3::from_mat4(m4);
+            assert_eq!(
+                $mat3::from_cols_array_2d(&[[1.0, 2.0, 3.0], [5.0, 6.0, 7.0], [9.0, 10.0, 11.0]]),
+                m3
+            );
+        });
+
+        glam_test!(test_from_mat4_minor, {
+            let m4 = $mat4::from_cols_array_2d(&ARRAY4X4);
+            for i in 0..4 {
+                for j in 0..4 {
+                    let m3 = $mat3::from_mat4_minor(m4, i, j);
+                    test_matrix_minor!(4, m3, m4, i, j);
+                }
+            }
+            should_panic!({ $mat3::from_mat4_minor(m4, 4, 0) });
+            should_panic!({ $mat3::from_mat4_minor(m4, 0, 4) });
+        });
+
+        glam_test!(test_mat3_transpose, {
+            let m = $newmat3(
+                $newvec3(1.0, 2.0, 3.0),
+                $newvec3(4.0, 5.0, 6.0),
+                $newvec3(7.0, 8.0, 9.0),
+            );
+            let mt = m.transpose();
+            assert_eq!($newvec3(1.0, 4.0, 7.0), mt.x_axis);
+            assert_eq!($newvec3(2.0, 5.0, 8.0), mt.y_axis);
+            assert_eq!($newvec3(3.0, 6.0, 9.0), mt.z_axis);
+        });
+
+        glam_test!(test_mat3_det, {
+            assert_eq!(0.0, $mat3::ZERO.determinant());
+            assert_eq!(1.0, $mat3::IDENTITY.determinant());
+            assert_eq!(1.0, $mat3::from_rotation_x(deg(90.0)).determinant());
+            assert_eq!(1.0, $mat3::from_rotation_y(deg(180.0)).determinant());
+            assert_eq!(1.0, $mat3::from_rotation_z(deg(270.0)).determinant());
+            assert_eq!(
+                2.0 * 2.0 * 2.0,
+                $mat3::from_diagonal($vec3::new(2.0, 2.0, 2.0)).determinant()
+            );
+        });
+
+        glam_test!(test_mat3_inverse, {
+            // assert_eq!(None, $mat3::ZERO.inverse());
+            let inv = $mat3::IDENTITY.inverse();
+            // assert_ne!(None, inv);
+            assert_approx_eq!($mat3::IDENTITY, inv);
+
+            let rotz = $mat3::from_rotation_z(deg(90.0));
+            let rotz_inv = rotz.inverse();
+            // assert_ne!(None, rotz_inv);
+            // let rotz_inv = rotz_inv.unwrap();
+            assert_approx_eq!($mat3::IDENTITY, rotz * rotz_inv);
+            assert_approx_eq!($mat3::IDENTITY, rotz_inv * rotz);
+
+            let scale = $mat3::from_diagonal($vec3::new(4.0, 5.0, 6.0));
+            let scale_inv = scale.inverse();
+            // assert_ne!(None, scale_inv);
+            // let scale_inv = scale_inv.unwrap();
+            assert_approx_eq!($mat3::IDENTITY, scale * scale_inv);
+            assert_approx_eq!($mat3::IDENTITY, scale_inv * scale);
+
+            let m = scale * rotz;
+            let m_inv = m.inverse();
+            // assert_ne!(None, m_inv);
+            // let m_inv = m_inv.unwrap();
+            assert_approx_eq!($mat3::IDENTITY, m * m_inv);
+            assert_approx_eq!($mat3::IDENTITY, m_inv * m);
+            assert_approx_eq!(m_inv, rotz_inv * scale_inv);
+
+            should_glam_assert!({ $mat3::ZERO.inverse() });
+        });
+
+        glam_test!(test_mat3_ops, {
+            let m0 = $mat3::from_cols_array_2d(&ARRAY3X3);
+            let m0x2 = $mat3::from_cols_array_2d(&[
+                [2.0, 4.0, 6.0],
+                [8.0, 10.0, 12.0],
+                [14.0, 16.0, 18.0],
+            ]);
+            let m0_neg = $mat3::from_cols_array_2d(&[
+                [-1.0, -2.0, -3.0],
+                [-4.0, -5.0, -6.0],
+                [-7.0, -8.0, -9.0],
+            ]);
+            assert_eq!(m0x2, m0 * 2.0);
+            assert_eq!(m0x2, 2.0 * m0);
+            assert_eq!(m0, m0x2 / 2.0);
+            assert_eq!(m0, 2.0 / m0x2);
+            assert_eq!(m0x2, m0 + m0);
+            assert_eq!($mat3::ZERO, m0 - m0);
+            assert_eq!(m0_neg, -m0);
+            assert_approx_eq!(m0, m0 * $mat3::IDENTITY);
+            assert_approx_eq!(m0, $mat3::IDENTITY * m0);
+
+            let mut m1 = m0;
+            m1 *= 2.0;
+            assert_eq!(m0x2, m1);
+
+            let mut m1 = m0x2;
+            m1 /= 2.0;
+            assert_eq!(m0, m1);
+
+            let mut m1 = m0;
+            m1 += m0;
+            assert_eq!(m0x2, m1);
+
+            let mut m1 = m0;
+            m1 -= m0;
+            assert_eq!($mat3::ZERO, m1);
+
+            let mut m1 = $mat3::IDENTITY;
+            m1 *= m0;
+            assert_approx_eq!(m0, m1);
+        });
+
+        glam_test!(test_mat3_fmt, {
+            let a = $mat3::from_cols_array_2d(&ARRAY3X3);
+            assert_eq!(format!("{}", a), "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]");
+            assert_eq!(
+                format!("{:.1}", a),
+                "[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]"
+            );
+        });
+
+        glam_test!(test_mat3_to_from_slice, {
+            let m = $mat3::from_cols_slice(&ARRAY1X9);
+            assert_eq!($mat3::from_cols_array(&ARRAY1X9), m);
+            let mut out: [$t; 9] = Default::default();
+            m.write_cols_to_slice(&mut out);
+            assert_eq!(ARRAY1X9, out);
+
+            should_panic!({ $mat3::from_cols_slice(&[0.0; 8]) });
+            should_panic!({ $mat3::IDENTITY.write_cols_to_slice(&mut [0.0; 8]) });
+        });
+
+        glam_test!(test_sum, {
+            let id = $mat3::IDENTITY;
+            assert_eq!([id, id].iter().sum::<$mat3>(), id + id);
+            assert_eq!([id, id].into_iter().sum::<$mat3>(), id + id);
+        });
+
+        glam_test!(test_product, {
+            let two = $mat3::IDENTITY + $mat3::IDENTITY;
+            assert_eq!([two, two].iter().product::<$mat3>(), two * two);
+            assert_eq!([two, two].into_iter().product::<$mat3>(), two * two);
+        });
+
+        glam_test!(test_mat3_is_finite, {
+            assert!($mat3::IDENTITY.is_finite());
+            assert!(!($mat3::IDENTITY * $t::INFINITY).is_finite());
+            assert!(!($mat3::IDENTITY * $t::NEG_INFINITY).is_finite());
+            assert!(!($mat3::IDENTITY * $t::NAN).is_finite());
+        });
+    };
+}
+
+macro_rules! impl_as_ref_tests {
+    ($mat:ident) => {
+        glam_test!(test_as_ref, {
+            let m = $mat::from_cols_array_2d(&ARRAY3X3);
+            assert_eq!(ARRAY1X9, *m.as_ref());
+        });
+        glam_test!(test_as_mut, {
+            let mut m = $mat::ZERO;
+            *m.as_mut() = ARRAY1X9;
+            assert_eq!($mat::from_cols_array_2d(&ARRAY3X3), m);
+        });
+    };
+}
+
+mod mat3 {
+    use super::support::deg;
+    use glam::{mat3, swizzles::*, vec3, vec3a, Mat2, Mat3, Mat4, Quat, Vec2, Vec3, Vec3A};
+
+    glam_test!(test_align, {
+        use std::mem;
+        assert_eq!(36, mem::size_of::<Mat3>());
+        assert_eq!(mem::align_of::<Vec3>(), mem::align_of::<Mat3>());
+    });
+
+    glam_test!(test_mul_vec3a, {
+        let mat_a = Mat3::from_axis_angle(Vec3::Z, deg(90.0));
+        assert_approx_eq!(vec3a(-1.0, 0.0, 0.0), mat_a * Vec3A::Y);
+        assert_approx_eq!(vec3a(-1.0, 0.0, 0.0), mat_a.mul_vec3a(Vec3A::Y));
+    });
+
+    glam_test!(test_as, {
+        use glam::DMat3;
+        assert_eq!(
+            DMat3::from_cols_array(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]),
+            Mat3::from_cols_array(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]).as_dmat3()
+        );
+        assert_eq!(
+            Mat3::from_cols_array(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]),
+            DMat3::from_cols_array(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]).as_mat3()
+        );
+    });
+
+    impl_mat3_tests!(f32, mat3, Mat3, Mat2, Mat4, Quat, vec3, Vec3, Vec2);
+    impl_as_ref_tests!(Mat3);
+}
+
+mod mat3a {
+    use super::support::deg;
+    use glam::{mat3a, swizzles::*, vec3a, Mat2, Mat3A, Mat4, Quat, Vec2, Vec3, Vec3A};
+
+    glam_test!(test_align, {
+        use std::mem;
+        assert_eq!(48, mem::size_of::<Mat3A>());
+        assert_eq!(mem::align_of::<Vec3A>(), mem::align_of::<Mat3A>());
+    });
+
+    glam_test!(test_mul_vec3a, {
+        let mat_a = Mat3A::from_axis_angle(Vec3::Z, deg(90.0));
+        assert_approx_eq!(vec3a(-1.0, 0.0, 0.0), mat_a * Vec3A::Y);
+        assert_approx_eq!(vec3a(-1.0, 0.0, 0.0), mat_a.mul_vec3a(Vec3A::Y));
+    });
+
+    glam_test!(test_as, {
+        use glam::DMat3;
+        assert_eq!(
+            DMat3::from_cols_array(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]),
+            Mat3A::from_cols_array(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]).as_dmat3()
+        );
+    });
+
+    impl_mat3_tests!(f32, mat3a, Mat3A, Mat2, Mat4, Quat, vec3a, Vec3, Vec2);
+}
+
+mod dmat3 {
+    use super::support::deg;
+    use glam::{dmat3, dvec3, swizzles::*, DMat2, DMat3, DMat4, DQuat, DVec2, DVec3};
+
+    glam_test!(test_align, {
+        use std::mem;
+        assert_eq!(72, mem::size_of::<DMat3>());
+        assert_eq!(mem::align_of::<DVec3>(), mem::align_of::<DMat3>());
+    });
+
+    impl_mat3_tests!(f64, dmat3, DMat3, DMat2, DMat4, DQuat, dvec3, DVec3, DVec2);
+    impl_as_ref_tests!(DMat3);
+}

vendor/glam/tests/mat4.rs

@@ -0,0 +1,815 @@
+#[macro_use]
+mod support;
+
+macro_rules! impl_mat4_tests {
+    ($t:ident, $newmat4:ident, $newvec4:ident, $newvec3:ident, $mat4:ident, $mat3:ident, $quat:ident, $vec4:ident, $vec3:ident) => {
+        const IDENTITY: [[$t; 4]; 4] = [
+            [1.0, 0.0, 0.0, 0.0],
+            [0.0, 1.0, 0.0, 0.0],
+            [0.0, 0.0, 1.0, 0.0],
+            [0.0, 0.0, 0.0, 1.0],
+        ];
+        const ARRAY4X4: [[$t; 4]; 4] = [
+            [1.0, 2.0, 3.0, 4.0],
+            [5.0, 6.0, 7.0, 8.0],
+            [9.0, 10.0, 11.0, 12.0],
+            [13.0, 14.0, 15.0, 16.0],
+        ];
+        const ARRAY1X16: [$t; 16] = [
+            1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
+        ];
+        const ARRAY3X3: [[$t; 3]; 3] = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]];
+
+        glam_test!(test_const, {
+            const M0: $mat4 = $mat4::from_cols(
+                $newvec4(1.0, 2.0, 3.0, 4.0),
+                $newvec4(5.0, 6.0, 7.0, 8.0),
+                $newvec4(9.0, 10.0, 11.0, 12.0),
+                $newvec4(13.0, 14.0, 15.0, 16.0),
+            );
+            const M1: $mat4 = $mat4::from_cols_array(&ARRAY1X16);
+            const M2: $mat4 = $mat4::from_cols_array_2d(&ARRAY4X4);
+
+            assert_eq!(ARRAY1X16, M0.to_cols_array());
+            assert_eq!(ARRAY1X16, M1.to_cols_array());
+            assert_eq!(ARRAY1X16, M2.to_cols_array());
+        });
+
+        glam_test!(test_mat4_identity, {
+            assert_eq!(
+                $mat4::IDENTITY,
+                $mat4::from_cols_array(&[
+                    1., 0., 0., 0., //
+                    0., 1., 0., 0., //
+                    0., 0., 1., 0., //
+                    0., 0., 0., 1., //
+                ])
+            );
+            let identity = $mat4::IDENTITY;
+            assert_eq!(IDENTITY, identity.to_cols_array_2d());
+            assert_eq!($mat4::from_cols_array_2d(&IDENTITY), identity);
+            assert_eq!(identity, identity * identity);
+            assert_eq!(identity, $mat4::default());
+            assert_eq!(identity, $mat4::from_diagonal($vec4::ONE));
+        });
+
+        glam_test!(test_mat4_zero, {
+            assert_eq!(
+                $mat4::ZERO,
+                $mat4::from_cols_array(&[
+                    0., 0., 0., 0., //
+                    0., 0., 0., 0., //
+                    0., 0., 0., 0., //
+                    0., 0., 0., 0., //
+                ])
+            );
+        });
+
+        glam_test!(test_mat4_nan, {
+            assert!($mat4::NAN.is_nan());
+            assert!(!$mat4::NAN.is_finite());
+        });
+
+        glam_test!(test_mat4_accessors, {
+            let mut m = $mat4::ZERO;
+            m.x_axis = $vec4::new(1.0, 2.0, 3.0, 4.0);
+            m.y_axis = $vec4::new(5.0, 6.0, 7.0, 8.0);
+            m.z_axis = $vec4::new(9.0, 10.0, 11.0, 12.0);
+            m.w_axis = $vec4::new(13.0, 14.0, 15.0, 16.0);
+            assert_eq!($mat4::from_cols_array_2d(&ARRAY4X4), m);
+            assert_eq!($vec4::new(1.0, 2.0, 3.0, 4.0), m.x_axis);
+            assert_eq!($vec4::new(5.0, 6.0, 7.0, 8.0), m.y_axis);
+            assert_eq!($vec4::new(9.0, 10.0, 11.0, 12.0), m.z_axis);
+            assert_eq!($vec4::new(13.0, 14.0, 15.0, 16.0), m.w_axis);
+
+            assert_eq!($vec4::new(1.0, 2.0, 3.0, 4.0), m.col(0));
+            assert_eq!($vec4::new(5.0, 6.0, 7.0, 8.0), m.col(1));
+            assert_eq!($vec4::new(9.0, 10.0, 11.0, 12.0), m.col(2));
+            assert_eq!($vec4::new(13.0, 14.0, 15.0, 16.0), m.col(3));
+
+            assert_eq!($newvec4(1.0, 5.0, 9.0, 13.0), m.row(0));
+            assert_eq!($newvec4(2.0, 6.0, 10.0, 14.0), m.row(1));
+            assert_eq!($newvec4(3.0, 7.0, 11.0, 15.0), m.row(2));
+            assert_eq!($newvec4(4.0, 8.0, 12.0, 16.0), m.row(3));
+
+            *m.col_mut(0) = m.col(0).wzyx();
+            *m.col_mut(1) = m.col(1).wzyx();
+            *m.col_mut(2) = m.col(2).wzyx();
+            *m.col_mut(3) = m.col(3).wzyx();
+            assert_eq!($newvec4(4.0, 3.0, 2.0, 1.0), m.col(0));
+            assert_eq!($newvec4(8.0, 7.0, 6.0, 5.0), m.col(1));
+            assert_eq!($newvec4(12.0, 11.0, 10.0, 9.0), m.col(2));
+            assert_eq!($newvec4(16.0, 15.0, 14.0, 13.0), m.col(3));
+
+            should_panic!({ $mat4::ZERO.col(4) });
+            should_panic!({
+                let mut m = $mat4::ZERO;
+                m.col_mut(4);
+            });
+            should_panic!({ $mat4::ZERO.row(4) });
+        });
+
+        glam_test!(test_mat4_from_axes, {
+            let a = $mat4::from_cols_array_2d(&[
+                [1.0, 2.0, 3.0, 4.0],
+                [5.0, 6.0, 7.0, 8.0],
+                [9.0, 10.0, 11.0, 12.0],
+                [13.0, 14.0, 15.0, 16.0],
+            ]);
+            assert_eq!(ARRAY4X4, a.to_cols_array_2d());
+            let b = $mat4::from_cols(
+                $newvec4(1.0, 2.0, 3.0, 4.0),
+                $newvec4(5.0, 6.0, 7.0, 8.0),
+                $newvec4(9.0, 10.0, 11.0, 12.0),
+                $newvec4(13.0, 14.0, 15.0, 16.0),
+            );
+            assert_eq!(a, b);
+            let c = $newmat4(
+                $newvec4(1.0, 2.0, 3.0, 4.0),
+                $newvec4(5.0, 6.0, 7.0, 8.0),
+                $newvec4(9.0, 10.0, 11.0, 12.0),
+                $newvec4(13.0, 14.0, 15.0, 16.0),
+            );
+            assert_eq!(a, c);
+            let d = b.to_cols_array();
+            let f = $mat4::from_cols_array(&d);
+            assert_eq!(b, f);
+        });
+
+        glam_test!(test_mat4_translation, {
+            let translate = $mat4::from_translation($newvec3(1.0, 2.0, 3.0));
+            assert_eq!(
+                $mat4::from_cols(
+                    $newvec4(1.0, 0.0, 0.0, 0.0),
+                    $newvec4(0.0, 1.0, 0.0, 0.0),
+                    $newvec4(0.0, 0.0, 1.0, 0.0),
+                    $newvec4(1.0, 2.0, 3.0, 1.0)
+                ),
+                translate
+            );
+        });
+
+        glam_test!(test_from_rotation, {
+            let rot_x1 = $mat4::from_rotation_x(deg(180.0));
+            let rot_x2 = $mat4::from_axis_angle($vec3::X, deg(180.0));
+            assert_approx_eq!(rot_x1, rot_x2);
+            let rot_y1 = $mat4::from_rotation_y(deg(180.0));
+            let rot_y2 = $mat4::from_axis_angle($vec3::Y, deg(180.0));
+            assert_approx_eq!(rot_y1, rot_y2);
+            let rot_z1 = $mat4::from_rotation_z(deg(180.0));
+            let rot_z2 = $mat4::from_axis_angle($vec3::Z, deg(180.0));
+            assert_approx_eq!(rot_z1, rot_z2);
+
+            assert_approx_eq!($mat4::IDENTITY, $mat4::from_quat($quat::IDENTITY));
+
+            should_glam_assert!({ $mat4::from_axis_angle($vec3::ZERO, 0.0) });
+            should_glam_assert!({ $mat4::from_quat($quat::from_xyzw(0.0, 0.0, 0.0, 0.0)) });
+        });
+
+        glam_test!(test_from_mat3, {
+            let m3 =
+                $mat3::from_cols_array_2d(&ARRAY3X3);
+            let m4 = $mat4::from_mat3(m3);
+            assert_eq!(
+                $mat4::from_cols_array_2d(&[
+                    [1.0, 2.0, 3.0, 0.0],
+                    [4.0, 5.0, 6.0, 0.0],
+                    [7.0, 8.0, 9.0, 0.0],
+                    [0.0, 0.0, 0.0, 1.0]
+                ]),
+                m4
+            );
+        });
+
+        glam_test!(test_mat4_mul, {
+            let m = $mat4::from_axis_angle($vec3::Z, deg(90.0));
+            let result3 = m.transform_vector3($vec3::Y);
+            assert_approx_eq!($newvec3(-1.0, 0.0, 0.0), result3);
+            assert_approx_eq!(result3, (m * $vec3::Y.extend(0.0)).truncate().into());
+            let result4 = m * $vec4::Y;
+            assert_approx_eq!($newvec4(-1.0, 0.0, 0.0, 0.0), result4);
+            assert_approx_eq!(result4, m * $vec4::Y);
+
+            let m = $mat4::from_scale_rotation_translation(
+                $vec3::new(0.5, 1.5, 2.0),
+                $quat::from_rotation_x(deg(90.0)),
+                $vec3::new(1.0, 2.0, 3.0),
+            );
+            let result3 = m.transform_vector3($vec3::Y);
+            assert_approx_eq!($newvec3(0.0, 0.0, 1.5), result3, 1.0e-6);
+            assert_approx_eq!(result3, (m * $vec3::Y.extend(0.0)).truncate().into());
+
+            let result3 = m.transform_point3($vec3::Y);
+            assert_approx_eq!($newvec3(1.0, 2.0, 4.5), result3, 1.0e-6);
+            assert_approx_eq!(result3, (m * $vec3::Y.extend(1.0)).truncate().into());
+
+            let m = $mat4::from_cols(
+                $newvec4(8.0, 0.0, 0.0, 0.0),
+                $newvec4(0.0, 4.0, 0.0, 0.0),
+                $newvec4(0.0, 0.0, 2.0, 2.0),
+                $newvec4(0.0, 0.0, 0.0, 0.0),
+            );
+            assert_approx_eq!(
+                $newvec3(4.0, 2.0, 1.0),
+                m.project_point3($newvec3(2.0, 2.0, 2.0))
+            );
+
+            should_glam_assert!({ $mat4::ZERO.transform_vector3($vec3::X) });
+            should_glam_assert!({ $mat4::ZERO.transform_point3($vec3::X) });
+        });
+
+        glam_test!(test_from_ypr, {
+            use glam::EulerRot;
+            let zero = deg(0.0);
+            let yaw = deg(30.0);
+            let pitch = deg(60.0);
+            let roll = deg(90.0);
+            let y0 = $mat4::from_rotation_y(yaw);
+            let y1 = $mat4::from_euler(EulerRot::YXZ, yaw, zero, zero);
+            assert_approx_eq!(y0, y1);
+
+            let x0 = $mat4::from_rotation_x(pitch);
+            let x1 = $mat4::from_euler(EulerRot::YXZ, zero, pitch, zero);
+            assert_approx_eq!(x0, x1);
+
+            let z0 = $mat4::from_rotation_z(roll);
+            let z1 = $mat4::from_euler(EulerRot::YXZ, zero, zero, roll);
+            assert_approx_eq!(z0, z1);
+
+            let yx0 = y0 * x0;
+            let yx1 = $mat4::from_euler(EulerRot::YXZ, yaw, pitch, zero);
+            assert_approx_eq!(yx0, yx1, 1e-6);
+
+            let yxz0 = y0 * x0 * z0;
+            let yxz1 = $mat4::from_euler(EulerRot::YXZ, yaw, pitch, roll);
+            assert_approx_eq!(yxz0, yxz1, 1e-6);
+        });
+
+        glam_test!(test_from_scale, {
+            let m = $mat4::from_scale($vec3::new(2.0, 4.0, 8.0));
+            assert_approx_eq!($vec4::X * 2.0, m.x_axis);
+            assert_approx_eq!($vec4::Y * 4.0, m.y_axis);
+            assert_approx_eq!($vec4::Z * 8.0, m.z_axis);
+            assert_approx_eq!($vec4::W, m.w_axis);
+            assert_approx_eq!(
+                m.transform_point3($vec3::new(1.0, 1.0, 1.0)),
+                $vec3::new(2.0, 4.0, 8.0)
+            );
+
+            should_glam_assert!({ $mat4::from_scale($vec3::ZERO) });
+        });
+
+        glam_test!(test_mat4_transpose, {
+            let m = $newmat4(
+                $newvec4(1.0, 2.0, 3.0, 4.0),
+                $newvec4(5.0, 6.0, 7.0, 8.0),
+                $newvec4(9.0, 10.0, 11.0, 12.0),
+                $newvec4(13.0, 14.0, 15.0, 16.0),
+            );
+            let mt = m.transpose();
+            assert_eq!($newvec4(1.0, 5.0, 9.0, 13.0), mt.x_axis);
+            assert_eq!($newvec4(2.0, 6.0, 10.0, 14.0), mt.y_axis);
+            assert_eq!($newvec4(3.0, 7.0, 11.0, 15.0), mt.z_axis);
+            assert_eq!($newvec4(4.0, 8.0, 12.0, 16.0), mt.w_axis);
+        });
+
+        glam_test!(test_mat4_det, {
+            assert_eq!(0.0, $mat4::ZERO.determinant());
+            assert_eq!(1.0, $mat4::IDENTITY.determinant());
+            assert_eq!(1.0, $mat4::from_rotation_x(deg(90.0)).determinant());
+            assert_eq!(1.0, $mat4::from_rotation_y(deg(180.0)).determinant());
+            assert_eq!(1.0, $mat4::from_rotation_z(deg(270.0)).determinant());
+            assert_eq!(
+                2.0 * 2.0 * 2.0,
+                $mat4::from_scale($newvec3(2.0, 2.0, 2.0)).determinant()
+            );
+            assert_eq!(
+                1.0,
+                $newmat4(
+                    $newvec4(0.0, 0.0, 0.0, 1.0),
+                    $newvec4(1.0, 0.0, 0.0, 0.0),
+                    $newvec4(0.0, 0.0, 1.0, 0.0),
+                    $newvec4(0.0, 1.0, 0.0, 0.0),
+                )
+                .determinant()
+            );
+        });
+
+        glam_test!(test_mat4_inverse, {
+            // assert_eq!(None, $mat4::ZERO.inverse());
+            let inv = $mat4::IDENTITY.inverse();
+            // assert_ne!(None, inv);
+            assert_approx_eq!($mat4::IDENTITY, inv);
+
+            let rotz = $mat4::from_rotation_z(deg(90.0));
+            let rotz_inv = rotz.inverse();
+            // assert_ne!(None, rotz_inv);
+            // let rotz_inv = rotz_inv.unwrap();
+            assert_approx_eq!($mat4::IDENTITY, rotz * rotz_inv);
+            assert_approx_eq!($mat4::IDENTITY, rotz_inv * rotz);
+
+            let trans = $mat4::from_translation($newvec3(1.0, 2.0, 3.0));
+            let trans_inv = trans.inverse();
+            // assert_ne!(None, trans_inv);
+            // let trans_inv = trans_inv.unwrap();
+            assert_approx_eq!($mat4::IDENTITY, trans * trans_inv);
+            assert_approx_eq!($mat4::IDENTITY, trans_inv * trans);
+
+            let scale = $mat4::from_scale($newvec3(4.0, 5.0, 6.0));
+            let scale_inv = scale.inverse();
+            // assert_ne!(None, scale_inv);
+            // let scale_inv = scale_inv.unwrap();
+            assert_approx_eq!($mat4::IDENTITY, scale * scale_inv);
+            assert_approx_eq!($mat4::IDENTITY, scale_inv * scale);
+
+            let m = scale * rotz * trans;
+            let m_inv = m.inverse();
+            // assert_ne!(None, m_inv);
+            // let m_inv = m_inv.unwrap();
+            assert_approx_eq!($mat4::IDENTITY, m * m_inv, 1.0e-5);
+            assert_approx_eq!($mat4::IDENTITY, m_inv * m, 1.0e-5);
+            assert_approx_eq!(m_inv, trans_inv * rotz_inv * scale_inv, 1.0e-6);
+
+            // Make sure we can invert a "random" matrix:
+            let m = $mat4::from_cols(
+                $newvec4(1.0, -0.3, 1.0, 1.0),
+                $newvec4(0.5, 0.6, 0.7, 0.8),
+                $newvec4(-0.9, -0.3, 0.0, 12.0),
+                $newvec4(0.13, 0.14, 0.15, 0.16),
+            );
+            let m_inv = m.inverse();
+            assert_approx_eq!($mat4::IDENTITY, m * m_inv, 1.0e-5);
+            assert_approx_eq!($mat4::IDENTITY, m_inv * m, 1.0e-5);
+
+            should_glam_assert!({ $mat4::ZERO.inverse() });
+        });
+
+        glam_test!(test_mat4_decompose, {
+            // identity
+            let (out_scale, out_rotation, out_translation) =
+                $mat4::IDENTITY.to_scale_rotation_translation();
+            assert_approx_eq!($vec3::ONE, out_scale);
+            assert!(out_rotation.is_near_identity());
+            assert_approx_eq!($vec3::ZERO, out_translation);
+
+            // no scale
+            let in_scale = $vec3::ONE;
+            let in_translation = $vec3::new(-2.0, 4.0, -0.125);
+            let in_rotation = $quat::from_euler(
+                glam::EulerRot::YXZ,
+                $t::to_radians(-45.0),
+                $t::to_radians(180.0),
+                $t::to_radians(270.0),
+            );
+            let in_mat =
+                $mat4::from_scale_rotation_translation(in_scale, in_rotation, in_translation);
+            let (out_scale, out_rotation, out_translation) = in_mat.to_scale_rotation_translation();
+            assert_approx_eq!(in_scale, out_scale, 1e-6);
+            // out_rotation is different but produces the same matrix
+            // assert_approx_eq!(in_rotation, out_rotation);
+            assert_approx_eq!(in_translation, out_translation);
+            assert_approx_eq!(
+                in_mat,
+                $mat4::from_scale_rotation_translation(out_scale, out_rotation, out_translation),
+                1e-6
+            );
+
+            // positive scale
+            let in_scale = $vec3::new(1.0, 2.0, 4.0);
+            let in_mat =
+                $mat4::from_scale_rotation_translation(in_scale, in_rotation, in_translation);
+            let (out_scale, out_rotation, out_translation) = in_mat.to_scale_rotation_translation();
+            assert_approx_eq!(in_scale, out_scale, 1e-6);
+            // out_rotation is different but produces the same matrix
+            // assert_approx_eq!(in_rotation, out_rotation);
+            assert_approx_eq!(in_translation, out_translation);
+            assert_approx_eq!(
+                in_mat,
+                $mat4::from_scale_rotation_translation(out_scale, out_rotation, out_translation),
+                1e-5
+            );
+
+            // negative scale
+            let in_scale = $vec3::new(-4.0, 1.0, 2.0);
+            let in_mat =
+                $mat4::from_scale_rotation_translation(in_scale, in_rotation, in_translation);
+            let (out_scale, out_rotation, out_translation) = in_mat.to_scale_rotation_translation();
+            assert_approx_eq!(in_scale, out_scale, 1e-6);
+            // out_rotation is different but produces the same matrix
+            // assert_approx_eq!(in_rotation, out_rotation);
+            assert_approx_eq!(in_translation, out_translation);
+            assert_approx_eq!(
+                in_mat,
+                $mat4::from_scale_rotation_translation(out_scale, out_rotation, out_translation),
+                1e-5
+            );
+
+            // negative scale
+            let in_scale = $vec3::new(4.0, -1.0, -2.0);
+            let in_mat =
+                $mat4::from_scale_rotation_translation(in_scale, in_rotation, in_translation);
+            let (out_scale, out_rotation, out_translation) = in_mat.to_scale_rotation_translation();
+            // out_scale and out_rotation are different but they produce the same matrix
+            // assert_approx_eq!(in_scale, out_scale, 1e-6);
+            // assert_approx_eq!(in_rotation, out_rotation);
+            assert_approx_eq!(in_translation, out_translation);
+            assert_approx_eq!(
+                in_mat,
+                $mat4::from_scale_rotation_translation(out_scale, out_rotation, out_translation),
+                1e-6
+            );
+
+            should_glam_assert!({
+                $mat4::from_scale_rotation_translation(
+                    $vec3::ONE,
+                    $quat::from_xyzw(0.0, 0.0, 0.0, 0.0),
+                    $vec3::ZERO,
+                )
+            });
+            should_glam_assert!({
+                $mat4::from_rotation_translation($quat::from_xyzw(0.0, 0.0, 0.0, 0.0), $vec3::ZERO)
+            });
+            // TODO: should check scale
+            // should_glam_assert!({ $mat4::from_scale_rotation_translation($vec3::ZERO, $quat::IDENTITY, $vec3::ZERO) });
+            should_glam_assert!({ $mat4::ZERO.to_scale_rotation_translation() });
+        });
+
+        glam_test!(test_mat4_look_at, {
+            let eye = $vec3::new(0.0, 0.0, -5.0);
+            let center = $vec3::new(0.0, 0.0, 0.0);
+            let up = $vec3::new(1.0, 0.0, 0.0);
+
+            let point = $vec3::new(1.0, 0.0, 0.0);
+
+            let lh = $mat4::look_at_lh(eye, center, up);
+            let rh = $mat4::look_at_rh(eye, center, up);
+            assert_approx_eq!(lh.transform_point3(point), $vec3::new(0.0, 1.0, 5.0));
+            assert_approx_eq!(rh.transform_point3(point), $vec3::new(0.0, 1.0, -5.0));
+
+            let dir = center - eye;
+            let lh = $mat4::look_to_lh(eye, dir, up);
+            let rh = $mat4::look_to_rh(eye, dir, up);
+            assert_approx_eq!(lh.transform_point3(point), $vec3::new(0.0, 1.0, 5.0));
+            assert_approx_eq!(rh.transform_point3(point), $vec3::new(0.0, 1.0, -5.0));
+
+            should_glam_assert!({ $mat4::look_at_lh($vec3::ONE, $vec3::ZERO, $vec3::ZERO) });
+            should_glam_assert!({ $mat4::look_at_rh($vec3::ONE, $vec3::ZERO, $vec3::ZERO) });
+        });
+
+        glam_test!(test_mat4_perspective_gl_rh, {
+            let projection = $mat4::perspective_rh_gl($t::to_radians(90.0), 2.0, 5.0, 15.0);
+
+            let original = $vec3::new(5.0, 5.0, -15.0);
+            let projected = projection * original.extend(1.0);
+            assert_approx_eq!($vec4::new(2.5, 5.0, 15.0, 15.0), projected);
+
+            let original = $vec3::new(5.0, 5.0, -5.0);
+            let projected = projection * original.extend(1.0);
+            assert_approx_eq!($vec4::new(2.5, 5.0, -5.0, 5.0), projected);
+        });
+
+        glam_test!(test_mat4_perspective_lh, {
+            let projection = $mat4::perspective_lh($t::to_radians(90.0), 2.0, 5.0, 15.0);
+
+            let original = $vec3::new(5.0, 5.0, 15.0);
+            let projected = projection * original.extend(1.0);
+            assert_approx_eq!($vec4::new(2.5, 5.0, 15.0, 15.0), projected, 1e-6);
+
+            let original = $vec3::new(5.0, 5.0, 5.0);
+            let projected = projection * original.extend(1.0);
+            assert_approx_eq!($vec4::new(2.5, 5.0, 0.0, 5.0), projected, 1e-6);
+
+            should_glam_assert!({ $mat4::perspective_lh(0.0, 1.0, 1.0, 0.0) });
+            should_glam_assert!({ $mat4::perspective_lh(0.0, 1.0, 0.0, 1.0) });
+        });
+
+        glam_test!(test_mat4_perspective_infinite_lh, {
+            let projection = $mat4::perspective_infinite_lh($t::to_radians(90.0), 2.0, 5.0);
+
+            let original = $vec3::new(5.0, 5.0, 15.0);
+            let projected = projection * original.extend(1.0);
+            assert_approx_eq!($vec4::new(2.5, 5.0, 10.0, 15.0), projected, 1e-6);
+
+            let original = $vec3::new(5.0, 5.0, 5.0);
+            let projected = projection * original.extend(1.0);
+            assert_approx_eq!($vec4::new(2.5, 5.0, 0.0, 5.0), projected, 1e-6);
+
+            should_glam_assert!({ $mat4::perspective_infinite_lh(0.0, 1.0, 0.0) });
+        });
+
+        glam_test!(test_mat4_perspective_infinite_reverse_lh, {
+            let projection = $mat4::perspective_infinite_reverse_lh($t::to_radians(90.0), 2.0, 5.0);
+
+            let original = $vec3::new(5.0, 5.0, 15.0);
+            let projected = projection * original.extend(1.0);
+            assert_approx_eq!($vec4::new(2.5, 5.0, 5.0, 15.0), projected, 1e-6);
+
+            let original = $vec3::new(5.0, 5.0, 5.0);
+            let projected = projection * original.extend(1.0);
+            assert_approx_eq!($vec4::new(2.5, 5.0, 5.0, 5.0), projected, 1e-6);
+
+            should_glam_assert!({ $mat4::perspective_infinite_reverse_lh(0.0, 1.0, 0.0) });
+        });
+
+        glam_test!(test_mat4_perspective_rh, {
+            let projection = $mat4::perspective_rh($t::to_radians(90.0), 2.0, 5.0, 15.0);
+
+            let original = $vec3::new(5.0, 5.0, 15.0);
+            let projected = projection * original.extend(1.0);
+            assert_approx_eq!($vec4::new(2.5, 5.0, -30.0, -15.0), projected, 1e-6);
+
+            let original = $vec3::new(5.0, 5.0, 5.0);
+            let projected = projection * original.extend(1.0);
+            assert_approx_eq!($vec4::new(2.5, 5.0, -15.0, -5.0), projected, 1e-6);
+
+            should_glam_assert!({ $mat4::perspective_rh(0.0, 1.0, 1.0, 0.0) });
+            should_glam_assert!({ $mat4::perspective_rh(0.0, 1.0, 0.0, 1.0) });
+        });
+
+        glam_test!(test_mat4_perspective_infinite_rh, {
+            let projection = $mat4::perspective_infinite_rh($t::to_radians(90.0), 2.0, 5.0);
+
+            let original = $vec3::new(5.0, 5.0, 15.0);
+            let projected = projection * original.extend(1.0);
+            assert_approx_eq!($vec4::new(2.5, 5.0, -20.0, -15.0), projected);
+
+            let original = $vec3::new(5.0, 5.0, 5.0);
+            let projected = projection * original.extend(1.0);
+            assert_approx_eq!($vec4::new(2.5, 5.0, -10.0, -5.0), projected);
+
+            should_glam_assert!({ $mat4::perspective_infinite_rh(0.0, 1.0, 0.0) });
+        });
+
+        glam_test!(test_mat4_perspective_infinite_reverse_rh, {
+            let projection = $mat4::perspective_infinite_reverse_rh($t::to_radians(90.0), 2.0, 5.0);
+
+            let original = $vec3::new(5.0, 5.0, 15.0);
+            let projected = projection * original.extend(1.0);
+            assert_approx_eq!($vec4::new(2.5, 5.0, 5.0, -15.0), projected);
+
+            let original = $vec3::new(5.0, 5.0, 5.0);
+            let projected = projection * original.extend(1.0);
+            assert_approx_eq!($vec4::new(2.5, 5.0, 5.0, -5.0), projected);
+
+            should_glam_assert!({ $mat4::perspective_infinite_reverse_rh(0.0, 1.0, 0.0) });
+        });
+
+        glam_test!(test_mat4_orthographic_gl_rh, {
+            let projection = $mat4::orthographic_rh_gl(-10.0, 10.0, -5.0, 5.0, 0.0, -10.0);
+            let original = $vec4::new(5.0, 5.0, -5.0, 1.0);
+            let projected = projection.mul_vec4(original);
+            assert_approx_eq!(projected, $vec4::new(0.5, 1.0, -2.0, 1.0));
+        });
+
+        glam_test!(test_mat4_orthographic_rh, {
+            let projection = $mat4::orthographic_rh(-10.0, 10.0, -5.0, 5.0, -10.0, 10.0);
+            let original = $vec4::new(5.0, 5.0, -5.0, 1.0);
+            let projected = projection.mul_vec4(original);
+            assert_approx_eq!(projected, $vec4::new(0.5, 1.0, 0.75, 1.0));
+
+            let original = $vec4::new(5.0, 5.0, 5.0, 1.0);
+            let projected = projection.mul_vec4(original);
+            assert_approx_eq!(projected, $vec4::new(0.5, 1.0, 0.25, 1.0));
+        });
+
+        glam_test!(test_mat4_orthographic_lh, {
+            let projection = $mat4::orthographic_lh(-10.0, 10.0, -5.0, 5.0, -10.0, 10.0);
+            let original = $vec4::new(5.0, 5.0, -5.0, 1.0);
+            let projected = projection.mul_vec4(original);
+            assert_approx_eq!(projected, $vec4::new(0.5, 1.0, 0.25, 1.0));
+
+            let original = $vec4::new(5.0, 5.0, 5.0, 1.0);
+            let projected = projection.mul_vec4(original);
+            assert_approx_eq!(projected, $vec4::new(0.5, 1.0, 0.75, 1.0));
+        });
+
+        glam_test!(test_mat4_ops, {
+            let m0 = $mat4::from_cols_array_2d(&ARRAY4X4);
+            let m0x2 = $mat4::from_cols_array_2d(&[
+                [2.0, 4.0, 6.0, 8.0],
+                [10.0, 12.0, 14.0, 16.0],
+                [18.0, 20.0, 22.0, 24.0],
+                [26.0, 28.0, 30.0, 32.0],
+            ]);
+            let m0_neg = $mat4::from_cols_array_2d(&[
+                [-1.0, -2.0, -3.0, -4.0],
+                [-5.0, -6.0, -7.0, -8.0],
+                [-9.0, -10.0, -11.0, -12.0],
+                [-13.0, -14.0, -15.0, -16.0],
+            ]);
+            assert_eq!(m0x2, m0 * 2.0);
+            assert_eq!(m0x2, 2.0 * m0);
+            assert_eq!(m0, m0x2 / 2.0);
+            assert_eq!(m0, 2.0 / m0x2);
+            assert_eq!(m0x2, m0 + m0);
+            assert_eq!($mat4::ZERO, m0 - m0);
+            assert_eq!(m0_neg, -m0);
+            assert_approx_eq!(m0, m0 * $mat4::IDENTITY);
+            assert_approx_eq!(m0, $mat4::IDENTITY * m0);
+
+            let mut m1 = m0;
+            m1 *= 2.0;
+            assert_eq!(m0x2, m1);
+
+            let mut m1 = m0x2;
+            m1 /= 2.0;
+            assert_eq!(m0, m1);
+
+            let mut m1 = m0;
+            m1 += m0;
+            assert_eq!(m0x2, m1);
+
+            let mut m1 = m0;
+            m1 -= m0;
+            assert_eq!($mat4::ZERO, m1);
+
+            let mut m1 = $mat4::IDENTITY;
+            m1 *= m0;
+            assert_approx_eq!(m0, m1);
+        });
+
+        glam_test!(test_mat4_fmt, {
+            let a = $mat4::from_cols_array_2d(&ARRAY4X4);
+            assert_eq!(
+                format!("{}", a),
+                "[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]"
+            );
+            assert_eq!(
+                format!("{:.1}", a),
+                "[[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0], [9.0, 10.0, 11.0, 12.0], [13.0, 14.0, 15.0, 16.0]]"
+            );
+        });
+
+        glam_test!(test_mat4_to_from_slice, {
+            let m = $mat4::from_cols_slice(&ARRAY1X16);
+            assert_eq!($mat4::from_cols_array(&ARRAY1X16), m);
+            let mut out: [$t; 16] = Default::default();
+            m.write_cols_to_slice(&mut out);
+            assert_eq!(ARRAY1X16, out);
+
+            should_panic!({ $mat4::from_cols_slice(&[0.0; 15]) });
+            should_panic!({ $mat4::IDENTITY.write_cols_to_slice(&mut [0.0; 15]) });
+        });
+
+        glam_test!(test_sum, {
+            let id = $mat4::IDENTITY;
+            assert_eq!([id, id].iter().sum::<$mat4>(), id + id);
+            assert_eq!([id, id].into_iter().sum::<$mat4>(), id + id);
+        });
+
+        glam_test!(test_product, {
+            let two = $mat4::IDENTITY + $mat4::IDENTITY;
+            assert_eq!([two, two].iter().product::<$mat4>(), two * two);
+            assert_eq!([two, two].into_iter().product::<$mat4>(), two * two);
+        });
+
+        glam_test!(test_mat4_is_finite, {
+            assert!($mat4::IDENTITY.is_finite());
+            assert!(!($mat4::IDENTITY * $t::INFINITY).is_finite());
+            assert!(!($mat4::IDENTITY * $t::NEG_INFINITY).is_finite());
+            assert!(!($mat4::IDENTITY * $t::NAN).is_finite());
+        });
+
+        glam_test!(test_mat4_abs, {
+            let neg = $mat4::IDENTITY * -1.0;
+            assert_eq!(neg.abs(), $mat4::IDENTITY);
+
+            let partial_neg = $mat4::from_cols_array_2d(&[
+                [1.0, -2.0, 3.0, -4.0],
+                [-5.0, 6.0, -7.0, 8.0],
+                [-9.0, 10.0, 11.0, -12.0],
+                [13.0, -14.0, -15.0, 16.0],
+            ]);
+
+            assert_eq!(
+                partial_neg.abs(),
+                $mat4::from_cols_array_2d(&[
+                    [1.0, 2.0, 3.0, 4.0],
+                    [5.0, 6.0, 7.0, 8.0],
+                    [9.0, 10.0, 11.0, 12.0],
+                    [13.0, 14.0, 15.0, 16.0],
+                ])
+            );
+        });
+    };
+}
+
+macro_rules! impl_as_ref_tests {
+    ($mat:ident) => {
+        glam_test!(test_as_ref, {
+            let m = $mat::from_cols_array_2d(&ARRAY4X4);
+            assert_eq!(ARRAY1X16, *m.as_ref());
+        });
+        glam_test!(test_as_mut, {
+            let mut m = $mat::ZERO;
+            *m.as_mut() = ARRAY1X16;
+            assert_eq!($mat::from_cols_array_2d(&ARRAY4X4), m);
+        });
+    };
+}
+
+mod mat4 {
+    use super::support::deg;
+    use glam::{mat4, swizzles::*, vec3, vec4, Mat3, Mat4, Quat, Vec3, Vec4};
+
+    glam_test!(test_align, {
+        use std::mem;
+        assert_eq!(mem::align_of::<Vec4>(), mem::align_of::<Mat4>());
+        assert_eq!(64, mem::size_of::<Mat4>());
+    });
+
+    glam_test!(test_from_mat3a, {
+        use glam::Mat3A;
+        let m3 = Mat3A::from_cols_array_2d(&ARRAY3X3);
+        let m4 = Mat4::from_mat3a(m3);
+        assert_eq!(
+            Mat4::from_cols_array_2d(&[
+                [1.0, 2.0, 3.0, 0.0],
+                [4.0, 5.0, 6.0, 0.0],
+                [7.0, 8.0, 9.0, 0.0],
+                [0.0, 0.0, 0.0, 1.0]
+            ]),
+            m4
+        );
+    });
+
+    glam_test!(test_transform_vec3a, {
+        use glam::Vec3A;
+        let m = Mat4::from_axis_angle(Vec3::Z, deg(90.0));
+        let result3 = m.transform_vector3a(Vec3A::Y);
+        assert_approx_eq!(Vec3A::new(-1.0, 0.0, 0.0), result3);
+
+        let m = Mat4::from_scale_rotation_translation(
+            Vec3::new(0.5, 1.5, 2.0),
+            Quat::from_rotation_x(deg(90.0)),
+            Vec3::new(1.0, 2.0, 3.0),
+        );
+        let result3 = m.transform_vector3a(Vec3A::Y);
+        assert_approx_eq!(Vec3A::new(0.0, 0.0, 1.5), result3, 1.0e-6);
+
+        let result3 = m.transform_point3a(Vec3A::Y);
+        assert_approx_eq!(Vec3A::new(1.0, 2.0, 4.5), result3, 1.0e-6);
+
+        let m = Mat4::from_cols(
+            vec4(8.0, 0.0, 0.0, 0.0),
+            vec4(0.0, 4.0, 0.0, 0.0),
+            vec4(0.0, 0.0, 2.0, 2.0),
+            vec4(0.0, 0.0, 0.0, 0.0),
+        );
+        assert_approx_eq!(
+            Vec3A::new(4.0, 2.0, 1.0),
+            m.project_point3a(Vec3A::new(2.0, 2.0, 2.0))
+        );
+    });
+
+    glam_test!(test_as, {
+        use glam::DMat4;
+        assert_eq!(
+            DMat4::from_cols_array_2d(&[
+                [1.0, 2.0, 3.0, 4.0],
+                [5.0, 6.0, 7.0, 8.0],
+                [9.0, 10.0, 11.0, 12.0],
+                [13.0, 14.0, 15.0, 16.0]
+            ]),
+            Mat4::from_cols_array_2d(&[
+                [1.0, 2.0, 3.0, 4.0],
+                [5.0, 6.0, 7.0, 8.0],
+                [9.0, 10.0, 11.0, 12.0],
+                [13.0, 14.0, 15.0, 16.0]
+            ])
+            .as_dmat4()
+        );
+        assert_eq!(
+            Mat4::from_cols_array_2d(&[
+                [1.0, 2.0, 3.0, 4.0],
+                [5.0, 6.0, 7.0, 8.0],
+                [9.0, 10.0, 11.0, 12.0],
+                [13.0, 14.0, 15.0, 16.0]
+            ]),
+            DMat4::from_cols_array_2d(&[
+                [1.0, 2.0, 3.0, 4.0],
+                [5.0, 6.0, 7.0, 8.0],
+                [9.0, 10.0, 11.0, 12.0],
+                [13.0, 14.0, 15.0, 16.0]
+            ])
+            .as_mat4()
+        );
+    });
+
+    impl_mat4_tests!(f32, mat4, vec4, vec3, Mat4, Mat3, Quat, Vec4, Vec3);
+    impl_as_ref_tests!(Mat4);
+}
+
+mod dmat4 {
+    use super::support::deg;
+    use glam::{dmat4, dvec3, dvec4, swizzles::*, DMat3, DMat4, DQuat, DVec3, DVec4};
+
+    glam_test!(test_align, {
+        use std::mem;
+        assert_eq!(mem::align_of::<DVec4>(), mem::align_of::<DMat4>());
+        assert_eq!(128, mem::size_of::<DMat4>());
+    });
+
+    impl_mat4_tests!(f64, dmat4, dvec4, dvec3, DMat4, DMat3, DQuat, DVec4, DVec3);
+    impl_as_ref_tests!(DMat4);
+}

vendor/glam/tests/quat.rs

@@ -0,0 +1,697 @@
+#![allow(clippy::excessive_precision)]
+
+#[macro_use]
+mod support;
+
+macro_rules! impl_quat_tests {
+    ($t:ident, $new:ident, $mat3:ident, $mat4:ident, $quat:ident, $vec2:ident, $vec3:ident, $vec4:ident) => {
+        glam_test!(test_const, {
+            const Q0: $quat = $quat::from_xyzw(1.0, 2.0, 3.0, 4.0);
+            const Q1: $quat = $quat::from_array([1.0, 2.0, 3.0, 4.0]);
+            assert_eq!([1.0, 2.0, 3.0, 4.0], *Q0.as_ref());
+            assert_eq!([1.0, 2.0, 3.0, 4.0], *Q1.as_ref());
+        });
+
+        glam_test!(test_nan, {
+            assert!($quat::NAN.is_nan());
+            assert!(!$quat::NAN.is_finite());
+        });
+
+        glam_test!(test_new, {
+            let ytheta = deg(45.0);
+            let q0 = $quat::from_rotation_y(ytheta);
+
+            let v1 = $vec4::new(0.0, (ytheta * 0.5).sin(), 0.0, (ytheta * 0.5).cos());
+            assert_eq!(q0, $quat::from_vec4(v1));
+            let q1 = $quat::from_vec4(v1);
+            assert_eq!(v1, q1.into());
+
+            assert_eq!(q0, $new(v1.x, v1.y, v1.z, v1.w));
+
+            let a1: [$t; 4] = q1.into();
+            assert_eq!([v1.x, v1.y, v1.z, v1.w], a1);
+
+            assert_eq!(q1, $quat::from_array(a1));
+
+            assert_eq!(a1, *q0.as_ref());
+        });
+
+        glam_test!(test_funcs, {
+            let q0 = $quat::from_euler(EulerRot::YXZ, deg(45.0), deg(180.0), deg(90.0));
+            assert!(q0.is_normalized());
+            assert_approx_eq!(q0.length_squared(), 1.0);
+            assert_approx_eq!(q0.length(), 1.0);
+            assert_approx_eq!(q0.length_recip(), 1.0);
+            assert_approx_eq!(q0, q0.normalize());
+
+            assert_approx_eq!(q0.dot(q0), 1.0);
+            assert_approx_eq!(q0.dot(q0), 1.0);
+
+            let q1 = $quat::from_vec4($vec4::from(q0) * 2.0);
+            assert!(!q1.is_normalized());
+            assert_approx_eq!(q1.length_squared(), 4.0, 1.0e-6);
+            assert_approx_eq!(q1.length(), 2.0);
+            assert_approx_eq!(q1.length_recip(), 0.5);
+            assert_approx_eq!(q0, q1.normalize());
+            assert_approx_eq!(q0.dot(q1), 2.0, 1.0e-6);
+
+            should_glam_assert!({ ($quat::IDENTITY * 0.0).normalize() });
+        });
+
+        glam_test!(test_rotation, {
+            let zero = deg(0.0);
+            let yaw = deg(30.0);
+            let pitch = deg(60.0);
+            let roll = deg(90.0);
+            let y0 = $quat::from_rotation_y(yaw);
+            assert!(y0.is_normalized());
+            let (axis, angle) = y0.to_axis_angle();
+            assert_approx_eq!(axis, $vec3::Y, 1.0e-6);
+            assert_approx_eq!(angle, yaw);
+            let y1 = $quat::from_euler(EulerRot::YXZ, yaw, zero, zero);
+            assert_approx_eq!(y0, y1);
+            let y2 = $quat::from_axis_angle($vec3::Y, yaw);
+            assert_approx_eq!(y0, y2);
+            let y3 = $quat::from_mat3(&$mat3::from_rotation_y(yaw));
+            assert_approx_eq!(y0, y3);
+            let y4 = $quat::from_mat3(&$mat3::from_quat(y0));
+            assert_approx_eq!(y0, y4);
+
+            let x0 = $quat::from_rotation_x(pitch);
+            assert!(x0.is_normalized());
+            let (axis, angle) = x0.to_axis_angle();
+            assert_approx_eq!(axis, $vec3::X);
+            assert_approx_eq!(angle, pitch, 1e-6);
+            let x1 = $quat::from_euler(EulerRot::YXZ, zero, pitch, zero);
+            assert_approx_eq!(x0, x1);
+            let x2 = $quat::from_axis_angle($vec3::X, pitch);
+            assert_approx_eq!(x0, x2);
+            let x3 = $quat::from_mat4(&$mat4::from_rotation_x(deg(180.0)));
+            assert!(x3.is_normalized());
+            assert_approx_eq!($quat::from_rotation_x(deg(180.0)), x3);
+
+            let z0 = $quat::from_rotation_z(roll);
+            assert!(z0.is_normalized());
+            let (axis, angle) = z0.to_axis_angle();
+            assert_approx_eq!(axis, $vec3::Z);
+            assert_approx_eq!(angle, roll);
+            let z1 = $quat::from_euler(EulerRot::YXZ, zero, zero, roll);
+            assert_approx_eq!(z0, z1);
+            let z2 = $quat::from_axis_angle($vec3::Z, roll);
+            assert_approx_eq!(z0, z2);
+            let z3 = $quat::from_mat4(&$mat4::from_rotation_z(roll));
+            assert_approx_eq!(z0, z3);
+
+            let yx0 = y0 * x0;
+            assert!(yx0.is_normalized());
+            let yx1 = $quat::from_euler(EulerRot::YXZ, yaw, pitch, zero);
+            assert_approx_eq!(yx0, yx1);
+
+            let yxz0 = y0 * x0 * z0;
+            assert!(yxz0.is_normalized());
+            let yxz1 = $quat::from_euler(EulerRot::YXZ, yaw, pitch, roll);
+            assert_approx_eq!(yxz0, yxz1);
+
+            // use the conjugate of z0 to remove the rotation from yxz0
+            let yx2 = yxz0 * z0.conjugate();
+            assert_approx_eq!(yx0, yx2);
+            assert!((yxz0 * yxz0.conjugate()).is_near_identity());
+
+            // test inverse does the same
+            let yx2 = yxz0 * z0.inverse();
+            assert_approx_eq!(yx0, yx2);
+            assert!((yxz0 * yxz0.inverse()).is_near_identity());
+
+            let yxz2 = $quat::from_mat4(&$mat4::from_quat(yxz0));
+            assert_approx_eq!(yxz0, yxz2);
+
+            // if near identity, just returns x axis and 0 rotation
+            let (axis, angle) = $quat::IDENTITY.to_axis_angle();
+            assert_eq!(axis, $vec3::X);
+            assert_eq!(angle, rad(0.0));
+
+            let mut x0 = $quat::from_rotation_x(pitch);
+            x0 *= x0;
+            assert_approx_eq!(x0, $quat::from_rotation_x(pitch * 2.0));
+
+            should_glam_assert!({ ($quat::IDENTITY * 2.0).inverse() });
+            should_glam_assert!({ $quat::from_axis_angle($vec3::ZERO, 0.0) });
+        });
+
+        glam_test!(test_from_scaled_axis, {
+            assert_eq!($quat::from_scaled_axis($vec3::ZERO), $quat::IDENTITY);
+            assert_eq!(
+                $quat::from_scaled_axis($vec3::Y * 1e-10),
+                $quat::from_axis_angle($vec3::Y, 1e-10)
+            );
+            assert_eq!(
+                $quat::from_scaled_axis($vec3::X * 1.0),
+                $quat::from_axis_angle($vec3::X, 1.0)
+            );
+            assert_eq!(
+                $quat::from_scaled_axis($vec3::Z * 2.0),
+                $quat::from_axis_angle($vec3::Z, 2.0)
+            );
+
+            assert_eq!(
+                $quat::from_scaled_axis($vec3::ZERO).to_scaled_axis(),
+                $vec3::ZERO
+            );
+            for &v in &vec3_float_test_vectors!($vec3) {
+                if v.length() < core::$t::consts::PI {
+                    assert!(($quat::from_scaled_axis(v).to_scaled_axis() - v).length() < 1e-6,);
+                }
+            }
+        });
+
+        glam_test!(test_mul_vec3, {
+            let qrz = $quat::from_rotation_z(deg(90.0));
+            assert_approx_eq!($vec3::Y, qrz * $vec3::X);
+            assert_approx_eq!($vec3::Y, qrz.mul_vec3($vec3::X));
+            assert_approx_eq!($vec3::Y, -qrz * $vec3::X);
+            assert_approx_eq!($vec3::Y, qrz.neg().mul_vec3($vec3::X));
+            assert_approx_eq!(-$vec3::X, qrz * $vec3::Y);
+            assert_approx_eq!(-$vec3::X, qrz.mul_vec3($vec3::Y));
+            assert_approx_eq!(-$vec3::X, -qrz * $vec3::Y);
+            assert_approx_eq!(-$vec3::X, qrz.neg().mul_vec3($vec3::Y));
+
+            // check vec3 * mat3 is the same
+            let mrz = $mat3::from_quat(qrz);
+            assert_approx_eq!($vec3::Y, mrz * $vec3::X);
+            assert_approx_eq!($vec3::Y, mrz.mul_vec3($vec3::X));
+            // assert_approx_eq!($vec3::Y, -mrz * $vec3::X);
+            assert_approx_eq!(-$vec3::X, mrz * $vec3::Y);
+            assert_approx_eq!(-$vec3::X, mrz.mul_vec3($vec3::Y));
+
+            let qrx = $quat::from_rotation_x(deg(90.0));
+            assert_approx_eq!($vec3::X, qrx * $vec3::X);
+            assert_approx_eq!($vec3::X, qrx.mul_vec3($vec3::X));
+            assert_approx_eq!($vec3::X, -qrx * $vec3::X);
+            assert_approx_eq!($vec3::X, qrx.neg().mul_vec3($vec3::X));
+            assert_approx_eq!($vec3::Z, qrx * $vec3::Y);
+            assert_approx_eq!($vec3::Z, qrx.mul_vec3($vec3::Y));
+            assert_approx_eq!($vec3::Z, -qrx * $vec3::Y);
+            assert_approx_eq!($vec3::Z, qrx.neg().mul_vec3($vec3::Y));
+
+            // check vec3 * mat3 is the same
+            let mrx = $mat3::from_quat(qrx);
+            assert_approx_eq!($vec3::X, mrx * $vec3::X);
+            assert_approx_eq!($vec3::X, mrx.mul_vec3($vec3::X));
+            assert_approx_eq!($vec3::Z, mrx * $vec3::Y);
+            assert_approx_eq!($vec3::Z, mrx.mul_vec3($vec3::Y));
+
+            let qrxz = qrz * qrx;
+            assert_approx_eq!($vec3::Y, qrxz * $vec3::X);
+            assert_approx_eq!($vec3::Y, qrxz.mul_vec3($vec3::X));
+            assert_approx_eq!($vec3::Z, qrxz * $vec3::Y);
+            assert_approx_eq!($vec3::Z, qrxz.mul_vec3($vec3::Y));
+
+            let mrxz = mrz * mrx;
+            assert_approx_eq!($vec3::Y, mrxz * $vec3::X);
+            assert_approx_eq!($vec3::Y, mrxz.mul_vec3($vec3::X));
+            assert_approx_eq!($vec3::Z, mrxz * $vec3::Y);
+            assert_approx_eq!($vec3::Z, mrxz.mul_vec3($vec3::Y));
+
+            let qrzx = qrx * qrz;
+            assert_approx_eq!($vec3::Z, qrzx * $vec3::X);
+            assert_approx_eq!($vec3::Z, qrzx.mul_vec3($vec3::X));
+            assert_approx_eq!(-$vec3::X, qrzx * $vec3::Y);
+            assert_approx_eq!(-$vec3::X, qrzx.mul_vec3($vec3::Y));
+
+            let mrzx = qrx * qrz;
+            assert_approx_eq!($vec3::Z, mrzx * $vec3::X);
+            assert_approx_eq!($vec3::Z, mrzx.mul_vec3($vec3::X));
+            assert_approx_eq!(-$vec3::X, mrzx * $vec3::Y);
+            assert_approx_eq!(-$vec3::X, mrzx.mul_vec3($vec3::Y));
+
+            should_glam_assert!({ ($quat::IDENTITY * 0.5).mul_vec3($vec3::X) });
+            should_glam_assert!({ ($quat::IDENTITY * 0.5) * $vec3::X });
+        });
+
+        glam_test!(test_angle_between, {
+            const TAU: $t = 2.0 * core::$t::consts::PI;
+            let eps = 10.0 * $t::EPSILON as f32;
+            let q1 = $quat::from_euler(EulerRot::YXZ, 0.0, 0.0, 0.0);
+            let q2 = $quat::from_euler(EulerRot::YXZ, TAU * 0.25, 0.0, 0.0);
+            let q3 = $quat::from_euler(EulerRot::YXZ, TAU * 0.5, 0.0, 0.0);
+            let q4 = $quat::from_euler(EulerRot::YXZ, 0.0, 0.0, TAU * 0.25);
+            let q5 = $quat::from_axis_angle($vec3::new(1.0, 2.0, 3.0).normalize(), TAU * 0.3718);
+            let q6 = $quat::from_axis_angle($vec3::new(-1.0, 5.0, 3.0).normalize(), TAU * 0.94);
+            assert_approx_eq!(q1.angle_between(q2), TAU * 0.25, eps);
+            assert_approx_eq!(q1.angle_between(q3), TAU * 0.5, eps);
+            assert_approx_eq!(q3.angle_between(q3), 0.0, eps);
+            assert_approx_eq!(q3.angle_between(-q3), 0.0, eps);
+            assert_approx_eq!((q4 * q2 * q2).angle_between(q4 * q2), TAU * 0.25, eps);
+            assert_approx_eq!(q1.angle_between(q5), TAU * 0.3718, eps);
+            assert_approx_eq!(
+                (q5 * q2 * q1).angle_between(q5 * q2 * q5),
+                TAU * 0.3718,
+                eps
+            );
+            assert_approx_eq!((q3 * q3).angle_between(q1), 0.0, eps);
+            assert_approx_eq!((q3 * q3 * q3).angle_between(q3), 0.0, eps);
+            assert_approx_eq!((q3 * q3 * q3 * q3).angle_between(q1), 0.0, eps);
+            assert_approx_eq!(q1.angle_between(q6), TAU - TAU * 0.94, eps);
+            assert_approx_eq!((q5 * q1).angle_between(q5 * q6), TAU - TAU * 0.94, eps);
+            assert_approx_eq!((q1 * q5).angle_between(q6 * q5), TAU - TAU * 0.94, eps);
+        });
+
+        glam_test!(test_lerp, {
+            let q0 = $quat::from_rotation_y(deg(0.0));
+            assert_approx_eq!(q0, q0.slerp(q0, 0.0));
+            assert_approx_eq!(q0, q0.slerp(q0, 1.0));
+
+            let q1 = $quat::from_rotation_y(deg(90.0));
+            assert_approx_eq!(q0, q0.lerp(q1, 0.0));
+            assert_approx_eq!(q1, q0.lerp(q1, 1.0));
+            assert_approx_eq!($quat::from_rotation_y(deg(45.0)), q0.lerp(q1, 0.5));
+
+            should_glam_assert!({ $quat::lerp($quat::IDENTITY * 2.0, $quat::IDENTITY, 1.0) });
+            should_glam_assert!({ $quat::lerp($quat::IDENTITY, $quat::IDENTITY * 0.5, 1.0) });
+        });
+
+        glam_test!(test_slerp, {
+            let q0 = $quat::from_rotation_y(deg(0.0));
+            assert_approx_eq!(q0, q0.slerp(q0, 0.0));
+            assert_approx_eq!(q0, q0.slerp(q0, 1.0));
+
+            let q1 = $quat::from_rotation_y(deg(90.0));
+            assert_approx_eq!(q0, q0.slerp(q1, 0.0), 1.0e-3);
+            assert_approx_eq!(q1, q0.slerp(q1, 1.0), 1.0e-3);
+            assert_approx_eq!($quat::from_rotation_y(deg(45.0)), q0.slerp(q1, 0.5), 1.0e-3);
+
+            should_glam_assert!({ $quat::slerp($quat::IDENTITY * 2.0, $quat::IDENTITY, 1.0) });
+            should_glam_assert!({ $quat::slerp($quat::IDENTITY, $quat::IDENTITY * 0.5, 1.0) });
+        });
+
+        glam_test!(test_slerp_constant_speed, {
+            let step = 0.01;
+            let mut s = 0.0;
+            while s <= 1.0 {
+                let q0 = $quat::from_rotation_y(deg(0.0));
+                let q1 = $quat::from_rotation_y(deg(90.0));
+                let result = q0.slerp(q1, s);
+                assert_approx_eq!($quat::from_rotation_y(deg(s * 90.0)), result, 1.0e-3);
+                assert!(result.is_normalized());
+                s += step;
+            }
+        });
+
+        glam_test!(test_slerp_tau, {
+            let q1 = $quat::IDENTITY;
+            let q2 = $quat::from_rotation_x(core::$t::consts::TAU);
+            let s = q1.slerp(q2, 1.);
+            assert!(s.is_finite());
+            assert!(s.is_normalized());
+        });
+
+        glam_test!(test_slerp_negative_tau, {
+            let q1 = $quat::IDENTITY;
+            let q2 = $quat::from_rotation_x(-core::$t::consts::TAU);
+            let s = q1.slerp(q2, 1.);
+            assert!(s.is_finite());
+            assert!(s.is_normalized());
+        });
+
+        glam_test!(test_slerp_pi, {
+            let q1 = $quat::IDENTITY;
+            let q2 = $quat::from_rotation_x(core::$t::consts::PI);
+            let s = q1.slerp(q2, 1.);
+            assert!(s.is_finite());
+            assert!(s.is_normalized());
+        });
+
+        glam_test!(test_slerp_negative_pi, {
+            let q1 = $quat::IDENTITY;
+            let q2 = $quat::from_rotation_x(-core::$t::consts::PI);
+            let s = q1.slerp(q2, 1.);
+            assert!(s.is_finite());
+            assert!(s.is_normalized());
+        });
+
+        glam_test!(test_rotate_towards, {
+            use core::$t::consts::{FRAC_PI_2, FRAC_PI_4};
+            let eps = 10.0 * $t::EPSILON as f32;
+
+            // Setup such that `q0` is `PI/2` and `-PI/2` radians away from `q1` and `q2` respectively.
+            let q0 = $quat::from_euler(EulerRot::YXZ, 0.0, 0.0, 0.0);
+            let q1 = $quat::from_euler(EulerRot::YXZ, FRAC_PI_2, 0.0, 0.0);
+            let q2 = $quat::from_euler(EulerRot::YXZ, -FRAC_PI_2, 0.0, 0.0);
+
+            // Positive delta
+            assert_approx_eq!(q0, q0.rotate_towards(q1, 0.0), eps);
+            assert_approx_eq!(
+                $quat::from_euler(EulerRot::YXZ, FRAC_PI_4, 0.0, 0.0),
+                q0.rotate_towards(q1, FRAC_PI_4),
+                eps
+            );
+            assert_approx_eq!(q1, q0.rotate_towards(q1, FRAC_PI_2), eps);
+            assert_approx_eq!(q1, q0.rotate_towards(q1, FRAC_PI_2 * 1.5), eps);
+
+            // Negative delta
+            assert_approx_eq!(
+                $quat::from_euler(EulerRot::YXZ, -FRAC_PI_4, 0.0, 0.0),
+                q0.rotate_towards(q1, -FRAC_PI_4),
+                eps
+            );
+            assert_approx_eq!(q2, q0.rotate_towards(q1, -FRAC_PI_2), eps);
+            assert_approx_eq!(q2, q0.rotate_towards(q1, -FRAC_PI_2 * 1.5), eps);
+        });
+
+        glam_test!(test_fmt, {
+            let a = $quat::IDENTITY;
+            assert_eq!(
+                format!("{:?}", a),
+                format!("{}(0.0, 0.0, 0.0, 1.0)", stringify!($quat))
+            );
+            // assert_eq!(
+            //     format!("{:#?}", a),
+            //     "$quat(\n    1.0,\n    2.0,\n    3.0,\n    4.0\n)"
+            // );
+            assert_eq!(format!("{}", a), "[0, 0, 0, 1]");
+            assert_eq!(format!("{:.2}", a), "[0.00, 0.00, 0.00, 1.00]");
+        });
+
+        glam_test!(test_identity, {
+            let identity = $quat::IDENTITY;
+            assert!(identity.is_near_identity());
+            assert!(identity.is_normalized());
+            assert_eq!(identity, $quat::from_xyzw(0.0, 0.0, 0.0, 1.0));
+            assert_eq!(identity, identity * identity);
+            let q = $quat::from_euler(EulerRot::YXZ, deg(10.0), deg(-10.0), deg(45.0));
+            assert_eq!(q, q * identity);
+            assert_eq!(q, identity * q);
+            assert_eq!(identity, $quat::default());
+        });
+
+        glam_test!(test_slice, {
+            let a: [$t; 4] =
+                $quat::from_euler(EulerRot::YXZ, deg(30.0), deg(60.0), deg(90.0)).into();
+            let b = $quat::from_slice(&a);
+            let c: [$t; 4] = b.into();
+            assert_eq!(a, c);
+            let mut d = [0.0, 0.0, 0.0, 0.0];
+            b.write_to_slice(&mut d[..]);
+            assert_eq!(a, d);
+
+            should_panic!({ $quat::IDENTITY.write_to_slice(&mut [0 as $t; 3]) });
+            should_panic!({ $quat::from_slice(&[0 as $t; 3]) });
+        });
+
+        glam_test!(test_elements, {
+            let x = 1.0;
+            let y = 2.0;
+            let z = 3.0;
+            let w = 4.0;
+
+            let a = $quat::from_xyzw(x, y, z, w);
+            assert!(a.x == x);
+            assert!(a.y == y);
+            assert!(a.z == z);
+            assert!(a.w == w);
+
+            assert_eq!($vec3::new(1.0, 2.0, 3.0), a.xyz());
+        });
+
+        glam_test!(test_addition, {
+            let a = $quat::from_xyzw(1.0, 2.0, 3.0, 4.0);
+            let b = $quat::from_xyzw(5.0, 6.0, 7.0, -9.0);
+            assert_eq!(a + b, $quat::from_xyzw(6.0, 8.0, 10.0, -5.0));
+        });
+
+        glam_test!(test_subtraction, {
+            let a = $quat::from_xyzw(6.0, 8.0, 10.0, -5.0);
+            let b = $quat::from_xyzw(5.0, 6.0, 7.0, -9.0);
+            assert_eq!(a - b, $quat::from_xyzw(1.0, 2.0, 3.0, 4.0));
+        });
+
+        glam_test!(test_scalar_multiplication, {
+            let a = $quat::from_xyzw(1.0, 2.0, 3.0, 4.0);
+            assert_eq!(a * 2.0, $quat::from_xyzw(2.0, 4.0, 6.0, 8.0));
+        });
+
+        glam_test!(test_scalar_division, {
+            let a = $quat::from_xyzw(2.0, 4.0, 6.0, 8.0);
+            assert_eq!(a / 2.0, $quat::from_xyzw(1.0, 2.0, 3.0, 4.0));
+        });
+
+        glam_test!(test_sum, {
+            let two = $new(2.0, 2.0, 2.0, 2.0);
+            assert_eq!([two, two].iter().sum::<$quat>(), two + two);
+            assert_eq!([two, two].into_iter().sum::<$quat>(), two + two);
+        });
+
+        glam_test!(test_product, {
+            let two = $new(2.0, 2.0, 2.0, 2.0).normalize();
+            assert_eq!([two, two].iter().product::<$quat>(), two * two);
+            assert_eq!([two, two].into_iter().product::<$quat>(), two * two);
+        });
+
+        glam_test!(test_is_finite, {
+            assert!($quat::from_xyzw(0.0, 0.0, 0.0, 0.0).is_finite());
+            assert!($quat::from_xyzw(-1e-10, 1.0, 1e10, 42.0).is_finite());
+            assert!(!$quat::from_xyzw($t::INFINITY, 0.0, 0.0, 0.0).is_finite());
+            assert!(!$quat::from_xyzw(0.0, $t::NAN, 0.0, 0.0).is_finite());
+            assert!(!$quat::from_xyzw(0.0, 0.0, $t::NEG_INFINITY, 0.0).is_finite());
+            assert!(!$quat::from_xyzw(0.0, 0.0, 0.0, $t::NAN).is_finite());
+        });
+
+        glam_test!(test_rotation_arc, {
+            let eps = 2.0 * $t::EPSILON.sqrt();
+
+            for &from in &vec3_float_test_vectors!($vec3) {
+                let from = from.normalize();
+
+                {
+                    let q = $quat::from_rotation_arc(from, from);
+                    assert!(q.is_near_identity(), "from: {}, q: {}", from, q);
+                }
+
+                {
+                    let q = $quat::from_rotation_arc_colinear(from, from);
+                    assert!(q.is_near_identity(), "from: {}, q: {}", from, q);
+                }
+
+                {
+                    let to = -from;
+                    let q = $quat::from_rotation_arc(from, to);
+                    assert!(q.is_normalized());
+                    assert!((q * from - to).length() < eps);
+                }
+
+                {
+                    let to = -from;
+                    let q = $quat::from_rotation_arc_colinear(from, to);
+                    assert!(q.is_near_identity(), "from: {}, q: {}", from, q);
+                }
+
+                for &to in &vec3_float_test_vectors!($vec3) {
+                    let to = to.normalize();
+
+                    let q = $quat::from_rotation_arc(from, to);
+                    assert!(q.is_normalized());
+                    assert!((q * from - to).length() < eps);
+
+                    let q = $quat::from_rotation_arc_colinear(from, to);
+                    assert!(q.is_normalized());
+                    let transformed = q * from;
+                    assert!(
+                        (transformed - to).length() < eps || (-transformed - to).length() < eps
+                    );
+                }
+            }
+
+            for &from in &vec2_float_test_vectors!($vec2) {
+                let from = from.normalize();
+
+                {
+                    let q = $quat::from_rotation_arc_2d(from, from);
+                    assert!(q.is_near_identity(), "from: {}, q: {}", from, q);
+                }
+
+                {
+                    let to = -from;
+                    let q = $quat::from_rotation_arc_2d(from, to);
+                    assert!(q.is_normalized());
+                    assert!((q * from.extend(0.0) - to.extend(0.0)).length() < eps);
+                }
+
+                for &to in &vec2_float_test_vectors!($vec2) {
+                    let to = to.normalize();
+
+                    let q = $quat::from_rotation_arc_2d(from, to);
+                    assert!(q.is_normalized());
+                    assert!((q * from.extend(0.0) - to.extend(0.0)).length() < eps);
+                }
+            }
+
+            should_glam_assert!({ $quat::from_rotation_arc($vec3::ZERO, $vec3::X) });
+            should_glam_assert!({ $quat::from_rotation_arc($vec3::X, $vec3::ZERO) });
+            should_glam_assert!({ $quat::from_rotation_arc_colinear($vec3::ZERO, $vec3::X) });
+            should_glam_assert!({ $quat::from_rotation_arc_colinear($vec3::X, $vec3::ZERO) });
+
+            should_glam_assert!({ $quat::from_rotation_arc_2d($vec2::ZERO, $vec2::X) });
+            should_glam_assert!({ $quat::from_rotation_arc_2d($vec2::X, $vec2::ZERO) });
+        });
+
+        glam_test!(test_to_array, {
+            assert!($new(1.0, 2.0, 3.0, 4.0).to_array() == [1.0, 2.0, 3.0, 4.0]);
+        });
+
+        glam_test!(test_to_axis_angle, {
+            {
+                let q = $quat::from_xyzw(
+                    5.28124762e-08,
+                    -5.12559303e-03,
+                    8.29266140e-08,
+                    9.99986828e-01,
+                );
+                assert!(q.is_normalized());
+                let (axis, angle) = q.to_axis_angle();
+                assert!(axis.is_normalized());
+                let q2 = $quat::from_axis_angle(axis, angle);
+                assert!((q.dot(q2) - 1.0).abs() < 1e-6);
+            }
+            {
+                let q = $quat::IDENTITY;
+                let (axis, angle) = q.to_axis_angle();
+                assert!(axis.is_normalized());
+                let q2 = $quat::from_axis_angle(axis, angle);
+                assert!((q.dot(q2) - 1.0).abs() < 1e-6);
+            }
+            {
+                let q = $quat::from_xyzw(0.0, 1.0, 0.0, 0.0);
+                assert!(q.is_normalized());
+                let (axis, angle) = q.to_axis_angle();
+                assert!(axis.is_normalized());
+                let q2 = $quat::from_axis_angle(axis, angle);
+                assert!((q.dot(q2) - 1.0).abs() < 1e-6);
+            }
+            {
+                let axis = $vec3::Z;
+                let angle = core::$t::consts::PI * 0.25;
+                let q = $quat::from_axis_angle(axis, angle);
+                assert!(q.is_normalized());
+                let (axis2, angle2) = q.to_axis_angle();
+                assert!(axis.is_normalized());
+                assert_approx_eq!(axis, axis2);
+                assert_approx_eq!(angle, angle2);
+            }
+        });
+    };
+}
+
+mod quat {
+    use crate::support::{deg, rad};
+    use core::ops::Neg;
+    use glam::{quat, EulerRot, Mat3, Mat4, Quat, Vec2, Vec3, Vec3A, Vec4};
+
+    glam_test!(test_align, {
+        use std::mem;
+        assert_eq!(16, mem::size_of::<Quat>());
+        if cfg!(feature = "scalar-math") {
+            assert_eq!(4, mem::align_of::<Quat>());
+        } else {
+            assert_eq!(16, mem::align_of::<Quat>());
+        }
+    });
+
+    glam_test!(test_mul_vec3a, {
+        let qrz = Quat::from_rotation_z(deg(90.0));
+        assert_approx_eq!(Vec3A::Y, qrz * Vec3A::X);
+        assert_approx_eq!(Vec3A::Y, qrz.mul_vec3a(Vec3A::X));
+        assert_approx_eq!(Vec3A::Y, -qrz * Vec3A::X);
+        assert_approx_eq!(Vec3A::Y, qrz.neg().mul_vec3a(Vec3A::X));
+        assert_approx_eq!(-Vec3A::X, qrz * Vec3A::Y);
+        assert_approx_eq!(-Vec3A::X, qrz.mul_vec3a(Vec3A::Y));
+        assert_approx_eq!(-Vec3A::X, -qrz * Vec3A::Y);
+        assert_approx_eq!(-Vec3A::X, qrz.neg().mul_vec3a(Vec3A::Y));
+
+        // check vec3 * mat3 is the same
+        let mrz = Mat3::from_quat(qrz);
+        assert_approx_eq!(Vec3A::Y, mrz * Vec3A::X);
+        assert_approx_eq!(Vec3A::Y, mrz.mul_vec3a(Vec3A::X));
+        // assert_approx_eq!(Vec3A::Y, -mrz * Vec3A::X);
+        assert_approx_eq!(-Vec3A::X, mrz * Vec3A::Y);
+        assert_approx_eq!(-Vec3A::X, mrz.mul_vec3a(Vec3A::Y));
+
+        let qrx = Quat::from_rotation_x(deg(90.0));
+        assert_approx_eq!(Vec3A::X, qrx * Vec3A::X);
+        assert_approx_eq!(Vec3A::X, qrx.mul_vec3a(Vec3A::X));
+        assert_approx_eq!(Vec3A::X, -qrx * Vec3A::X);
+        assert_approx_eq!(Vec3A::X, qrx.neg().mul_vec3a(Vec3A::X));
+        assert_approx_eq!(Vec3A::Z, qrx * Vec3A::Y);
+        assert_approx_eq!(Vec3A::Z, qrx.mul_vec3a(Vec3A::Y));
+        assert_approx_eq!(Vec3A::Z, -qrx * Vec3A::Y);
+        assert_approx_eq!(Vec3A::Z, qrx.neg().mul_vec3a(Vec3A::Y));
+
+        // check vec3 * mat3 is the same
+        let mrx = Mat3::from_quat(qrx);
+        assert_approx_eq!(Vec3A::X, mrx * Vec3A::X);
+        assert_approx_eq!(Vec3A::X, mrx.mul_vec3a(Vec3A::X));
+        assert_approx_eq!(Vec3A::Z, mrx * Vec3A::Y);
+        assert_approx_eq!(Vec3A::Z, mrx.mul_vec3a(Vec3A::Y));
+
+        let qrxz = qrz * qrx;
+        assert_approx_eq!(Vec3A::Y, qrxz * Vec3A::X);
+        assert_approx_eq!(Vec3A::Y, qrxz.mul_vec3a(Vec3A::X));
+        assert_approx_eq!(Vec3A::Z, qrxz * Vec3A::Y);
+        assert_approx_eq!(Vec3A::Z, qrxz.mul_vec3a(Vec3A::Y));
+
+        let mrxz = mrz * mrx;
+        assert_approx_eq!(Vec3A::Y, mrxz * Vec3A::X);
+        assert_approx_eq!(Vec3A::Y, mrxz.mul_vec3a(Vec3A::X));
+        assert_approx_eq!(Vec3A::Z, mrxz * Vec3A::Y);
+        assert_approx_eq!(Vec3A::Z, mrxz.mul_vec3a(Vec3A::Y));
+
+        let qrzx = qrx * qrz;
+        assert_approx_eq!(Vec3A::Z, qrzx * Vec3A::X);
+        assert_approx_eq!(Vec3A::Z, qrzx.mul_vec3a(Vec3A::X));
+        assert_approx_eq!(-Vec3A::X, qrzx * Vec3A::Y);
+        assert_approx_eq!(-Vec3A::X, qrzx.mul_vec3a(Vec3A::Y));
+
+        let mrzx = qrx * qrz;
+        assert_approx_eq!(Vec3A::Z, mrzx * Vec3A::X);
+        assert_approx_eq!(Vec3A::Z, mrzx.mul_vec3a(Vec3A::X));
+        assert_approx_eq!(-Vec3A::X, mrzx * Vec3A::Y);
+        assert_approx_eq!(-Vec3A::X, mrzx.mul_vec3a(Vec3A::Y));
+    });
+
+    glam_test!(test_from_mat3a, {
+        use glam::Mat3A;
+        let yaw = deg(30.0);
+        let y0 = Quat::from_rotation_y(yaw);
+        let y1 = Quat::from_mat3a(&Mat3A::from_rotation_y(yaw));
+        assert_approx_eq!(y0, y1);
+        let y2 = Quat::from_mat3a(&Mat3A::from_quat(y0));
+        assert_approx_eq!(y0, y2);
+    });
+
+    glam_test!(test_as, {
+        use glam::DQuat;
+        assert_approx_eq!(
+            DQuat::from_euler(EulerRot::YXZ, 1.0, 2.0, 3.0),
+            Quat::from_euler(EulerRot::YXZ, 1.0, 2.0, 3.0).as_dquat()
+        );
+        assert_approx_eq!(
+            Quat::from_euler(EulerRot::YXZ, 1.0, 2.0, 3.0),
+            DQuat::from_euler(EulerRot::YXZ, 1.0, 2.0, 3.0).as_quat()
+        );
+    });
+
+    impl_quat_tests!(f32, quat, Mat3, Mat4, Quat, Vec2, Vec3, Vec4);
+}
+
+mod dquat {
+    use crate::support::{deg, rad};
+    use core::ops::Neg;
+    use glam::{dquat, DMat3, DMat4, DQuat, DVec2, DVec3, DVec4, EulerRot};
+
+    glam_test!(test_align, {
+        use std::mem;
+        assert_eq!(32, mem::size_of::<DQuat>());
+        assert_eq!(mem::align_of::<f64>(), mem::align_of::<DQuat>());
+    });
+
+    impl_quat_tests!(f64, dquat, DMat3, DMat4, DQuat, DVec2, DVec3, DVec4);
+}

vendor/glam/tests/support.rs

@@ -0,0 +1,282 @@
+#![allow(dead_code)]
+#[path = "support/macros.rs"]
+#[macro_use]
+mod macros;
+
+#[cfg(target_arch = "wasm32")]
+wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser);
+
+use glam::{
+    DMat2, DMat3, DMat4, DQuat, DVec2, DVec3, DVec4, Mat2, Mat3, Mat3A, Mat4, Quat, Vec2, Vec3,
+    Vec3A, Vec4,
+};
+
+pub trait Deg {
+    fn to_radians(self) -> Self;
+}
+
+impl Deg for f32 {
+    fn to_radians(self) -> f32 {
+        f32::to_radians(self)
+    }
+}
+
+impl Deg for f64 {
+    fn to_radians(self) -> f64 {
+        f64::to_radians(self)
+    }
+}
+
+/// Helper function for migrating away from `glam::angle::deg`.
+#[allow(dead_code)]
+#[inline]
+pub fn deg<T: Deg>(angle: T) -> T {
+    angle.to_radians()
+}
+
+/// Helper function for migrating away from `glam::angle::rad`.
+#[allow(dead_code)]
+#[inline]
+pub fn rad<T>(angle: T) -> T {
+    angle
+}
+
+/// Trait used by the `assert_approx_eq` macro for floating point comparisons.
+pub trait FloatCompare<Rhs: ?Sized = Self> {
+    /// Return true if the absolute difference between `self` and `other` is
+    /// less then or equal to `max_abs_diff`.
+    fn approx_eq(&self, other: &Rhs, max_abs_diff: f32) -> bool;
+    /// Returns the absolute difference of `self` and `other` which is printed
+    /// if `assert_approx_eq` fails.
+    fn abs_diff(&self, other: &Rhs) -> Rhs;
+}
+
+impl FloatCompare for f32 {
+    #[inline]
+    fn approx_eq(&self, other: &f32, max_abs_diff: f32) -> bool {
+        (self - other).abs() <= max_abs_diff
+    }
+    #[inline]
+    fn abs_diff(&self, other: &f32) -> f32 {
+        (self - other).abs()
+    }
+}
+
+impl FloatCompare for f64 {
+    #[inline]
+    fn approx_eq(&self, other: &f64, max_abs_diff: f32) -> bool {
+        (self - other).abs() <= max_abs_diff as f64
+    }
+    #[inline]
+    fn abs_diff(&self, other: &f64) -> f64 {
+        (self - other).abs()
+    }
+}
+
+impl FloatCompare for Mat2 {
+    #[inline]
+    fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
+        self.abs_diff_eq(*other, max_abs_diff)
+    }
+    #[inline]
+    fn abs_diff(&self, other: &Self) -> Self {
+        Self::from_cols(
+            (self.x_axis - other.x_axis).abs(),
+            (self.y_axis - other.y_axis).abs(),
+        )
+    }
+}
+
+impl FloatCompare for DMat2 {
+    #[inline]
+    fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
+        self.abs_diff_eq(*other, max_abs_diff as f64)
+    }
+    #[inline]
+    fn abs_diff(&self, other: &Self) -> Self {
+        Self::from_cols(
+            (self.x_axis - other.x_axis).abs(),
+            (self.y_axis - other.y_axis).abs(),
+        )
+    }
+}
+
+impl FloatCompare for Mat3 {
+    #[inline]
+    fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
+        self.abs_diff_eq(*other, max_abs_diff)
+    }
+    #[inline]
+    fn abs_diff(&self, other: &Self) -> Self {
+        Self::from_cols(
+            (self.x_axis - other.x_axis).abs(),
+            (self.y_axis - other.y_axis).abs(),
+            (self.z_axis - other.z_axis).abs(),
+        )
+    }
+}
+
+impl FloatCompare for Mat3A {
+    #[inline]
+    fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
+        self.abs_diff_eq(*other, max_abs_diff)
+    }
+    #[inline]
+    fn abs_diff(&self, other: &Self) -> Self {
+        Self::from_cols(
+            (self.x_axis - other.x_axis).abs(),
+            (self.y_axis - other.y_axis).abs(),
+            (self.z_axis - other.z_axis).abs(),
+        )
+    }
+}
+
+impl FloatCompare for DMat3 {
+    #[inline]
+    fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
+        self.abs_diff_eq(*other, max_abs_diff as f64)
+    }
+    #[inline]
+    fn abs_diff(&self, other: &Self) -> Self {
+        Self::from_cols(
+            (self.x_axis - other.x_axis).abs(),
+            (self.y_axis - other.y_axis).abs(),
+            (self.z_axis - other.z_axis).abs(),
+        )
+    }
+}
+
+impl FloatCompare for DMat4 {
+    #[inline]
+    fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
+        self.abs_diff_eq(*other, max_abs_diff as f64)
+    }
+    #[inline]
+    fn abs_diff(&self, other: &Self) -> Self {
+        Self::from_cols(
+            (self.x_axis - other.x_axis).abs(),
+            (self.y_axis - other.y_axis).abs(),
+            (self.z_axis - other.z_axis).abs(),
+            (self.w_axis - other.w_axis).abs(),
+        )
+    }
+}
+
+impl FloatCompare for Mat4 {
+    #[inline]
+    fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
+        self.abs_diff_eq(*other, max_abs_diff)
+    }
+    #[inline]
+    fn abs_diff(&self, other: &Self) -> Self {
+        Self::from_cols(
+            (self.x_axis - other.x_axis).abs(),
+            (self.y_axis - other.y_axis).abs(),
+            (self.z_axis - other.z_axis).abs(),
+            (self.w_axis - other.w_axis).abs(),
+        )
+    }
+}
+
+impl FloatCompare for Quat {
+    #[inline]
+    fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
+        self.abs_diff_eq(*other, max_abs_diff)
+    }
+    #[inline]
+    fn abs_diff(&self, other: &Self) -> Self {
+        let a: Vec4 = (*self).into();
+        let b: Vec4 = (*other).into();
+        Quat::from_vec4((a - b).abs())
+    }
+}
+
+impl FloatCompare for Vec2 {
+    #[inline]
+    fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
+        self.abs_diff_eq(*other, max_abs_diff)
+    }
+    #[inline]
+    fn abs_diff(&self, other: &Self) -> Self {
+        (*self - *other).abs()
+    }
+}
+
+impl FloatCompare for Vec3 {
+    #[inline]
+    fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
+        self.abs_diff_eq(*other, max_abs_diff)
+    }
+    #[inline]
+    fn abs_diff(&self, other: &Self) -> Self {
+        (*self - *other).abs()
+    }
+}
+
+impl FloatCompare for Vec3A {
+    #[inline]
+    fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
+        self.abs_diff_eq(*other, max_abs_diff)
+    }
+    #[inline]
+    fn abs_diff(&self, other: &Self) -> Self {
+        (*self - *other).abs()
+    }
+}
+
+impl FloatCompare for Vec4 {
+    #[inline]
+    fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
+        self.abs_diff_eq(*other, max_abs_diff)
+    }
+    #[inline]
+    fn abs_diff(&self, other: &Self) -> Self {
+        (*self - *other).abs()
+    }
+}
+
+impl FloatCompare for DQuat {
+    #[inline]
+    fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
+        self.abs_diff_eq(*other, max_abs_diff as f64)
+    }
+    #[inline]
+    fn abs_diff(&self, other: &Self) -> Self {
+        let a: DVec4 = (*self).into();
+        let b: DVec4 = (*other).into();
+        DQuat::from_vec4((a - b).abs())
+    }
+}
+
+impl FloatCompare for DVec2 {
+    #[inline]
+    fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
+        self.abs_diff_eq(*other, max_abs_diff as f64)
+    }
+    #[inline]
+    fn abs_diff(&self, other: &Self) -> Self {
+        (*self - *other).abs()
+    }
+}
+
+impl FloatCompare for DVec3 {
+    #[inline]
+    fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
+        self.abs_diff_eq(*other, max_abs_diff as f64)
+    }
+    #[inline]
+    fn abs_diff(&self, other: &Self) -> Self {
+        (*self - *other).abs()
+    }
+}
+
+impl FloatCompare for DVec4 {
+    #[inline]
+    fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
+        self.abs_diff_eq(*other, max_abs_diff as f64)
+    }
+    #[inline]
+    fn abs_diff(&self, other: &Self) -> Self {
+        (*self - *other).abs()
+    }
+}

vendor/glam/tests/support/macros.rs

@@ -0,0 +1,268 @@
+#[macro_export]
+macro_rules! glam_test {
+    ($name:ident, $block:block) => {
+        #[cfg_attr(not(target_arch = "wasm32"), test)]
+        #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+        fn $name() {
+            $block
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! should_panic {
+    ($block:block) => {{
+        #[cfg(all(feature = "std", panic = "unwind"))]
+        assert!(std::panic::catch_unwind(|| $block).is_err());
+    }};
+}
+
+#[macro_export]
+macro_rules! should_glam_assert {
+    ($block:block) => {{
+        #[cfg(any(feature = "glam-assert", feature = "debug-glam-assert"))]
+        should_panic!($block);
+    }};
+}
+
+#[macro_export]
+macro_rules! assert_approx_eq {
+    ($a:expr, $b:expr) => {{
+        #[allow(unused_imports)]
+        use $crate::support::FloatCompare;
+        let eps = f32::EPSILON;
+        let (a, b) = (&$a, &$b);
+        assert!(
+            a.approx_eq(b, eps),
+            "assertion failed: `(left !== right)` \
+             (left: `{:?}`, right: `{:?}`, expect diff: `{:?}`, real diff: `{:?}`)",
+            *a,
+            *b,
+            eps,
+            a.abs_diff(b)
+        );
+    }};
+    ($a:expr, $b:expr, $eps:expr) => {{
+        use $crate::support::FloatCompare;
+        let (a, b) = (&$a, &$b);
+        let eps = $eps;
+        assert!(
+            a.approx_eq(b, $eps),
+            "assertion failed: `(left !== right)` \
+             (left: `{:?}`, right: `{:?}`, expect diff: `{:?}`, real diff: `{:?}`)",
+            *a,
+            *b,
+            eps,
+            a.abs_diff(b)
+        );
+    }};
+    ($a:expr, $b:expr, $eps:expr, $ctx:expr) => {{
+        use $crate::support::FloatCompare;
+        let (a, b) = (&$a, &$b);
+        let eps = $eps;
+        assert!(
+            a.approx_eq(b, $eps),
+            "assertion failed: `(left !== right)` \
+             (left: `{:?}`, right: `{:?}`, expect diff: `{:?}`, real diff: `{:?}`), \
+             additional context: {}",
+            *a,
+            *b,
+            eps,
+            a.abs_diff(b),
+            $ctx
+        );
+    }};
+}
+
+/// Test vector normalization for float vector
+#[macro_export]
+macro_rules! impl_vec_float_normalize_tests {
+    ($t:ident, $vec:ident) => {
+        /// Works for vec2, vec3, vec4
+        fn from_x_y(x: $t, y: $t) -> $vec {
+            let mut v = $vec::ZERO;
+            v.x = x;
+            v.y = y;
+            v
+        }
+
+        glam_test!(test_normalize, {
+            assert_eq!(from_x_y(-42.0, 0.0).normalize(), from_x_y(-1.0, 0.0));
+            assert_eq!(
+                from_x_y($t::MAX.sqrt(), 0.0).normalize(),
+                from_x_y(1.0, 0.0)
+            );
+            // assert_eq!(from_x_y($t::MAX, 0.0).normalize(), from_x_y(1.0, 0.0)); // normalize fails for huge vectors and returns zero
+
+            // We expect not to be able to normalize small numbers:
+            should_glam_assert!({ from_x_y(0.0, 0.0).normalize() });
+            should_glam_assert!({ from_x_y($t::MIN_POSITIVE, 0.0).normalize() });
+
+            // We expect not to be able to normalize non-finite vectors:
+            should_glam_assert!({ from_x_y($t::INFINITY, 0.0).normalize() });
+            should_glam_assert!({ from_x_y($t::NAN, 0.0).normalize() });
+        });
+
+        #[cfg(not(any(feature = "debug-glam-assert", feature = "glam-assert")))]
+        glam_test!(test_normalize_no_glam_assert, {
+            // We expect not to be able to normalize small numbers:
+            assert!(!from_x_y(0.0, 0.0).normalize().is_finite());
+            assert!(!from_x_y($t::MIN_POSITIVE, 0.0).normalize().is_finite());
+
+            // We expect not to be able to normalize non-finite vectors:
+            assert!(!from_x_y($t::INFINITY, 0.0).normalize().is_finite());
+            assert!(!from_x_y($t::NAN, 0.0).normalize().is_finite());
+        });
+
+        glam_test!(test_try_normalize, {
+            assert_eq!(
+                from_x_y(-42.0, 0.0).try_normalize(),
+                Some(from_x_y(-1.0, 0.0))
+            );
+            assert_eq!(
+                from_x_y($t::MAX.sqrt(), 0.0).try_normalize(),
+                Some(from_x_y(1.0, 0.0))
+            );
+
+            // We expect `try_normalize` to return None when inputs are very small:
+            assert_eq!(from_x_y(0.0, 0.0).try_normalize(), None);
+            assert_eq!(from_x_y($t::MIN_POSITIVE, 0.0).try_normalize(), None);
+
+            // We expect `try_normalize` to return None when inputs are non-finite:
+            assert_eq!(from_x_y($t::INFINITY, 0.0).try_normalize(), None);
+            assert_eq!(from_x_y($t::NAN, 0.0).try_normalize(), None);
+
+            // We expect `try_normalize` to return None when inputs are very large:
+            assert_eq!(from_x_y($t::MAX, 0.0).try_normalize(), None);
+            assert_eq!(from_x_y($t::MAX, $t::MAX).try_normalize(), None);
+        });
+
+        glam_test!(test_normalize_or, {
+            assert_eq!(
+                from_x_y(-42.0, 0.0).normalize_or($vec::Y),
+                from_x_y(-1.0, 0.0)
+            );
+            assert_eq!(
+                from_x_y($t::MAX.sqrt(), 0.0).normalize_or($vec::Y),
+                from_x_y(1.0, 0.0)
+            );
+
+            // We expect `normalize_or` to return the fallback value when inputs are very small:
+            assert_eq!(from_x_y(0.0, 0.0).normalize_or($vec::Y), $vec::Y);
+            assert_eq!(
+                from_x_y($t::MIN_POSITIVE, 0.0).normalize_or($vec::Y),
+                $vec::Y
+            );
+
+            // We expect `normalize` to return zero when inputs are non-finite:
+            assert_eq!(from_x_y($t::INFINITY, 0.0).normalize_or($vec::Y), $vec::Y);
+            assert_eq!(from_x_y($t::NAN, 0.0).normalize_or($vec::Y), $vec::Y);
+
+            // We expect `normalize` to return zero when inputs are very large:
+            assert_eq!(from_x_y($t::MAX, 0.0).normalize_or($vec::Y), $vec::Y);
+            assert_eq!(from_x_y($t::MAX, $t::MAX).normalize_or($vec::Y), $vec::Y);
+        });
+
+        glam_test!(test_normalize_or_zero, {
+            assert_eq!(
+                from_x_y(-42.0, 0.0).normalize_or_zero(),
+                from_x_y(-1.0, 0.0)
+            );
+            assert_eq!(
+                from_x_y($t::MAX.sqrt(), 0.0).normalize_or_zero(),
+                from_x_y(1.0, 0.0)
+            );
+
+            // We expect `normalize_or_zero` to return zero when inputs are very small:
+            assert_eq!(from_x_y(0.0, 0.0).normalize_or_zero(), $vec::ZERO);
+            assert_eq!(
+                from_x_y($t::MIN_POSITIVE, 0.0).normalize_or_zero(),
+                $vec::ZERO
+            );
+
+            // We expect `normalize_or_zero` to return zero when inputs are non-finite:
+            assert_eq!(from_x_y($t::INFINITY, 0.0).normalize_or_zero(), $vec::ZERO);
+            assert_eq!(from_x_y($t::NAN, 0.0).normalize_or_zero(), $vec::ZERO);
+
+            // We expect `normalize_or_zero` to return zero when inputs are very large:
+            assert_eq!(from_x_y($t::MAX, 0.0).normalize_or_zero(), $vec::ZERO);
+            assert_eq!(from_x_y($t::MAX, $t::MAX).normalize_or_zero(), $vec::ZERO);
+        });
+    };
+}
+
+/// Useful test vectors
+#[macro_export]
+macro_rules! vec3_float_test_vectors {
+    ($vec3:ident) => {
+        [
+            $vec3::X,
+            $vec3::Y,
+            $vec3::Z,
+            -$vec3::X,
+            -$vec3::Y,
+            -$vec3::Z,
+            $vec3::new(1.0, 1e-3, 0.0),
+            $vec3::new(1.0, 1e-4, 0.0),
+            $vec3::new(1.0, 1e-5, 0.0),
+            $vec3::new(1.0, 1e-6, 0.0),
+            $vec3::new(1.0, 1e-7, 0.0),
+            $vec3::new(1.0, 1e-14, 0.0),
+            $vec3::new(1.0, 1e-15, 0.0),
+            $vec3::new(1.0, 1e-16, 0.0),
+            $vec3::new(0.1, 0.2, 0.3),
+            $vec3::new(0.2, 0.3, 0.4),
+            $vec3::new(4.0, -5.0, 6.0),
+            $vec3::new(-2.0, 0.5, -1.0),
+            // Pathological cases from <https://graphics.pixar.com/library/OrthonormalB/paper.pdf>:
+            $vec3::new(0.00038527316, 0.00038460016, -0.99999988079),
+            $vec3::new(-0.00019813581, -0.00008946839, -0.99999988079),
+        ]
+    };
+}
+
+#[macro_export]
+macro_rules! vec2_float_test_vectors {
+    ($vec2:ident) => {
+        [
+            $vec2::X,
+            $vec2::Y,
+            -$vec2::X,
+            -$vec2::Y,
+            $vec2::new(1.0, 1e-3),
+            $vec2::new(1.0, 1e-4),
+            $vec2::new(1.0, 1e-5),
+            $vec2::new(1.0, 1e-6),
+            $vec2::new(1.0, 1e-7),
+            $vec2::new(1.0, 1e-14),
+            $vec2::new(1.0, 1e-15),
+            $vec2::new(1.0, 1e-16),
+            $vec2::new(0.1, 0.2),
+            $vec2::new(0.2, 0.3),
+            $vec2::new(4.0, -5.0),
+            $vec2::new(-2.0, 0.5),
+            // Pathological cases from <https://graphics.pixar.com/library/OrthonormalB/paper.pdf>:
+            $vec2::new(0.00038527316, 0.00038460016),
+            $vec2::new(-0.00019813581, -0.00008946839),
+        ]
+    };
+}
+
+#[macro_export]
+macro_rules! test_matrix_minor {
+    ($n:expr, $minor:expr, $input:expr, $i:expr, $j:expr) => {
+        let mut yy = 0;
+        for y in 0..$n {
+            if y != $j {
+                let mut xx = 0;
+                for x in 0..$n {
+                    if x != $i {
+                        assert_eq!($minor.col(xx)[yy], $input.col(x)[y]);
+                        xx += 1;
+                    }
+                }
+                yy += 1;
+            }
+        }
+    };
+}

vendor/glam/tests/swizzles_f32.rs

@@ -0,0 +1,618 @@
+// Generated by swizzlegen. Do not edit.
+#[macro_use]
+mod support;
+use glam::*;
+
+glam_test!(test_vec4_swizzles, {
+    let v = vec4(1_f32, 2_f32, 3_f32, 4_f32);
+    assert_eq!(v, v.xyzw());
+    assert_eq!(v.xxxx(), vec4(1_f32, 1_f32, 1_f32, 1_f32));
+    assert_eq!(v.xxxy(), vec4(1_f32, 1_f32, 1_f32, 2_f32));
+    assert_eq!(v.xxxz(), vec4(1_f32, 1_f32, 1_f32, 3_f32));
+    assert_eq!(v.xxxw(), vec4(1_f32, 1_f32, 1_f32, 4_f32));
+    assert_eq!(v.xxyx(), vec4(1_f32, 1_f32, 2_f32, 1_f32));
+    assert_eq!(v.xxyy(), vec4(1_f32, 1_f32, 2_f32, 2_f32));
+    assert_eq!(v.xxyz(), vec4(1_f32, 1_f32, 2_f32, 3_f32));
+    assert_eq!(v.xxyw(), vec4(1_f32, 1_f32, 2_f32, 4_f32));
+    assert_eq!(v.xxzx(), vec4(1_f32, 1_f32, 3_f32, 1_f32));
+    assert_eq!(v.xxzy(), vec4(1_f32, 1_f32, 3_f32, 2_f32));
+    assert_eq!(v.xxzz(), vec4(1_f32, 1_f32, 3_f32, 3_f32));
+    assert_eq!(v.xxzw(), vec4(1_f32, 1_f32, 3_f32, 4_f32));
+    assert_eq!(v.xxwx(), vec4(1_f32, 1_f32, 4_f32, 1_f32));
+    assert_eq!(v.xxwy(), vec4(1_f32, 1_f32, 4_f32, 2_f32));
+    assert_eq!(v.xxwz(), vec4(1_f32, 1_f32, 4_f32, 3_f32));
+    assert_eq!(v.xxww(), vec4(1_f32, 1_f32, 4_f32, 4_f32));
+    assert_eq!(v.xyxx(), vec4(1_f32, 2_f32, 1_f32, 1_f32));
+    assert_eq!(v.xyxy(), vec4(1_f32, 2_f32, 1_f32, 2_f32));
+    assert_eq!(v.xyxz(), vec4(1_f32, 2_f32, 1_f32, 3_f32));
+    assert_eq!(v.xyxw(), vec4(1_f32, 2_f32, 1_f32, 4_f32));
+    assert_eq!(v.xyyx(), vec4(1_f32, 2_f32, 2_f32, 1_f32));
+    assert_eq!(v.xyyy(), vec4(1_f32, 2_f32, 2_f32, 2_f32));
+    assert_eq!(v.xyyz(), vec4(1_f32, 2_f32, 2_f32, 3_f32));
+    assert_eq!(v.xyyw(), vec4(1_f32, 2_f32, 2_f32, 4_f32));
+    assert_eq!(v.xyzx(), vec4(1_f32, 2_f32, 3_f32, 1_f32));
+    assert_eq!(v.xyzy(), vec4(1_f32, 2_f32, 3_f32, 2_f32));
+    assert_eq!(v.xyzz(), vec4(1_f32, 2_f32, 3_f32, 3_f32));
+    assert_eq!(v.xywx(), vec4(1_f32, 2_f32, 4_f32, 1_f32));
+    assert_eq!(v.xywy(), vec4(1_f32, 2_f32, 4_f32, 2_f32));
+    assert_eq!(v.xywz(), vec4(1_f32, 2_f32, 4_f32, 3_f32));
+    assert_eq!(v.xyww(), vec4(1_f32, 2_f32, 4_f32, 4_f32));
+    assert_eq!(v.xzxx(), vec4(1_f32, 3_f32, 1_f32, 1_f32));
+    assert_eq!(v.xzxy(), vec4(1_f32, 3_f32, 1_f32, 2_f32));
+    assert_eq!(v.xzxz(), vec4(1_f32, 3_f32, 1_f32, 3_f32));
+    assert_eq!(v.xzxw(), vec4(1_f32, 3_f32, 1_f32, 4_f32));
+    assert_eq!(v.xzyx(), vec4(1_f32, 3_f32, 2_f32, 1_f32));
+    assert_eq!(v.xzyy(), vec4(1_f32, 3_f32, 2_f32, 2_f32));
+    assert_eq!(v.xzyz(), vec4(1_f32, 3_f32, 2_f32, 3_f32));
+    assert_eq!(v.xzyw(), vec4(1_f32, 3_f32, 2_f32, 4_f32));
+    assert_eq!(v.xzzx(), vec4(1_f32, 3_f32, 3_f32, 1_f32));
+    assert_eq!(v.xzzy(), vec4(1_f32, 3_f32, 3_f32, 2_f32));
+    assert_eq!(v.xzzz(), vec4(1_f32, 3_f32, 3_f32, 3_f32));
+    assert_eq!(v.xzzw(), vec4(1_f32, 3_f32, 3_f32, 4_f32));
+    assert_eq!(v.xzwx(), vec4(1_f32, 3_f32, 4_f32, 1_f32));
+    assert_eq!(v.xzwy(), vec4(1_f32, 3_f32, 4_f32, 2_f32));
+    assert_eq!(v.xzwz(), vec4(1_f32, 3_f32, 4_f32, 3_f32));
+    assert_eq!(v.xzww(), vec4(1_f32, 3_f32, 4_f32, 4_f32));
+    assert_eq!(v.xwxx(), vec4(1_f32, 4_f32, 1_f32, 1_f32));
+    assert_eq!(v.xwxy(), vec4(1_f32, 4_f32, 1_f32, 2_f32));
+    assert_eq!(v.xwxz(), vec4(1_f32, 4_f32, 1_f32, 3_f32));
+    assert_eq!(v.xwxw(), vec4(1_f32, 4_f32, 1_f32, 4_f32));
+    assert_eq!(v.xwyx(), vec4(1_f32, 4_f32, 2_f32, 1_f32));
+    assert_eq!(v.xwyy(), vec4(1_f32, 4_f32, 2_f32, 2_f32));
+    assert_eq!(v.xwyz(), vec4(1_f32, 4_f32, 2_f32, 3_f32));
+    assert_eq!(v.xwyw(), vec4(1_f32, 4_f32, 2_f32, 4_f32));
+    assert_eq!(v.xwzx(), vec4(1_f32, 4_f32, 3_f32, 1_f32));
+    assert_eq!(v.xwzy(), vec4(1_f32, 4_f32, 3_f32, 2_f32));
+    assert_eq!(v.xwzz(), vec4(1_f32, 4_f32, 3_f32, 3_f32));
+    assert_eq!(v.xwzw(), vec4(1_f32, 4_f32, 3_f32, 4_f32));
+    assert_eq!(v.xwwx(), vec4(1_f32, 4_f32, 4_f32, 1_f32));
+    assert_eq!(v.xwwy(), vec4(1_f32, 4_f32, 4_f32, 2_f32));
+    assert_eq!(v.xwwz(), vec4(1_f32, 4_f32, 4_f32, 3_f32));
+    assert_eq!(v.xwww(), vec4(1_f32, 4_f32, 4_f32, 4_f32));
+    assert_eq!(v.yxxx(), vec4(2_f32, 1_f32, 1_f32, 1_f32));
+    assert_eq!(v.yxxy(), vec4(2_f32, 1_f32, 1_f32, 2_f32));
+    assert_eq!(v.yxxz(), vec4(2_f32, 1_f32, 1_f32, 3_f32));
+    assert_eq!(v.yxxw(), vec4(2_f32, 1_f32, 1_f32, 4_f32));
+    assert_eq!(v.yxyx(), vec4(2_f32, 1_f32, 2_f32, 1_f32));
+    assert_eq!(v.yxyy(), vec4(2_f32, 1_f32, 2_f32, 2_f32));
+    assert_eq!(v.yxyz(), vec4(2_f32, 1_f32, 2_f32, 3_f32));
+    assert_eq!(v.yxyw(), vec4(2_f32, 1_f32, 2_f32, 4_f32));
+    assert_eq!(v.yxzx(), vec4(2_f32, 1_f32, 3_f32, 1_f32));
+    assert_eq!(v.yxzy(), vec4(2_f32, 1_f32, 3_f32, 2_f32));
+    assert_eq!(v.yxzz(), vec4(2_f32, 1_f32, 3_f32, 3_f32));
+    assert_eq!(v.yxzw(), vec4(2_f32, 1_f32, 3_f32, 4_f32));
+    assert_eq!(v.yxwx(), vec4(2_f32, 1_f32, 4_f32, 1_f32));
+    assert_eq!(v.yxwy(), vec4(2_f32, 1_f32, 4_f32, 2_f32));
+    assert_eq!(v.yxwz(), vec4(2_f32, 1_f32, 4_f32, 3_f32));
+    assert_eq!(v.yxww(), vec4(2_f32, 1_f32, 4_f32, 4_f32));
+    assert_eq!(v.yyxx(), vec4(2_f32, 2_f32, 1_f32, 1_f32));
+    assert_eq!(v.yyxy(), vec4(2_f32, 2_f32, 1_f32, 2_f32));
+    assert_eq!(v.yyxz(), vec4(2_f32, 2_f32, 1_f32, 3_f32));
+    assert_eq!(v.yyxw(), vec4(2_f32, 2_f32, 1_f32, 4_f32));
+    assert_eq!(v.yyyx(), vec4(2_f32, 2_f32, 2_f32, 1_f32));
+    assert_eq!(v.yyyy(), vec4(2_f32, 2_f32, 2_f32, 2_f32));
+    assert_eq!(v.yyyz(), vec4(2_f32, 2_f32, 2_f32, 3_f32));
+    assert_eq!(v.yyyw(), vec4(2_f32, 2_f32, 2_f32, 4_f32));
+    assert_eq!(v.yyzx(), vec4(2_f32, 2_f32, 3_f32, 1_f32));
+    assert_eq!(v.yyzy(), vec4(2_f32, 2_f32, 3_f32, 2_f32));
+    assert_eq!(v.yyzz(), vec4(2_f32, 2_f32, 3_f32, 3_f32));
+    assert_eq!(v.yyzw(), vec4(2_f32, 2_f32, 3_f32, 4_f32));
+    assert_eq!(v.yywx(), vec4(2_f32, 2_f32, 4_f32, 1_f32));
+    assert_eq!(v.yywy(), vec4(2_f32, 2_f32, 4_f32, 2_f32));
+    assert_eq!(v.yywz(), vec4(2_f32, 2_f32, 4_f32, 3_f32));
+    assert_eq!(v.yyww(), vec4(2_f32, 2_f32, 4_f32, 4_f32));
+    assert_eq!(v.yzxx(), vec4(2_f32, 3_f32, 1_f32, 1_f32));
+    assert_eq!(v.yzxy(), vec4(2_f32, 3_f32, 1_f32, 2_f32));
+    assert_eq!(v.yzxz(), vec4(2_f32, 3_f32, 1_f32, 3_f32));
+    assert_eq!(v.yzxw(), vec4(2_f32, 3_f32, 1_f32, 4_f32));
+    assert_eq!(v.yzyx(), vec4(2_f32, 3_f32, 2_f32, 1_f32));
+    assert_eq!(v.yzyy(), vec4(2_f32, 3_f32, 2_f32, 2_f32));
+    assert_eq!(v.yzyz(), vec4(2_f32, 3_f32, 2_f32, 3_f32));
+    assert_eq!(v.yzyw(), vec4(2_f32, 3_f32, 2_f32, 4_f32));
+    assert_eq!(v.yzzx(), vec4(2_f32, 3_f32, 3_f32, 1_f32));
+    assert_eq!(v.yzzy(), vec4(2_f32, 3_f32, 3_f32, 2_f32));
+    assert_eq!(v.yzzz(), vec4(2_f32, 3_f32, 3_f32, 3_f32));
+    assert_eq!(v.yzzw(), vec4(2_f32, 3_f32, 3_f32, 4_f32));
+    assert_eq!(v.yzwx(), vec4(2_f32, 3_f32, 4_f32, 1_f32));
+    assert_eq!(v.yzwy(), vec4(2_f32, 3_f32, 4_f32, 2_f32));
+    assert_eq!(v.yzwz(), vec4(2_f32, 3_f32, 4_f32, 3_f32));
+    assert_eq!(v.yzww(), vec4(2_f32, 3_f32, 4_f32, 4_f32));
+    assert_eq!(v.ywxx(), vec4(2_f32, 4_f32, 1_f32, 1_f32));
+    assert_eq!(v.ywxy(), vec4(2_f32, 4_f32, 1_f32, 2_f32));
+    assert_eq!(v.ywxz(), vec4(2_f32, 4_f32, 1_f32, 3_f32));
+    assert_eq!(v.ywxw(), vec4(2_f32, 4_f32, 1_f32, 4_f32));
+    assert_eq!(v.ywyx(), vec4(2_f32, 4_f32, 2_f32, 1_f32));
+    assert_eq!(v.ywyy(), vec4(2_f32, 4_f32, 2_f32, 2_f32));
+    assert_eq!(v.ywyz(), vec4(2_f32, 4_f32, 2_f32, 3_f32));
+    assert_eq!(v.ywyw(), vec4(2_f32, 4_f32, 2_f32, 4_f32));
+    assert_eq!(v.ywzx(), vec4(2_f32, 4_f32, 3_f32, 1_f32));
+    assert_eq!(v.ywzy(), vec4(2_f32, 4_f32, 3_f32, 2_f32));
+    assert_eq!(v.ywzz(), vec4(2_f32, 4_f32, 3_f32, 3_f32));
+    assert_eq!(v.ywzw(), vec4(2_f32, 4_f32, 3_f32, 4_f32));
+    assert_eq!(v.ywwx(), vec4(2_f32, 4_f32, 4_f32, 1_f32));
+    assert_eq!(v.ywwy(), vec4(2_f32, 4_f32, 4_f32, 2_f32));
+    assert_eq!(v.ywwz(), vec4(2_f32, 4_f32, 4_f32, 3_f32));
+    assert_eq!(v.ywww(), vec4(2_f32, 4_f32, 4_f32, 4_f32));
+    assert_eq!(v.zxxx(), vec4(3_f32, 1_f32, 1_f32, 1_f32));
+    assert_eq!(v.zxxy(), vec4(3_f32, 1_f32, 1_f32, 2_f32));
+    assert_eq!(v.zxxz(), vec4(3_f32, 1_f32, 1_f32, 3_f32));
+    assert_eq!(v.zxxw(), vec4(3_f32, 1_f32, 1_f32, 4_f32));
+    assert_eq!(v.zxyx(), vec4(3_f32, 1_f32, 2_f32, 1_f32));
+    assert_eq!(v.zxyy(), vec4(3_f32, 1_f32, 2_f32, 2_f32));
+    assert_eq!(v.zxyz(), vec4(3_f32, 1_f32, 2_f32, 3_f32));
+    assert_eq!(v.zxyw(), vec4(3_f32, 1_f32, 2_f32, 4_f32));
+    assert_eq!(v.zxzx(), vec4(3_f32, 1_f32, 3_f32, 1_f32));
+    assert_eq!(v.zxzy(), vec4(3_f32, 1_f32, 3_f32, 2_f32));
+    assert_eq!(v.zxzz(), vec4(3_f32, 1_f32, 3_f32, 3_f32));
+    assert_eq!(v.zxzw(), vec4(3_f32, 1_f32, 3_f32, 4_f32));
+    assert_eq!(v.zxwx(), vec4(3_f32, 1_f32, 4_f32, 1_f32));
+    assert_eq!(v.zxwy(), vec4(3_f32, 1_f32, 4_f32, 2_f32));
+    assert_eq!(v.zxwz(), vec4(3_f32, 1_f32, 4_f32, 3_f32));
+    assert_eq!(v.zxww(), vec4(3_f32, 1_f32, 4_f32, 4_f32));
+    assert_eq!(v.zyxx(), vec4(3_f32, 2_f32, 1_f32, 1_f32));
+    assert_eq!(v.zyxy(), vec4(3_f32, 2_f32, 1_f32, 2_f32));
+    assert_eq!(v.zyxz(), vec4(3_f32, 2_f32, 1_f32, 3_f32));
+    assert_eq!(v.zyxw(), vec4(3_f32, 2_f32, 1_f32, 4_f32));
+    assert_eq!(v.zyyx(), vec4(3_f32, 2_f32, 2_f32, 1_f32));
+    assert_eq!(v.zyyy(), vec4(3_f32, 2_f32, 2_f32, 2_f32));
+    assert_eq!(v.zyyz(), vec4(3_f32, 2_f32, 2_f32, 3_f32));
+    assert_eq!(v.zyyw(), vec4(3_f32, 2_f32, 2_f32, 4_f32));
+    assert_eq!(v.zyzx(), vec4(3_f32, 2_f32, 3_f32, 1_f32));
+    assert_eq!(v.zyzy(), vec4(3_f32, 2_f32, 3_f32, 2_f32));
+    assert_eq!(v.zyzz(), vec4(3_f32, 2_f32, 3_f32, 3_f32));
+    assert_eq!(v.zyzw(), vec4(3_f32, 2_f32, 3_f32, 4_f32));
+    assert_eq!(v.zywx(), vec4(3_f32, 2_f32, 4_f32, 1_f32));
+    assert_eq!(v.zywy(), vec4(3_f32, 2_f32, 4_f32, 2_f32));
+    assert_eq!(v.zywz(), vec4(3_f32, 2_f32, 4_f32, 3_f32));
+    assert_eq!(v.zyww(), vec4(3_f32, 2_f32, 4_f32, 4_f32));
+    assert_eq!(v.zzxx(), vec4(3_f32, 3_f32, 1_f32, 1_f32));
+    assert_eq!(v.zzxy(), vec4(3_f32, 3_f32, 1_f32, 2_f32));
+    assert_eq!(v.zzxz(), vec4(3_f32, 3_f32, 1_f32, 3_f32));
+    assert_eq!(v.zzxw(), vec4(3_f32, 3_f32, 1_f32, 4_f32));
+    assert_eq!(v.zzyx(), vec4(3_f32, 3_f32, 2_f32, 1_f32));
+    assert_eq!(v.zzyy(), vec4(3_f32, 3_f32, 2_f32, 2_f32));
+    assert_eq!(v.zzyz(), vec4(3_f32, 3_f32, 2_f32, 3_f32));
+    assert_eq!(v.zzyw(), vec4(3_f32, 3_f32, 2_f32, 4_f32));
+    assert_eq!(v.zzzx(), vec4(3_f32, 3_f32, 3_f32, 1_f32));
+    assert_eq!(v.zzzy(), vec4(3_f32, 3_f32, 3_f32, 2_f32));
+    assert_eq!(v.zzzz(), vec4(3_f32, 3_f32, 3_f32, 3_f32));
+    assert_eq!(v.zzzw(), vec4(3_f32, 3_f32, 3_f32, 4_f32));
+    assert_eq!(v.zzwx(), vec4(3_f32, 3_f32, 4_f32, 1_f32));
+    assert_eq!(v.zzwy(), vec4(3_f32, 3_f32, 4_f32, 2_f32));
+    assert_eq!(v.zzwz(), vec4(3_f32, 3_f32, 4_f32, 3_f32));
+    assert_eq!(v.zzww(), vec4(3_f32, 3_f32, 4_f32, 4_f32));
+    assert_eq!(v.zwxx(), vec4(3_f32, 4_f32, 1_f32, 1_f32));
+    assert_eq!(v.zwxy(), vec4(3_f32, 4_f32, 1_f32, 2_f32));
+    assert_eq!(v.zwxz(), vec4(3_f32, 4_f32, 1_f32, 3_f32));
+    assert_eq!(v.zwxw(), vec4(3_f32, 4_f32, 1_f32, 4_f32));
+    assert_eq!(v.zwyx(), vec4(3_f32, 4_f32, 2_f32, 1_f32));
+    assert_eq!(v.zwyy(), vec4(3_f32, 4_f32, 2_f32, 2_f32));
+    assert_eq!(v.zwyz(), vec4(3_f32, 4_f32, 2_f32, 3_f32));
+    assert_eq!(v.zwyw(), vec4(3_f32, 4_f32, 2_f32, 4_f32));
+    assert_eq!(v.zwzx(), vec4(3_f32, 4_f32, 3_f32, 1_f32));
+    assert_eq!(v.zwzy(), vec4(3_f32, 4_f32, 3_f32, 2_f32));
+    assert_eq!(v.zwzz(), vec4(3_f32, 4_f32, 3_f32, 3_f32));
+    assert_eq!(v.zwzw(), vec4(3_f32, 4_f32, 3_f32, 4_f32));
+    assert_eq!(v.zwwx(), vec4(3_f32, 4_f32, 4_f32, 1_f32));
+    assert_eq!(v.zwwy(), vec4(3_f32, 4_f32, 4_f32, 2_f32));
+    assert_eq!(v.zwwz(), vec4(3_f32, 4_f32, 4_f32, 3_f32));
+    assert_eq!(v.zwww(), vec4(3_f32, 4_f32, 4_f32, 4_f32));
+    assert_eq!(v.wxxx(), vec4(4_f32, 1_f32, 1_f32, 1_f32));
+    assert_eq!(v.wxxy(), vec4(4_f32, 1_f32, 1_f32, 2_f32));
+    assert_eq!(v.wxxz(), vec4(4_f32, 1_f32, 1_f32, 3_f32));
+    assert_eq!(v.wxxw(), vec4(4_f32, 1_f32, 1_f32, 4_f32));
+    assert_eq!(v.wxyx(), vec4(4_f32, 1_f32, 2_f32, 1_f32));
+    assert_eq!(v.wxyy(), vec4(4_f32, 1_f32, 2_f32, 2_f32));
+    assert_eq!(v.wxyz(), vec4(4_f32, 1_f32, 2_f32, 3_f32));
+    assert_eq!(v.wxyw(), vec4(4_f32, 1_f32, 2_f32, 4_f32));
+    assert_eq!(v.wxzx(), vec4(4_f32, 1_f32, 3_f32, 1_f32));
+    assert_eq!(v.wxzy(), vec4(4_f32, 1_f32, 3_f32, 2_f32));
+    assert_eq!(v.wxzz(), vec4(4_f32, 1_f32, 3_f32, 3_f32));
+    assert_eq!(v.wxzw(), vec4(4_f32, 1_f32, 3_f32, 4_f32));
+    assert_eq!(v.wxwx(), vec4(4_f32, 1_f32, 4_f32, 1_f32));
+    assert_eq!(v.wxwy(), vec4(4_f32, 1_f32, 4_f32, 2_f32));
+    assert_eq!(v.wxwz(), vec4(4_f32, 1_f32, 4_f32, 3_f32));
+    assert_eq!(v.wxww(), vec4(4_f32, 1_f32, 4_f32, 4_f32));
+    assert_eq!(v.wyxx(), vec4(4_f32, 2_f32, 1_f32, 1_f32));
+    assert_eq!(v.wyxy(), vec4(4_f32, 2_f32, 1_f32, 2_f32));
+    assert_eq!(v.wyxz(), vec4(4_f32, 2_f32, 1_f32, 3_f32));
+    assert_eq!(v.wyxw(), vec4(4_f32, 2_f32, 1_f32, 4_f32));
+    assert_eq!(v.wyyx(), vec4(4_f32, 2_f32, 2_f32, 1_f32));
+    assert_eq!(v.wyyy(), vec4(4_f32, 2_f32, 2_f32, 2_f32));
+    assert_eq!(v.wyyz(), vec4(4_f32, 2_f32, 2_f32, 3_f32));
+    assert_eq!(v.wyyw(), vec4(4_f32, 2_f32, 2_f32, 4_f32));
+    assert_eq!(v.wyzx(), vec4(4_f32, 2_f32, 3_f32, 1_f32));
+    assert_eq!(v.wyzy(), vec4(4_f32, 2_f32, 3_f32, 2_f32));
+    assert_eq!(v.wyzz(), vec4(4_f32, 2_f32, 3_f32, 3_f32));
+    assert_eq!(v.wyzw(), vec4(4_f32, 2_f32, 3_f32, 4_f32));
+    assert_eq!(v.wywx(), vec4(4_f32, 2_f32, 4_f32, 1_f32));
+    assert_eq!(v.wywy(), vec4(4_f32, 2_f32, 4_f32, 2_f32));
+    assert_eq!(v.wywz(), vec4(4_f32, 2_f32, 4_f32, 3_f32));
+    assert_eq!(v.wyww(), vec4(4_f32, 2_f32, 4_f32, 4_f32));
+    assert_eq!(v.wzxx(), vec4(4_f32, 3_f32, 1_f32, 1_f32));
+    assert_eq!(v.wzxy(), vec4(4_f32, 3_f32, 1_f32, 2_f32));
+    assert_eq!(v.wzxz(), vec4(4_f32, 3_f32, 1_f32, 3_f32));
+    assert_eq!(v.wzxw(), vec4(4_f32, 3_f32, 1_f32, 4_f32));
+    assert_eq!(v.wzyx(), vec4(4_f32, 3_f32, 2_f32, 1_f32));
+    assert_eq!(v.wzyy(), vec4(4_f32, 3_f32, 2_f32, 2_f32));
+    assert_eq!(v.wzyz(), vec4(4_f32, 3_f32, 2_f32, 3_f32));
+    assert_eq!(v.wzyw(), vec4(4_f32, 3_f32, 2_f32, 4_f32));
+    assert_eq!(v.wzzx(), vec4(4_f32, 3_f32, 3_f32, 1_f32));
+    assert_eq!(v.wzzy(), vec4(4_f32, 3_f32, 3_f32, 2_f32));
+    assert_eq!(v.wzzz(), vec4(4_f32, 3_f32, 3_f32, 3_f32));
+    assert_eq!(v.wzzw(), vec4(4_f32, 3_f32, 3_f32, 4_f32));
+    assert_eq!(v.wzwx(), vec4(4_f32, 3_f32, 4_f32, 1_f32));
+    assert_eq!(v.wzwy(), vec4(4_f32, 3_f32, 4_f32, 2_f32));
+    assert_eq!(v.wzwz(), vec4(4_f32, 3_f32, 4_f32, 3_f32));
+    assert_eq!(v.wzww(), vec4(4_f32, 3_f32, 4_f32, 4_f32));
+    assert_eq!(v.wwxx(), vec4(4_f32, 4_f32, 1_f32, 1_f32));
+    assert_eq!(v.wwxy(), vec4(4_f32, 4_f32, 1_f32, 2_f32));
+    assert_eq!(v.wwxz(), vec4(4_f32, 4_f32, 1_f32, 3_f32));
+    assert_eq!(v.wwxw(), vec4(4_f32, 4_f32, 1_f32, 4_f32));
+    assert_eq!(v.wwyx(), vec4(4_f32, 4_f32, 2_f32, 1_f32));
+    assert_eq!(v.wwyy(), vec4(4_f32, 4_f32, 2_f32, 2_f32));
+    assert_eq!(v.wwyz(), vec4(4_f32, 4_f32, 2_f32, 3_f32));
+    assert_eq!(v.wwyw(), vec4(4_f32, 4_f32, 2_f32, 4_f32));
+    assert_eq!(v.wwzx(), vec4(4_f32, 4_f32, 3_f32, 1_f32));
+    assert_eq!(v.wwzy(), vec4(4_f32, 4_f32, 3_f32, 2_f32));
+    assert_eq!(v.wwzz(), vec4(4_f32, 4_f32, 3_f32, 3_f32));
+    assert_eq!(v.wwzw(), vec4(4_f32, 4_f32, 3_f32, 4_f32));
+    assert_eq!(v.wwwx(), vec4(4_f32, 4_f32, 4_f32, 1_f32));
+    assert_eq!(v.wwwy(), vec4(4_f32, 4_f32, 4_f32, 2_f32));
+    assert_eq!(v.wwwz(), vec4(4_f32, 4_f32, 4_f32, 3_f32));
+    assert_eq!(v.wwww(), vec4(4_f32, 4_f32, 4_f32, 4_f32));
+    assert_eq!(v.xxx(), vec3(1_f32, 1_f32, 1_f32));
+    assert_eq!(v.xxy(), vec3(1_f32, 1_f32, 2_f32));
+    assert_eq!(v.xxz(), vec3(1_f32, 1_f32, 3_f32));
+    assert_eq!(v.xxw(), vec3(1_f32, 1_f32, 4_f32));
+    assert_eq!(v.xyx(), vec3(1_f32, 2_f32, 1_f32));
+    assert_eq!(v.xyy(), vec3(1_f32, 2_f32, 2_f32));
+    assert_eq!(v.xyz(), vec3(1_f32, 2_f32, 3_f32));
+    assert_eq!(v.xyw(), vec3(1_f32, 2_f32, 4_f32));
+    assert_eq!(v.xzx(), vec3(1_f32, 3_f32, 1_f32));
+    assert_eq!(v.xzy(), vec3(1_f32, 3_f32, 2_f32));
+    assert_eq!(v.xzz(), vec3(1_f32, 3_f32, 3_f32));
+    assert_eq!(v.xzw(), vec3(1_f32, 3_f32, 4_f32));
+    assert_eq!(v.xwx(), vec3(1_f32, 4_f32, 1_f32));
+    assert_eq!(v.xwy(), vec3(1_f32, 4_f32, 2_f32));
+    assert_eq!(v.xwz(), vec3(1_f32, 4_f32, 3_f32));
+    assert_eq!(v.xww(), vec3(1_f32, 4_f32, 4_f32));
+    assert_eq!(v.yxx(), vec3(2_f32, 1_f32, 1_f32));
+    assert_eq!(v.yxy(), vec3(2_f32, 1_f32, 2_f32));
+    assert_eq!(v.yxz(), vec3(2_f32, 1_f32, 3_f32));
+    assert_eq!(v.yxw(), vec3(2_f32, 1_f32, 4_f32));
+    assert_eq!(v.yyx(), vec3(2_f32, 2_f32, 1_f32));
+    assert_eq!(v.yyy(), vec3(2_f32, 2_f32, 2_f32));
+    assert_eq!(v.yyz(), vec3(2_f32, 2_f32, 3_f32));
+    assert_eq!(v.yyw(), vec3(2_f32, 2_f32, 4_f32));
+    assert_eq!(v.yzx(), vec3(2_f32, 3_f32, 1_f32));
+    assert_eq!(v.yzy(), vec3(2_f32, 3_f32, 2_f32));
+    assert_eq!(v.yzz(), vec3(2_f32, 3_f32, 3_f32));
+    assert_eq!(v.yzw(), vec3(2_f32, 3_f32, 4_f32));
+    assert_eq!(v.ywx(), vec3(2_f32, 4_f32, 1_f32));
+    assert_eq!(v.ywy(), vec3(2_f32, 4_f32, 2_f32));
+    assert_eq!(v.ywz(), vec3(2_f32, 4_f32, 3_f32));
+    assert_eq!(v.yww(), vec3(2_f32, 4_f32, 4_f32));
+    assert_eq!(v.zxx(), vec3(3_f32, 1_f32, 1_f32));
+    assert_eq!(v.zxy(), vec3(3_f32, 1_f32, 2_f32));
+    assert_eq!(v.zxz(), vec3(3_f32, 1_f32, 3_f32));
+    assert_eq!(v.zxw(), vec3(3_f32, 1_f32, 4_f32));
+    assert_eq!(v.zyx(), vec3(3_f32, 2_f32, 1_f32));
+    assert_eq!(v.zyy(), vec3(3_f32, 2_f32, 2_f32));
+    assert_eq!(v.zyz(), vec3(3_f32, 2_f32, 3_f32));
+    assert_eq!(v.zyw(), vec3(3_f32, 2_f32, 4_f32));
+    assert_eq!(v.zzx(), vec3(3_f32, 3_f32, 1_f32));
+    assert_eq!(v.zzy(), vec3(3_f32, 3_f32, 2_f32));
+    assert_eq!(v.zzz(), vec3(3_f32, 3_f32, 3_f32));
+    assert_eq!(v.zzw(), vec3(3_f32, 3_f32, 4_f32));
+    assert_eq!(v.zwx(), vec3(3_f32, 4_f32, 1_f32));
+    assert_eq!(v.zwy(), vec3(3_f32, 4_f32, 2_f32));
+    assert_eq!(v.zwz(), vec3(3_f32, 4_f32, 3_f32));
+    assert_eq!(v.zww(), vec3(3_f32, 4_f32, 4_f32));
+    assert_eq!(v.wxx(), vec3(4_f32, 1_f32, 1_f32));
+    assert_eq!(v.wxy(), vec3(4_f32, 1_f32, 2_f32));
+    assert_eq!(v.wxz(), vec3(4_f32, 1_f32, 3_f32));
+    assert_eq!(v.wxw(), vec3(4_f32, 1_f32, 4_f32));
+    assert_eq!(v.wyx(), vec3(4_f32, 2_f32, 1_f32));
+    assert_eq!(v.wyy(), vec3(4_f32, 2_f32, 2_f32));
+    assert_eq!(v.wyz(), vec3(4_f32, 2_f32, 3_f32));
+    assert_eq!(v.wyw(), vec3(4_f32, 2_f32, 4_f32));
+    assert_eq!(v.wzx(), vec3(4_f32, 3_f32, 1_f32));
+    assert_eq!(v.wzy(), vec3(4_f32, 3_f32, 2_f32));
+    assert_eq!(v.wzz(), vec3(4_f32, 3_f32, 3_f32));
+    assert_eq!(v.wzw(), vec3(4_f32, 3_f32, 4_f32));
+    assert_eq!(v.wwx(), vec3(4_f32, 4_f32, 1_f32));
+    assert_eq!(v.wwy(), vec3(4_f32, 4_f32, 2_f32));
+    assert_eq!(v.wwz(), vec3(4_f32, 4_f32, 3_f32));
+    assert_eq!(v.www(), vec3(4_f32, 4_f32, 4_f32));
+    assert_eq!(v.xx(), vec2(1_f32, 1_f32));
+    assert_eq!(v.xy(), vec2(1_f32, 2_f32));
+    assert_eq!(v.xz(), vec2(1_f32, 3_f32));
+    assert_eq!(v.xw(), vec2(1_f32, 4_f32));
+    assert_eq!(v.yx(), vec2(2_f32, 1_f32));
+    assert_eq!(v.yy(), vec2(2_f32, 2_f32));
+    assert_eq!(v.yz(), vec2(2_f32, 3_f32));
+    assert_eq!(v.yw(), vec2(2_f32, 4_f32));
+    assert_eq!(v.zx(), vec2(3_f32, 1_f32));
+    assert_eq!(v.zy(), vec2(3_f32, 2_f32));
+    assert_eq!(v.zz(), vec2(3_f32, 3_f32));
+    assert_eq!(v.zw(), vec2(3_f32, 4_f32));
+    assert_eq!(v.wx(), vec2(4_f32, 1_f32));
+    assert_eq!(v.wy(), vec2(4_f32, 2_f32));
+    assert_eq!(v.wz(), vec2(4_f32, 3_f32));
+    assert_eq!(v.ww(), vec2(4_f32, 4_f32));
+});
+
+glam_test!(test_vec3a_swizzles, {
+    let v = vec3a(1_f32, 2_f32, 3_f32);
+    assert_eq!(v, v.xyz());
+    assert_eq!(v.xxxx(), vec4(1_f32, 1_f32, 1_f32, 1_f32));
+    assert_eq!(v.xxxy(), vec4(1_f32, 1_f32, 1_f32, 2_f32));
+    assert_eq!(v.xxxz(), vec4(1_f32, 1_f32, 1_f32, 3_f32));
+    assert_eq!(v.xxyx(), vec4(1_f32, 1_f32, 2_f32, 1_f32));
+    assert_eq!(v.xxyy(), vec4(1_f32, 1_f32, 2_f32, 2_f32));
+    assert_eq!(v.xxyz(), vec4(1_f32, 1_f32, 2_f32, 3_f32));
+    assert_eq!(v.xxzx(), vec4(1_f32, 1_f32, 3_f32, 1_f32));
+    assert_eq!(v.xxzy(), vec4(1_f32, 1_f32, 3_f32, 2_f32));
+    assert_eq!(v.xxzz(), vec4(1_f32, 1_f32, 3_f32, 3_f32));
+    assert_eq!(v.xyxx(), vec4(1_f32, 2_f32, 1_f32, 1_f32));
+    assert_eq!(v.xyxy(), vec4(1_f32, 2_f32, 1_f32, 2_f32));
+    assert_eq!(v.xyxz(), vec4(1_f32, 2_f32, 1_f32, 3_f32));
+    assert_eq!(v.xyyx(), vec4(1_f32, 2_f32, 2_f32, 1_f32));
+    assert_eq!(v.xyyy(), vec4(1_f32, 2_f32, 2_f32, 2_f32));
+    assert_eq!(v.xyyz(), vec4(1_f32, 2_f32, 2_f32, 3_f32));
+    assert_eq!(v.xyzx(), vec4(1_f32, 2_f32, 3_f32, 1_f32));
+    assert_eq!(v.xyzy(), vec4(1_f32, 2_f32, 3_f32, 2_f32));
+    assert_eq!(v.xyzz(), vec4(1_f32, 2_f32, 3_f32, 3_f32));
+    assert_eq!(v.xzxx(), vec4(1_f32, 3_f32, 1_f32, 1_f32));
+    assert_eq!(v.xzxy(), vec4(1_f32, 3_f32, 1_f32, 2_f32));
+    assert_eq!(v.xzxz(), vec4(1_f32, 3_f32, 1_f32, 3_f32));
+    assert_eq!(v.xzyx(), vec4(1_f32, 3_f32, 2_f32, 1_f32));
+    assert_eq!(v.xzyy(), vec4(1_f32, 3_f32, 2_f32, 2_f32));
+    assert_eq!(v.xzyz(), vec4(1_f32, 3_f32, 2_f32, 3_f32));
+    assert_eq!(v.xzzx(), vec4(1_f32, 3_f32, 3_f32, 1_f32));
+    assert_eq!(v.xzzy(), vec4(1_f32, 3_f32, 3_f32, 2_f32));
+    assert_eq!(v.xzzz(), vec4(1_f32, 3_f32, 3_f32, 3_f32));
+    assert_eq!(v.yxxx(), vec4(2_f32, 1_f32, 1_f32, 1_f32));
+    assert_eq!(v.yxxy(), vec4(2_f32, 1_f32, 1_f32, 2_f32));
+    assert_eq!(v.yxxz(), vec4(2_f32, 1_f32, 1_f32, 3_f32));
+    assert_eq!(v.yxyx(), vec4(2_f32, 1_f32, 2_f32, 1_f32));
+    assert_eq!(v.yxyy(), vec4(2_f32, 1_f32, 2_f32, 2_f32));
+    assert_eq!(v.yxyz(), vec4(2_f32, 1_f32, 2_f32, 3_f32));
+    assert_eq!(v.yxzx(), vec4(2_f32, 1_f32, 3_f32, 1_f32));
+    assert_eq!(v.yxzy(), vec4(2_f32, 1_f32, 3_f32, 2_f32));
+    assert_eq!(v.yxzz(), vec4(2_f32, 1_f32, 3_f32, 3_f32));
+    assert_eq!(v.yyxx(), vec4(2_f32, 2_f32, 1_f32, 1_f32));
+    assert_eq!(v.yyxy(), vec4(2_f32, 2_f32, 1_f32, 2_f32));
+    assert_eq!(v.yyxz(), vec4(2_f32, 2_f32, 1_f32, 3_f32));
+    assert_eq!(v.yyyx(), vec4(2_f32, 2_f32, 2_f32, 1_f32));
+    assert_eq!(v.yyyy(), vec4(2_f32, 2_f32, 2_f32, 2_f32));
+    assert_eq!(v.yyyz(), vec4(2_f32, 2_f32, 2_f32, 3_f32));
+    assert_eq!(v.yyzx(), vec4(2_f32, 2_f32, 3_f32, 1_f32));
+    assert_eq!(v.yyzy(), vec4(2_f32, 2_f32, 3_f32, 2_f32));
+    assert_eq!(v.yyzz(), vec4(2_f32, 2_f32, 3_f32, 3_f32));
+    assert_eq!(v.yzxx(), vec4(2_f32, 3_f32, 1_f32, 1_f32));
+    assert_eq!(v.yzxy(), vec4(2_f32, 3_f32, 1_f32, 2_f32));
+    assert_eq!(v.yzxz(), vec4(2_f32, 3_f32, 1_f32, 3_f32));
+    assert_eq!(v.yzyx(), vec4(2_f32, 3_f32, 2_f32, 1_f32));
+    assert_eq!(v.yzyy(), vec4(2_f32, 3_f32, 2_f32, 2_f32));
+    assert_eq!(v.yzyz(), vec4(2_f32, 3_f32, 2_f32, 3_f32));
+    assert_eq!(v.yzzx(), vec4(2_f32, 3_f32, 3_f32, 1_f32));
+    assert_eq!(v.yzzy(), vec4(2_f32, 3_f32, 3_f32, 2_f32));
+    assert_eq!(v.yzzz(), vec4(2_f32, 3_f32, 3_f32, 3_f32));
+    assert_eq!(v.zxxx(), vec4(3_f32, 1_f32, 1_f32, 1_f32));
+    assert_eq!(v.zxxy(), vec4(3_f32, 1_f32, 1_f32, 2_f32));
+    assert_eq!(v.zxxz(), vec4(3_f32, 1_f32, 1_f32, 3_f32));
+    assert_eq!(v.zxyx(), vec4(3_f32, 1_f32, 2_f32, 1_f32));
+    assert_eq!(v.zxyy(), vec4(3_f32, 1_f32, 2_f32, 2_f32));
+    assert_eq!(v.zxyz(), vec4(3_f32, 1_f32, 2_f32, 3_f32));
+    assert_eq!(v.zxzx(), vec4(3_f32, 1_f32, 3_f32, 1_f32));
+    assert_eq!(v.zxzy(), vec4(3_f32, 1_f32, 3_f32, 2_f32));
+    assert_eq!(v.zxzz(), vec4(3_f32, 1_f32, 3_f32, 3_f32));
+    assert_eq!(v.zyxx(), vec4(3_f32, 2_f32, 1_f32, 1_f32));
+    assert_eq!(v.zyxy(), vec4(3_f32, 2_f32, 1_f32, 2_f32));
+    assert_eq!(v.zyxz(), vec4(3_f32, 2_f32, 1_f32, 3_f32));
+    assert_eq!(v.zyyx(), vec4(3_f32, 2_f32, 2_f32, 1_f32));
+    assert_eq!(v.zyyy(), vec4(3_f32, 2_f32, 2_f32, 2_f32));
+    assert_eq!(v.zyyz(), vec4(3_f32, 2_f32, 2_f32, 3_f32));
+    assert_eq!(v.zyzx(), vec4(3_f32, 2_f32, 3_f32, 1_f32));
+    assert_eq!(v.zyzy(), vec4(3_f32, 2_f32, 3_f32, 2_f32));
+    assert_eq!(v.zyzz(), vec4(3_f32, 2_f32, 3_f32, 3_f32));
+    assert_eq!(v.zzxx(), vec4(3_f32, 3_f32, 1_f32, 1_f32));
+    assert_eq!(v.zzxy(), vec4(3_f32, 3_f32, 1_f32, 2_f32));
+    assert_eq!(v.zzxz(), vec4(3_f32, 3_f32, 1_f32, 3_f32));
+    assert_eq!(v.zzyx(), vec4(3_f32, 3_f32, 2_f32, 1_f32));
+    assert_eq!(v.zzyy(), vec4(3_f32, 3_f32, 2_f32, 2_f32));
+    assert_eq!(v.zzyz(), vec4(3_f32, 3_f32, 2_f32, 3_f32));
+    assert_eq!(v.zzzx(), vec4(3_f32, 3_f32, 3_f32, 1_f32));
+    assert_eq!(v.zzzy(), vec4(3_f32, 3_f32, 3_f32, 2_f32));
+    assert_eq!(v.zzzz(), vec4(3_f32, 3_f32, 3_f32, 3_f32));
+    assert_eq!(v.xxx(), vec3a(1_f32, 1_f32, 1_f32));
+    assert_eq!(v.xxy(), vec3a(1_f32, 1_f32, 2_f32));
+    assert_eq!(v.xxz(), vec3a(1_f32, 1_f32, 3_f32));
+    assert_eq!(v.xyx(), vec3a(1_f32, 2_f32, 1_f32));
+    assert_eq!(v.xyy(), vec3a(1_f32, 2_f32, 2_f32));
+    assert_eq!(v.xzx(), vec3a(1_f32, 3_f32, 1_f32));
+    assert_eq!(v.xzy(), vec3a(1_f32, 3_f32, 2_f32));
+    assert_eq!(v.xzz(), vec3a(1_f32, 3_f32, 3_f32));
+    assert_eq!(v.yxx(), vec3a(2_f32, 1_f32, 1_f32));
+    assert_eq!(v.yxy(), vec3a(2_f32, 1_f32, 2_f32));
+    assert_eq!(v.yxz(), vec3a(2_f32, 1_f32, 3_f32));
+    assert_eq!(v.yyx(), vec3a(2_f32, 2_f32, 1_f32));
+    assert_eq!(v.yyy(), vec3a(2_f32, 2_f32, 2_f32));
+    assert_eq!(v.yyz(), vec3a(2_f32, 2_f32, 3_f32));
+    assert_eq!(v.yzx(), vec3a(2_f32, 3_f32, 1_f32));
+    assert_eq!(v.yzy(), vec3a(2_f32, 3_f32, 2_f32));
+    assert_eq!(v.yzz(), vec3a(2_f32, 3_f32, 3_f32));
+    assert_eq!(v.zxx(), vec3a(3_f32, 1_f32, 1_f32));
+    assert_eq!(v.zxy(), vec3a(3_f32, 1_f32, 2_f32));
+    assert_eq!(v.zxz(), vec3a(3_f32, 1_f32, 3_f32));
+    assert_eq!(v.zyx(), vec3a(3_f32, 2_f32, 1_f32));
+    assert_eq!(v.zyy(), vec3a(3_f32, 2_f32, 2_f32));
+    assert_eq!(v.zyz(), vec3a(3_f32, 2_f32, 3_f32));
+    assert_eq!(v.zzx(), vec3a(3_f32, 3_f32, 1_f32));
+    assert_eq!(v.zzy(), vec3a(3_f32, 3_f32, 2_f32));
+    assert_eq!(v.zzz(), vec3a(3_f32, 3_f32, 3_f32));
+    assert_eq!(v.xx(), vec2(1_f32, 1_f32));
+    assert_eq!(v.xy(), vec2(1_f32, 2_f32));
+    assert_eq!(v.xz(), vec2(1_f32, 3_f32));
+    assert_eq!(v.yx(), vec2(2_f32, 1_f32));
+    assert_eq!(v.yy(), vec2(2_f32, 2_f32));
+    assert_eq!(v.yz(), vec2(2_f32, 3_f32));
+    assert_eq!(v.zx(), vec2(3_f32, 1_f32));
+    assert_eq!(v.zy(), vec2(3_f32, 2_f32));
+    assert_eq!(v.zz(), vec2(3_f32, 3_f32));
+});
+
+glam_test!(test_vec3_swizzles, {
+    let v = vec3(1_f32, 2_f32, 3_f32);
+    assert_eq!(v, v.xyz());
+    assert_eq!(v.xxxx(), vec4(1_f32, 1_f32, 1_f32, 1_f32));
+    assert_eq!(v.xxxy(), vec4(1_f32, 1_f32, 1_f32, 2_f32));
+    assert_eq!(v.xxxz(), vec4(1_f32, 1_f32, 1_f32, 3_f32));
+    assert_eq!(v.xxyx(), vec4(1_f32, 1_f32, 2_f32, 1_f32));
+    assert_eq!(v.xxyy(), vec4(1_f32, 1_f32, 2_f32, 2_f32));
+    assert_eq!(v.xxyz(), vec4(1_f32, 1_f32, 2_f32, 3_f32));
+    assert_eq!(v.xxzx(), vec4(1_f32, 1_f32, 3_f32, 1_f32));
+    assert_eq!(v.xxzy(), vec4(1_f32, 1_f32, 3_f32, 2_f32));
+    assert_eq!(v.xxzz(), vec4(1_f32, 1_f32, 3_f32, 3_f32));
+    assert_eq!(v.xyxx(), vec4(1_f32, 2_f32, 1_f32, 1_f32));
+    assert_eq!(v.xyxy(), vec4(1_f32, 2_f32, 1_f32, 2_f32));
+    assert_eq!(v.xyxz(), vec4(1_f32, 2_f32, 1_f32, 3_f32));
+    assert_eq!(v.xyyx(), vec4(1_f32, 2_f32, 2_f32, 1_f32));
+    assert_eq!(v.xyyy(), vec4(1_f32, 2_f32, 2_f32, 2_f32));
+    assert_eq!(v.xyyz(), vec4(1_f32, 2_f32, 2_f32, 3_f32));
+    assert_eq!(v.xyzx(), vec4(1_f32, 2_f32, 3_f32, 1_f32));
+    assert_eq!(v.xyzy(), vec4(1_f32, 2_f32, 3_f32, 2_f32));
+    assert_eq!(v.xyzz(), vec4(1_f32, 2_f32, 3_f32, 3_f32));
+    assert_eq!(v.xzxx(), vec4(1_f32, 3_f32, 1_f32, 1_f32));
+    assert_eq!(v.xzxy(), vec4(1_f32, 3_f32, 1_f32, 2_f32));
+    assert_eq!(v.xzxz(), vec4(1_f32, 3_f32, 1_f32, 3_f32));
+    assert_eq!(v.xzyx(), vec4(1_f32, 3_f32, 2_f32, 1_f32));
+    assert_eq!(v.xzyy(), vec4(1_f32, 3_f32, 2_f32, 2_f32));
+    assert_eq!(v.xzyz(), vec4(1_f32, 3_f32, 2_f32, 3_f32));
+    assert_eq!(v.xzzx(), vec4(1_f32, 3_f32, 3_f32, 1_f32));
+    assert_eq!(v.xzzy(), vec4(1_f32, 3_f32, 3_f32, 2_f32));
+    assert_eq!(v.xzzz(), vec4(1_f32, 3_f32, 3_f32, 3_f32));
+    assert_eq!(v.yxxx(), vec4(2_f32, 1_f32, 1_f32, 1_f32));
+    assert_eq!(v.yxxy(), vec4(2_f32, 1_f32, 1_f32, 2_f32));
+    assert_eq!(v.yxxz(), vec4(2_f32, 1_f32, 1_f32, 3_f32));
+    assert_eq!(v.yxyx(), vec4(2_f32, 1_f32, 2_f32, 1_f32));
+    assert_eq!(v.yxyy(), vec4(2_f32, 1_f32, 2_f32, 2_f32));
+    assert_eq!(v.yxyz(), vec4(2_f32, 1_f32, 2_f32, 3_f32));
+    assert_eq!(v.yxzx(), vec4(2_f32, 1_f32, 3_f32, 1_f32));
+    assert_eq!(v.yxzy(), vec4(2_f32, 1_f32, 3_f32, 2_f32));
+    assert_eq!(v.yxzz(), vec4(2_f32, 1_f32, 3_f32, 3_f32));
+    assert_eq!(v.yyxx(), vec4(2_f32, 2_f32, 1_f32, 1_f32));
+    assert_eq!(v.yyxy(), vec4(2_f32, 2_f32, 1_f32, 2_f32));
+    assert_eq!(v.yyxz(), vec4(2_f32, 2_f32, 1_f32, 3_f32));
+    assert_eq!(v.yyyx(), vec4(2_f32, 2_f32, 2_f32, 1_f32));
+    assert_eq!(v.yyyy(), vec4(2_f32, 2_f32, 2_f32, 2_f32));
+    assert_eq!(v.yyyz(), vec4(2_f32, 2_f32, 2_f32, 3_f32));
+    assert_eq!(v.yyzx(), vec4(2_f32, 2_f32, 3_f32, 1_f32));
+    assert_eq!(v.yyzy(), vec4(2_f32, 2_f32, 3_f32, 2_f32));
+    assert_eq!(v.yyzz(), vec4(2_f32, 2_f32, 3_f32, 3_f32));
+    assert_eq!(v.yzxx(), vec4(2_f32, 3_f32, 1_f32, 1_f32));
+    assert_eq!(v.yzxy(), vec4(2_f32, 3_f32, 1_f32, 2_f32));
+    assert_eq!(v.yzxz(), vec4(2_f32, 3_f32, 1_f32, 3_f32));
+    assert_eq!(v.yzyx(), vec4(2_f32, 3_f32, 2_f32, 1_f32));
+    assert_eq!(v.yzyy(), vec4(2_f32, 3_f32, 2_f32, 2_f32));
+    assert_eq!(v.yzyz(), vec4(2_f32, 3_f32, 2_f32, 3_f32));
+    assert_eq!(v.yzzx(), vec4(2_f32, 3_f32, 3_f32, 1_f32));
+    assert_eq!(v.yzzy(), vec4(2_f32, 3_f32, 3_f32, 2_f32));
+    assert_eq!(v.yzzz(), vec4(2_f32, 3_f32, 3_f32, 3_f32));
+    assert_eq!(v.zxxx(), vec4(3_f32, 1_f32, 1_f32, 1_f32));
+    assert_eq!(v.zxxy(), vec4(3_f32, 1_f32, 1_f32, 2_f32));
+    assert_eq!(v.zxxz(), vec4(3_f32, 1_f32, 1_f32, 3_f32));
+    assert_eq!(v.zxyx(), vec4(3_f32, 1_f32, 2_f32, 1_f32));
+    assert_eq!(v.zxyy(), vec4(3_f32, 1_f32, 2_f32, 2_f32));
+    assert_eq!(v.zxyz(), vec4(3_f32, 1_f32, 2_f32, 3_f32));
+    assert_eq!(v.zxzx(), vec4(3_f32, 1_f32, 3_f32, 1_f32));
+    assert_eq!(v.zxzy(), vec4(3_f32, 1_f32, 3_f32, 2_f32));
+    assert_eq!(v.zxzz(), vec4(3_f32, 1_f32, 3_f32, 3_f32));
+    assert_eq!(v.zyxx(), vec4(3_f32, 2_f32, 1_f32, 1_f32));
+    assert_eq!(v.zyxy(), vec4(3_f32, 2_f32, 1_f32, 2_f32));
+    assert_eq!(v.zyxz(), vec4(3_f32, 2_f32, 1_f32, 3_f32));
+    assert_eq!(v.zyyx(), vec4(3_f32, 2_f32, 2_f32, 1_f32));
+    assert_eq!(v.zyyy(), vec4(3_f32, 2_f32, 2_f32, 2_f32));
+    assert_eq!(v.zyyz(), vec4(3_f32, 2_f32, 2_f32, 3_f32));
+    assert_eq!(v.zyzx(), vec4(3_f32, 2_f32, 3_f32, 1_f32));
+    assert_eq!(v.zyzy(), vec4(3_f32, 2_f32, 3_f32, 2_f32));
+    assert_eq!(v.zyzz(), vec4(3_f32, 2_f32, 3_f32, 3_f32));
+    assert_eq!(v.zzxx(), vec4(3_f32, 3_f32, 1_f32, 1_f32));
+    assert_eq!(v.zzxy(), vec4(3_f32, 3_f32, 1_f32, 2_f32));
+    assert_eq!(v.zzxz(), vec4(3_f32, 3_f32, 1_f32, 3_f32));
+    assert_eq!(v.zzyx(), vec4(3_f32, 3_f32, 2_f32, 1_f32));
+    assert_eq!(v.zzyy(), vec4(3_f32, 3_f32, 2_f32, 2_f32));
+    assert_eq!(v.zzyz(), vec4(3_f32, 3_f32, 2_f32, 3_f32));
+    assert_eq!(v.zzzx(), vec4(3_f32, 3_f32, 3_f32, 1_f32));
+    assert_eq!(v.zzzy(), vec4(3_f32, 3_f32, 3_f32, 2_f32));
+    assert_eq!(v.zzzz(), vec4(3_f32, 3_f32, 3_f32, 3_f32));
+    assert_eq!(v.xxx(), vec3(1_f32, 1_f32, 1_f32));
+    assert_eq!(v.xxy(), vec3(1_f32, 1_f32, 2_f32));
+    assert_eq!(v.xxz(), vec3(1_f32, 1_f32, 3_f32));
+    assert_eq!(v.xyx(), vec3(1_f32, 2_f32, 1_f32));
+    assert_eq!(v.xyy(), vec3(1_f32, 2_f32, 2_f32));
+    assert_eq!(v.xzx(), vec3(1_f32, 3_f32, 1_f32));
+    assert_eq!(v.xzy(), vec3(1_f32, 3_f32, 2_f32));
+    assert_eq!(v.xzz(), vec3(1_f32, 3_f32, 3_f32));
+    assert_eq!(v.yxx(), vec3(2_f32, 1_f32, 1_f32));
+    assert_eq!(v.yxy(), vec3(2_f32, 1_f32, 2_f32));
+    assert_eq!(v.yxz(), vec3(2_f32, 1_f32, 3_f32));
+    assert_eq!(v.yyx(), vec3(2_f32, 2_f32, 1_f32));
+    assert_eq!(v.yyy(), vec3(2_f32, 2_f32, 2_f32));
+    assert_eq!(v.yyz(), vec3(2_f32, 2_f32, 3_f32));
+    assert_eq!(v.yzx(), vec3(2_f32, 3_f32, 1_f32));
+    assert_eq!(v.yzy(), vec3(2_f32, 3_f32, 2_f32));
+    assert_eq!(v.yzz(), vec3(2_f32, 3_f32, 3_f32));
+    assert_eq!(v.zxx(), vec3(3_f32, 1_f32, 1_f32));
+    assert_eq!(v.zxy(), vec3(3_f32, 1_f32, 2_f32));
+    assert_eq!(v.zxz(), vec3(3_f32, 1_f32, 3_f32));
+    assert_eq!(v.zyx(), vec3(3_f32, 2_f32, 1_f32));
+    assert_eq!(v.zyy(), vec3(3_f32, 2_f32, 2_f32));
+    assert_eq!(v.zyz(), vec3(3_f32, 2_f32, 3_f32));
+    assert_eq!(v.zzx(), vec3(3_f32, 3_f32, 1_f32));
+    assert_eq!(v.zzy(), vec3(3_f32, 3_f32, 2_f32));
+    assert_eq!(v.zzz(), vec3(3_f32, 3_f32, 3_f32));
+    assert_eq!(v.xx(), vec2(1_f32, 1_f32));
+    assert_eq!(v.xy(), vec2(1_f32, 2_f32));
+    assert_eq!(v.xz(), vec2(1_f32, 3_f32));
+    assert_eq!(v.yx(), vec2(2_f32, 1_f32));
+    assert_eq!(v.yy(), vec2(2_f32, 2_f32));
+    assert_eq!(v.yz(), vec2(2_f32, 3_f32));
+    assert_eq!(v.zx(), vec2(3_f32, 1_f32));
+    assert_eq!(v.zy(), vec2(3_f32, 2_f32));
+    assert_eq!(v.zz(), vec2(3_f32, 3_f32));
+});
+
+glam_test!(test_vec2_swizzles, {
+    let v = vec2(1_f32, 2_f32);
+    assert_eq!(v, v.xy());
+    assert_eq!(v.xxxx(), vec4(1_f32, 1_f32, 1_f32, 1_f32));
+    assert_eq!(v.xxxy(), vec4(1_f32, 1_f32, 1_f32, 2_f32));
+    assert_eq!(v.xxyx(), vec4(1_f32, 1_f32, 2_f32, 1_f32));
+    assert_eq!(v.xxyy(), vec4(1_f32, 1_f32, 2_f32, 2_f32));
+    assert_eq!(v.xyxx(), vec4(1_f32, 2_f32, 1_f32, 1_f32));
+    assert_eq!(v.xyxy(), vec4(1_f32, 2_f32, 1_f32, 2_f32));
+    assert_eq!(v.xyyx(), vec4(1_f32, 2_f32, 2_f32, 1_f32));
+    assert_eq!(v.xyyy(), vec4(1_f32, 2_f32, 2_f32, 2_f32));
+    assert_eq!(v.yxxx(), vec4(2_f32, 1_f32, 1_f32, 1_f32));
+    assert_eq!(v.yxxy(), vec4(2_f32, 1_f32, 1_f32, 2_f32));
+    assert_eq!(v.yxyx(), vec4(2_f32, 1_f32, 2_f32, 1_f32));
+    assert_eq!(v.yxyy(), vec4(2_f32, 1_f32, 2_f32, 2_f32));
+    assert_eq!(v.yyxx(), vec4(2_f32, 2_f32, 1_f32, 1_f32));
+    assert_eq!(v.yyxy(), vec4(2_f32, 2_f32, 1_f32, 2_f32));
+    assert_eq!(v.yyyx(), vec4(2_f32, 2_f32, 2_f32, 1_f32));
+    assert_eq!(v.yyyy(), vec4(2_f32, 2_f32, 2_f32, 2_f32));
+    assert_eq!(v.xxx(), vec3(1_f32, 1_f32, 1_f32));
+    assert_eq!(v.xxy(), vec3(1_f32, 1_f32, 2_f32));
+    assert_eq!(v.xyx(), vec3(1_f32, 2_f32, 1_f32));
+    assert_eq!(v.xyy(), vec3(1_f32, 2_f32, 2_f32));
+    assert_eq!(v.yxx(), vec3(2_f32, 1_f32, 1_f32));
+    assert_eq!(v.yxy(), vec3(2_f32, 1_f32, 2_f32));
+    assert_eq!(v.yyx(), vec3(2_f32, 2_f32, 1_f32));
+    assert_eq!(v.yyy(), vec3(2_f32, 2_f32, 2_f32));
+    assert_eq!(v.xx(), vec2(1_f32, 1_f32));
+    assert_eq!(v.yx(), vec2(2_f32, 1_f32));
+    assert_eq!(v.yy(), vec2(2_f32, 2_f32));
+});

vendor/glam/tests/swizzles_f64.rs

@@ -0,0 +1,501 @@
+// Generated by swizzlegen. Do not edit.
+#[macro_use]
+mod support;
+use glam::*;
+
+glam_test!(test_dvec4_swizzles, {
+    let v = dvec4(1_f64, 2_f64, 3_f64, 4_f64);
+    assert_eq!(v, v.xyzw());
+    assert_eq!(v.xxxx(), dvec4(1_f64, 1_f64, 1_f64, 1_f64));
+    assert_eq!(v.xxxy(), dvec4(1_f64, 1_f64, 1_f64, 2_f64));
+    assert_eq!(v.xxxz(), dvec4(1_f64, 1_f64, 1_f64, 3_f64));
+    assert_eq!(v.xxxw(), dvec4(1_f64, 1_f64, 1_f64, 4_f64));
+    assert_eq!(v.xxyx(), dvec4(1_f64, 1_f64, 2_f64, 1_f64));
+    assert_eq!(v.xxyy(), dvec4(1_f64, 1_f64, 2_f64, 2_f64));
+    assert_eq!(v.xxyz(), dvec4(1_f64, 1_f64, 2_f64, 3_f64));
+    assert_eq!(v.xxyw(), dvec4(1_f64, 1_f64, 2_f64, 4_f64));
+    assert_eq!(v.xxzx(), dvec4(1_f64, 1_f64, 3_f64, 1_f64));
+    assert_eq!(v.xxzy(), dvec4(1_f64, 1_f64, 3_f64, 2_f64));
+    assert_eq!(v.xxzz(), dvec4(1_f64, 1_f64, 3_f64, 3_f64));
+    assert_eq!(v.xxzw(), dvec4(1_f64, 1_f64, 3_f64, 4_f64));
+    assert_eq!(v.xxwx(), dvec4(1_f64, 1_f64, 4_f64, 1_f64));
+    assert_eq!(v.xxwy(), dvec4(1_f64, 1_f64, 4_f64, 2_f64));
+    assert_eq!(v.xxwz(), dvec4(1_f64, 1_f64, 4_f64, 3_f64));
+    assert_eq!(v.xxww(), dvec4(1_f64, 1_f64, 4_f64, 4_f64));
+    assert_eq!(v.xyxx(), dvec4(1_f64, 2_f64, 1_f64, 1_f64));
+    assert_eq!(v.xyxy(), dvec4(1_f64, 2_f64, 1_f64, 2_f64));
+    assert_eq!(v.xyxz(), dvec4(1_f64, 2_f64, 1_f64, 3_f64));
+    assert_eq!(v.xyxw(), dvec4(1_f64, 2_f64, 1_f64, 4_f64));
+    assert_eq!(v.xyyx(), dvec4(1_f64, 2_f64, 2_f64, 1_f64));
+    assert_eq!(v.xyyy(), dvec4(1_f64, 2_f64, 2_f64, 2_f64));
+    assert_eq!(v.xyyz(), dvec4(1_f64, 2_f64, 2_f64, 3_f64));
+    assert_eq!(v.xyyw(), dvec4(1_f64, 2_f64, 2_f64, 4_f64));
+    assert_eq!(v.xyzx(), dvec4(1_f64, 2_f64, 3_f64, 1_f64));
+    assert_eq!(v.xyzy(), dvec4(1_f64, 2_f64, 3_f64, 2_f64));
+    assert_eq!(v.xyzz(), dvec4(1_f64, 2_f64, 3_f64, 3_f64));
+    assert_eq!(v.xywx(), dvec4(1_f64, 2_f64, 4_f64, 1_f64));
+    assert_eq!(v.xywy(), dvec4(1_f64, 2_f64, 4_f64, 2_f64));
+    assert_eq!(v.xywz(), dvec4(1_f64, 2_f64, 4_f64, 3_f64));
+    assert_eq!(v.xyww(), dvec4(1_f64, 2_f64, 4_f64, 4_f64));
+    assert_eq!(v.xzxx(), dvec4(1_f64, 3_f64, 1_f64, 1_f64));
+    assert_eq!(v.xzxy(), dvec4(1_f64, 3_f64, 1_f64, 2_f64));
+    assert_eq!(v.xzxz(), dvec4(1_f64, 3_f64, 1_f64, 3_f64));
+    assert_eq!(v.xzxw(), dvec4(1_f64, 3_f64, 1_f64, 4_f64));
+    assert_eq!(v.xzyx(), dvec4(1_f64, 3_f64, 2_f64, 1_f64));
+    assert_eq!(v.xzyy(), dvec4(1_f64, 3_f64, 2_f64, 2_f64));
+    assert_eq!(v.xzyz(), dvec4(1_f64, 3_f64, 2_f64, 3_f64));
+    assert_eq!(v.xzyw(), dvec4(1_f64, 3_f64, 2_f64, 4_f64));
+    assert_eq!(v.xzzx(), dvec4(1_f64, 3_f64, 3_f64, 1_f64));
+    assert_eq!(v.xzzy(), dvec4(1_f64, 3_f64, 3_f64, 2_f64));
+    assert_eq!(v.xzzz(), dvec4(1_f64, 3_f64, 3_f64, 3_f64));
+    assert_eq!(v.xzzw(), dvec4(1_f64, 3_f64, 3_f64, 4_f64));
+    assert_eq!(v.xzwx(), dvec4(1_f64, 3_f64, 4_f64, 1_f64));
+    assert_eq!(v.xzwy(), dvec4(1_f64, 3_f64, 4_f64, 2_f64));
+    assert_eq!(v.xzwz(), dvec4(1_f64, 3_f64, 4_f64, 3_f64));
+    assert_eq!(v.xzww(), dvec4(1_f64, 3_f64, 4_f64, 4_f64));
+    assert_eq!(v.xwxx(), dvec4(1_f64, 4_f64, 1_f64, 1_f64));
+    assert_eq!(v.xwxy(), dvec4(1_f64, 4_f64, 1_f64, 2_f64));
+    assert_eq!(v.xwxz(), dvec4(1_f64, 4_f64, 1_f64, 3_f64));
+    assert_eq!(v.xwxw(), dvec4(1_f64, 4_f64, 1_f64, 4_f64));
+    assert_eq!(v.xwyx(), dvec4(1_f64, 4_f64, 2_f64, 1_f64));
+    assert_eq!(v.xwyy(), dvec4(1_f64, 4_f64, 2_f64, 2_f64));
+    assert_eq!(v.xwyz(), dvec4(1_f64, 4_f64, 2_f64, 3_f64));
+    assert_eq!(v.xwyw(), dvec4(1_f64, 4_f64, 2_f64, 4_f64));
+    assert_eq!(v.xwzx(), dvec4(1_f64, 4_f64, 3_f64, 1_f64));
+    assert_eq!(v.xwzy(), dvec4(1_f64, 4_f64, 3_f64, 2_f64));
+    assert_eq!(v.xwzz(), dvec4(1_f64, 4_f64, 3_f64, 3_f64));
+    assert_eq!(v.xwzw(), dvec4(1_f64, 4_f64, 3_f64, 4_f64));
+    assert_eq!(v.xwwx(), dvec4(1_f64, 4_f64, 4_f64, 1_f64));
+    assert_eq!(v.xwwy(), dvec4(1_f64, 4_f64, 4_f64, 2_f64));
+    assert_eq!(v.xwwz(), dvec4(1_f64, 4_f64, 4_f64, 3_f64));
+    assert_eq!(v.xwww(), dvec4(1_f64, 4_f64, 4_f64, 4_f64));
+    assert_eq!(v.yxxx(), dvec4(2_f64, 1_f64, 1_f64, 1_f64));
+    assert_eq!(v.yxxy(), dvec4(2_f64, 1_f64, 1_f64, 2_f64));
+    assert_eq!(v.yxxz(), dvec4(2_f64, 1_f64, 1_f64, 3_f64));
+    assert_eq!(v.yxxw(), dvec4(2_f64, 1_f64, 1_f64, 4_f64));
+    assert_eq!(v.yxyx(), dvec4(2_f64, 1_f64, 2_f64, 1_f64));
+    assert_eq!(v.yxyy(), dvec4(2_f64, 1_f64, 2_f64, 2_f64));
+    assert_eq!(v.yxyz(), dvec4(2_f64, 1_f64, 2_f64, 3_f64));
+    assert_eq!(v.yxyw(), dvec4(2_f64, 1_f64, 2_f64, 4_f64));
+    assert_eq!(v.yxzx(), dvec4(2_f64, 1_f64, 3_f64, 1_f64));
+    assert_eq!(v.yxzy(), dvec4(2_f64, 1_f64, 3_f64, 2_f64));
+    assert_eq!(v.yxzz(), dvec4(2_f64, 1_f64, 3_f64, 3_f64));
+    assert_eq!(v.yxzw(), dvec4(2_f64, 1_f64, 3_f64, 4_f64));
+    assert_eq!(v.yxwx(), dvec4(2_f64, 1_f64, 4_f64, 1_f64));
+    assert_eq!(v.yxwy(), dvec4(2_f64, 1_f64, 4_f64, 2_f64));
+    assert_eq!(v.yxwz(), dvec4(2_f64, 1_f64, 4_f64, 3_f64));
+    assert_eq!(v.yxww(), dvec4(2_f64, 1_f64, 4_f64, 4_f64));
+    assert_eq!(v.yyxx(), dvec4(2_f64, 2_f64, 1_f64, 1_f64));
+    assert_eq!(v.yyxy(), dvec4(2_f64, 2_f64, 1_f64, 2_f64));
+    assert_eq!(v.yyxz(), dvec4(2_f64, 2_f64, 1_f64, 3_f64));
+    assert_eq!(v.yyxw(), dvec4(2_f64, 2_f64, 1_f64, 4_f64));
+    assert_eq!(v.yyyx(), dvec4(2_f64, 2_f64, 2_f64, 1_f64));
+    assert_eq!(v.yyyy(), dvec4(2_f64, 2_f64, 2_f64, 2_f64));
+    assert_eq!(v.yyyz(), dvec4(2_f64, 2_f64, 2_f64, 3_f64));
+    assert_eq!(v.yyyw(), dvec4(2_f64, 2_f64, 2_f64, 4_f64));
+    assert_eq!(v.yyzx(), dvec4(2_f64, 2_f64, 3_f64, 1_f64));
+    assert_eq!(v.yyzy(), dvec4(2_f64, 2_f64, 3_f64, 2_f64));
+    assert_eq!(v.yyzz(), dvec4(2_f64, 2_f64, 3_f64, 3_f64));
+    assert_eq!(v.yyzw(), dvec4(2_f64, 2_f64, 3_f64, 4_f64));
+    assert_eq!(v.yywx(), dvec4(2_f64, 2_f64, 4_f64, 1_f64));
+    assert_eq!(v.yywy(), dvec4(2_f64, 2_f64, 4_f64, 2_f64));
+    assert_eq!(v.yywz(), dvec4(2_f64, 2_f64, 4_f64, 3_f64));
+    assert_eq!(v.yyww(), dvec4(2_f64, 2_f64, 4_f64, 4_f64));
+    assert_eq!(v.yzxx(), dvec4(2_f64, 3_f64, 1_f64, 1_f64));
+    assert_eq!(v.yzxy(), dvec4(2_f64, 3_f64, 1_f64, 2_f64));
+    assert_eq!(v.yzxz(), dvec4(2_f64, 3_f64, 1_f64, 3_f64));
+    assert_eq!(v.yzxw(), dvec4(2_f64, 3_f64, 1_f64, 4_f64));
+    assert_eq!(v.yzyx(), dvec4(2_f64, 3_f64, 2_f64, 1_f64));
+    assert_eq!(v.yzyy(), dvec4(2_f64, 3_f64, 2_f64, 2_f64));
+    assert_eq!(v.yzyz(), dvec4(2_f64, 3_f64, 2_f64, 3_f64));
+    assert_eq!(v.yzyw(), dvec4(2_f64, 3_f64, 2_f64, 4_f64));
+    assert_eq!(v.yzzx(), dvec4(2_f64, 3_f64, 3_f64, 1_f64));
+    assert_eq!(v.yzzy(), dvec4(2_f64, 3_f64, 3_f64, 2_f64));
+    assert_eq!(v.yzzz(), dvec4(2_f64, 3_f64, 3_f64, 3_f64));
+    assert_eq!(v.yzzw(), dvec4(2_f64, 3_f64, 3_f64, 4_f64));
+    assert_eq!(v.yzwx(), dvec4(2_f64, 3_f64, 4_f64, 1_f64));
+    assert_eq!(v.yzwy(), dvec4(2_f64, 3_f64, 4_f64, 2_f64));
+    assert_eq!(v.yzwz(), dvec4(2_f64, 3_f64, 4_f64, 3_f64));
+    assert_eq!(v.yzww(), dvec4(2_f64, 3_f64, 4_f64, 4_f64));
+    assert_eq!(v.ywxx(), dvec4(2_f64, 4_f64, 1_f64, 1_f64));
+    assert_eq!(v.ywxy(), dvec4(2_f64, 4_f64, 1_f64, 2_f64));
+    assert_eq!(v.ywxz(), dvec4(2_f64, 4_f64, 1_f64, 3_f64));
+    assert_eq!(v.ywxw(), dvec4(2_f64, 4_f64, 1_f64, 4_f64));
+    assert_eq!(v.ywyx(), dvec4(2_f64, 4_f64, 2_f64, 1_f64));
+    assert_eq!(v.ywyy(), dvec4(2_f64, 4_f64, 2_f64, 2_f64));
+    assert_eq!(v.ywyz(), dvec4(2_f64, 4_f64, 2_f64, 3_f64));
+    assert_eq!(v.ywyw(), dvec4(2_f64, 4_f64, 2_f64, 4_f64));
+    assert_eq!(v.ywzx(), dvec4(2_f64, 4_f64, 3_f64, 1_f64));
+    assert_eq!(v.ywzy(), dvec4(2_f64, 4_f64, 3_f64, 2_f64));
+    assert_eq!(v.ywzz(), dvec4(2_f64, 4_f64, 3_f64, 3_f64));
+    assert_eq!(v.ywzw(), dvec4(2_f64, 4_f64, 3_f64, 4_f64));
+    assert_eq!(v.ywwx(), dvec4(2_f64, 4_f64, 4_f64, 1_f64));
+    assert_eq!(v.ywwy(), dvec4(2_f64, 4_f64, 4_f64, 2_f64));
+    assert_eq!(v.ywwz(), dvec4(2_f64, 4_f64, 4_f64, 3_f64));
+    assert_eq!(v.ywww(), dvec4(2_f64, 4_f64, 4_f64, 4_f64));
+    assert_eq!(v.zxxx(), dvec4(3_f64, 1_f64, 1_f64, 1_f64));
+    assert_eq!(v.zxxy(), dvec4(3_f64, 1_f64, 1_f64, 2_f64));
+    assert_eq!(v.zxxz(), dvec4(3_f64, 1_f64, 1_f64, 3_f64));
+    assert_eq!(v.zxxw(), dvec4(3_f64, 1_f64, 1_f64, 4_f64));
+    assert_eq!(v.zxyx(), dvec4(3_f64, 1_f64, 2_f64, 1_f64));
+    assert_eq!(v.zxyy(), dvec4(3_f64, 1_f64, 2_f64, 2_f64));
+    assert_eq!(v.zxyz(), dvec4(3_f64, 1_f64, 2_f64, 3_f64));
+    assert_eq!(v.zxyw(), dvec4(3_f64, 1_f64, 2_f64, 4_f64));
+    assert_eq!(v.zxzx(), dvec4(3_f64, 1_f64, 3_f64, 1_f64));
+    assert_eq!(v.zxzy(), dvec4(3_f64, 1_f64, 3_f64, 2_f64));
+    assert_eq!(v.zxzz(), dvec4(3_f64, 1_f64, 3_f64, 3_f64));
+    assert_eq!(v.zxzw(), dvec4(3_f64, 1_f64, 3_f64, 4_f64));
+    assert_eq!(v.zxwx(), dvec4(3_f64, 1_f64, 4_f64, 1_f64));
+    assert_eq!(v.zxwy(), dvec4(3_f64, 1_f64, 4_f64, 2_f64));
+    assert_eq!(v.zxwz(), dvec4(3_f64, 1_f64, 4_f64, 3_f64));
+    assert_eq!(v.zxww(), dvec4(3_f64, 1_f64, 4_f64, 4_f64));
+    assert_eq!(v.zyxx(), dvec4(3_f64, 2_f64, 1_f64, 1_f64));
+    assert_eq!(v.zyxy(), dvec4(3_f64, 2_f64, 1_f64, 2_f64));
+    assert_eq!(v.zyxz(), dvec4(3_f64, 2_f64, 1_f64, 3_f64));
+    assert_eq!(v.zyxw(), dvec4(3_f64, 2_f64, 1_f64, 4_f64));
+    assert_eq!(v.zyyx(), dvec4(3_f64, 2_f64, 2_f64, 1_f64));
+    assert_eq!(v.zyyy(), dvec4(3_f64, 2_f64, 2_f64, 2_f64));
+    assert_eq!(v.zyyz(), dvec4(3_f64, 2_f64, 2_f64, 3_f64));
+    assert_eq!(v.zyyw(), dvec4(3_f64, 2_f64, 2_f64, 4_f64));
+    assert_eq!(v.zyzx(), dvec4(3_f64, 2_f64, 3_f64, 1_f64));
+    assert_eq!(v.zyzy(), dvec4(3_f64, 2_f64, 3_f64, 2_f64));
+    assert_eq!(v.zyzz(), dvec4(3_f64, 2_f64, 3_f64, 3_f64));
+    assert_eq!(v.zyzw(), dvec4(3_f64, 2_f64, 3_f64, 4_f64));
+    assert_eq!(v.zywx(), dvec4(3_f64, 2_f64, 4_f64, 1_f64));
+    assert_eq!(v.zywy(), dvec4(3_f64, 2_f64, 4_f64, 2_f64));
+    assert_eq!(v.zywz(), dvec4(3_f64, 2_f64, 4_f64, 3_f64));
+    assert_eq!(v.zyww(), dvec4(3_f64, 2_f64, 4_f64, 4_f64));
+    assert_eq!(v.zzxx(), dvec4(3_f64, 3_f64, 1_f64, 1_f64));
+    assert_eq!(v.zzxy(), dvec4(3_f64, 3_f64, 1_f64, 2_f64));
+    assert_eq!(v.zzxz(), dvec4(3_f64, 3_f64, 1_f64, 3_f64));
+    assert_eq!(v.zzxw(), dvec4(3_f64, 3_f64, 1_f64, 4_f64));
+    assert_eq!(v.zzyx(), dvec4(3_f64, 3_f64, 2_f64, 1_f64));
+    assert_eq!(v.zzyy(), dvec4(3_f64, 3_f64, 2_f64, 2_f64));
+    assert_eq!(v.zzyz(), dvec4(3_f64, 3_f64, 2_f64, 3_f64));
+    assert_eq!(v.zzyw(), dvec4(3_f64, 3_f64, 2_f64, 4_f64));
+    assert_eq!(v.zzzx(), dvec4(3_f64, 3_f64, 3_f64, 1_f64));
+    assert_eq!(v.zzzy(), dvec4(3_f64, 3_f64, 3_f64, 2_f64));
+    assert_eq!(v.zzzz(), dvec4(3_f64, 3_f64, 3_f64, 3_f64));
+    assert_eq!(v.zzzw(), dvec4(3_f64, 3_f64, 3_f64, 4_f64));
+    assert_eq!(v.zzwx(), dvec4(3_f64, 3_f64, 4_f64, 1_f64));
+    assert_eq!(v.zzwy(), dvec4(3_f64, 3_f64, 4_f64, 2_f64));
+    assert_eq!(v.zzwz(), dvec4(3_f64, 3_f64, 4_f64, 3_f64));
+    assert_eq!(v.zzww(), dvec4(3_f64, 3_f64, 4_f64, 4_f64));
+    assert_eq!(v.zwxx(), dvec4(3_f64, 4_f64, 1_f64, 1_f64));
+    assert_eq!(v.zwxy(), dvec4(3_f64, 4_f64, 1_f64, 2_f64));
+    assert_eq!(v.zwxz(), dvec4(3_f64, 4_f64, 1_f64, 3_f64));
+    assert_eq!(v.zwxw(), dvec4(3_f64, 4_f64, 1_f64, 4_f64));
+    assert_eq!(v.zwyx(), dvec4(3_f64, 4_f64, 2_f64, 1_f64));
+    assert_eq!(v.zwyy(), dvec4(3_f64, 4_f64, 2_f64, 2_f64));
+    assert_eq!(v.zwyz(), dvec4(3_f64, 4_f64, 2_f64, 3_f64));
+    assert_eq!(v.zwyw(), dvec4(3_f64, 4_f64, 2_f64, 4_f64));
+    assert_eq!(v.zwzx(), dvec4(3_f64, 4_f64, 3_f64, 1_f64));
+    assert_eq!(v.zwzy(), dvec4(3_f64, 4_f64, 3_f64, 2_f64));
+    assert_eq!(v.zwzz(), dvec4(3_f64, 4_f64, 3_f64, 3_f64));
+    assert_eq!(v.zwzw(), dvec4(3_f64, 4_f64, 3_f64, 4_f64));
+    assert_eq!(v.zwwx(), dvec4(3_f64, 4_f64, 4_f64, 1_f64));
+    assert_eq!(v.zwwy(), dvec4(3_f64, 4_f64, 4_f64, 2_f64));
+    assert_eq!(v.zwwz(), dvec4(3_f64, 4_f64, 4_f64, 3_f64));
+    assert_eq!(v.zwww(), dvec4(3_f64, 4_f64, 4_f64, 4_f64));
+    assert_eq!(v.wxxx(), dvec4(4_f64, 1_f64, 1_f64, 1_f64));
+    assert_eq!(v.wxxy(), dvec4(4_f64, 1_f64, 1_f64, 2_f64));
+    assert_eq!(v.wxxz(), dvec4(4_f64, 1_f64, 1_f64, 3_f64));
+    assert_eq!(v.wxxw(), dvec4(4_f64, 1_f64, 1_f64, 4_f64));
+    assert_eq!(v.wxyx(), dvec4(4_f64, 1_f64, 2_f64, 1_f64));
+    assert_eq!(v.wxyy(), dvec4(4_f64, 1_f64, 2_f64, 2_f64));
+    assert_eq!(v.wxyz(), dvec4(4_f64, 1_f64, 2_f64, 3_f64));
+    assert_eq!(v.wxyw(), dvec4(4_f64, 1_f64, 2_f64, 4_f64));
+    assert_eq!(v.wxzx(), dvec4(4_f64, 1_f64, 3_f64, 1_f64));
+    assert_eq!(v.wxzy(), dvec4(4_f64, 1_f64, 3_f64, 2_f64));
+    assert_eq!(v.wxzz(), dvec4(4_f64, 1_f64, 3_f64, 3_f64));
+    assert_eq!(v.wxzw(), dvec4(4_f64, 1_f64, 3_f64, 4_f64));
+    assert_eq!(v.wxwx(), dvec4(4_f64, 1_f64, 4_f64, 1_f64));
+    assert_eq!(v.wxwy(), dvec4(4_f64, 1_f64, 4_f64, 2_f64));
+    assert_eq!(v.wxwz(), dvec4(4_f64, 1_f64, 4_f64, 3_f64));
+    assert_eq!(v.wxww(), dvec4(4_f64, 1_f64, 4_f64, 4_f64));
+    assert_eq!(v.wyxx(), dvec4(4_f64, 2_f64, 1_f64, 1_f64));
+    assert_eq!(v.wyxy(), dvec4(4_f64, 2_f64, 1_f64, 2_f64));
+    assert_eq!(v.wyxz(), dvec4(4_f64, 2_f64, 1_f64, 3_f64));
+    assert_eq!(v.wyxw(), dvec4(4_f64, 2_f64, 1_f64, 4_f64));
+    assert_eq!(v.wyyx(), dvec4(4_f64, 2_f64, 2_f64, 1_f64));
+    assert_eq!(v.wyyy(), dvec4(4_f64, 2_f64, 2_f64, 2_f64));
+    assert_eq!(v.wyyz(), dvec4(4_f64, 2_f64, 2_f64, 3_f64));
+    assert_eq!(v.wyyw(), dvec4(4_f64, 2_f64, 2_f64, 4_f64));
+    assert_eq!(v.wyzx(), dvec4(4_f64, 2_f64, 3_f64, 1_f64));
+    assert_eq!(v.wyzy(), dvec4(4_f64, 2_f64, 3_f64, 2_f64));
+    assert_eq!(v.wyzz(), dvec4(4_f64, 2_f64, 3_f64, 3_f64));
+    assert_eq!(v.wyzw(), dvec4(4_f64, 2_f64, 3_f64, 4_f64));
+    assert_eq!(v.wywx(), dvec4(4_f64, 2_f64, 4_f64, 1_f64));
+    assert_eq!(v.wywy(), dvec4(4_f64, 2_f64, 4_f64, 2_f64));
+    assert_eq!(v.wywz(), dvec4(4_f64, 2_f64, 4_f64, 3_f64));
+    assert_eq!(v.wyww(), dvec4(4_f64, 2_f64, 4_f64, 4_f64));
+    assert_eq!(v.wzxx(), dvec4(4_f64, 3_f64, 1_f64, 1_f64));
+    assert_eq!(v.wzxy(), dvec4(4_f64, 3_f64, 1_f64, 2_f64));
+    assert_eq!(v.wzxz(), dvec4(4_f64, 3_f64, 1_f64, 3_f64));
+    assert_eq!(v.wzxw(), dvec4(4_f64, 3_f64, 1_f64, 4_f64));
+    assert_eq!(v.wzyx(), dvec4(4_f64, 3_f64, 2_f64, 1_f64));
+    assert_eq!(v.wzyy(), dvec4(4_f64, 3_f64, 2_f64, 2_f64));
+    assert_eq!(v.wzyz(), dvec4(4_f64, 3_f64, 2_f64, 3_f64));
+    assert_eq!(v.wzyw(), dvec4(4_f64, 3_f64, 2_f64, 4_f64));
+    assert_eq!(v.wzzx(), dvec4(4_f64, 3_f64, 3_f64, 1_f64));
+    assert_eq!(v.wzzy(), dvec4(4_f64, 3_f64, 3_f64, 2_f64));
+    assert_eq!(v.wzzz(), dvec4(4_f64, 3_f64, 3_f64, 3_f64));
+    assert_eq!(v.wzzw(), dvec4(4_f64, 3_f64, 3_f64, 4_f64));
+    assert_eq!(v.wzwx(), dvec4(4_f64, 3_f64, 4_f64, 1_f64));
+    assert_eq!(v.wzwy(), dvec4(4_f64, 3_f64, 4_f64, 2_f64));
+    assert_eq!(v.wzwz(), dvec4(4_f64, 3_f64, 4_f64, 3_f64));
+    assert_eq!(v.wzww(), dvec4(4_f64, 3_f64, 4_f64, 4_f64));
+    assert_eq!(v.wwxx(), dvec4(4_f64, 4_f64, 1_f64, 1_f64));
+    assert_eq!(v.wwxy(), dvec4(4_f64, 4_f64, 1_f64, 2_f64));
+    assert_eq!(v.wwxz(), dvec4(4_f64, 4_f64, 1_f64, 3_f64));
+    assert_eq!(v.wwxw(), dvec4(4_f64, 4_f64, 1_f64, 4_f64));
+    assert_eq!(v.wwyx(), dvec4(4_f64, 4_f64, 2_f64, 1_f64));
+    assert_eq!(v.wwyy(), dvec4(4_f64, 4_f64, 2_f64, 2_f64));
+    assert_eq!(v.wwyz(), dvec4(4_f64, 4_f64, 2_f64, 3_f64));
+    assert_eq!(v.wwyw(), dvec4(4_f64, 4_f64, 2_f64, 4_f64));
+    assert_eq!(v.wwzx(), dvec4(4_f64, 4_f64, 3_f64, 1_f64));
+    assert_eq!(v.wwzy(), dvec4(4_f64, 4_f64, 3_f64, 2_f64));
+    assert_eq!(v.wwzz(), dvec4(4_f64, 4_f64, 3_f64, 3_f64));
+    assert_eq!(v.wwzw(), dvec4(4_f64, 4_f64, 3_f64, 4_f64));
+    assert_eq!(v.wwwx(), dvec4(4_f64, 4_f64, 4_f64, 1_f64));
+    assert_eq!(v.wwwy(), dvec4(4_f64, 4_f64, 4_f64, 2_f64));
+    assert_eq!(v.wwwz(), dvec4(4_f64, 4_f64, 4_f64, 3_f64));
+    assert_eq!(v.wwww(), dvec4(4_f64, 4_f64, 4_f64, 4_f64));
+});
+
+glam_test!(test_dvec4_swizzles_2, {
+    let v = dvec4(1_f64, 2_f64, 3_f64, 4_f64);
+    assert_eq!(v.xxx(), dvec3(1_f64, 1_f64, 1_f64));
+    assert_eq!(v.xxy(), dvec3(1_f64, 1_f64, 2_f64));
+    assert_eq!(v.xxz(), dvec3(1_f64, 1_f64, 3_f64));
+    assert_eq!(v.xxw(), dvec3(1_f64, 1_f64, 4_f64));
+    assert_eq!(v.xyx(), dvec3(1_f64, 2_f64, 1_f64));
+    assert_eq!(v.xyy(), dvec3(1_f64, 2_f64, 2_f64));
+    assert_eq!(v.xyz(), dvec3(1_f64, 2_f64, 3_f64));
+    assert_eq!(v.xyw(), dvec3(1_f64, 2_f64, 4_f64));
+    assert_eq!(v.xzx(), dvec3(1_f64, 3_f64, 1_f64));
+    assert_eq!(v.xzy(), dvec3(1_f64, 3_f64, 2_f64));
+    assert_eq!(v.xzz(), dvec3(1_f64, 3_f64, 3_f64));
+    assert_eq!(v.xzw(), dvec3(1_f64, 3_f64, 4_f64));
+    assert_eq!(v.xwx(), dvec3(1_f64, 4_f64, 1_f64));
+    assert_eq!(v.xwy(), dvec3(1_f64, 4_f64, 2_f64));
+    assert_eq!(v.xwz(), dvec3(1_f64, 4_f64, 3_f64));
+    assert_eq!(v.xww(), dvec3(1_f64, 4_f64, 4_f64));
+    assert_eq!(v.yxx(), dvec3(2_f64, 1_f64, 1_f64));
+    assert_eq!(v.yxy(), dvec3(2_f64, 1_f64, 2_f64));
+    assert_eq!(v.yxz(), dvec3(2_f64, 1_f64, 3_f64));
+    assert_eq!(v.yxw(), dvec3(2_f64, 1_f64, 4_f64));
+    assert_eq!(v.yyx(), dvec3(2_f64, 2_f64, 1_f64));
+    assert_eq!(v.yyy(), dvec3(2_f64, 2_f64, 2_f64));
+    assert_eq!(v.yyz(), dvec3(2_f64, 2_f64, 3_f64));
+    assert_eq!(v.yyw(), dvec3(2_f64, 2_f64, 4_f64));
+    assert_eq!(v.yzx(), dvec3(2_f64, 3_f64, 1_f64));
+    assert_eq!(v.yzy(), dvec3(2_f64, 3_f64, 2_f64));
+    assert_eq!(v.yzz(), dvec3(2_f64, 3_f64, 3_f64));
+    assert_eq!(v.yzw(), dvec3(2_f64, 3_f64, 4_f64));
+    assert_eq!(v.ywx(), dvec3(2_f64, 4_f64, 1_f64));
+    assert_eq!(v.ywy(), dvec3(2_f64, 4_f64, 2_f64));
+    assert_eq!(v.ywz(), dvec3(2_f64, 4_f64, 3_f64));
+    assert_eq!(v.yww(), dvec3(2_f64, 4_f64, 4_f64));
+    assert_eq!(v.zxx(), dvec3(3_f64, 1_f64, 1_f64));
+    assert_eq!(v.zxy(), dvec3(3_f64, 1_f64, 2_f64));
+    assert_eq!(v.zxz(), dvec3(3_f64, 1_f64, 3_f64));
+    assert_eq!(v.zxw(), dvec3(3_f64, 1_f64, 4_f64));
+    assert_eq!(v.zyx(), dvec3(3_f64, 2_f64, 1_f64));
+    assert_eq!(v.zyy(), dvec3(3_f64, 2_f64, 2_f64));
+    assert_eq!(v.zyz(), dvec3(3_f64, 2_f64, 3_f64));
+    assert_eq!(v.zyw(), dvec3(3_f64, 2_f64, 4_f64));
+    assert_eq!(v.zzx(), dvec3(3_f64, 3_f64, 1_f64));
+    assert_eq!(v.zzy(), dvec3(3_f64, 3_f64, 2_f64));
+    assert_eq!(v.zzz(), dvec3(3_f64, 3_f64, 3_f64));
+    assert_eq!(v.zzw(), dvec3(3_f64, 3_f64, 4_f64));
+    assert_eq!(v.zwx(), dvec3(3_f64, 4_f64, 1_f64));
+    assert_eq!(v.zwy(), dvec3(3_f64, 4_f64, 2_f64));
+    assert_eq!(v.zwz(), dvec3(3_f64, 4_f64, 3_f64));
+    assert_eq!(v.zww(), dvec3(3_f64, 4_f64, 4_f64));
+    assert_eq!(v.wxx(), dvec3(4_f64, 1_f64, 1_f64));
+    assert_eq!(v.wxy(), dvec3(4_f64, 1_f64, 2_f64));
+    assert_eq!(v.wxz(), dvec3(4_f64, 1_f64, 3_f64));
+    assert_eq!(v.wxw(), dvec3(4_f64, 1_f64, 4_f64));
+    assert_eq!(v.wyx(), dvec3(4_f64, 2_f64, 1_f64));
+    assert_eq!(v.wyy(), dvec3(4_f64, 2_f64, 2_f64));
+    assert_eq!(v.wyz(), dvec3(4_f64, 2_f64, 3_f64));
+    assert_eq!(v.wyw(), dvec3(4_f64, 2_f64, 4_f64));
+    assert_eq!(v.wzx(), dvec3(4_f64, 3_f64, 1_f64));
+    assert_eq!(v.wzy(), dvec3(4_f64, 3_f64, 2_f64));
+    assert_eq!(v.wzz(), dvec3(4_f64, 3_f64, 3_f64));
+    assert_eq!(v.wzw(), dvec3(4_f64, 3_f64, 4_f64));
+    assert_eq!(v.wwx(), dvec3(4_f64, 4_f64, 1_f64));
+    assert_eq!(v.wwy(), dvec3(4_f64, 4_f64, 2_f64));
+    assert_eq!(v.wwz(), dvec3(4_f64, 4_f64, 3_f64));
+    assert_eq!(v.www(), dvec3(4_f64, 4_f64, 4_f64));
+    assert_eq!(v.xx(), dvec2(1_f64, 1_f64));
+    assert_eq!(v.xy(), dvec2(1_f64, 2_f64));
+    assert_eq!(v.xz(), dvec2(1_f64, 3_f64));
+    assert_eq!(v.xw(), dvec2(1_f64, 4_f64));
+    assert_eq!(v.yx(), dvec2(2_f64, 1_f64));
+    assert_eq!(v.yy(), dvec2(2_f64, 2_f64));
+    assert_eq!(v.yz(), dvec2(2_f64, 3_f64));
+    assert_eq!(v.yw(), dvec2(2_f64, 4_f64));
+    assert_eq!(v.zx(), dvec2(3_f64, 1_f64));
+    assert_eq!(v.zy(), dvec2(3_f64, 2_f64));
+    assert_eq!(v.zz(), dvec2(3_f64, 3_f64));
+    assert_eq!(v.zw(), dvec2(3_f64, 4_f64));
+    assert_eq!(v.wx(), dvec2(4_f64, 1_f64));
+    assert_eq!(v.wy(), dvec2(4_f64, 2_f64));
+    assert_eq!(v.wz(), dvec2(4_f64, 3_f64));
+    assert_eq!(v.ww(), dvec2(4_f64, 4_f64));
+});
+
+glam_test!(test_dvec3_swizzles, {
+    let v = dvec3(1_f64, 2_f64, 3_f64);
+    assert_eq!(v, v.xyz());
+    assert_eq!(v.xxxx(), dvec4(1_f64, 1_f64, 1_f64, 1_f64));
+    assert_eq!(v.xxxy(), dvec4(1_f64, 1_f64, 1_f64, 2_f64));
+    assert_eq!(v.xxxz(), dvec4(1_f64, 1_f64, 1_f64, 3_f64));
+    assert_eq!(v.xxyx(), dvec4(1_f64, 1_f64, 2_f64, 1_f64));
+    assert_eq!(v.xxyy(), dvec4(1_f64, 1_f64, 2_f64, 2_f64));
+    assert_eq!(v.xxyz(), dvec4(1_f64, 1_f64, 2_f64, 3_f64));
+    assert_eq!(v.xxzx(), dvec4(1_f64, 1_f64, 3_f64, 1_f64));
+    assert_eq!(v.xxzy(), dvec4(1_f64, 1_f64, 3_f64, 2_f64));
+    assert_eq!(v.xxzz(), dvec4(1_f64, 1_f64, 3_f64, 3_f64));
+    assert_eq!(v.xyxx(), dvec4(1_f64, 2_f64, 1_f64, 1_f64));
+    assert_eq!(v.xyxy(), dvec4(1_f64, 2_f64, 1_f64, 2_f64));
+    assert_eq!(v.xyxz(), dvec4(1_f64, 2_f64, 1_f64, 3_f64));
+    assert_eq!(v.xyyx(), dvec4(1_f64, 2_f64, 2_f64, 1_f64));
+    assert_eq!(v.xyyy(), dvec4(1_f64, 2_f64, 2_f64, 2_f64));
+    assert_eq!(v.xyyz(), dvec4(1_f64, 2_f64, 2_f64, 3_f64));
+    assert_eq!(v.xyzx(), dvec4(1_f64, 2_f64, 3_f64, 1_f64));
+    assert_eq!(v.xyzy(), dvec4(1_f64, 2_f64, 3_f64, 2_f64));
+    assert_eq!(v.xyzz(), dvec4(1_f64, 2_f64, 3_f64, 3_f64));
+    assert_eq!(v.xzxx(), dvec4(1_f64, 3_f64, 1_f64, 1_f64));
+    assert_eq!(v.xzxy(), dvec4(1_f64, 3_f64, 1_f64, 2_f64));
+    assert_eq!(v.xzxz(), dvec4(1_f64, 3_f64, 1_f64, 3_f64));
+    assert_eq!(v.xzyx(), dvec4(1_f64, 3_f64, 2_f64, 1_f64));
+    assert_eq!(v.xzyy(), dvec4(1_f64, 3_f64, 2_f64, 2_f64));
+    assert_eq!(v.xzyz(), dvec4(1_f64, 3_f64, 2_f64, 3_f64));
+    assert_eq!(v.xzzx(), dvec4(1_f64, 3_f64, 3_f64, 1_f64));
+    assert_eq!(v.xzzy(), dvec4(1_f64, 3_f64, 3_f64, 2_f64));
+    assert_eq!(v.xzzz(), dvec4(1_f64, 3_f64, 3_f64, 3_f64));
+    assert_eq!(v.yxxx(), dvec4(2_f64, 1_f64, 1_f64, 1_f64));
+    assert_eq!(v.yxxy(), dvec4(2_f64, 1_f64, 1_f64, 2_f64));
+    assert_eq!(v.yxxz(), dvec4(2_f64, 1_f64, 1_f64, 3_f64));
+    assert_eq!(v.yxyx(), dvec4(2_f64, 1_f64, 2_f64, 1_f64));
+    assert_eq!(v.yxyy(), dvec4(2_f64, 1_f64, 2_f64, 2_f64));
+    assert_eq!(v.yxyz(), dvec4(2_f64, 1_f64, 2_f64, 3_f64));
+    assert_eq!(v.yxzx(), dvec4(2_f64, 1_f64, 3_f64, 1_f64));
+    assert_eq!(v.yxzy(), dvec4(2_f64, 1_f64, 3_f64, 2_f64));
+    assert_eq!(v.yxzz(), dvec4(2_f64, 1_f64, 3_f64, 3_f64));
+    assert_eq!(v.yyxx(), dvec4(2_f64, 2_f64, 1_f64, 1_f64));
+    assert_eq!(v.yyxy(), dvec4(2_f64, 2_f64, 1_f64, 2_f64));
+    assert_eq!(v.yyxz(), dvec4(2_f64, 2_f64, 1_f64, 3_f64));
+    assert_eq!(v.yyyx(), dvec4(2_f64, 2_f64, 2_f64, 1_f64));
+    assert_eq!(v.yyyy(), dvec4(2_f64, 2_f64, 2_f64, 2_f64));
+    assert_eq!(v.yyyz(), dvec4(2_f64, 2_f64, 2_f64, 3_f64));
+    assert_eq!(v.yyzx(), dvec4(2_f64, 2_f64, 3_f64, 1_f64));
+    assert_eq!(v.yyzy(), dvec4(2_f64, 2_f64, 3_f64, 2_f64));
+    assert_eq!(v.yyzz(), dvec4(2_f64, 2_f64, 3_f64, 3_f64));
+    assert_eq!(v.yzxx(), dvec4(2_f64, 3_f64, 1_f64, 1_f64));
+    assert_eq!(v.yzxy(), dvec4(2_f64, 3_f64, 1_f64, 2_f64));
+    assert_eq!(v.yzxz(), dvec4(2_f64, 3_f64, 1_f64, 3_f64));
+    assert_eq!(v.yzyx(), dvec4(2_f64, 3_f64, 2_f64, 1_f64));
+    assert_eq!(v.yzyy(), dvec4(2_f64, 3_f64, 2_f64, 2_f64));
+    assert_eq!(v.yzyz(), dvec4(2_f64, 3_f64, 2_f64, 3_f64));
+    assert_eq!(v.yzzx(), dvec4(2_f64, 3_f64, 3_f64, 1_f64));
+    assert_eq!(v.yzzy(), dvec4(2_f64, 3_f64, 3_f64, 2_f64));
+    assert_eq!(v.yzzz(), dvec4(2_f64, 3_f64, 3_f64, 3_f64));
+    assert_eq!(v.zxxx(), dvec4(3_f64, 1_f64, 1_f64, 1_f64));
+    assert_eq!(v.zxxy(), dvec4(3_f64, 1_f64, 1_f64, 2_f64));
+    assert_eq!(v.zxxz(), dvec4(3_f64, 1_f64, 1_f64, 3_f64));
+    assert_eq!(v.zxyx(), dvec4(3_f64, 1_f64, 2_f64, 1_f64));
+    assert_eq!(v.zxyy(), dvec4(3_f64, 1_f64, 2_f64, 2_f64));
+    assert_eq!(v.zxyz(), dvec4(3_f64, 1_f64, 2_f64, 3_f64));
+    assert_eq!(v.zxzx(), dvec4(3_f64, 1_f64, 3_f64, 1_f64));
+    assert_eq!(v.zxzy(), dvec4(3_f64, 1_f64, 3_f64, 2_f64));
+    assert_eq!(v.zxzz(), dvec4(3_f64, 1_f64, 3_f64, 3_f64));
+    assert_eq!(v.zyxx(), dvec4(3_f64, 2_f64, 1_f64, 1_f64));
+    assert_eq!(v.zyxy(), dvec4(3_f64, 2_f64, 1_f64, 2_f64));
+    assert_eq!(v.zyxz(), dvec4(3_f64, 2_f64, 1_f64, 3_f64));
+    assert_eq!(v.zyyx(), dvec4(3_f64, 2_f64, 2_f64, 1_f64));
+    assert_eq!(v.zyyy(), dvec4(3_f64, 2_f64, 2_f64, 2_f64));
+    assert_eq!(v.zyyz(), dvec4(3_f64, 2_f64, 2_f64, 3_f64));
+    assert_eq!(v.zyzx(), dvec4(3_f64, 2_f64, 3_f64, 1_f64));
+    assert_eq!(v.zyzy(), dvec4(3_f64, 2_f64, 3_f64, 2_f64));
+    assert_eq!(v.zyzz(), dvec4(3_f64, 2_f64, 3_f64, 3_f64));
+    assert_eq!(v.zzxx(), dvec4(3_f64, 3_f64, 1_f64, 1_f64));
+    assert_eq!(v.zzxy(), dvec4(3_f64, 3_f64, 1_f64, 2_f64));
+    assert_eq!(v.zzxz(), dvec4(3_f64, 3_f64, 1_f64, 3_f64));
+    assert_eq!(v.zzyx(), dvec4(3_f64, 3_f64, 2_f64, 1_f64));
+    assert_eq!(v.zzyy(), dvec4(3_f64, 3_f64, 2_f64, 2_f64));
+    assert_eq!(v.zzyz(), dvec4(3_f64, 3_f64, 2_f64, 3_f64));
+    assert_eq!(v.zzzx(), dvec4(3_f64, 3_f64, 3_f64, 1_f64));
+    assert_eq!(v.zzzy(), dvec4(3_f64, 3_f64, 3_f64, 2_f64));
+    assert_eq!(v.zzzz(), dvec4(3_f64, 3_f64, 3_f64, 3_f64));
+    assert_eq!(v.xxx(), dvec3(1_f64, 1_f64, 1_f64));
+    assert_eq!(v.xxy(), dvec3(1_f64, 1_f64, 2_f64));
+    assert_eq!(v.xxz(), dvec3(1_f64, 1_f64, 3_f64));
+    assert_eq!(v.xyx(), dvec3(1_f64, 2_f64, 1_f64));
+    assert_eq!(v.xyy(), dvec3(1_f64, 2_f64, 2_f64));
+    assert_eq!(v.xzx(), dvec3(1_f64, 3_f64, 1_f64));
+    assert_eq!(v.xzy(), dvec3(1_f64, 3_f64, 2_f64));
+    assert_eq!(v.xzz(), dvec3(1_f64, 3_f64, 3_f64));
+    assert_eq!(v.yxx(), dvec3(2_f64, 1_f64, 1_f64));
+    assert_eq!(v.yxy(), dvec3(2_f64, 1_f64, 2_f64));
+    assert_eq!(v.yxz(), dvec3(2_f64, 1_f64, 3_f64));
+    assert_eq!(v.yyx(), dvec3(2_f64, 2_f64, 1_f64));
+    assert_eq!(v.yyy(), dvec3(2_f64, 2_f64, 2_f64));
+    assert_eq!(v.yyz(), dvec3(2_f64, 2_f64, 3_f64));
+    assert_eq!(v.yzx(), dvec3(2_f64, 3_f64, 1_f64));
+    assert_eq!(v.yzy(), dvec3(2_f64, 3_f64, 2_f64));
+    assert_eq!(v.yzz(), dvec3(2_f64, 3_f64, 3_f64));
+    assert_eq!(v.zxx(), dvec3(3_f64, 1_f64, 1_f64));
+    assert_eq!(v.zxy(), dvec3(3_f64, 1_f64, 2_f64));
+    assert_eq!(v.zxz(), dvec3(3_f64, 1_f64, 3_f64));
+    assert_eq!(v.zyx(), dvec3(3_f64, 2_f64, 1_f64));
+    assert_eq!(v.zyy(), dvec3(3_f64, 2_f64, 2_f64));
+    assert_eq!(v.zyz(), dvec3(3_f64, 2_f64, 3_f64));
+    assert_eq!(v.zzx(), dvec3(3_f64, 3_f64, 1_f64));
+    assert_eq!(v.zzy(), dvec3(3_f64, 3_f64, 2_f64));
+    assert_eq!(v.zzz(), dvec3(3_f64, 3_f64, 3_f64));
+    assert_eq!(v.xx(), dvec2(1_f64, 1_f64));
+    assert_eq!(v.xy(), dvec2(1_f64, 2_f64));
+    assert_eq!(v.xz(), dvec2(1_f64, 3_f64));
+    assert_eq!(v.yx(), dvec2(2_f64, 1_f64));
+    assert_eq!(v.yy(), dvec2(2_f64, 2_f64));
+    assert_eq!(v.yz(), dvec2(2_f64, 3_f64));
+    assert_eq!(v.zx(), dvec2(3_f64, 1_f64));
+    assert_eq!(v.zy(), dvec2(3_f64, 2_f64));
+    assert_eq!(v.zz(), dvec2(3_f64, 3_f64));
+});
+
+glam_test!(test_dvec2_swizzles, {
+    let v = dvec2(1_f64, 2_f64);
+    assert_eq!(v, v.xy());
+    assert_eq!(v.xxxx(), dvec4(1_f64, 1_f64, 1_f64, 1_f64));
+    assert_eq!(v.xxxy(), dvec4(1_f64, 1_f64, 1_f64, 2_f64));
+    assert_eq!(v.xxyx(), dvec4(1_f64, 1_f64, 2_f64, 1_f64));
+    assert_eq!(v.xxyy(), dvec4(1_f64, 1_f64, 2_f64, 2_f64));
+    assert_eq!(v.xyxx(), dvec4(1_f64, 2_f64, 1_f64, 1_f64));
+    assert_eq!(v.xyxy(), dvec4(1_f64, 2_f64, 1_f64, 2_f64));
+    assert_eq!(v.xyyx(), dvec4(1_f64, 2_f64, 2_f64, 1_f64));
+    assert_eq!(v.xyyy(), dvec4(1_f64, 2_f64, 2_f64, 2_f64));
+    assert_eq!(v.yxxx(), dvec4(2_f64, 1_f64, 1_f64, 1_f64));
+    assert_eq!(v.yxxy(), dvec4(2_f64, 1_f64, 1_f64, 2_f64));
+    assert_eq!(v.yxyx(), dvec4(2_f64, 1_f64, 2_f64, 1_f64));
+    assert_eq!(v.yxyy(), dvec4(2_f64, 1_f64, 2_f64, 2_f64));
+    assert_eq!(v.yyxx(), dvec4(2_f64, 2_f64, 1_f64, 1_f64));
+    assert_eq!(v.yyxy(), dvec4(2_f64, 2_f64, 1_f64, 2_f64));
+    assert_eq!(v.yyyx(), dvec4(2_f64, 2_f64, 2_f64, 1_f64));
+    assert_eq!(v.yyyy(), dvec4(2_f64, 2_f64, 2_f64, 2_f64));
+    assert_eq!(v.xxx(), dvec3(1_f64, 1_f64, 1_f64));
+    assert_eq!(v.xxy(), dvec3(1_f64, 1_f64, 2_f64));
+    assert_eq!(v.xyx(), dvec3(1_f64, 2_f64, 1_f64));
+    assert_eq!(v.xyy(), dvec3(1_f64, 2_f64, 2_f64));
+    assert_eq!(v.yxx(), dvec3(2_f64, 1_f64, 1_f64));
+    assert_eq!(v.yxy(), dvec3(2_f64, 1_f64, 2_f64));
+    assert_eq!(v.yyx(), dvec3(2_f64, 2_f64, 1_f64));
+    assert_eq!(v.yyy(), dvec3(2_f64, 2_f64, 2_f64));
+    assert_eq!(v.xx(), dvec2(1_f64, 1_f64));
+    assert_eq!(v.yx(), dvec2(2_f64, 1_f64));
+    assert_eq!(v.yy(), dvec2(2_f64, 2_f64));
+});

vendor/glam/tests/swizzles_i16.rs

@@ -0,0 +1,497 @@
+// Generated by swizzlegen. Do not edit.
+#[macro_use]
+mod support;
+use glam::*;
+
+glam_test!(test_i16vec4_swizzles, {
+    let v = i16vec4(1_i16, 2_i16, 3_i16, 4_i16);
+    assert_eq!(v, v.xyzw());
+    assert_eq!(v.xxxx(), i16vec4(1_i16, 1_i16, 1_i16, 1_i16));
+    assert_eq!(v.xxxy(), i16vec4(1_i16, 1_i16, 1_i16, 2_i16));
+    assert_eq!(v.xxxz(), i16vec4(1_i16, 1_i16, 1_i16, 3_i16));
+    assert_eq!(v.xxxw(), i16vec4(1_i16, 1_i16, 1_i16, 4_i16));
+    assert_eq!(v.xxyx(), i16vec4(1_i16, 1_i16, 2_i16, 1_i16));
+    assert_eq!(v.xxyy(), i16vec4(1_i16, 1_i16, 2_i16, 2_i16));
+    assert_eq!(v.xxyz(), i16vec4(1_i16, 1_i16, 2_i16, 3_i16));
+    assert_eq!(v.xxyw(), i16vec4(1_i16, 1_i16, 2_i16, 4_i16));
+    assert_eq!(v.xxzx(), i16vec4(1_i16, 1_i16, 3_i16, 1_i16));
+    assert_eq!(v.xxzy(), i16vec4(1_i16, 1_i16, 3_i16, 2_i16));
+    assert_eq!(v.xxzz(), i16vec4(1_i16, 1_i16, 3_i16, 3_i16));
+    assert_eq!(v.xxzw(), i16vec4(1_i16, 1_i16, 3_i16, 4_i16));
+    assert_eq!(v.xxwx(), i16vec4(1_i16, 1_i16, 4_i16, 1_i16));
+    assert_eq!(v.xxwy(), i16vec4(1_i16, 1_i16, 4_i16, 2_i16));
+    assert_eq!(v.xxwz(), i16vec4(1_i16, 1_i16, 4_i16, 3_i16));
+    assert_eq!(v.xxww(), i16vec4(1_i16, 1_i16, 4_i16, 4_i16));
+    assert_eq!(v.xyxx(), i16vec4(1_i16, 2_i16, 1_i16, 1_i16));
+    assert_eq!(v.xyxy(), i16vec4(1_i16, 2_i16, 1_i16, 2_i16));
+    assert_eq!(v.xyxz(), i16vec4(1_i16, 2_i16, 1_i16, 3_i16));
+    assert_eq!(v.xyxw(), i16vec4(1_i16, 2_i16, 1_i16, 4_i16));
+    assert_eq!(v.xyyx(), i16vec4(1_i16, 2_i16, 2_i16, 1_i16));
+    assert_eq!(v.xyyy(), i16vec4(1_i16, 2_i16, 2_i16, 2_i16));
+    assert_eq!(v.xyyz(), i16vec4(1_i16, 2_i16, 2_i16, 3_i16));
+    assert_eq!(v.xyyw(), i16vec4(1_i16, 2_i16, 2_i16, 4_i16));
+    assert_eq!(v.xyzx(), i16vec4(1_i16, 2_i16, 3_i16, 1_i16));
+    assert_eq!(v.xyzy(), i16vec4(1_i16, 2_i16, 3_i16, 2_i16));
+    assert_eq!(v.xyzz(), i16vec4(1_i16, 2_i16, 3_i16, 3_i16));
+    assert_eq!(v.xywx(), i16vec4(1_i16, 2_i16, 4_i16, 1_i16));
+    assert_eq!(v.xywy(), i16vec4(1_i16, 2_i16, 4_i16, 2_i16));
+    assert_eq!(v.xywz(), i16vec4(1_i16, 2_i16, 4_i16, 3_i16));
+    assert_eq!(v.xyww(), i16vec4(1_i16, 2_i16, 4_i16, 4_i16));
+    assert_eq!(v.xzxx(), i16vec4(1_i16, 3_i16, 1_i16, 1_i16));
+    assert_eq!(v.xzxy(), i16vec4(1_i16, 3_i16, 1_i16, 2_i16));
+    assert_eq!(v.xzxz(), i16vec4(1_i16, 3_i16, 1_i16, 3_i16));
+    assert_eq!(v.xzxw(), i16vec4(1_i16, 3_i16, 1_i16, 4_i16));
+    assert_eq!(v.xzyx(), i16vec4(1_i16, 3_i16, 2_i16, 1_i16));
+    assert_eq!(v.xzyy(), i16vec4(1_i16, 3_i16, 2_i16, 2_i16));
+    assert_eq!(v.xzyz(), i16vec4(1_i16, 3_i16, 2_i16, 3_i16));
+    assert_eq!(v.xzyw(), i16vec4(1_i16, 3_i16, 2_i16, 4_i16));
+    assert_eq!(v.xzzx(), i16vec4(1_i16, 3_i16, 3_i16, 1_i16));
+    assert_eq!(v.xzzy(), i16vec4(1_i16, 3_i16, 3_i16, 2_i16));
+    assert_eq!(v.xzzz(), i16vec4(1_i16, 3_i16, 3_i16, 3_i16));
+    assert_eq!(v.xzzw(), i16vec4(1_i16, 3_i16, 3_i16, 4_i16));
+    assert_eq!(v.xzwx(), i16vec4(1_i16, 3_i16, 4_i16, 1_i16));
+    assert_eq!(v.xzwy(), i16vec4(1_i16, 3_i16, 4_i16, 2_i16));
+    assert_eq!(v.xzwz(), i16vec4(1_i16, 3_i16, 4_i16, 3_i16));
+    assert_eq!(v.xzww(), i16vec4(1_i16, 3_i16, 4_i16, 4_i16));
+    assert_eq!(v.xwxx(), i16vec4(1_i16, 4_i16, 1_i16, 1_i16));
+    assert_eq!(v.xwxy(), i16vec4(1_i16, 4_i16, 1_i16, 2_i16));
+    assert_eq!(v.xwxz(), i16vec4(1_i16, 4_i16, 1_i16, 3_i16));
+    assert_eq!(v.xwxw(), i16vec4(1_i16, 4_i16, 1_i16, 4_i16));
+    assert_eq!(v.xwyx(), i16vec4(1_i16, 4_i16, 2_i16, 1_i16));
+    assert_eq!(v.xwyy(), i16vec4(1_i16, 4_i16, 2_i16, 2_i16));
+    assert_eq!(v.xwyz(), i16vec4(1_i16, 4_i16, 2_i16, 3_i16));
+    assert_eq!(v.xwyw(), i16vec4(1_i16, 4_i16, 2_i16, 4_i16));
+    assert_eq!(v.xwzx(), i16vec4(1_i16, 4_i16, 3_i16, 1_i16));
+    assert_eq!(v.xwzy(), i16vec4(1_i16, 4_i16, 3_i16, 2_i16));
+    assert_eq!(v.xwzz(), i16vec4(1_i16, 4_i16, 3_i16, 3_i16));
+    assert_eq!(v.xwzw(), i16vec4(1_i16, 4_i16, 3_i16, 4_i16));
+    assert_eq!(v.xwwx(), i16vec4(1_i16, 4_i16, 4_i16, 1_i16));
+    assert_eq!(v.xwwy(), i16vec4(1_i16, 4_i16, 4_i16, 2_i16));
+    assert_eq!(v.xwwz(), i16vec4(1_i16, 4_i16, 4_i16, 3_i16));
+    assert_eq!(v.xwww(), i16vec4(1_i16, 4_i16, 4_i16, 4_i16));
+    assert_eq!(v.yxxx(), i16vec4(2_i16, 1_i16, 1_i16, 1_i16));
+    assert_eq!(v.yxxy(), i16vec4(2_i16, 1_i16, 1_i16, 2_i16));
+    assert_eq!(v.yxxz(), i16vec4(2_i16, 1_i16, 1_i16, 3_i16));
+    assert_eq!(v.yxxw(), i16vec4(2_i16, 1_i16, 1_i16, 4_i16));
+    assert_eq!(v.yxyx(), i16vec4(2_i16, 1_i16, 2_i16, 1_i16));
+    assert_eq!(v.yxyy(), i16vec4(2_i16, 1_i16, 2_i16, 2_i16));
+    assert_eq!(v.yxyz(), i16vec4(2_i16, 1_i16, 2_i16, 3_i16));
+    assert_eq!(v.yxyw(), i16vec4(2_i16, 1_i16, 2_i16, 4_i16));
+    assert_eq!(v.yxzx(), i16vec4(2_i16, 1_i16, 3_i16, 1_i16));
+    assert_eq!(v.yxzy(), i16vec4(2_i16, 1_i16, 3_i16, 2_i16));
+    assert_eq!(v.yxzz(), i16vec4(2_i16, 1_i16, 3_i16, 3_i16));
+    assert_eq!(v.yxzw(), i16vec4(2_i16, 1_i16, 3_i16, 4_i16));
+    assert_eq!(v.yxwx(), i16vec4(2_i16, 1_i16, 4_i16, 1_i16));
+    assert_eq!(v.yxwy(), i16vec4(2_i16, 1_i16, 4_i16, 2_i16));
+    assert_eq!(v.yxwz(), i16vec4(2_i16, 1_i16, 4_i16, 3_i16));
+    assert_eq!(v.yxww(), i16vec4(2_i16, 1_i16, 4_i16, 4_i16));
+    assert_eq!(v.yyxx(), i16vec4(2_i16, 2_i16, 1_i16, 1_i16));
+    assert_eq!(v.yyxy(), i16vec4(2_i16, 2_i16, 1_i16, 2_i16));
+    assert_eq!(v.yyxz(), i16vec4(2_i16, 2_i16, 1_i16, 3_i16));
+    assert_eq!(v.yyxw(), i16vec4(2_i16, 2_i16, 1_i16, 4_i16));
+    assert_eq!(v.yyyx(), i16vec4(2_i16, 2_i16, 2_i16, 1_i16));
+    assert_eq!(v.yyyy(), i16vec4(2_i16, 2_i16, 2_i16, 2_i16));
+    assert_eq!(v.yyyz(), i16vec4(2_i16, 2_i16, 2_i16, 3_i16));
+    assert_eq!(v.yyyw(), i16vec4(2_i16, 2_i16, 2_i16, 4_i16));
+    assert_eq!(v.yyzx(), i16vec4(2_i16, 2_i16, 3_i16, 1_i16));
+    assert_eq!(v.yyzy(), i16vec4(2_i16, 2_i16, 3_i16, 2_i16));
+    assert_eq!(v.yyzz(), i16vec4(2_i16, 2_i16, 3_i16, 3_i16));
+    assert_eq!(v.yyzw(), i16vec4(2_i16, 2_i16, 3_i16, 4_i16));
+    assert_eq!(v.yywx(), i16vec4(2_i16, 2_i16, 4_i16, 1_i16));
+    assert_eq!(v.yywy(), i16vec4(2_i16, 2_i16, 4_i16, 2_i16));
+    assert_eq!(v.yywz(), i16vec4(2_i16, 2_i16, 4_i16, 3_i16));
+    assert_eq!(v.yyww(), i16vec4(2_i16, 2_i16, 4_i16, 4_i16));
+    assert_eq!(v.yzxx(), i16vec4(2_i16, 3_i16, 1_i16, 1_i16));
+    assert_eq!(v.yzxy(), i16vec4(2_i16, 3_i16, 1_i16, 2_i16));
+    assert_eq!(v.yzxz(), i16vec4(2_i16, 3_i16, 1_i16, 3_i16));
+    assert_eq!(v.yzxw(), i16vec4(2_i16, 3_i16, 1_i16, 4_i16));
+    assert_eq!(v.yzyx(), i16vec4(2_i16, 3_i16, 2_i16, 1_i16));
+    assert_eq!(v.yzyy(), i16vec4(2_i16, 3_i16, 2_i16, 2_i16));
+    assert_eq!(v.yzyz(), i16vec4(2_i16, 3_i16, 2_i16, 3_i16));
+    assert_eq!(v.yzyw(), i16vec4(2_i16, 3_i16, 2_i16, 4_i16));
+    assert_eq!(v.yzzx(), i16vec4(2_i16, 3_i16, 3_i16, 1_i16));
+    assert_eq!(v.yzzy(), i16vec4(2_i16, 3_i16, 3_i16, 2_i16));
+    assert_eq!(v.yzzz(), i16vec4(2_i16, 3_i16, 3_i16, 3_i16));
+    assert_eq!(v.yzzw(), i16vec4(2_i16, 3_i16, 3_i16, 4_i16));
+    assert_eq!(v.yzwx(), i16vec4(2_i16, 3_i16, 4_i16, 1_i16));
+    assert_eq!(v.yzwy(), i16vec4(2_i16, 3_i16, 4_i16, 2_i16));
+    assert_eq!(v.yzwz(), i16vec4(2_i16, 3_i16, 4_i16, 3_i16));
+    assert_eq!(v.yzww(), i16vec4(2_i16, 3_i16, 4_i16, 4_i16));
+    assert_eq!(v.ywxx(), i16vec4(2_i16, 4_i16, 1_i16, 1_i16));
+    assert_eq!(v.ywxy(), i16vec4(2_i16, 4_i16, 1_i16, 2_i16));
+    assert_eq!(v.ywxz(), i16vec4(2_i16, 4_i16, 1_i16, 3_i16));
+    assert_eq!(v.ywxw(), i16vec4(2_i16, 4_i16, 1_i16, 4_i16));
+    assert_eq!(v.ywyx(), i16vec4(2_i16, 4_i16, 2_i16, 1_i16));
+    assert_eq!(v.ywyy(), i16vec4(2_i16, 4_i16, 2_i16, 2_i16));
+    assert_eq!(v.ywyz(), i16vec4(2_i16, 4_i16, 2_i16, 3_i16));
+    assert_eq!(v.ywyw(), i16vec4(2_i16, 4_i16, 2_i16, 4_i16));
+    assert_eq!(v.ywzx(), i16vec4(2_i16, 4_i16, 3_i16, 1_i16));
+    assert_eq!(v.ywzy(), i16vec4(2_i16, 4_i16, 3_i16, 2_i16));
+    assert_eq!(v.ywzz(), i16vec4(2_i16, 4_i16, 3_i16, 3_i16));
+    assert_eq!(v.ywzw(), i16vec4(2_i16, 4_i16, 3_i16, 4_i16));
+    assert_eq!(v.ywwx(), i16vec4(2_i16, 4_i16, 4_i16, 1_i16));
+    assert_eq!(v.ywwy(), i16vec4(2_i16, 4_i16, 4_i16, 2_i16));
+    assert_eq!(v.ywwz(), i16vec4(2_i16, 4_i16, 4_i16, 3_i16));
+    assert_eq!(v.ywww(), i16vec4(2_i16, 4_i16, 4_i16, 4_i16));
+    assert_eq!(v.zxxx(), i16vec4(3_i16, 1_i16, 1_i16, 1_i16));
+    assert_eq!(v.zxxy(), i16vec4(3_i16, 1_i16, 1_i16, 2_i16));
+    assert_eq!(v.zxxz(), i16vec4(3_i16, 1_i16, 1_i16, 3_i16));
+    assert_eq!(v.zxxw(), i16vec4(3_i16, 1_i16, 1_i16, 4_i16));
+    assert_eq!(v.zxyx(), i16vec4(3_i16, 1_i16, 2_i16, 1_i16));
+    assert_eq!(v.zxyy(), i16vec4(3_i16, 1_i16, 2_i16, 2_i16));
+    assert_eq!(v.zxyz(), i16vec4(3_i16, 1_i16, 2_i16, 3_i16));
+    assert_eq!(v.zxyw(), i16vec4(3_i16, 1_i16, 2_i16, 4_i16));
+    assert_eq!(v.zxzx(), i16vec4(3_i16, 1_i16, 3_i16, 1_i16));
+    assert_eq!(v.zxzy(), i16vec4(3_i16, 1_i16, 3_i16, 2_i16));
+    assert_eq!(v.zxzz(), i16vec4(3_i16, 1_i16, 3_i16, 3_i16));
+    assert_eq!(v.zxzw(), i16vec4(3_i16, 1_i16, 3_i16, 4_i16));
+    assert_eq!(v.zxwx(), i16vec4(3_i16, 1_i16, 4_i16, 1_i16));
+    assert_eq!(v.zxwy(), i16vec4(3_i16, 1_i16, 4_i16, 2_i16));
+    assert_eq!(v.zxwz(), i16vec4(3_i16, 1_i16, 4_i16, 3_i16));
+    assert_eq!(v.zxww(), i16vec4(3_i16, 1_i16, 4_i16, 4_i16));
+    assert_eq!(v.zyxx(), i16vec4(3_i16, 2_i16, 1_i16, 1_i16));
+    assert_eq!(v.zyxy(), i16vec4(3_i16, 2_i16, 1_i16, 2_i16));
+    assert_eq!(v.zyxz(), i16vec4(3_i16, 2_i16, 1_i16, 3_i16));
+    assert_eq!(v.zyxw(), i16vec4(3_i16, 2_i16, 1_i16, 4_i16));
+    assert_eq!(v.zyyx(), i16vec4(3_i16, 2_i16, 2_i16, 1_i16));
+    assert_eq!(v.zyyy(), i16vec4(3_i16, 2_i16, 2_i16, 2_i16));
+    assert_eq!(v.zyyz(), i16vec4(3_i16, 2_i16, 2_i16, 3_i16));
+    assert_eq!(v.zyyw(), i16vec4(3_i16, 2_i16, 2_i16, 4_i16));
+    assert_eq!(v.zyzx(), i16vec4(3_i16, 2_i16, 3_i16, 1_i16));
+    assert_eq!(v.zyzy(), i16vec4(3_i16, 2_i16, 3_i16, 2_i16));
+    assert_eq!(v.zyzz(), i16vec4(3_i16, 2_i16, 3_i16, 3_i16));
+    assert_eq!(v.zyzw(), i16vec4(3_i16, 2_i16, 3_i16, 4_i16));
+    assert_eq!(v.zywx(), i16vec4(3_i16, 2_i16, 4_i16, 1_i16));
+    assert_eq!(v.zywy(), i16vec4(3_i16, 2_i16, 4_i16, 2_i16));
+    assert_eq!(v.zywz(), i16vec4(3_i16, 2_i16, 4_i16, 3_i16));
+    assert_eq!(v.zyww(), i16vec4(3_i16, 2_i16, 4_i16, 4_i16));
+    assert_eq!(v.zzxx(), i16vec4(3_i16, 3_i16, 1_i16, 1_i16));
+    assert_eq!(v.zzxy(), i16vec4(3_i16, 3_i16, 1_i16, 2_i16));
+    assert_eq!(v.zzxz(), i16vec4(3_i16, 3_i16, 1_i16, 3_i16));
+    assert_eq!(v.zzxw(), i16vec4(3_i16, 3_i16, 1_i16, 4_i16));
+    assert_eq!(v.zzyx(), i16vec4(3_i16, 3_i16, 2_i16, 1_i16));
+    assert_eq!(v.zzyy(), i16vec4(3_i16, 3_i16, 2_i16, 2_i16));
+    assert_eq!(v.zzyz(), i16vec4(3_i16, 3_i16, 2_i16, 3_i16));
+    assert_eq!(v.zzyw(), i16vec4(3_i16, 3_i16, 2_i16, 4_i16));
+    assert_eq!(v.zzzx(), i16vec4(3_i16, 3_i16, 3_i16, 1_i16));
+    assert_eq!(v.zzzy(), i16vec4(3_i16, 3_i16, 3_i16, 2_i16));
+    assert_eq!(v.zzzz(), i16vec4(3_i16, 3_i16, 3_i16, 3_i16));
+    assert_eq!(v.zzzw(), i16vec4(3_i16, 3_i16, 3_i16, 4_i16));
+    assert_eq!(v.zzwx(), i16vec4(3_i16, 3_i16, 4_i16, 1_i16));
+    assert_eq!(v.zzwy(), i16vec4(3_i16, 3_i16, 4_i16, 2_i16));
+    assert_eq!(v.zzwz(), i16vec4(3_i16, 3_i16, 4_i16, 3_i16));
+    assert_eq!(v.zzww(), i16vec4(3_i16, 3_i16, 4_i16, 4_i16));
+    assert_eq!(v.zwxx(), i16vec4(3_i16, 4_i16, 1_i16, 1_i16));
+    assert_eq!(v.zwxy(), i16vec4(3_i16, 4_i16, 1_i16, 2_i16));
+    assert_eq!(v.zwxz(), i16vec4(3_i16, 4_i16, 1_i16, 3_i16));
+    assert_eq!(v.zwxw(), i16vec4(3_i16, 4_i16, 1_i16, 4_i16));
+    assert_eq!(v.zwyx(), i16vec4(3_i16, 4_i16, 2_i16, 1_i16));
+    assert_eq!(v.zwyy(), i16vec4(3_i16, 4_i16, 2_i16, 2_i16));
+    assert_eq!(v.zwyz(), i16vec4(3_i16, 4_i16, 2_i16, 3_i16));
+    assert_eq!(v.zwyw(), i16vec4(3_i16, 4_i16, 2_i16, 4_i16));
+    assert_eq!(v.zwzx(), i16vec4(3_i16, 4_i16, 3_i16, 1_i16));
+    assert_eq!(v.zwzy(), i16vec4(3_i16, 4_i16, 3_i16, 2_i16));
+    assert_eq!(v.zwzz(), i16vec4(3_i16, 4_i16, 3_i16, 3_i16));
+    assert_eq!(v.zwzw(), i16vec4(3_i16, 4_i16, 3_i16, 4_i16));
+    assert_eq!(v.zwwx(), i16vec4(3_i16, 4_i16, 4_i16, 1_i16));
+    assert_eq!(v.zwwy(), i16vec4(3_i16, 4_i16, 4_i16, 2_i16));
+    assert_eq!(v.zwwz(), i16vec4(3_i16, 4_i16, 4_i16, 3_i16));
+    assert_eq!(v.zwww(), i16vec4(3_i16, 4_i16, 4_i16, 4_i16));
+    assert_eq!(v.wxxx(), i16vec4(4_i16, 1_i16, 1_i16, 1_i16));
+    assert_eq!(v.wxxy(), i16vec4(4_i16, 1_i16, 1_i16, 2_i16));
+    assert_eq!(v.wxxz(), i16vec4(4_i16, 1_i16, 1_i16, 3_i16));
+    assert_eq!(v.wxxw(), i16vec4(4_i16, 1_i16, 1_i16, 4_i16));
+    assert_eq!(v.wxyx(), i16vec4(4_i16, 1_i16, 2_i16, 1_i16));
+    assert_eq!(v.wxyy(), i16vec4(4_i16, 1_i16, 2_i16, 2_i16));
+    assert_eq!(v.wxyz(), i16vec4(4_i16, 1_i16, 2_i16, 3_i16));
+    assert_eq!(v.wxyw(), i16vec4(4_i16, 1_i16, 2_i16, 4_i16));
+    assert_eq!(v.wxzx(), i16vec4(4_i16, 1_i16, 3_i16, 1_i16));
+    assert_eq!(v.wxzy(), i16vec4(4_i16, 1_i16, 3_i16, 2_i16));
+    assert_eq!(v.wxzz(), i16vec4(4_i16, 1_i16, 3_i16, 3_i16));
+    assert_eq!(v.wxzw(), i16vec4(4_i16, 1_i16, 3_i16, 4_i16));
+    assert_eq!(v.wxwx(), i16vec4(4_i16, 1_i16, 4_i16, 1_i16));
+    assert_eq!(v.wxwy(), i16vec4(4_i16, 1_i16, 4_i16, 2_i16));
+    assert_eq!(v.wxwz(), i16vec4(4_i16, 1_i16, 4_i16, 3_i16));
+    assert_eq!(v.wxww(), i16vec4(4_i16, 1_i16, 4_i16, 4_i16));
+    assert_eq!(v.wyxx(), i16vec4(4_i16, 2_i16, 1_i16, 1_i16));
+    assert_eq!(v.wyxy(), i16vec4(4_i16, 2_i16, 1_i16, 2_i16));
+    assert_eq!(v.wyxz(), i16vec4(4_i16, 2_i16, 1_i16, 3_i16));
+    assert_eq!(v.wyxw(), i16vec4(4_i16, 2_i16, 1_i16, 4_i16));
+    assert_eq!(v.wyyx(), i16vec4(4_i16, 2_i16, 2_i16, 1_i16));
+    assert_eq!(v.wyyy(), i16vec4(4_i16, 2_i16, 2_i16, 2_i16));
+    assert_eq!(v.wyyz(), i16vec4(4_i16, 2_i16, 2_i16, 3_i16));
+    assert_eq!(v.wyyw(), i16vec4(4_i16, 2_i16, 2_i16, 4_i16));
+    assert_eq!(v.wyzx(), i16vec4(4_i16, 2_i16, 3_i16, 1_i16));
+    assert_eq!(v.wyzy(), i16vec4(4_i16, 2_i16, 3_i16, 2_i16));
+    assert_eq!(v.wyzz(), i16vec4(4_i16, 2_i16, 3_i16, 3_i16));
+    assert_eq!(v.wyzw(), i16vec4(4_i16, 2_i16, 3_i16, 4_i16));
+    assert_eq!(v.wywx(), i16vec4(4_i16, 2_i16, 4_i16, 1_i16));
+    assert_eq!(v.wywy(), i16vec4(4_i16, 2_i16, 4_i16, 2_i16));
+    assert_eq!(v.wywz(), i16vec4(4_i16, 2_i16, 4_i16, 3_i16));
+    assert_eq!(v.wyww(), i16vec4(4_i16, 2_i16, 4_i16, 4_i16));
+    assert_eq!(v.wzxx(), i16vec4(4_i16, 3_i16, 1_i16, 1_i16));
+    assert_eq!(v.wzxy(), i16vec4(4_i16, 3_i16, 1_i16, 2_i16));
+    assert_eq!(v.wzxz(), i16vec4(4_i16, 3_i16, 1_i16, 3_i16));
+    assert_eq!(v.wzxw(), i16vec4(4_i16, 3_i16, 1_i16, 4_i16));
+    assert_eq!(v.wzyx(), i16vec4(4_i16, 3_i16, 2_i16, 1_i16));
+    assert_eq!(v.wzyy(), i16vec4(4_i16, 3_i16, 2_i16, 2_i16));
+    assert_eq!(v.wzyz(), i16vec4(4_i16, 3_i16, 2_i16, 3_i16));
+    assert_eq!(v.wzyw(), i16vec4(4_i16, 3_i16, 2_i16, 4_i16));
+    assert_eq!(v.wzzx(), i16vec4(4_i16, 3_i16, 3_i16, 1_i16));
+    assert_eq!(v.wzzy(), i16vec4(4_i16, 3_i16, 3_i16, 2_i16));
+    assert_eq!(v.wzzz(), i16vec4(4_i16, 3_i16, 3_i16, 3_i16));
+    assert_eq!(v.wzzw(), i16vec4(4_i16, 3_i16, 3_i16, 4_i16));
+    assert_eq!(v.wzwx(), i16vec4(4_i16, 3_i16, 4_i16, 1_i16));
+    assert_eq!(v.wzwy(), i16vec4(4_i16, 3_i16, 4_i16, 2_i16));
+    assert_eq!(v.wzwz(), i16vec4(4_i16, 3_i16, 4_i16, 3_i16));
+    assert_eq!(v.wzww(), i16vec4(4_i16, 3_i16, 4_i16, 4_i16));
+    assert_eq!(v.wwxx(), i16vec4(4_i16, 4_i16, 1_i16, 1_i16));
+    assert_eq!(v.wwxy(), i16vec4(4_i16, 4_i16, 1_i16, 2_i16));
+    assert_eq!(v.wwxz(), i16vec4(4_i16, 4_i16, 1_i16, 3_i16));
+    assert_eq!(v.wwxw(), i16vec4(4_i16, 4_i16, 1_i16, 4_i16));
+    assert_eq!(v.wwyx(), i16vec4(4_i16, 4_i16, 2_i16, 1_i16));
+    assert_eq!(v.wwyy(), i16vec4(4_i16, 4_i16, 2_i16, 2_i16));
+    assert_eq!(v.wwyz(), i16vec4(4_i16, 4_i16, 2_i16, 3_i16));
+    assert_eq!(v.wwyw(), i16vec4(4_i16, 4_i16, 2_i16, 4_i16));
+    assert_eq!(v.wwzx(), i16vec4(4_i16, 4_i16, 3_i16, 1_i16));
+    assert_eq!(v.wwzy(), i16vec4(4_i16, 4_i16, 3_i16, 2_i16));
+    assert_eq!(v.wwzz(), i16vec4(4_i16, 4_i16, 3_i16, 3_i16));
+    assert_eq!(v.wwzw(), i16vec4(4_i16, 4_i16, 3_i16, 4_i16));
+    assert_eq!(v.wwwx(), i16vec4(4_i16, 4_i16, 4_i16, 1_i16));
+    assert_eq!(v.wwwy(), i16vec4(4_i16, 4_i16, 4_i16, 2_i16));
+    assert_eq!(v.wwwz(), i16vec4(4_i16, 4_i16, 4_i16, 3_i16));
+    assert_eq!(v.wwww(), i16vec4(4_i16, 4_i16, 4_i16, 4_i16));
+    assert_eq!(v.xxx(), i16vec3(1_i16, 1_i16, 1_i16));
+    assert_eq!(v.xxy(), i16vec3(1_i16, 1_i16, 2_i16));
+    assert_eq!(v.xxz(), i16vec3(1_i16, 1_i16, 3_i16));
+    assert_eq!(v.xxw(), i16vec3(1_i16, 1_i16, 4_i16));
+    assert_eq!(v.xyx(), i16vec3(1_i16, 2_i16, 1_i16));
+    assert_eq!(v.xyy(), i16vec3(1_i16, 2_i16, 2_i16));
+    assert_eq!(v.xyz(), i16vec3(1_i16, 2_i16, 3_i16));
+    assert_eq!(v.xyw(), i16vec3(1_i16, 2_i16, 4_i16));
+    assert_eq!(v.xzx(), i16vec3(1_i16, 3_i16, 1_i16));
+    assert_eq!(v.xzy(), i16vec3(1_i16, 3_i16, 2_i16));
+    assert_eq!(v.xzz(), i16vec3(1_i16, 3_i16, 3_i16));
+    assert_eq!(v.xzw(), i16vec3(1_i16, 3_i16, 4_i16));
+    assert_eq!(v.xwx(), i16vec3(1_i16, 4_i16, 1_i16));
+    assert_eq!(v.xwy(), i16vec3(1_i16, 4_i16, 2_i16));
+    assert_eq!(v.xwz(), i16vec3(1_i16, 4_i16, 3_i16));
+    assert_eq!(v.xww(), i16vec3(1_i16, 4_i16, 4_i16));
+    assert_eq!(v.yxx(), i16vec3(2_i16, 1_i16, 1_i16));
+    assert_eq!(v.yxy(), i16vec3(2_i16, 1_i16, 2_i16));
+    assert_eq!(v.yxz(), i16vec3(2_i16, 1_i16, 3_i16));
+    assert_eq!(v.yxw(), i16vec3(2_i16, 1_i16, 4_i16));
+    assert_eq!(v.yyx(), i16vec3(2_i16, 2_i16, 1_i16));
+    assert_eq!(v.yyy(), i16vec3(2_i16, 2_i16, 2_i16));
+    assert_eq!(v.yyz(), i16vec3(2_i16, 2_i16, 3_i16));
+    assert_eq!(v.yyw(), i16vec3(2_i16, 2_i16, 4_i16));
+    assert_eq!(v.yzx(), i16vec3(2_i16, 3_i16, 1_i16));
+    assert_eq!(v.yzy(), i16vec3(2_i16, 3_i16, 2_i16));
+    assert_eq!(v.yzz(), i16vec3(2_i16, 3_i16, 3_i16));
+    assert_eq!(v.yzw(), i16vec3(2_i16, 3_i16, 4_i16));
+    assert_eq!(v.ywx(), i16vec3(2_i16, 4_i16, 1_i16));
+    assert_eq!(v.ywy(), i16vec3(2_i16, 4_i16, 2_i16));
+    assert_eq!(v.ywz(), i16vec3(2_i16, 4_i16, 3_i16));
+    assert_eq!(v.yww(), i16vec3(2_i16, 4_i16, 4_i16));
+    assert_eq!(v.zxx(), i16vec3(3_i16, 1_i16, 1_i16));
+    assert_eq!(v.zxy(), i16vec3(3_i16, 1_i16, 2_i16));
+    assert_eq!(v.zxz(), i16vec3(3_i16, 1_i16, 3_i16));
+    assert_eq!(v.zxw(), i16vec3(3_i16, 1_i16, 4_i16));
+    assert_eq!(v.zyx(), i16vec3(3_i16, 2_i16, 1_i16));
+    assert_eq!(v.zyy(), i16vec3(3_i16, 2_i16, 2_i16));
+    assert_eq!(v.zyz(), i16vec3(3_i16, 2_i16, 3_i16));
+    assert_eq!(v.zyw(), i16vec3(3_i16, 2_i16, 4_i16));
+    assert_eq!(v.zzx(), i16vec3(3_i16, 3_i16, 1_i16));
+    assert_eq!(v.zzy(), i16vec3(3_i16, 3_i16, 2_i16));
+    assert_eq!(v.zzz(), i16vec3(3_i16, 3_i16, 3_i16));
+    assert_eq!(v.zzw(), i16vec3(3_i16, 3_i16, 4_i16));
+    assert_eq!(v.zwx(), i16vec3(3_i16, 4_i16, 1_i16));
+    assert_eq!(v.zwy(), i16vec3(3_i16, 4_i16, 2_i16));
+    assert_eq!(v.zwz(), i16vec3(3_i16, 4_i16, 3_i16));
+    assert_eq!(v.zww(), i16vec3(3_i16, 4_i16, 4_i16));
+    assert_eq!(v.wxx(), i16vec3(4_i16, 1_i16, 1_i16));
+    assert_eq!(v.wxy(), i16vec3(4_i16, 1_i16, 2_i16));
+    assert_eq!(v.wxz(), i16vec3(4_i16, 1_i16, 3_i16));
+    assert_eq!(v.wxw(), i16vec3(4_i16, 1_i16, 4_i16));
+    assert_eq!(v.wyx(), i16vec3(4_i16, 2_i16, 1_i16));
+    assert_eq!(v.wyy(), i16vec3(4_i16, 2_i16, 2_i16));
+    assert_eq!(v.wyz(), i16vec3(4_i16, 2_i16, 3_i16));
+    assert_eq!(v.wyw(), i16vec3(4_i16, 2_i16, 4_i16));
+    assert_eq!(v.wzx(), i16vec3(4_i16, 3_i16, 1_i16));
+    assert_eq!(v.wzy(), i16vec3(4_i16, 3_i16, 2_i16));
+    assert_eq!(v.wzz(), i16vec3(4_i16, 3_i16, 3_i16));
+    assert_eq!(v.wzw(), i16vec3(4_i16, 3_i16, 4_i16));
+    assert_eq!(v.wwx(), i16vec3(4_i16, 4_i16, 1_i16));
+    assert_eq!(v.wwy(), i16vec3(4_i16, 4_i16, 2_i16));
+    assert_eq!(v.wwz(), i16vec3(4_i16, 4_i16, 3_i16));
+    assert_eq!(v.www(), i16vec3(4_i16, 4_i16, 4_i16));
+    assert_eq!(v.xx(), i16vec2(1_i16, 1_i16));
+    assert_eq!(v.xy(), i16vec2(1_i16, 2_i16));
+    assert_eq!(v.xz(), i16vec2(1_i16, 3_i16));
+    assert_eq!(v.xw(), i16vec2(1_i16, 4_i16));
+    assert_eq!(v.yx(), i16vec2(2_i16, 1_i16));
+    assert_eq!(v.yy(), i16vec2(2_i16, 2_i16));
+    assert_eq!(v.yz(), i16vec2(2_i16, 3_i16));
+    assert_eq!(v.yw(), i16vec2(2_i16, 4_i16));
+    assert_eq!(v.zx(), i16vec2(3_i16, 1_i16));
+    assert_eq!(v.zy(), i16vec2(3_i16, 2_i16));
+    assert_eq!(v.zz(), i16vec2(3_i16, 3_i16));
+    assert_eq!(v.zw(), i16vec2(3_i16, 4_i16));
+    assert_eq!(v.wx(), i16vec2(4_i16, 1_i16));
+    assert_eq!(v.wy(), i16vec2(4_i16, 2_i16));
+    assert_eq!(v.wz(), i16vec2(4_i16, 3_i16));
+    assert_eq!(v.ww(), i16vec2(4_i16, 4_i16));
+});
+
+glam_test!(test_i16vec3_swizzles, {
+    let v = i16vec3(1_i16, 2_i16, 3_i16);
+    assert_eq!(v, v.xyz());
+    assert_eq!(v.xxxx(), i16vec4(1_i16, 1_i16, 1_i16, 1_i16));
+    assert_eq!(v.xxxy(), i16vec4(1_i16, 1_i16, 1_i16, 2_i16));
+    assert_eq!(v.xxxz(), i16vec4(1_i16, 1_i16, 1_i16, 3_i16));
+    assert_eq!(v.xxyx(), i16vec4(1_i16, 1_i16, 2_i16, 1_i16));
+    assert_eq!(v.xxyy(), i16vec4(1_i16, 1_i16, 2_i16, 2_i16));
+    assert_eq!(v.xxyz(), i16vec4(1_i16, 1_i16, 2_i16, 3_i16));
+    assert_eq!(v.xxzx(), i16vec4(1_i16, 1_i16, 3_i16, 1_i16));
+    assert_eq!(v.xxzy(), i16vec4(1_i16, 1_i16, 3_i16, 2_i16));
+    assert_eq!(v.xxzz(), i16vec4(1_i16, 1_i16, 3_i16, 3_i16));
+    assert_eq!(v.xyxx(), i16vec4(1_i16, 2_i16, 1_i16, 1_i16));
+    assert_eq!(v.xyxy(), i16vec4(1_i16, 2_i16, 1_i16, 2_i16));
+    assert_eq!(v.xyxz(), i16vec4(1_i16, 2_i16, 1_i16, 3_i16));
+    assert_eq!(v.xyyx(), i16vec4(1_i16, 2_i16, 2_i16, 1_i16));
+    assert_eq!(v.xyyy(), i16vec4(1_i16, 2_i16, 2_i16, 2_i16));
+    assert_eq!(v.xyyz(), i16vec4(1_i16, 2_i16, 2_i16, 3_i16));
+    assert_eq!(v.xyzx(), i16vec4(1_i16, 2_i16, 3_i16, 1_i16));
+    assert_eq!(v.xyzy(), i16vec4(1_i16, 2_i16, 3_i16, 2_i16));
+    assert_eq!(v.xyzz(), i16vec4(1_i16, 2_i16, 3_i16, 3_i16));
+    assert_eq!(v.xzxx(), i16vec4(1_i16, 3_i16, 1_i16, 1_i16));
+    assert_eq!(v.xzxy(), i16vec4(1_i16, 3_i16, 1_i16, 2_i16));
+    assert_eq!(v.xzxz(), i16vec4(1_i16, 3_i16, 1_i16, 3_i16));
+    assert_eq!(v.xzyx(), i16vec4(1_i16, 3_i16, 2_i16, 1_i16));
+    assert_eq!(v.xzyy(), i16vec4(1_i16, 3_i16, 2_i16, 2_i16));
+    assert_eq!(v.xzyz(), i16vec4(1_i16, 3_i16, 2_i16, 3_i16));
+    assert_eq!(v.xzzx(), i16vec4(1_i16, 3_i16, 3_i16, 1_i16));
+    assert_eq!(v.xzzy(), i16vec4(1_i16, 3_i16, 3_i16, 2_i16));
+    assert_eq!(v.xzzz(), i16vec4(1_i16, 3_i16, 3_i16, 3_i16));
+    assert_eq!(v.yxxx(), i16vec4(2_i16, 1_i16, 1_i16, 1_i16));
+    assert_eq!(v.yxxy(), i16vec4(2_i16, 1_i16, 1_i16, 2_i16));
+    assert_eq!(v.yxxz(), i16vec4(2_i16, 1_i16, 1_i16, 3_i16));
+    assert_eq!(v.yxyx(), i16vec4(2_i16, 1_i16, 2_i16, 1_i16));
+    assert_eq!(v.yxyy(), i16vec4(2_i16, 1_i16, 2_i16, 2_i16));
+    assert_eq!(v.yxyz(), i16vec4(2_i16, 1_i16, 2_i16, 3_i16));
+    assert_eq!(v.yxzx(), i16vec4(2_i16, 1_i16, 3_i16, 1_i16));
+    assert_eq!(v.yxzy(), i16vec4(2_i16, 1_i16, 3_i16, 2_i16));
+    assert_eq!(v.yxzz(), i16vec4(2_i16, 1_i16, 3_i16, 3_i16));
+    assert_eq!(v.yyxx(), i16vec4(2_i16, 2_i16, 1_i16, 1_i16));
+    assert_eq!(v.yyxy(), i16vec4(2_i16, 2_i16, 1_i16, 2_i16));
+    assert_eq!(v.yyxz(), i16vec4(2_i16, 2_i16, 1_i16, 3_i16));
+    assert_eq!(v.yyyx(), i16vec4(2_i16, 2_i16, 2_i16, 1_i16));
+    assert_eq!(v.yyyy(), i16vec4(2_i16, 2_i16, 2_i16, 2_i16));
+    assert_eq!(v.yyyz(), i16vec4(2_i16, 2_i16, 2_i16, 3_i16));
+    assert_eq!(v.yyzx(), i16vec4(2_i16, 2_i16, 3_i16, 1_i16));
+    assert_eq!(v.yyzy(), i16vec4(2_i16, 2_i16, 3_i16, 2_i16));
+    assert_eq!(v.yyzz(), i16vec4(2_i16, 2_i16, 3_i16, 3_i16));
+    assert_eq!(v.yzxx(), i16vec4(2_i16, 3_i16, 1_i16, 1_i16));
+    assert_eq!(v.yzxy(), i16vec4(2_i16, 3_i16, 1_i16, 2_i16));
+    assert_eq!(v.yzxz(), i16vec4(2_i16, 3_i16, 1_i16, 3_i16));
+    assert_eq!(v.yzyx(), i16vec4(2_i16, 3_i16, 2_i16, 1_i16));
+    assert_eq!(v.yzyy(), i16vec4(2_i16, 3_i16, 2_i16, 2_i16));
+    assert_eq!(v.yzyz(), i16vec4(2_i16, 3_i16, 2_i16, 3_i16));
+    assert_eq!(v.yzzx(), i16vec4(2_i16, 3_i16, 3_i16, 1_i16));
+    assert_eq!(v.yzzy(), i16vec4(2_i16, 3_i16, 3_i16, 2_i16));
+    assert_eq!(v.yzzz(), i16vec4(2_i16, 3_i16, 3_i16, 3_i16));
+    assert_eq!(v.zxxx(), i16vec4(3_i16, 1_i16, 1_i16, 1_i16));
+    assert_eq!(v.zxxy(), i16vec4(3_i16, 1_i16, 1_i16, 2_i16));
+    assert_eq!(v.zxxz(), i16vec4(3_i16, 1_i16, 1_i16, 3_i16));
+    assert_eq!(v.zxyx(), i16vec4(3_i16, 1_i16, 2_i16, 1_i16));
+    assert_eq!(v.zxyy(), i16vec4(3_i16, 1_i16, 2_i16, 2_i16));
+    assert_eq!(v.zxyz(), i16vec4(3_i16, 1_i16, 2_i16, 3_i16));
+    assert_eq!(v.zxzx(), i16vec4(3_i16, 1_i16, 3_i16, 1_i16));
+    assert_eq!(v.zxzy(), i16vec4(3_i16, 1_i16, 3_i16, 2_i16));
+    assert_eq!(v.zxzz(), i16vec4(3_i16, 1_i16, 3_i16, 3_i16));
+    assert_eq!(v.zyxx(), i16vec4(3_i16, 2_i16, 1_i16, 1_i16));
+    assert_eq!(v.zyxy(), i16vec4(3_i16, 2_i16, 1_i16, 2_i16));
+    assert_eq!(v.zyxz(), i16vec4(3_i16, 2_i16, 1_i16, 3_i16));
+    assert_eq!(v.zyyx(), i16vec4(3_i16, 2_i16, 2_i16, 1_i16));
+    assert_eq!(v.zyyy(), i16vec4(3_i16, 2_i16, 2_i16, 2_i16));
+    assert_eq!(v.zyyz(), i16vec4(3_i16, 2_i16, 2_i16, 3_i16));
+    assert_eq!(v.zyzx(), i16vec4(3_i16, 2_i16, 3_i16, 1_i16));
+    assert_eq!(v.zyzy(), i16vec4(3_i16, 2_i16, 3_i16, 2_i16));
+    assert_eq!(v.zyzz(), i16vec4(3_i16, 2_i16, 3_i16, 3_i16));
+    assert_eq!(v.zzxx(), i16vec4(3_i16, 3_i16, 1_i16, 1_i16));
+    assert_eq!(v.zzxy(), i16vec4(3_i16, 3_i16, 1_i16, 2_i16));
+    assert_eq!(v.zzxz(), i16vec4(3_i16, 3_i16, 1_i16, 3_i16));
+    assert_eq!(v.zzyx(), i16vec4(3_i16, 3_i16, 2_i16, 1_i16));
+    assert_eq!(v.zzyy(), i16vec4(3_i16, 3_i16, 2_i16, 2_i16));
+    assert_eq!(v.zzyz(), i16vec4(3_i16, 3_i16, 2_i16, 3_i16));
+    assert_eq!(v.zzzx(), i16vec4(3_i16, 3_i16, 3_i16, 1_i16));
+    assert_eq!(v.zzzy(), i16vec4(3_i16, 3_i16, 3_i16, 2_i16));
+    assert_eq!(v.zzzz(), i16vec4(3_i16, 3_i16, 3_i16, 3_i16));
+    assert_eq!(v.xxx(), i16vec3(1_i16, 1_i16, 1_i16));
+    assert_eq!(v.xxy(), i16vec3(1_i16, 1_i16, 2_i16));
+    assert_eq!(v.xxz(), i16vec3(1_i16, 1_i16, 3_i16));
+    assert_eq!(v.xyx(), i16vec3(1_i16, 2_i16, 1_i16));
+    assert_eq!(v.xyy(), i16vec3(1_i16, 2_i16, 2_i16));
+    assert_eq!(v.xzx(), i16vec3(1_i16, 3_i16, 1_i16));
+    assert_eq!(v.xzy(), i16vec3(1_i16, 3_i16, 2_i16));
+    assert_eq!(v.xzz(), i16vec3(1_i16, 3_i16, 3_i16));
+    assert_eq!(v.yxx(), i16vec3(2_i16, 1_i16, 1_i16));
+    assert_eq!(v.yxy(), i16vec3(2_i16, 1_i16, 2_i16));
+    assert_eq!(v.yxz(), i16vec3(2_i16, 1_i16, 3_i16));
+    assert_eq!(v.yyx(), i16vec3(2_i16, 2_i16, 1_i16));
+    assert_eq!(v.yyy(), i16vec3(2_i16, 2_i16, 2_i16));
+    assert_eq!(v.yyz(), i16vec3(2_i16, 2_i16, 3_i16));
+    assert_eq!(v.yzx(), i16vec3(2_i16, 3_i16, 1_i16));
+    assert_eq!(v.yzy(), i16vec3(2_i16, 3_i16, 2_i16));
+    assert_eq!(v.yzz(), i16vec3(2_i16, 3_i16, 3_i16));
+    assert_eq!(v.zxx(), i16vec3(3_i16, 1_i16, 1_i16));
+    assert_eq!(v.zxy(), i16vec3(3_i16, 1_i16, 2_i16));
+    assert_eq!(v.zxz(), i16vec3(3_i16, 1_i16, 3_i16));
+    assert_eq!(v.zyx(), i16vec3(3_i16, 2_i16, 1_i16));
+    assert_eq!(v.zyy(), i16vec3(3_i16, 2_i16, 2_i16));
+    assert_eq!(v.zyz(), i16vec3(3_i16, 2_i16, 3_i16));
+    assert_eq!(v.zzx(), i16vec3(3_i16, 3_i16, 1_i16));
+    assert_eq!(v.zzy(), i16vec3(3_i16, 3_i16, 2_i16));
+    assert_eq!(v.zzz(), i16vec3(3_i16, 3_i16, 3_i16));
+    assert_eq!(v.xx(), i16vec2(1_i16, 1_i16));
+    assert_eq!(v.xy(), i16vec2(1_i16, 2_i16));
+    assert_eq!(v.xz(), i16vec2(1_i16, 3_i16));
+    assert_eq!(v.yx(), i16vec2(2_i16, 1_i16));
+    assert_eq!(v.yy(), i16vec2(2_i16, 2_i16));
+    assert_eq!(v.yz(), i16vec2(2_i16, 3_i16));
+    assert_eq!(v.zx(), i16vec2(3_i16, 1_i16));
+    assert_eq!(v.zy(), i16vec2(3_i16, 2_i16));
+    assert_eq!(v.zz(), i16vec2(3_i16, 3_i16));
+});
+
+glam_test!(test_i16vec2_swizzles, {
+    let v = i16vec2(1_i16, 2_i16);
+    assert_eq!(v, v.xy());
+    assert_eq!(v.xxxx(), i16vec4(1_i16, 1_i16, 1_i16, 1_i16));
+    assert_eq!(v.xxxy(), i16vec4(1_i16, 1_i16, 1_i16, 2_i16));
+    assert_eq!(v.xxyx(), i16vec4(1_i16, 1_i16, 2_i16, 1_i16));
+    assert_eq!(v.xxyy(), i16vec4(1_i16, 1_i16, 2_i16, 2_i16));
+    assert_eq!(v.xyxx(), i16vec4(1_i16, 2_i16, 1_i16, 1_i16));
+    assert_eq!(v.xyxy(), i16vec4(1_i16, 2_i16, 1_i16, 2_i16));
+    assert_eq!(v.xyyx(), i16vec4(1_i16, 2_i16, 2_i16, 1_i16));
+    assert_eq!(v.xyyy(), i16vec4(1_i16, 2_i16, 2_i16, 2_i16));
+    assert_eq!(v.yxxx(), i16vec4(2_i16, 1_i16, 1_i16, 1_i16));
+    assert_eq!(v.yxxy(), i16vec4(2_i16, 1_i16, 1_i16, 2_i16));
+    assert_eq!(v.yxyx(), i16vec4(2_i16, 1_i16, 2_i16, 1_i16));
+    assert_eq!(v.yxyy(), i16vec4(2_i16, 1_i16, 2_i16, 2_i16));
+    assert_eq!(v.yyxx(), i16vec4(2_i16, 2_i16, 1_i16, 1_i16));
+    assert_eq!(v.yyxy(), i16vec4(2_i16, 2_i16, 1_i16, 2_i16));
+    assert_eq!(v.yyyx(), i16vec4(2_i16, 2_i16, 2_i16, 1_i16));
+    assert_eq!(v.yyyy(), i16vec4(2_i16, 2_i16, 2_i16, 2_i16));
+    assert_eq!(v.xxx(), i16vec3(1_i16, 1_i16, 1_i16));
+    assert_eq!(v.xxy(), i16vec3(1_i16, 1_i16, 2_i16));
+    assert_eq!(v.xyx(), i16vec3(1_i16, 2_i16, 1_i16));
+    assert_eq!(v.xyy(), i16vec3(1_i16, 2_i16, 2_i16));
+    assert_eq!(v.yxx(), i16vec3(2_i16, 1_i16, 1_i16));
+    assert_eq!(v.yxy(), i16vec3(2_i16, 1_i16, 2_i16));
+    assert_eq!(v.yyx(), i16vec3(2_i16, 2_i16, 1_i16));
+    assert_eq!(v.yyy(), i16vec3(2_i16, 2_i16, 2_i16));
+    assert_eq!(v.xx(), i16vec2(1_i16, 1_i16));
+    assert_eq!(v.yx(), i16vec2(2_i16, 1_i16));
+    assert_eq!(v.yy(), i16vec2(2_i16, 2_i16));
+});

vendor/glam/tests/swizzles_i32.rs

@@ -0,0 +1,497 @@
+// Generated by swizzlegen. Do not edit.
+#[macro_use]
+mod support;
+use glam::*;
+
+glam_test!(test_ivec4_swizzles, {
+    let v = ivec4(1_i32, 2_i32, 3_i32, 4_i32);
+    assert_eq!(v, v.xyzw());
+    assert_eq!(v.xxxx(), ivec4(1_i32, 1_i32, 1_i32, 1_i32));
+    assert_eq!(v.xxxy(), ivec4(1_i32, 1_i32, 1_i32, 2_i32));
+    assert_eq!(v.xxxz(), ivec4(1_i32, 1_i32, 1_i32, 3_i32));
+    assert_eq!(v.xxxw(), ivec4(1_i32, 1_i32, 1_i32, 4_i32));
+    assert_eq!(v.xxyx(), ivec4(1_i32, 1_i32, 2_i32, 1_i32));
+    assert_eq!(v.xxyy(), ivec4(1_i32, 1_i32, 2_i32, 2_i32));
+    assert_eq!(v.xxyz(), ivec4(1_i32, 1_i32, 2_i32, 3_i32));
+    assert_eq!(v.xxyw(), ivec4(1_i32, 1_i32, 2_i32, 4_i32));
+    assert_eq!(v.xxzx(), ivec4(1_i32, 1_i32, 3_i32, 1_i32));
+    assert_eq!(v.xxzy(), ivec4(1_i32, 1_i32, 3_i32, 2_i32));
+    assert_eq!(v.xxzz(), ivec4(1_i32, 1_i32, 3_i32, 3_i32));
+    assert_eq!(v.xxzw(), ivec4(1_i32, 1_i32, 3_i32, 4_i32));
+    assert_eq!(v.xxwx(), ivec4(1_i32, 1_i32, 4_i32, 1_i32));
+    assert_eq!(v.xxwy(), ivec4(1_i32, 1_i32, 4_i32, 2_i32));
+    assert_eq!(v.xxwz(), ivec4(1_i32, 1_i32, 4_i32, 3_i32));
+    assert_eq!(v.xxww(), ivec4(1_i32, 1_i32, 4_i32, 4_i32));
+    assert_eq!(v.xyxx(), ivec4(1_i32, 2_i32, 1_i32, 1_i32));
+    assert_eq!(v.xyxy(), ivec4(1_i32, 2_i32, 1_i32, 2_i32));
+    assert_eq!(v.xyxz(), ivec4(1_i32, 2_i32, 1_i32, 3_i32));
+    assert_eq!(v.xyxw(), ivec4(1_i32, 2_i32, 1_i32, 4_i32));
+    assert_eq!(v.xyyx(), ivec4(1_i32, 2_i32, 2_i32, 1_i32));
+    assert_eq!(v.xyyy(), ivec4(1_i32, 2_i32, 2_i32, 2_i32));
+    assert_eq!(v.xyyz(), ivec4(1_i32, 2_i32, 2_i32, 3_i32));
+    assert_eq!(v.xyyw(), ivec4(1_i32, 2_i32, 2_i32, 4_i32));
+    assert_eq!(v.xyzx(), ivec4(1_i32, 2_i32, 3_i32, 1_i32));
+    assert_eq!(v.xyzy(), ivec4(1_i32, 2_i32, 3_i32, 2_i32));
+    assert_eq!(v.xyzz(), ivec4(1_i32, 2_i32, 3_i32, 3_i32));
+    assert_eq!(v.xywx(), ivec4(1_i32, 2_i32, 4_i32, 1_i32));
+    assert_eq!(v.xywy(), ivec4(1_i32, 2_i32, 4_i32, 2_i32));
+    assert_eq!(v.xywz(), ivec4(1_i32, 2_i32, 4_i32, 3_i32));
+    assert_eq!(v.xyww(), ivec4(1_i32, 2_i32, 4_i32, 4_i32));
+    assert_eq!(v.xzxx(), ivec4(1_i32, 3_i32, 1_i32, 1_i32));
+    assert_eq!(v.xzxy(), ivec4(1_i32, 3_i32, 1_i32, 2_i32));
+    assert_eq!(v.xzxz(), ivec4(1_i32, 3_i32, 1_i32, 3_i32));
+    assert_eq!(v.xzxw(), ivec4(1_i32, 3_i32, 1_i32, 4_i32));
+    assert_eq!(v.xzyx(), ivec4(1_i32, 3_i32, 2_i32, 1_i32));
+    assert_eq!(v.xzyy(), ivec4(1_i32, 3_i32, 2_i32, 2_i32));
+    assert_eq!(v.xzyz(), ivec4(1_i32, 3_i32, 2_i32, 3_i32));
+    assert_eq!(v.xzyw(), ivec4(1_i32, 3_i32, 2_i32, 4_i32));
+    assert_eq!(v.xzzx(), ivec4(1_i32, 3_i32, 3_i32, 1_i32));
+    assert_eq!(v.xzzy(), ivec4(1_i32, 3_i32, 3_i32, 2_i32));
+    assert_eq!(v.xzzz(), ivec4(1_i32, 3_i32, 3_i32, 3_i32));
+    assert_eq!(v.xzzw(), ivec4(1_i32, 3_i32, 3_i32, 4_i32));
+    assert_eq!(v.xzwx(), ivec4(1_i32, 3_i32, 4_i32, 1_i32));
+    assert_eq!(v.xzwy(), ivec4(1_i32, 3_i32, 4_i32, 2_i32));
+    assert_eq!(v.xzwz(), ivec4(1_i32, 3_i32, 4_i32, 3_i32));
+    assert_eq!(v.xzww(), ivec4(1_i32, 3_i32, 4_i32, 4_i32));
+    assert_eq!(v.xwxx(), ivec4(1_i32, 4_i32, 1_i32, 1_i32));
+    assert_eq!(v.xwxy(), ivec4(1_i32, 4_i32, 1_i32, 2_i32));
+    assert_eq!(v.xwxz(), ivec4(1_i32, 4_i32, 1_i32, 3_i32));
+    assert_eq!(v.xwxw(), ivec4(1_i32, 4_i32, 1_i32, 4_i32));
+    assert_eq!(v.xwyx(), ivec4(1_i32, 4_i32, 2_i32, 1_i32));
+    assert_eq!(v.xwyy(), ivec4(1_i32, 4_i32, 2_i32, 2_i32));
+    assert_eq!(v.xwyz(), ivec4(1_i32, 4_i32, 2_i32, 3_i32));
+    assert_eq!(v.xwyw(), ivec4(1_i32, 4_i32, 2_i32, 4_i32));
+    assert_eq!(v.xwzx(), ivec4(1_i32, 4_i32, 3_i32, 1_i32));
+    assert_eq!(v.xwzy(), ivec4(1_i32, 4_i32, 3_i32, 2_i32));
+    assert_eq!(v.xwzz(), ivec4(1_i32, 4_i32, 3_i32, 3_i32));
+    assert_eq!(v.xwzw(), ivec4(1_i32, 4_i32, 3_i32, 4_i32));
+    assert_eq!(v.xwwx(), ivec4(1_i32, 4_i32, 4_i32, 1_i32));
+    assert_eq!(v.xwwy(), ivec4(1_i32, 4_i32, 4_i32, 2_i32));
+    assert_eq!(v.xwwz(), ivec4(1_i32, 4_i32, 4_i32, 3_i32));
+    assert_eq!(v.xwww(), ivec4(1_i32, 4_i32, 4_i32, 4_i32));
+    assert_eq!(v.yxxx(), ivec4(2_i32, 1_i32, 1_i32, 1_i32));
+    assert_eq!(v.yxxy(), ivec4(2_i32, 1_i32, 1_i32, 2_i32));
+    assert_eq!(v.yxxz(), ivec4(2_i32, 1_i32, 1_i32, 3_i32));
+    assert_eq!(v.yxxw(), ivec4(2_i32, 1_i32, 1_i32, 4_i32));
+    assert_eq!(v.yxyx(), ivec4(2_i32, 1_i32, 2_i32, 1_i32));
+    assert_eq!(v.yxyy(), ivec4(2_i32, 1_i32, 2_i32, 2_i32));
+    assert_eq!(v.yxyz(), ivec4(2_i32, 1_i32, 2_i32, 3_i32));
+    assert_eq!(v.yxyw(), ivec4(2_i32, 1_i32, 2_i32, 4_i32));
+    assert_eq!(v.yxzx(), ivec4(2_i32, 1_i32, 3_i32, 1_i32));
+    assert_eq!(v.yxzy(), ivec4(2_i32, 1_i32, 3_i32, 2_i32));
+    assert_eq!(v.yxzz(), ivec4(2_i32, 1_i32, 3_i32, 3_i32));
+    assert_eq!(v.yxzw(), ivec4(2_i32, 1_i32, 3_i32, 4_i32));
+    assert_eq!(v.yxwx(), ivec4(2_i32, 1_i32, 4_i32, 1_i32));
+    assert_eq!(v.yxwy(), ivec4(2_i32, 1_i32, 4_i32, 2_i32));
+    assert_eq!(v.yxwz(), ivec4(2_i32, 1_i32, 4_i32, 3_i32));
+    assert_eq!(v.yxww(), ivec4(2_i32, 1_i32, 4_i32, 4_i32));
+    assert_eq!(v.yyxx(), ivec4(2_i32, 2_i32, 1_i32, 1_i32));
+    assert_eq!(v.yyxy(), ivec4(2_i32, 2_i32, 1_i32, 2_i32));
+    assert_eq!(v.yyxz(), ivec4(2_i32, 2_i32, 1_i32, 3_i32));
+    assert_eq!(v.yyxw(), ivec4(2_i32, 2_i32, 1_i32, 4_i32));
+    assert_eq!(v.yyyx(), ivec4(2_i32, 2_i32, 2_i32, 1_i32));
+    assert_eq!(v.yyyy(), ivec4(2_i32, 2_i32, 2_i32, 2_i32));
+    assert_eq!(v.yyyz(), ivec4(2_i32, 2_i32, 2_i32, 3_i32));
+    assert_eq!(v.yyyw(), ivec4(2_i32, 2_i32, 2_i32, 4_i32));
+    assert_eq!(v.yyzx(), ivec4(2_i32, 2_i32, 3_i32, 1_i32));
+    assert_eq!(v.yyzy(), ivec4(2_i32, 2_i32, 3_i32, 2_i32));
+    assert_eq!(v.yyzz(), ivec4(2_i32, 2_i32, 3_i32, 3_i32));
+    assert_eq!(v.yyzw(), ivec4(2_i32, 2_i32, 3_i32, 4_i32));
+    assert_eq!(v.yywx(), ivec4(2_i32, 2_i32, 4_i32, 1_i32));
+    assert_eq!(v.yywy(), ivec4(2_i32, 2_i32, 4_i32, 2_i32));
+    assert_eq!(v.yywz(), ivec4(2_i32, 2_i32, 4_i32, 3_i32));
+    assert_eq!(v.yyww(), ivec4(2_i32, 2_i32, 4_i32, 4_i32));
+    assert_eq!(v.yzxx(), ivec4(2_i32, 3_i32, 1_i32, 1_i32));
+    assert_eq!(v.yzxy(), ivec4(2_i32, 3_i32, 1_i32, 2_i32));
+    assert_eq!(v.yzxz(), ivec4(2_i32, 3_i32, 1_i32, 3_i32));
+    assert_eq!(v.yzxw(), ivec4(2_i32, 3_i32, 1_i32, 4_i32));
+    assert_eq!(v.yzyx(), ivec4(2_i32, 3_i32, 2_i32, 1_i32));
+    assert_eq!(v.yzyy(), ivec4(2_i32, 3_i32, 2_i32, 2_i32));
+    assert_eq!(v.yzyz(), ivec4(2_i32, 3_i32, 2_i32, 3_i32));
+    assert_eq!(v.yzyw(), ivec4(2_i32, 3_i32, 2_i32, 4_i32));
+    assert_eq!(v.yzzx(), ivec4(2_i32, 3_i32, 3_i32, 1_i32));
+    assert_eq!(v.yzzy(), ivec4(2_i32, 3_i32, 3_i32, 2_i32));
+    assert_eq!(v.yzzz(), ivec4(2_i32, 3_i32, 3_i32, 3_i32));
+    assert_eq!(v.yzzw(), ivec4(2_i32, 3_i32, 3_i32, 4_i32));
+    assert_eq!(v.yzwx(), ivec4(2_i32, 3_i32, 4_i32, 1_i32));
+    assert_eq!(v.yzwy(), ivec4(2_i32, 3_i32, 4_i32, 2_i32));
+    assert_eq!(v.yzwz(), ivec4(2_i32, 3_i32, 4_i32, 3_i32));
+    assert_eq!(v.yzww(), ivec4(2_i32, 3_i32, 4_i32, 4_i32));
+    assert_eq!(v.ywxx(), ivec4(2_i32, 4_i32, 1_i32, 1_i32));
+    assert_eq!(v.ywxy(), ivec4(2_i32, 4_i32, 1_i32, 2_i32));
+    assert_eq!(v.ywxz(), ivec4(2_i32, 4_i32, 1_i32, 3_i32));
+    assert_eq!(v.ywxw(), ivec4(2_i32, 4_i32, 1_i32, 4_i32));
+    assert_eq!(v.ywyx(), ivec4(2_i32, 4_i32, 2_i32, 1_i32));
+    assert_eq!(v.ywyy(), ivec4(2_i32, 4_i32, 2_i32, 2_i32));
+    assert_eq!(v.ywyz(), ivec4(2_i32, 4_i32, 2_i32, 3_i32));
+    assert_eq!(v.ywyw(), ivec4(2_i32, 4_i32, 2_i32, 4_i32));
+    assert_eq!(v.ywzx(), ivec4(2_i32, 4_i32, 3_i32, 1_i32));
+    assert_eq!(v.ywzy(), ivec4(2_i32, 4_i32, 3_i32, 2_i32));
+    assert_eq!(v.ywzz(), ivec4(2_i32, 4_i32, 3_i32, 3_i32));
+    assert_eq!(v.ywzw(), ivec4(2_i32, 4_i32, 3_i32, 4_i32));
+    assert_eq!(v.ywwx(), ivec4(2_i32, 4_i32, 4_i32, 1_i32));
+    assert_eq!(v.ywwy(), ivec4(2_i32, 4_i32, 4_i32, 2_i32));
+    assert_eq!(v.ywwz(), ivec4(2_i32, 4_i32, 4_i32, 3_i32));
+    assert_eq!(v.ywww(), ivec4(2_i32, 4_i32, 4_i32, 4_i32));
+    assert_eq!(v.zxxx(), ivec4(3_i32, 1_i32, 1_i32, 1_i32));
+    assert_eq!(v.zxxy(), ivec4(3_i32, 1_i32, 1_i32, 2_i32));
+    assert_eq!(v.zxxz(), ivec4(3_i32, 1_i32, 1_i32, 3_i32));
+    assert_eq!(v.zxxw(), ivec4(3_i32, 1_i32, 1_i32, 4_i32));
+    assert_eq!(v.zxyx(), ivec4(3_i32, 1_i32, 2_i32, 1_i32));
+    assert_eq!(v.zxyy(), ivec4(3_i32, 1_i32, 2_i32, 2_i32));
+    assert_eq!(v.zxyz(), ivec4(3_i32, 1_i32, 2_i32, 3_i32));
+    assert_eq!(v.zxyw(), ivec4(3_i32, 1_i32, 2_i32, 4_i32));
+    assert_eq!(v.zxzx(), ivec4(3_i32, 1_i32, 3_i32, 1_i32));
+    assert_eq!(v.zxzy(), ivec4(3_i32, 1_i32, 3_i32, 2_i32));
+    assert_eq!(v.zxzz(), ivec4(3_i32, 1_i32, 3_i32, 3_i32));
+    assert_eq!(v.zxzw(), ivec4(3_i32, 1_i32, 3_i32, 4_i32));
+    assert_eq!(v.zxwx(), ivec4(3_i32, 1_i32, 4_i32, 1_i32));
+    assert_eq!(v.zxwy(), ivec4(3_i32, 1_i32, 4_i32, 2_i32));
+    assert_eq!(v.zxwz(), ivec4(3_i32, 1_i32, 4_i32, 3_i32));
+    assert_eq!(v.zxww(), ivec4(3_i32, 1_i32, 4_i32, 4_i32));
+    assert_eq!(v.zyxx(), ivec4(3_i32, 2_i32, 1_i32, 1_i32));
+    assert_eq!(v.zyxy(), ivec4(3_i32, 2_i32, 1_i32, 2_i32));
+    assert_eq!(v.zyxz(), ivec4(3_i32, 2_i32, 1_i32, 3_i32));
+    assert_eq!(v.zyxw(), ivec4(3_i32, 2_i32, 1_i32, 4_i32));
+    assert_eq!(v.zyyx(), ivec4(3_i32, 2_i32, 2_i32, 1_i32));
+    assert_eq!(v.zyyy(), ivec4(3_i32, 2_i32, 2_i32, 2_i32));
+    assert_eq!(v.zyyz(), ivec4(3_i32, 2_i32, 2_i32, 3_i32));
+    assert_eq!(v.zyyw(), ivec4(3_i32, 2_i32, 2_i32, 4_i32));
+    assert_eq!(v.zyzx(), ivec4(3_i32, 2_i32, 3_i32, 1_i32));
+    assert_eq!(v.zyzy(), ivec4(3_i32, 2_i32, 3_i32, 2_i32));
+    assert_eq!(v.zyzz(), ivec4(3_i32, 2_i32, 3_i32, 3_i32));
+    assert_eq!(v.zyzw(), ivec4(3_i32, 2_i32, 3_i32, 4_i32));
+    assert_eq!(v.zywx(), ivec4(3_i32, 2_i32, 4_i32, 1_i32));
+    assert_eq!(v.zywy(), ivec4(3_i32, 2_i32, 4_i32, 2_i32));
+    assert_eq!(v.zywz(), ivec4(3_i32, 2_i32, 4_i32, 3_i32));
+    assert_eq!(v.zyww(), ivec4(3_i32, 2_i32, 4_i32, 4_i32));
+    assert_eq!(v.zzxx(), ivec4(3_i32, 3_i32, 1_i32, 1_i32));
+    assert_eq!(v.zzxy(), ivec4(3_i32, 3_i32, 1_i32, 2_i32));
+    assert_eq!(v.zzxz(), ivec4(3_i32, 3_i32, 1_i32, 3_i32));
+    assert_eq!(v.zzxw(), ivec4(3_i32, 3_i32, 1_i32, 4_i32));
+    assert_eq!(v.zzyx(), ivec4(3_i32, 3_i32, 2_i32, 1_i32));
+    assert_eq!(v.zzyy(), ivec4(3_i32, 3_i32, 2_i32, 2_i32));
+    assert_eq!(v.zzyz(), ivec4(3_i32, 3_i32, 2_i32, 3_i32));
+    assert_eq!(v.zzyw(), ivec4(3_i32, 3_i32, 2_i32, 4_i32));
+    assert_eq!(v.zzzx(), ivec4(3_i32, 3_i32, 3_i32, 1_i32));
+    assert_eq!(v.zzzy(), ivec4(3_i32, 3_i32, 3_i32, 2_i32));
+    assert_eq!(v.zzzz(), ivec4(3_i32, 3_i32, 3_i32, 3_i32));
+    assert_eq!(v.zzzw(), ivec4(3_i32, 3_i32, 3_i32, 4_i32));
+    assert_eq!(v.zzwx(), ivec4(3_i32, 3_i32, 4_i32, 1_i32));
+    assert_eq!(v.zzwy(), ivec4(3_i32, 3_i32, 4_i32, 2_i32));
+    assert_eq!(v.zzwz(), ivec4(3_i32, 3_i32, 4_i32, 3_i32));
+    assert_eq!(v.zzww(), ivec4(3_i32, 3_i32, 4_i32, 4_i32));
+    assert_eq!(v.zwxx(), ivec4(3_i32, 4_i32, 1_i32, 1_i32));
+    assert_eq!(v.zwxy(), ivec4(3_i32, 4_i32, 1_i32, 2_i32));
+    assert_eq!(v.zwxz(), ivec4(3_i32, 4_i32, 1_i32, 3_i32));
+    assert_eq!(v.zwxw(), ivec4(3_i32, 4_i32, 1_i32, 4_i32));
+    assert_eq!(v.zwyx(), ivec4(3_i32, 4_i32, 2_i32, 1_i32));
+    assert_eq!(v.zwyy(), ivec4(3_i32, 4_i32, 2_i32, 2_i32));
+    assert_eq!(v.zwyz(), ivec4(3_i32, 4_i32, 2_i32, 3_i32));
+    assert_eq!(v.zwyw(), ivec4(3_i32, 4_i32, 2_i32, 4_i32));
+    assert_eq!(v.zwzx(), ivec4(3_i32, 4_i32, 3_i32, 1_i32));
+    assert_eq!(v.zwzy(), ivec4(3_i32, 4_i32, 3_i32, 2_i32));
+    assert_eq!(v.zwzz(), ivec4(3_i32, 4_i32, 3_i32, 3_i32));
+    assert_eq!(v.zwzw(), ivec4(3_i32, 4_i32, 3_i32, 4_i32));
+    assert_eq!(v.zwwx(), ivec4(3_i32, 4_i32, 4_i32, 1_i32));
+    assert_eq!(v.zwwy(), ivec4(3_i32, 4_i32, 4_i32, 2_i32));
+    assert_eq!(v.zwwz(), ivec4(3_i32, 4_i32, 4_i32, 3_i32));
+    assert_eq!(v.zwww(), ivec4(3_i32, 4_i32, 4_i32, 4_i32));
+    assert_eq!(v.wxxx(), ivec4(4_i32, 1_i32, 1_i32, 1_i32));
+    assert_eq!(v.wxxy(), ivec4(4_i32, 1_i32, 1_i32, 2_i32));
+    assert_eq!(v.wxxz(), ivec4(4_i32, 1_i32, 1_i32, 3_i32));
+    assert_eq!(v.wxxw(), ivec4(4_i32, 1_i32, 1_i32, 4_i32));
+    assert_eq!(v.wxyx(), ivec4(4_i32, 1_i32, 2_i32, 1_i32));
+    assert_eq!(v.wxyy(), ivec4(4_i32, 1_i32, 2_i32, 2_i32));
+    assert_eq!(v.wxyz(), ivec4(4_i32, 1_i32, 2_i32, 3_i32));
+    assert_eq!(v.wxyw(), ivec4(4_i32, 1_i32, 2_i32, 4_i32));
+    assert_eq!(v.wxzx(), ivec4(4_i32, 1_i32, 3_i32, 1_i32));
+    assert_eq!(v.wxzy(), ivec4(4_i32, 1_i32, 3_i32, 2_i32));
+    assert_eq!(v.wxzz(), ivec4(4_i32, 1_i32, 3_i32, 3_i32));
+    assert_eq!(v.wxzw(), ivec4(4_i32, 1_i32, 3_i32, 4_i32));
+    assert_eq!(v.wxwx(), ivec4(4_i32, 1_i32, 4_i32, 1_i32));
+    assert_eq!(v.wxwy(), ivec4(4_i32, 1_i32, 4_i32, 2_i32));
+    assert_eq!(v.wxwz(), ivec4(4_i32, 1_i32, 4_i32, 3_i32));
+    assert_eq!(v.wxww(), ivec4(4_i32, 1_i32, 4_i32, 4_i32));
+    assert_eq!(v.wyxx(), ivec4(4_i32, 2_i32, 1_i32, 1_i32));
+    assert_eq!(v.wyxy(), ivec4(4_i32, 2_i32, 1_i32, 2_i32));
+    assert_eq!(v.wyxz(), ivec4(4_i32, 2_i32, 1_i32, 3_i32));
+    assert_eq!(v.wyxw(), ivec4(4_i32, 2_i32, 1_i32, 4_i32));
+    assert_eq!(v.wyyx(), ivec4(4_i32, 2_i32, 2_i32, 1_i32));
+    assert_eq!(v.wyyy(), ivec4(4_i32, 2_i32, 2_i32, 2_i32));
+    assert_eq!(v.wyyz(), ivec4(4_i32, 2_i32, 2_i32, 3_i32));
+    assert_eq!(v.wyyw(), ivec4(4_i32, 2_i32, 2_i32, 4_i32));
+    assert_eq!(v.wyzx(), ivec4(4_i32, 2_i32, 3_i32, 1_i32));
+    assert_eq!(v.wyzy(), ivec4(4_i32, 2_i32, 3_i32, 2_i32));
+    assert_eq!(v.wyzz(), ivec4(4_i32, 2_i32, 3_i32, 3_i32));
+    assert_eq!(v.wyzw(), ivec4(4_i32, 2_i32, 3_i32, 4_i32));
+    assert_eq!(v.wywx(), ivec4(4_i32, 2_i32, 4_i32, 1_i32));
+    assert_eq!(v.wywy(), ivec4(4_i32, 2_i32, 4_i32, 2_i32));
+    assert_eq!(v.wywz(), ivec4(4_i32, 2_i32, 4_i32, 3_i32));
+    assert_eq!(v.wyww(), ivec4(4_i32, 2_i32, 4_i32, 4_i32));
+    assert_eq!(v.wzxx(), ivec4(4_i32, 3_i32, 1_i32, 1_i32));
+    assert_eq!(v.wzxy(), ivec4(4_i32, 3_i32, 1_i32, 2_i32));
+    assert_eq!(v.wzxz(), ivec4(4_i32, 3_i32, 1_i32, 3_i32));
+    assert_eq!(v.wzxw(), ivec4(4_i32, 3_i32, 1_i32, 4_i32));
+    assert_eq!(v.wzyx(), ivec4(4_i32, 3_i32, 2_i32, 1_i32));
+    assert_eq!(v.wzyy(), ivec4(4_i32, 3_i32, 2_i32, 2_i32));
+    assert_eq!(v.wzyz(), ivec4(4_i32, 3_i32, 2_i32, 3_i32));
+    assert_eq!(v.wzyw(), ivec4(4_i32, 3_i32, 2_i32, 4_i32));
+    assert_eq!(v.wzzx(), ivec4(4_i32, 3_i32, 3_i32, 1_i32));
+    assert_eq!(v.wzzy(), ivec4(4_i32, 3_i32, 3_i32, 2_i32));
+    assert_eq!(v.wzzz(), ivec4(4_i32, 3_i32, 3_i32, 3_i32));
+    assert_eq!(v.wzzw(), ivec4(4_i32, 3_i32, 3_i32, 4_i32));
+    assert_eq!(v.wzwx(), ivec4(4_i32, 3_i32, 4_i32, 1_i32));
+    assert_eq!(v.wzwy(), ivec4(4_i32, 3_i32, 4_i32, 2_i32));
+    assert_eq!(v.wzwz(), ivec4(4_i32, 3_i32, 4_i32, 3_i32));
+    assert_eq!(v.wzww(), ivec4(4_i32, 3_i32, 4_i32, 4_i32));
+    assert_eq!(v.wwxx(), ivec4(4_i32, 4_i32, 1_i32, 1_i32));
+    assert_eq!(v.wwxy(), ivec4(4_i32, 4_i32, 1_i32, 2_i32));
+    assert_eq!(v.wwxz(), ivec4(4_i32, 4_i32, 1_i32, 3_i32));
+    assert_eq!(v.wwxw(), ivec4(4_i32, 4_i32, 1_i32, 4_i32));
+    assert_eq!(v.wwyx(), ivec4(4_i32, 4_i32, 2_i32, 1_i32));
+    assert_eq!(v.wwyy(), ivec4(4_i32, 4_i32, 2_i32, 2_i32));
+    assert_eq!(v.wwyz(), ivec4(4_i32, 4_i32, 2_i32, 3_i32));
+    assert_eq!(v.wwyw(), ivec4(4_i32, 4_i32, 2_i32, 4_i32));
+    assert_eq!(v.wwzx(), ivec4(4_i32, 4_i32, 3_i32, 1_i32));
+    assert_eq!(v.wwzy(), ivec4(4_i32, 4_i32, 3_i32, 2_i32));
+    assert_eq!(v.wwzz(), ivec4(4_i32, 4_i32, 3_i32, 3_i32));
+    assert_eq!(v.wwzw(), ivec4(4_i32, 4_i32, 3_i32, 4_i32));
+    assert_eq!(v.wwwx(), ivec4(4_i32, 4_i32, 4_i32, 1_i32));
+    assert_eq!(v.wwwy(), ivec4(4_i32, 4_i32, 4_i32, 2_i32));
+    assert_eq!(v.wwwz(), ivec4(4_i32, 4_i32, 4_i32, 3_i32));
+    assert_eq!(v.wwww(), ivec4(4_i32, 4_i32, 4_i32, 4_i32));
+    assert_eq!(v.xxx(), ivec3(1_i32, 1_i32, 1_i32));
+    assert_eq!(v.xxy(), ivec3(1_i32, 1_i32, 2_i32));
+    assert_eq!(v.xxz(), ivec3(1_i32, 1_i32, 3_i32));
+    assert_eq!(v.xxw(), ivec3(1_i32, 1_i32, 4_i32));
+    assert_eq!(v.xyx(), ivec3(1_i32, 2_i32, 1_i32));
+    assert_eq!(v.xyy(), ivec3(1_i32, 2_i32, 2_i32));
+    assert_eq!(v.xyz(), ivec3(1_i32, 2_i32, 3_i32));
+    assert_eq!(v.xyw(), ivec3(1_i32, 2_i32, 4_i32));
+    assert_eq!(v.xzx(), ivec3(1_i32, 3_i32, 1_i32));
+    assert_eq!(v.xzy(), ivec3(1_i32, 3_i32, 2_i32));
+    assert_eq!(v.xzz(), ivec3(1_i32, 3_i32, 3_i32));
+    assert_eq!(v.xzw(), ivec3(1_i32, 3_i32, 4_i32));
+    assert_eq!(v.xwx(), ivec3(1_i32, 4_i32, 1_i32));
+    assert_eq!(v.xwy(), ivec3(1_i32, 4_i32, 2_i32));
+    assert_eq!(v.xwz(), ivec3(1_i32, 4_i32, 3_i32));
+    assert_eq!(v.xww(), ivec3(1_i32, 4_i32, 4_i32));
+    assert_eq!(v.yxx(), ivec3(2_i32, 1_i32, 1_i32));
+    assert_eq!(v.yxy(), ivec3(2_i32, 1_i32, 2_i32));
+    assert_eq!(v.yxz(), ivec3(2_i32, 1_i32, 3_i32));
+    assert_eq!(v.yxw(), ivec3(2_i32, 1_i32, 4_i32));
+    assert_eq!(v.yyx(), ivec3(2_i32, 2_i32, 1_i32));
+    assert_eq!(v.yyy(), ivec3(2_i32, 2_i32, 2_i32));
+    assert_eq!(v.yyz(), ivec3(2_i32, 2_i32, 3_i32));
+    assert_eq!(v.yyw(), ivec3(2_i32, 2_i32, 4_i32));
+    assert_eq!(v.yzx(), ivec3(2_i32, 3_i32, 1_i32));
+    assert_eq!(v.yzy(), ivec3(2_i32, 3_i32, 2_i32));
+    assert_eq!(v.yzz(), ivec3(2_i32, 3_i32, 3_i32));
+    assert_eq!(v.yzw(), ivec3(2_i32, 3_i32, 4_i32));
+    assert_eq!(v.ywx(), ivec3(2_i32, 4_i32, 1_i32));
+    assert_eq!(v.ywy(), ivec3(2_i32, 4_i32, 2_i32));
+    assert_eq!(v.ywz(), ivec3(2_i32, 4_i32, 3_i32));
+    assert_eq!(v.yww(), ivec3(2_i32, 4_i32, 4_i32));
+    assert_eq!(v.zxx(), ivec3(3_i32, 1_i32, 1_i32));
+    assert_eq!(v.zxy(), ivec3(3_i32, 1_i32, 2_i32));
+    assert_eq!(v.zxz(), ivec3(3_i32, 1_i32, 3_i32));
+    assert_eq!(v.zxw(), ivec3(3_i32, 1_i32, 4_i32));
+    assert_eq!(v.zyx(), ivec3(3_i32, 2_i32, 1_i32));
+    assert_eq!(v.zyy(), ivec3(3_i32, 2_i32, 2_i32));
+    assert_eq!(v.zyz(), ivec3(3_i32, 2_i32, 3_i32));
+    assert_eq!(v.zyw(), ivec3(3_i32, 2_i32, 4_i32));
+    assert_eq!(v.zzx(), ivec3(3_i32, 3_i32, 1_i32));
+    assert_eq!(v.zzy(), ivec3(3_i32, 3_i32, 2_i32));
+    assert_eq!(v.zzz(), ivec3(3_i32, 3_i32, 3_i32));
+    assert_eq!(v.zzw(), ivec3(3_i32, 3_i32, 4_i32));
+    assert_eq!(v.zwx(), ivec3(3_i32, 4_i32, 1_i32));
+    assert_eq!(v.zwy(), ivec3(3_i32, 4_i32, 2_i32));
+    assert_eq!(v.zwz(), ivec3(3_i32, 4_i32, 3_i32));
+    assert_eq!(v.zww(), ivec3(3_i32, 4_i32, 4_i32));
+    assert_eq!(v.wxx(), ivec3(4_i32, 1_i32, 1_i32));
+    assert_eq!(v.wxy(), ivec3(4_i32, 1_i32, 2_i32));
+    assert_eq!(v.wxz(), ivec3(4_i32, 1_i32, 3_i32));
+    assert_eq!(v.wxw(), ivec3(4_i32, 1_i32, 4_i32));
+    assert_eq!(v.wyx(), ivec3(4_i32, 2_i32, 1_i32));
+    assert_eq!(v.wyy(), ivec3(4_i32, 2_i32, 2_i32));
+    assert_eq!(v.wyz(), ivec3(4_i32, 2_i32, 3_i32));
+    assert_eq!(v.wyw(), ivec3(4_i32, 2_i32, 4_i32));
+    assert_eq!(v.wzx(), ivec3(4_i32, 3_i32, 1_i32));
+    assert_eq!(v.wzy(), ivec3(4_i32, 3_i32, 2_i32));
+    assert_eq!(v.wzz(), ivec3(4_i32, 3_i32, 3_i32));
+    assert_eq!(v.wzw(), ivec3(4_i32, 3_i32, 4_i32));
+    assert_eq!(v.wwx(), ivec3(4_i32, 4_i32, 1_i32));
+    assert_eq!(v.wwy(), ivec3(4_i32, 4_i32, 2_i32));
+    assert_eq!(v.wwz(), ivec3(4_i32, 4_i32, 3_i32));
+    assert_eq!(v.www(), ivec3(4_i32, 4_i32, 4_i32));
+    assert_eq!(v.xx(), ivec2(1_i32, 1_i32));
+    assert_eq!(v.xy(), ivec2(1_i32, 2_i32));
+    assert_eq!(v.xz(), ivec2(1_i32, 3_i32));
+    assert_eq!(v.xw(), ivec2(1_i32, 4_i32));
+    assert_eq!(v.yx(), ivec2(2_i32, 1_i32));
+    assert_eq!(v.yy(), ivec2(2_i32, 2_i32));
+    assert_eq!(v.yz(), ivec2(2_i32, 3_i32));
+    assert_eq!(v.yw(), ivec2(2_i32, 4_i32));
+    assert_eq!(v.zx(), ivec2(3_i32, 1_i32));
+    assert_eq!(v.zy(), ivec2(3_i32, 2_i32));
+    assert_eq!(v.zz(), ivec2(3_i32, 3_i32));
+    assert_eq!(v.zw(), ivec2(3_i32, 4_i32));
+    assert_eq!(v.wx(), ivec2(4_i32, 1_i32));
+    assert_eq!(v.wy(), ivec2(4_i32, 2_i32));
+    assert_eq!(v.wz(), ivec2(4_i32, 3_i32));
+    assert_eq!(v.ww(), ivec2(4_i32, 4_i32));
+});
+
+glam_test!(test_ivec3_swizzles, {
+    let v = ivec3(1_i32, 2_i32, 3_i32);
+    assert_eq!(v, v.xyz());
+    assert_eq!(v.xxxx(), ivec4(1_i32, 1_i32, 1_i32, 1_i32));
+    assert_eq!(v.xxxy(), ivec4(1_i32, 1_i32, 1_i32, 2_i32));
+    assert_eq!(v.xxxz(), ivec4(1_i32, 1_i32, 1_i32, 3_i32));
+    assert_eq!(v.xxyx(), ivec4(1_i32, 1_i32, 2_i32, 1_i32));
+    assert_eq!(v.xxyy(), ivec4(1_i32, 1_i32, 2_i32, 2_i32));
+    assert_eq!(v.xxyz(), ivec4(1_i32, 1_i32, 2_i32, 3_i32));
+    assert_eq!(v.xxzx(), ivec4(1_i32, 1_i32, 3_i32, 1_i32));
+    assert_eq!(v.xxzy(), ivec4(1_i32, 1_i32, 3_i32, 2_i32));
+    assert_eq!(v.xxzz(), ivec4(1_i32, 1_i32, 3_i32, 3_i32));
+    assert_eq!(v.xyxx(), ivec4(1_i32, 2_i32, 1_i32, 1_i32));
+    assert_eq!(v.xyxy(), ivec4(1_i32, 2_i32, 1_i32, 2_i32));
+    assert_eq!(v.xyxz(), ivec4(1_i32, 2_i32, 1_i32, 3_i32));
+    assert_eq!(v.xyyx(), ivec4(1_i32, 2_i32, 2_i32, 1_i32));
+    assert_eq!(v.xyyy(), ivec4(1_i32, 2_i32, 2_i32, 2_i32));
+    assert_eq!(v.xyyz(), ivec4(1_i32, 2_i32, 2_i32, 3_i32));
+    assert_eq!(v.xyzx(), ivec4(1_i32, 2_i32, 3_i32, 1_i32));
+    assert_eq!(v.xyzy(), ivec4(1_i32, 2_i32, 3_i32, 2_i32));
+    assert_eq!(v.xyzz(), ivec4(1_i32, 2_i32, 3_i32, 3_i32));
+    assert_eq!(v.xzxx(), ivec4(1_i32, 3_i32, 1_i32, 1_i32));
+    assert_eq!(v.xzxy(), ivec4(1_i32, 3_i32, 1_i32, 2_i32));
+    assert_eq!(v.xzxz(), ivec4(1_i32, 3_i32, 1_i32, 3_i32));
+    assert_eq!(v.xzyx(), ivec4(1_i32, 3_i32, 2_i32, 1_i32));
+    assert_eq!(v.xzyy(), ivec4(1_i32, 3_i32, 2_i32, 2_i32));
+    assert_eq!(v.xzyz(), ivec4(1_i32, 3_i32, 2_i32, 3_i32));
+    assert_eq!(v.xzzx(), ivec4(1_i32, 3_i32, 3_i32, 1_i32));
+    assert_eq!(v.xzzy(), ivec4(1_i32, 3_i32, 3_i32, 2_i32));
+    assert_eq!(v.xzzz(), ivec4(1_i32, 3_i32, 3_i32, 3_i32));
+    assert_eq!(v.yxxx(), ivec4(2_i32, 1_i32, 1_i32, 1_i32));
+    assert_eq!(v.yxxy(), ivec4(2_i32, 1_i32, 1_i32, 2_i32));
+    assert_eq!(v.yxxz(), ivec4(2_i32, 1_i32, 1_i32, 3_i32));
+    assert_eq!(v.yxyx(), ivec4(2_i32, 1_i32, 2_i32, 1_i32));
+    assert_eq!(v.yxyy(), ivec4(2_i32, 1_i32, 2_i32, 2_i32));
+    assert_eq!(v.yxyz(), ivec4(2_i32, 1_i32, 2_i32, 3_i32));
+    assert_eq!(v.yxzx(), ivec4(2_i32, 1_i32, 3_i32, 1_i32));
+    assert_eq!(v.yxzy(), ivec4(2_i32, 1_i32, 3_i32, 2_i32));
+    assert_eq!(v.yxzz(), ivec4(2_i32, 1_i32, 3_i32, 3_i32));
+    assert_eq!(v.yyxx(), ivec4(2_i32, 2_i32, 1_i32, 1_i32));
+    assert_eq!(v.yyxy(), ivec4(2_i32, 2_i32, 1_i32, 2_i32));
+    assert_eq!(v.yyxz(), ivec4(2_i32, 2_i32, 1_i32, 3_i32));
+    assert_eq!(v.yyyx(), ivec4(2_i32, 2_i32, 2_i32, 1_i32));
+    assert_eq!(v.yyyy(), ivec4(2_i32, 2_i32, 2_i32, 2_i32));
+    assert_eq!(v.yyyz(), ivec4(2_i32, 2_i32, 2_i32, 3_i32));
+    assert_eq!(v.yyzx(), ivec4(2_i32, 2_i32, 3_i32, 1_i32));
+    assert_eq!(v.yyzy(), ivec4(2_i32, 2_i32, 3_i32, 2_i32));
+    assert_eq!(v.yyzz(), ivec4(2_i32, 2_i32, 3_i32, 3_i32));
+    assert_eq!(v.yzxx(), ivec4(2_i32, 3_i32, 1_i32, 1_i32));
+    assert_eq!(v.yzxy(), ivec4(2_i32, 3_i32, 1_i32, 2_i32));
+    assert_eq!(v.yzxz(), ivec4(2_i32, 3_i32, 1_i32, 3_i32));
+    assert_eq!(v.yzyx(), ivec4(2_i32, 3_i32, 2_i32, 1_i32));
+    assert_eq!(v.yzyy(), ivec4(2_i32, 3_i32, 2_i32, 2_i32));
+    assert_eq!(v.yzyz(), ivec4(2_i32, 3_i32, 2_i32, 3_i32));
+    assert_eq!(v.yzzx(), ivec4(2_i32, 3_i32, 3_i32, 1_i32));
+    assert_eq!(v.yzzy(), ivec4(2_i32, 3_i32, 3_i32, 2_i32));
+    assert_eq!(v.yzzz(), ivec4(2_i32, 3_i32, 3_i32, 3_i32));
+    assert_eq!(v.zxxx(), ivec4(3_i32, 1_i32, 1_i32, 1_i32));
+    assert_eq!(v.zxxy(), ivec4(3_i32, 1_i32, 1_i32, 2_i32));
+    assert_eq!(v.zxxz(), ivec4(3_i32, 1_i32, 1_i32, 3_i32));
+    assert_eq!(v.zxyx(), ivec4(3_i32, 1_i32, 2_i32, 1_i32));
+    assert_eq!(v.zxyy(), ivec4(3_i32, 1_i32, 2_i32, 2_i32));
+    assert_eq!(v.zxyz(), ivec4(3_i32, 1_i32, 2_i32, 3_i32));
+    assert_eq!(v.zxzx(), ivec4(3_i32, 1_i32, 3_i32, 1_i32));
+    assert_eq!(v.zxzy(), ivec4(3_i32, 1_i32, 3_i32, 2_i32));
+    assert_eq!(v.zxzz(), ivec4(3_i32, 1_i32, 3_i32, 3_i32));
+    assert_eq!(v.zyxx(), ivec4(3_i32, 2_i32, 1_i32, 1_i32));
+    assert_eq!(v.zyxy(), ivec4(3_i32, 2_i32, 1_i32, 2_i32));
+    assert_eq!(v.zyxz(), ivec4(3_i32, 2_i32, 1_i32, 3_i32));
+    assert_eq!(v.zyyx(), ivec4(3_i32, 2_i32, 2_i32, 1_i32));
+    assert_eq!(v.zyyy(), ivec4(3_i32, 2_i32, 2_i32, 2_i32));
+    assert_eq!(v.zyyz(), ivec4(3_i32, 2_i32, 2_i32, 3_i32));
+    assert_eq!(v.zyzx(), ivec4(3_i32, 2_i32, 3_i32, 1_i32));
+    assert_eq!(v.zyzy(), ivec4(3_i32, 2_i32, 3_i32, 2_i32));
+    assert_eq!(v.zyzz(), ivec4(3_i32, 2_i32, 3_i32, 3_i32));
+    assert_eq!(v.zzxx(), ivec4(3_i32, 3_i32, 1_i32, 1_i32));
+    assert_eq!(v.zzxy(), ivec4(3_i32, 3_i32, 1_i32, 2_i32));
+    assert_eq!(v.zzxz(), ivec4(3_i32, 3_i32, 1_i32, 3_i32));
+    assert_eq!(v.zzyx(), ivec4(3_i32, 3_i32, 2_i32, 1_i32));
+    assert_eq!(v.zzyy(), ivec4(3_i32, 3_i32, 2_i32, 2_i32));
+    assert_eq!(v.zzyz(), ivec4(3_i32, 3_i32, 2_i32, 3_i32));
+    assert_eq!(v.zzzx(), ivec4(3_i32, 3_i32, 3_i32, 1_i32));
+    assert_eq!(v.zzzy(), ivec4(3_i32, 3_i32, 3_i32, 2_i32));
+    assert_eq!(v.zzzz(), ivec4(3_i32, 3_i32, 3_i32, 3_i32));
+    assert_eq!(v.xxx(), ivec3(1_i32, 1_i32, 1_i32));
+    assert_eq!(v.xxy(), ivec3(1_i32, 1_i32, 2_i32));
+    assert_eq!(v.xxz(), ivec3(1_i32, 1_i32, 3_i32));
+    assert_eq!(v.xyx(), ivec3(1_i32, 2_i32, 1_i32));
+    assert_eq!(v.xyy(), ivec3(1_i32, 2_i32, 2_i32));
+    assert_eq!(v.xzx(), ivec3(1_i32, 3_i32, 1_i32));
+    assert_eq!(v.xzy(), ivec3(1_i32, 3_i32, 2_i32));
+    assert_eq!(v.xzz(), ivec3(1_i32, 3_i32, 3_i32));
+    assert_eq!(v.yxx(), ivec3(2_i32, 1_i32, 1_i32));
+    assert_eq!(v.yxy(), ivec3(2_i32, 1_i32, 2_i32));
+    assert_eq!(v.yxz(), ivec3(2_i32, 1_i32, 3_i32));
+    assert_eq!(v.yyx(), ivec3(2_i32, 2_i32, 1_i32));
+    assert_eq!(v.yyy(), ivec3(2_i32, 2_i32, 2_i32));
+    assert_eq!(v.yyz(), ivec3(2_i32, 2_i32, 3_i32));
+    assert_eq!(v.yzx(), ivec3(2_i32, 3_i32, 1_i32));
+    assert_eq!(v.yzy(), ivec3(2_i32, 3_i32, 2_i32));
+    assert_eq!(v.yzz(), ivec3(2_i32, 3_i32, 3_i32));
+    assert_eq!(v.zxx(), ivec3(3_i32, 1_i32, 1_i32));
+    assert_eq!(v.zxy(), ivec3(3_i32, 1_i32, 2_i32));
+    assert_eq!(v.zxz(), ivec3(3_i32, 1_i32, 3_i32));
+    assert_eq!(v.zyx(), ivec3(3_i32, 2_i32, 1_i32));
+    assert_eq!(v.zyy(), ivec3(3_i32, 2_i32, 2_i32));
+    assert_eq!(v.zyz(), ivec3(3_i32, 2_i32, 3_i32));
+    assert_eq!(v.zzx(), ivec3(3_i32, 3_i32, 1_i32));
+    assert_eq!(v.zzy(), ivec3(3_i32, 3_i32, 2_i32));
+    assert_eq!(v.zzz(), ivec3(3_i32, 3_i32, 3_i32));
+    assert_eq!(v.xx(), ivec2(1_i32, 1_i32));
+    assert_eq!(v.xy(), ivec2(1_i32, 2_i32));
+    assert_eq!(v.xz(), ivec2(1_i32, 3_i32));
+    assert_eq!(v.yx(), ivec2(2_i32, 1_i32));
+    assert_eq!(v.yy(), ivec2(2_i32, 2_i32));
+    assert_eq!(v.yz(), ivec2(2_i32, 3_i32));
+    assert_eq!(v.zx(), ivec2(3_i32, 1_i32));
+    assert_eq!(v.zy(), ivec2(3_i32, 2_i32));
+    assert_eq!(v.zz(), ivec2(3_i32, 3_i32));
+});
+
+glam_test!(test_ivec2_swizzles, {
+    let v = ivec2(1_i32, 2_i32);
+    assert_eq!(v, v.xy());
+    assert_eq!(v.xxxx(), ivec4(1_i32, 1_i32, 1_i32, 1_i32));
+    assert_eq!(v.xxxy(), ivec4(1_i32, 1_i32, 1_i32, 2_i32));
+    assert_eq!(v.xxyx(), ivec4(1_i32, 1_i32, 2_i32, 1_i32));
+    assert_eq!(v.xxyy(), ivec4(1_i32, 1_i32, 2_i32, 2_i32));
+    assert_eq!(v.xyxx(), ivec4(1_i32, 2_i32, 1_i32, 1_i32));
+    assert_eq!(v.xyxy(), ivec4(1_i32, 2_i32, 1_i32, 2_i32));
+    assert_eq!(v.xyyx(), ivec4(1_i32, 2_i32, 2_i32, 1_i32));
+    assert_eq!(v.xyyy(), ivec4(1_i32, 2_i32, 2_i32, 2_i32));
+    assert_eq!(v.yxxx(), ivec4(2_i32, 1_i32, 1_i32, 1_i32));
+    assert_eq!(v.yxxy(), ivec4(2_i32, 1_i32, 1_i32, 2_i32));
+    assert_eq!(v.yxyx(), ivec4(2_i32, 1_i32, 2_i32, 1_i32));
+    assert_eq!(v.yxyy(), ivec4(2_i32, 1_i32, 2_i32, 2_i32));
+    assert_eq!(v.yyxx(), ivec4(2_i32, 2_i32, 1_i32, 1_i32));
+    assert_eq!(v.yyxy(), ivec4(2_i32, 2_i32, 1_i32, 2_i32));
+    assert_eq!(v.yyyx(), ivec4(2_i32, 2_i32, 2_i32, 1_i32));
+    assert_eq!(v.yyyy(), ivec4(2_i32, 2_i32, 2_i32, 2_i32));
+    assert_eq!(v.xxx(), ivec3(1_i32, 1_i32, 1_i32));
+    assert_eq!(v.xxy(), ivec3(1_i32, 1_i32, 2_i32));
+    assert_eq!(v.xyx(), ivec3(1_i32, 2_i32, 1_i32));
+    assert_eq!(v.xyy(), ivec3(1_i32, 2_i32, 2_i32));
+    assert_eq!(v.yxx(), ivec3(2_i32, 1_i32, 1_i32));
+    assert_eq!(v.yxy(), ivec3(2_i32, 1_i32, 2_i32));
+    assert_eq!(v.yyx(), ivec3(2_i32, 2_i32, 1_i32));
+    assert_eq!(v.yyy(), ivec3(2_i32, 2_i32, 2_i32));
+    assert_eq!(v.xx(), ivec2(1_i32, 1_i32));
+    assert_eq!(v.yx(), ivec2(2_i32, 1_i32));
+    assert_eq!(v.yy(), ivec2(2_i32, 2_i32));
+});

vendor/glam/tests/swizzles_i64.rs

@@ -0,0 +1,497 @@
+// Generated by swizzlegen. Do not edit.
+#[macro_use]
+mod support;
+use glam::*;
+
+glam_test!(test_i64vec4_swizzles, {
+    let v = i64vec4(1_i64, 2_i64, 3_i64, 4_i64);
+    assert_eq!(v, v.xyzw());
+    assert_eq!(v.xxxx(), i64vec4(1_i64, 1_i64, 1_i64, 1_i64));
+    assert_eq!(v.xxxy(), i64vec4(1_i64, 1_i64, 1_i64, 2_i64));
+    assert_eq!(v.xxxz(), i64vec4(1_i64, 1_i64, 1_i64, 3_i64));
+    assert_eq!(v.xxxw(), i64vec4(1_i64, 1_i64, 1_i64, 4_i64));
+    assert_eq!(v.xxyx(), i64vec4(1_i64, 1_i64, 2_i64, 1_i64));
+    assert_eq!(v.xxyy(), i64vec4(1_i64, 1_i64, 2_i64, 2_i64));
+    assert_eq!(v.xxyz(), i64vec4(1_i64, 1_i64, 2_i64, 3_i64));
+    assert_eq!(v.xxyw(), i64vec4(1_i64, 1_i64, 2_i64, 4_i64));
+    assert_eq!(v.xxzx(), i64vec4(1_i64, 1_i64, 3_i64, 1_i64));
+    assert_eq!(v.xxzy(), i64vec4(1_i64, 1_i64, 3_i64, 2_i64));
+    assert_eq!(v.xxzz(), i64vec4(1_i64, 1_i64, 3_i64, 3_i64));
+    assert_eq!(v.xxzw(), i64vec4(1_i64, 1_i64, 3_i64, 4_i64));
+    assert_eq!(v.xxwx(), i64vec4(1_i64, 1_i64, 4_i64, 1_i64));
+    assert_eq!(v.xxwy(), i64vec4(1_i64, 1_i64, 4_i64, 2_i64));
+    assert_eq!(v.xxwz(), i64vec4(1_i64, 1_i64, 4_i64, 3_i64));
+    assert_eq!(v.xxww(), i64vec4(1_i64, 1_i64, 4_i64, 4_i64));
+    assert_eq!(v.xyxx(), i64vec4(1_i64, 2_i64, 1_i64, 1_i64));
+    assert_eq!(v.xyxy(), i64vec4(1_i64, 2_i64, 1_i64, 2_i64));
+    assert_eq!(v.xyxz(), i64vec4(1_i64, 2_i64, 1_i64, 3_i64));
+    assert_eq!(v.xyxw(), i64vec4(1_i64, 2_i64, 1_i64, 4_i64));
+    assert_eq!(v.xyyx(), i64vec4(1_i64, 2_i64, 2_i64, 1_i64));
+    assert_eq!(v.xyyy(), i64vec4(1_i64, 2_i64, 2_i64, 2_i64));
+    assert_eq!(v.xyyz(), i64vec4(1_i64, 2_i64, 2_i64, 3_i64));
+    assert_eq!(v.xyyw(), i64vec4(1_i64, 2_i64, 2_i64, 4_i64));
+    assert_eq!(v.xyzx(), i64vec4(1_i64, 2_i64, 3_i64, 1_i64));
+    assert_eq!(v.xyzy(), i64vec4(1_i64, 2_i64, 3_i64, 2_i64));
+    assert_eq!(v.xyzz(), i64vec4(1_i64, 2_i64, 3_i64, 3_i64));
+    assert_eq!(v.xywx(), i64vec4(1_i64, 2_i64, 4_i64, 1_i64));
+    assert_eq!(v.xywy(), i64vec4(1_i64, 2_i64, 4_i64, 2_i64));
+    assert_eq!(v.xywz(), i64vec4(1_i64, 2_i64, 4_i64, 3_i64));
+    assert_eq!(v.xyww(), i64vec4(1_i64, 2_i64, 4_i64, 4_i64));
+    assert_eq!(v.xzxx(), i64vec4(1_i64, 3_i64, 1_i64, 1_i64));
+    assert_eq!(v.xzxy(), i64vec4(1_i64, 3_i64, 1_i64, 2_i64));
+    assert_eq!(v.xzxz(), i64vec4(1_i64, 3_i64, 1_i64, 3_i64));
+    assert_eq!(v.xzxw(), i64vec4(1_i64, 3_i64, 1_i64, 4_i64));
+    assert_eq!(v.xzyx(), i64vec4(1_i64, 3_i64, 2_i64, 1_i64));
+    assert_eq!(v.xzyy(), i64vec4(1_i64, 3_i64, 2_i64, 2_i64));
+    assert_eq!(v.xzyz(), i64vec4(1_i64, 3_i64, 2_i64, 3_i64));
+    assert_eq!(v.xzyw(), i64vec4(1_i64, 3_i64, 2_i64, 4_i64));
+    assert_eq!(v.xzzx(), i64vec4(1_i64, 3_i64, 3_i64, 1_i64));
+    assert_eq!(v.xzzy(), i64vec4(1_i64, 3_i64, 3_i64, 2_i64));
+    assert_eq!(v.xzzz(), i64vec4(1_i64, 3_i64, 3_i64, 3_i64));
+    assert_eq!(v.xzzw(), i64vec4(1_i64, 3_i64, 3_i64, 4_i64));
+    assert_eq!(v.xzwx(), i64vec4(1_i64, 3_i64, 4_i64, 1_i64));
+    assert_eq!(v.xzwy(), i64vec4(1_i64, 3_i64, 4_i64, 2_i64));
+    assert_eq!(v.xzwz(), i64vec4(1_i64, 3_i64, 4_i64, 3_i64));
+    assert_eq!(v.xzww(), i64vec4(1_i64, 3_i64, 4_i64, 4_i64));
+    assert_eq!(v.xwxx(), i64vec4(1_i64, 4_i64, 1_i64, 1_i64));
+    assert_eq!(v.xwxy(), i64vec4(1_i64, 4_i64, 1_i64, 2_i64));
+    assert_eq!(v.xwxz(), i64vec4(1_i64, 4_i64, 1_i64, 3_i64));
+    assert_eq!(v.xwxw(), i64vec4(1_i64, 4_i64, 1_i64, 4_i64));
+    assert_eq!(v.xwyx(), i64vec4(1_i64, 4_i64, 2_i64, 1_i64));
+    assert_eq!(v.xwyy(), i64vec4(1_i64, 4_i64, 2_i64, 2_i64));
+    assert_eq!(v.xwyz(), i64vec4(1_i64, 4_i64, 2_i64, 3_i64));
+    assert_eq!(v.xwyw(), i64vec4(1_i64, 4_i64, 2_i64, 4_i64));
+    assert_eq!(v.xwzx(), i64vec4(1_i64, 4_i64, 3_i64, 1_i64));
+    assert_eq!(v.xwzy(), i64vec4(1_i64, 4_i64, 3_i64, 2_i64));
+    assert_eq!(v.xwzz(), i64vec4(1_i64, 4_i64, 3_i64, 3_i64));
+    assert_eq!(v.xwzw(), i64vec4(1_i64, 4_i64, 3_i64, 4_i64));
+    assert_eq!(v.xwwx(), i64vec4(1_i64, 4_i64, 4_i64, 1_i64));
+    assert_eq!(v.xwwy(), i64vec4(1_i64, 4_i64, 4_i64, 2_i64));
+    assert_eq!(v.xwwz(), i64vec4(1_i64, 4_i64, 4_i64, 3_i64));
+    assert_eq!(v.xwww(), i64vec4(1_i64, 4_i64, 4_i64, 4_i64));
+    assert_eq!(v.yxxx(), i64vec4(2_i64, 1_i64, 1_i64, 1_i64));
+    assert_eq!(v.yxxy(), i64vec4(2_i64, 1_i64, 1_i64, 2_i64));
+    assert_eq!(v.yxxz(), i64vec4(2_i64, 1_i64, 1_i64, 3_i64));
+    assert_eq!(v.yxxw(), i64vec4(2_i64, 1_i64, 1_i64, 4_i64));
+    assert_eq!(v.yxyx(), i64vec4(2_i64, 1_i64, 2_i64, 1_i64));
+    assert_eq!(v.yxyy(), i64vec4(2_i64, 1_i64, 2_i64, 2_i64));
+    assert_eq!(v.yxyz(), i64vec4(2_i64, 1_i64, 2_i64, 3_i64));
+    assert_eq!(v.yxyw(), i64vec4(2_i64, 1_i64, 2_i64, 4_i64));
+    assert_eq!(v.yxzx(), i64vec4(2_i64, 1_i64, 3_i64, 1_i64));
+    assert_eq!(v.yxzy(), i64vec4(2_i64, 1_i64, 3_i64, 2_i64));
+    assert_eq!(v.yxzz(), i64vec4(2_i64, 1_i64, 3_i64, 3_i64));
+    assert_eq!(v.yxzw(), i64vec4(2_i64, 1_i64, 3_i64, 4_i64));
+    assert_eq!(v.yxwx(), i64vec4(2_i64, 1_i64, 4_i64, 1_i64));
+    assert_eq!(v.yxwy(), i64vec4(2_i64, 1_i64, 4_i64, 2_i64));
+    assert_eq!(v.yxwz(), i64vec4(2_i64, 1_i64, 4_i64, 3_i64));
+    assert_eq!(v.yxww(), i64vec4(2_i64, 1_i64, 4_i64, 4_i64));
+    assert_eq!(v.yyxx(), i64vec4(2_i64, 2_i64, 1_i64, 1_i64));
+    assert_eq!(v.yyxy(), i64vec4(2_i64, 2_i64, 1_i64, 2_i64));
+    assert_eq!(v.yyxz(), i64vec4(2_i64, 2_i64, 1_i64, 3_i64));
+    assert_eq!(v.yyxw(), i64vec4(2_i64, 2_i64, 1_i64, 4_i64));
+    assert_eq!(v.yyyx(), i64vec4(2_i64, 2_i64, 2_i64, 1_i64));
+    assert_eq!(v.yyyy(), i64vec4(2_i64, 2_i64, 2_i64, 2_i64));
+    assert_eq!(v.yyyz(), i64vec4(2_i64, 2_i64, 2_i64, 3_i64));
+    assert_eq!(v.yyyw(), i64vec4(2_i64, 2_i64, 2_i64, 4_i64));
+    assert_eq!(v.yyzx(), i64vec4(2_i64, 2_i64, 3_i64, 1_i64));
+    assert_eq!(v.yyzy(), i64vec4(2_i64, 2_i64, 3_i64, 2_i64));
+    assert_eq!(v.yyzz(), i64vec4(2_i64, 2_i64, 3_i64, 3_i64));
+    assert_eq!(v.yyzw(), i64vec4(2_i64, 2_i64, 3_i64, 4_i64));
+    assert_eq!(v.yywx(), i64vec4(2_i64, 2_i64, 4_i64, 1_i64));
+    assert_eq!(v.yywy(), i64vec4(2_i64, 2_i64, 4_i64, 2_i64));
+    assert_eq!(v.yywz(), i64vec4(2_i64, 2_i64, 4_i64, 3_i64));
+    assert_eq!(v.yyww(), i64vec4(2_i64, 2_i64, 4_i64, 4_i64));
+    assert_eq!(v.yzxx(), i64vec4(2_i64, 3_i64, 1_i64, 1_i64));
+    assert_eq!(v.yzxy(), i64vec4(2_i64, 3_i64, 1_i64, 2_i64));
+    assert_eq!(v.yzxz(), i64vec4(2_i64, 3_i64, 1_i64, 3_i64));
+    assert_eq!(v.yzxw(), i64vec4(2_i64, 3_i64, 1_i64, 4_i64));
+    assert_eq!(v.yzyx(), i64vec4(2_i64, 3_i64, 2_i64, 1_i64));
+    assert_eq!(v.yzyy(), i64vec4(2_i64, 3_i64, 2_i64, 2_i64));
+    assert_eq!(v.yzyz(), i64vec4(2_i64, 3_i64, 2_i64, 3_i64));
+    assert_eq!(v.yzyw(), i64vec4(2_i64, 3_i64, 2_i64, 4_i64));
+    assert_eq!(v.yzzx(), i64vec4(2_i64, 3_i64, 3_i64, 1_i64));
+    assert_eq!(v.yzzy(), i64vec4(2_i64, 3_i64, 3_i64, 2_i64));
+    assert_eq!(v.yzzz(), i64vec4(2_i64, 3_i64, 3_i64, 3_i64));
+    assert_eq!(v.yzzw(), i64vec4(2_i64, 3_i64, 3_i64, 4_i64));
+    assert_eq!(v.yzwx(), i64vec4(2_i64, 3_i64, 4_i64, 1_i64));
+    assert_eq!(v.yzwy(), i64vec4(2_i64, 3_i64, 4_i64, 2_i64));
+    assert_eq!(v.yzwz(), i64vec4(2_i64, 3_i64, 4_i64, 3_i64));
+    assert_eq!(v.yzww(), i64vec4(2_i64, 3_i64, 4_i64, 4_i64));
+    assert_eq!(v.ywxx(), i64vec4(2_i64, 4_i64, 1_i64, 1_i64));
+    assert_eq!(v.ywxy(), i64vec4(2_i64, 4_i64, 1_i64, 2_i64));
+    assert_eq!(v.ywxz(), i64vec4(2_i64, 4_i64, 1_i64, 3_i64));
+    assert_eq!(v.ywxw(), i64vec4(2_i64, 4_i64, 1_i64, 4_i64));
+    assert_eq!(v.ywyx(), i64vec4(2_i64, 4_i64, 2_i64, 1_i64));
+    assert_eq!(v.ywyy(), i64vec4(2_i64, 4_i64, 2_i64, 2_i64));
+    assert_eq!(v.ywyz(), i64vec4(2_i64, 4_i64, 2_i64, 3_i64));
+    assert_eq!(v.ywyw(), i64vec4(2_i64, 4_i64, 2_i64, 4_i64));
+    assert_eq!(v.ywzx(), i64vec4(2_i64, 4_i64, 3_i64, 1_i64));
+    assert_eq!(v.ywzy(), i64vec4(2_i64, 4_i64, 3_i64, 2_i64));
+    assert_eq!(v.ywzz(), i64vec4(2_i64, 4_i64, 3_i64, 3_i64));
+    assert_eq!(v.ywzw(), i64vec4(2_i64, 4_i64, 3_i64, 4_i64));
+    assert_eq!(v.ywwx(), i64vec4(2_i64, 4_i64, 4_i64, 1_i64));
+    assert_eq!(v.ywwy(), i64vec4(2_i64, 4_i64, 4_i64, 2_i64));
+    assert_eq!(v.ywwz(), i64vec4(2_i64, 4_i64, 4_i64, 3_i64));
+    assert_eq!(v.ywww(), i64vec4(2_i64, 4_i64, 4_i64, 4_i64));
+    assert_eq!(v.zxxx(), i64vec4(3_i64, 1_i64, 1_i64, 1_i64));
+    assert_eq!(v.zxxy(), i64vec4(3_i64, 1_i64, 1_i64, 2_i64));
+    assert_eq!(v.zxxz(), i64vec4(3_i64, 1_i64, 1_i64, 3_i64));
+    assert_eq!(v.zxxw(), i64vec4(3_i64, 1_i64, 1_i64, 4_i64));
+    assert_eq!(v.zxyx(), i64vec4(3_i64, 1_i64, 2_i64, 1_i64));
+    assert_eq!(v.zxyy(), i64vec4(3_i64, 1_i64, 2_i64, 2_i64));
+    assert_eq!(v.zxyz(), i64vec4(3_i64, 1_i64, 2_i64, 3_i64));
+    assert_eq!(v.zxyw(), i64vec4(3_i64, 1_i64, 2_i64, 4_i64));
+    assert_eq!(v.zxzx(), i64vec4(3_i64, 1_i64, 3_i64, 1_i64));
+    assert_eq!(v.zxzy(), i64vec4(3_i64, 1_i64, 3_i64, 2_i64));
+    assert_eq!(v.zxzz(), i64vec4(3_i64, 1_i64, 3_i64, 3_i64));
+    assert_eq!(v.zxzw(), i64vec4(3_i64, 1_i64, 3_i64, 4_i64));
+    assert_eq!(v.zxwx(), i64vec4(3_i64, 1_i64, 4_i64, 1_i64));
+    assert_eq!(v.zxwy(), i64vec4(3_i64, 1_i64, 4_i64, 2_i64));
+    assert_eq!(v.zxwz(), i64vec4(3_i64, 1_i64, 4_i64, 3_i64));
+    assert_eq!(v.zxww(), i64vec4(3_i64, 1_i64, 4_i64, 4_i64));
+    assert_eq!(v.zyxx(), i64vec4(3_i64, 2_i64, 1_i64, 1_i64));
+    assert_eq!(v.zyxy(), i64vec4(3_i64, 2_i64, 1_i64, 2_i64));
+    assert_eq!(v.zyxz(), i64vec4(3_i64, 2_i64, 1_i64, 3_i64));
+    assert_eq!(v.zyxw(), i64vec4(3_i64, 2_i64, 1_i64, 4_i64));
+    assert_eq!(v.zyyx(), i64vec4(3_i64, 2_i64, 2_i64, 1_i64));
+    assert_eq!(v.zyyy(), i64vec4(3_i64, 2_i64, 2_i64, 2_i64));
+    assert_eq!(v.zyyz(), i64vec4(3_i64, 2_i64, 2_i64, 3_i64));
+    assert_eq!(v.zyyw(), i64vec4(3_i64, 2_i64, 2_i64, 4_i64));
+    assert_eq!(v.zyzx(), i64vec4(3_i64, 2_i64, 3_i64, 1_i64));
+    assert_eq!(v.zyzy(), i64vec4(3_i64, 2_i64, 3_i64, 2_i64));
+    assert_eq!(v.zyzz(), i64vec4(3_i64, 2_i64, 3_i64, 3_i64));
+    assert_eq!(v.zyzw(), i64vec4(3_i64, 2_i64, 3_i64, 4_i64));
+    assert_eq!(v.zywx(), i64vec4(3_i64, 2_i64, 4_i64, 1_i64));
+    assert_eq!(v.zywy(), i64vec4(3_i64, 2_i64, 4_i64, 2_i64));
+    assert_eq!(v.zywz(), i64vec4(3_i64, 2_i64, 4_i64, 3_i64));
+    assert_eq!(v.zyww(), i64vec4(3_i64, 2_i64, 4_i64, 4_i64));
+    assert_eq!(v.zzxx(), i64vec4(3_i64, 3_i64, 1_i64, 1_i64));
+    assert_eq!(v.zzxy(), i64vec4(3_i64, 3_i64, 1_i64, 2_i64));
+    assert_eq!(v.zzxz(), i64vec4(3_i64, 3_i64, 1_i64, 3_i64));
+    assert_eq!(v.zzxw(), i64vec4(3_i64, 3_i64, 1_i64, 4_i64));
+    assert_eq!(v.zzyx(), i64vec4(3_i64, 3_i64, 2_i64, 1_i64));
+    assert_eq!(v.zzyy(), i64vec4(3_i64, 3_i64, 2_i64, 2_i64));
+    assert_eq!(v.zzyz(), i64vec4(3_i64, 3_i64, 2_i64, 3_i64));
+    assert_eq!(v.zzyw(), i64vec4(3_i64, 3_i64, 2_i64, 4_i64));
+    assert_eq!(v.zzzx(), i64vec4(3_i64, 3_i64, 3_i64, 1_i64));
+    assert_eq!(v.zzzy(), i64vec4(3_i64, 3_i64, 3_i64, 2_i64));
+    assert_eq!(v.zzzz(), i64vec4(3_i64, 3_i64, 3_i64, 3_i64));
+    assert_eq!(v.zzzw(), i64vec4(3_i64, 3_i64, 3_i64, 4_i64));
+    assert_eq!(v.zzwx(), i64vec4(3_i64, 3_i64, 4_i64, 1_i64));
+    assert_eq!(v.zzwy(), i64vec4(3_i64, 3_i64, 4_i64, 2_i64));
+    assert_eq!(v.zzwz(), i64vec4(3_i64, 3_i64, 4_i64, 3_i64));
+    assert_eq!(v.zzww(), i64vec4(3_i64, 3_i64, 4_i64, 4_i64));
+    assert_eq!(v.zwxx(), i64vec4(3_i64, 4_i64, 1_i64, 1_i64));
+    assert_eq!(v.zwxy(), i64vec4(3_i64, 4_i64, 1_i64, 2_i64));
+    assert_eq!(v.zwxz(), i64vec4(3_i64, 4_i64, 1_i64, 3_i64));
+    assert_eq!(v.zwxw(), i64vec4(3_i64, 4_i64, 1_i64, 4_i64));
+    assert_eq!(v.zwyx(), i64vec4(3_i64, 4_i64, 2_i64, 1_i64));
+    assert_eq!(v.zwyy(), i64vec4(3_i64, 4_i64, 2_i64, 2_i64));
+    assert_eq!(v.zwyz(), i64vec4(3_i64, 4_i64, 2_i64, 3_i64));
+    assert_eq!(v.zwyw(), i64vec4(3_i64, 4_i64, 2_i64, 4_i64));
+    assert_eq!(v.zwzx(), i64vec4(3_i64, 4_i64, 3_i64, 1_i64));
+    assert_eq!(v.zwzy(), i64vec4(3_i64, 4_i64, 3_i64, 2_i64));
+    assert_eq!(v.zwzz(), i64vec4(3_i64, 4_i64, 3_i64, 3_i64));
+    assert_eq!(v.zwzw(), i64vec4(3_i64, 4_i64, 3_i64, 4_i64));
+    assert_eq!(v.zwwx(), i64vec4(3_i64, 4_i64, 4_i64, 1_i64));
+    assert_eq!(v.zwwy(), i64vec4(3_i64, 4_i64, 4_i64, 2_i64));
+    assert_eq!(v.zwwz(), i64vec4(3_i64, 4_i64, 4_i64, 3_i64));
+    assert_eq!(v.zwww(), i64vec4(3_i64, 4_i64, 4_i64, 4_i64));
+    assert_eq!(v.wxxx(), i64vec4(4_i64, 1_i64, 1_i64, 1_i64));
+    assert_eq!(v.wxxy(), i64vec4(4_i64, 1_i64, 1_i64, 2_i64));
+    assert_eq!(v.wxxz(), i64vec4(4_i64, 1_i64, 1_i64, 3_i64));
+    assert_eq!(v.wxxw(), i64vec4(4_i64, 1_i64, 1_i64, 4_i64));
+    assert_eq!(v.wxyx(), i64vec4(4_i64, 1_i64, 2_i64, 1_i64));
+    assert_eq!(v.wxyy(), i64vec4(4_i64, 1_i64, 2_i64, 2_i64));
+    assert_eq!(v.wxyz(), i64vec4(4_i64, 1_i64, 2_i64, 3_i64));
+    assert_eq!(v.wxyw(), i64vec4(4_i64, 1_i64, 2_i64, 4_i64));
+    assert_eq!(v.wxzx(), i64vec4(4_i64, 1_i64, 3_i64, 1_i64));
+    assert_eq!(v.wxzy(), i64vec4(4_i64, 1_i64, 3_i64, 2_i64));
+    assert_eq!(v.wxzz(), i64vec4(4_i64, 1_i64, 3_i64, 3_i64));
+    assert_eq!(v.wxzw(), i64vec4(4_i64, 1_i64, 3_i64, 4_i64));
+    assert_eq!(v.wxwx(), i64vec4(4_i64, 1_i64, 4_i64, 1_i64));
+    assert_eq!(v.wxwy(), i64vec4(4_i64, 1_i64, 4_i64, 2_i64));
+    assert_eq!(v.wxwz(), i64vec4(4_i64, 1_i64, 4_i64, 3_i64));
+    assert_eq!(v.wxww(), i64vec4(4_i64, 1_i64, 4_i64, 4_i64));
+    assert_eq!(v.wyxx(), i64vec4(4_i64, 2_i64, 1_i64, 1_i64));
+    assert_eq!(v.wyxy(), i64vec4(4_i64, 2_i64, 1_i64, 2_i64));
+    assert_eq!(v.wyxz(), i64vec4(4_i64, 2_i64, 1_i64, 3_i64));
+    assert_eq!(v.wyxw(), i64vec4(4_i64, 2_i64, 1_i64, 4_i64));
+    assert_eq!(v.wyyx(), i64vec4(4_i64, 2_i64, 2_i64, 1_i64));
+    assert_eq!(v.wyyy(), i64vec4(4_i64, 2_i64, 2_i64, 2_i64));
+    assert_eq!(v.wyyz(), i64vec4(4_i64, 2_i64, 2_i64, 3_i64));
+    assert_eq!(v.wyyw(), i64vec4(4_i64, 2_i64, 2_i64, 4_i64));
+    assert_eq!(v.wyzx(), i64vec4(4_i64, 2_i64, 3_i64, 1_i64));
+    assert_eq!(v.wyzy(), i64vec4(4_i64, 2_i64, 3_i64, 2_i64));
+    assert_eq!(v.wyzz(), i64vec4(4_i64, 2_i64, 3_i64, 3_i64));
+    assert_eq!(v.wyzw(), i64vec4(4_i64, 2_i64, 3_i64, 4_i64));
+    assert_eq!(v.wywx(), i64vec4(4_i64, 2_i64, 4_i64, 1_i64));
+    assert_eq!(v.wywy(), i64vec4(4_i64, 2_i64, 4_i64, 2_i64));
+    assert_eq!(v.wywz(), i64vec4(4_i64, 2_i64, 4_i64, 3_i64));
+    assert_eq!(v.wyww(), i64vec4(4_i64, 2_i64, 4_i64, 4_i64));
+    assert_eq!(v.wzxx(), i64vec4(4_i64, 3_i64, 1_i64, 1_i64));
+    assert_eq!(v.wzxy(), i64vec4(4_i64, 3_i64, 1_i64, 2_i64));
+    assert_eq!(v.wzxz(), i64vec4(4_i64, 3_i64, 1_i64, 3_i64));
+    assert_eq!(v.wzxw(), i64vec4(4_i64, 3_i64, 1_i64, 4_i64));
+    assert_eq!(v.wzyx(), i64vec4(4_i64, 3_i64, 2_i64, 1_i64));
+    assert_eq!(v.wzyy(), i64vec4(4_i64, 3_i64, 2_i64, 2_i64));
+    assert_eq!(v.wzyz(), i64vec4(4_i64, 3_i64, 2_i64, 3_i64));
+    assert_eq!(v.wzyw(), i64vec4(4_i64, 3_i64, 2_i64, 4_i64));
+    assert_eq!(v.wzzx(), i64vec4(4_i64, 3_i64, 3_i64, 1_i64));
+    assert_eq!(v.wzzy(), i64vec4(4_i64, 3_i64, 3_i64, 2_i64));
+    assert_eq!(v.wzzz(), i64vec4(4_i64, 3_i64, 3_i64, 3_i64));
+    assert_eq!(v.wzzw(), i64vec4(4_i64, 3_i64, 3_i64, 4_i64));
+    assert_eq!(v.wzwx(), i64vec4(4_i64, 3_i64, 4_i64, 1_i64));
+    assert_eq!(v.wzwy(), i64vec4(4_i64, 3_i64, 4_i64, 2_i64));
+    assert_eq!(v.wzwz(), i64vec4(4_i64, 3_i64, 4_i64, 3_i64));
+    assert_eq!(v.wzww(), i64vec4(4_i64, 3_i64, 4_i64, 4_i64));
+    assert_eq!(v.wwxx(), i64vec4(4_i64, 4_i64, 1_i64, 1_i64));
+    assert_eq!(v.wwxy(), i64vec4(4_i64, 4_i64, 1_i64, 2_i64));
+    assert_eq!(v.wwxz(), i64vec4(4_i64, 4_i64, 1_i64, 3_i64));
+    assert_eq!(v.wwxw(), i64vec4(4_i64, 4_i64, 1_i64, 4_i64));
+    assert_eq!(v.wwyx(), i64vec4(4_i64, 4_i64, 2_i64, 1_i64));
+    assert_eq!(v.wwyy(), i64vec4(4_i64, 4_i64, 2_i64, 2_i64));
+    assert_eq!(v.wwyz(), i64vec4(4_i64, 4_i64, 2_i64, 3_i64));
+    assert_eq!(v.wwyw(), i64vec4(4_i64, 4_i64, 2_i64, 4_i64));
+    assert_eq!(v.wwzx(), i64vec4(4_i64, 4_i64, 3_i64, 1_i64));
+    assert_eq!(v.wwzy(), i64vec4(4_i64, 4_i64, 3_i64, 2_i64));
+    assert_eq!(v.wwzz(), i64vec4(4_i64, 4_i64, 3_i64, 3_i64));
+    assert_eq!(v.wwzw(), i64vec4(4_i64, 4_i64, 3_i64, 4_i64));
+    assert_eq!(v.wwwx(), i64vec4(4_i64, 4_i64, 4_i64, 1_i64));
+    assert_eq!(v.wwwy(), i64vec4(4_i64, 4_i64, 4_i64, 2_i64));
+    assert_eq!(v.wwwz(), i64vec4(4_i64, 4_i64, 4_i64, 3_i64));
+    assert_eq!(v.wwww(), i64vec4(4_i64, 4_i64, 4_i64, 4_i64));
+    assert_eq!(v.xxx(), i64vec3(1_i64, 1_i64, 1_i64));
+    assert_eq!(v.xxy(), i64vec3(1_i64, 1_i64, 2_i64));
+    assert_eq!(v.xxz(), i64vec3(1_i64, 1_i64, 3_i64));
+    assert_eq!(v.xxw(), i64vec3(1_i64, 1_i64, 4_i64));
+    assert_eq!(v.xyx(), i64vec3(1_i64, 2_i64, 1_i64));
+    assert_eq!(v.xyy(), i64vec3(1_i64, 2_i64, 2_i64));
+    assert_eq!(v.xyz(), i64vec3(1_i64, 2_i64, 3_i64));
+    assert_eq!(v.xyw(), i64vec3(1_i64, 2_i64, 4_i64));
+    assert_eq!(v.xzx(), i64vec3(1_i64, 3_i64, 1_i64));
+    assert_eq!(v.xzy(), i64vec3(1_i64, 3_i64, 2_i64));
+    assert_eq!(v.xzz(), i64vec3(1_i64, 3_i64, 3_i64));
+    assert_eq!(v.xzw(), i64vec3(1_i64, 3_i64, 4_i64));
+    assert_eq!(v.xwx(), i64vec3(1_i64, 4_i64, 1_i64));
+    assert_eq!(v.xwy(), i64vec3(1_i64, 4_i64, 2_i64));
+    assert_eq!(v.xwz(), i64vec3(1_i64, 4_i64, 3_i64));
+    assert_eq!(v.xww(), i64vec3(1_i64, 4_i64, 4_i64));
+    assert_eq!(v.yxx(), i64vec3(2_i64, 1_i64, 1_i64));
+    assert_eq!(v.yxy(), i64vec3(2_i64, 1_i64, 2_i64));
+    assert_eq!(v.yxz(), i64vec3(2_i64, 1_i64, 3_i64));
+    assert_eq!(v.yxw(), i64vec3(2_i64, 1_i64, 4_i64));
+    assert_eq!(v.yyx(), i64vec3(2_i64, 2_i64, 1_i64));
+    assert_eq!(v.yyy(), i64vec3(2_i64, 2_i64, 2_i64));
+    assert_eq!(v.yyz(), i64vec3(2_i64, 2_i64, 3_i64));
+    assert_eq!(v.yyw(), i64vec3(2_i64, 2_i64, 4_i64));
+    assert_eq!(v.yzx(), i64vec3(2_i64, 3_i64, 1_i64));
+    assert_eq!(v.yzy(), i64vec3(2_i64, 3_i64, 2_i64));
+    assert_eq!(v.yzz(), i64vec3(2_i64, 3_i64, 3_i64));
+    assert_eq!(v.yzw(), i64vec3(2_i64, 3_i64, 4_i64));
+    assert_eq!(v.ywx(), i64vec3(2_i64, 4_i64, 1_i64));
+    assert_eq!(v.ywy(), i64vec3(2_i64, 4_i64, 2_i64));
+    assert_eq!(v.ywz(), i64vec3(2_i64, 4_i64, 3_i64));
+    assert_eq!(v.yww(), i64vec3(2_i64, 4_i64, 4_i64));
+    assert_eq!(v.zxx(), i64vec3(3_i64, 1_i64, 1_i64));
+    assert_eq!(v.zxy(), i64vec3(3_i64, 1_i64, 2_i64));
+    assert_eq!(v.zxz(), i64vec3(3_i64, 1_i64, 3_i64));
+    assert_eq!(v.zxw(), i64vec3(3_i64, 1_i64, 4_i64));
+    assert_eq!(v.zyx(), i64vec3(3_i64, 2_i64, 1_i64));
+    assert_eq!(v.zyy(), i64vec3(3_i64, 2_i64, 2_i64));
+    assert_eq!(v.zyz(), i64vec3(3_i64, 2_i64, 3_i64));
+    assert_eq!(v.zyw(), i64vec3(3_i64, 2_i64, 4_i64));
+    assert_eq!(v.zzx(), i64vec3(3_i64, 3_i64, 1_i64));
+    assert_eq!(v.zzy(), i64vec3(3_i64, 3_i64, 2_i64));
+    assert_eq!(v.zzz(), i64vec3(3_i64, 3_i64, 3_i64));
+    assert_eq!(v.zzw(), i64vec3(3_i64, 3_i64, 4_i64));
+    assert_eq!(v.zwx(), i64vec3(3_i64, 4_i64, 1_i64));
+    assert_eq!(v.zwy(), i64vec3(3_i64, 4_i64, 2_i64));
+    assert_eq!(v.zwz(), i64vec3(3_i64, 4_i64, 3_i64));
+    assert_eq!(v.zww(), i64vec3(3_i64, 4_i64, 4_i64));
+    assert_eq!(v.wxx(), i64vec3(4_i64, 1_i64, 1_i64));
+    assert_eq!(v.wxy(), i64vec3(4_i64, 1_i64, 2_i64));
+    assert_eq!(v.wxz(), i64vec3(4_i64, 1_i64, 3_i64));
+    assert_eq!(v.wxw(), i64vec3(4_i64, 1_i64, 4_i64));
+    assert_eq!(v.wyx(), i64vec3(4_i64, 2_i64, 1_i64));
+    assert_eq!(v.wyy(), i64vec3(4_i64, 2_i64, 2_i64));
+    assert_eq!(v.wyz(), i64vec3(4_i64, 2_i64, 3_i64));
+    assert_eq!(v.wyw(), i64vec3(4_i64, 2_i64, 4_i64));
+    assert_eq!(v.wzx(), i64vec3(4_i64, 3_i64, 1_i64));
+    assert_eq!(v.wzy(), i64vec3(4_i64, 3_i64, 2_i64));
+    assert_eq!(v.wzz(), i64vec3(4_i64, 3_i64, 3_i64));
+    assert_eq!(v.wzw(), i64vec3(4_i64, 3_i64, 4_i64));
+    assert_eq!(v.wwx(), i64vec3(4_i64, 4_i64, 1_i64));
+    assert_eq!(v.wwy(), i64vec3(4_i64, 4_i64, 2_i64));
+    assert_eq!(v.wwz(), i64vec3(4_i64, 4_i64, 3_i64));
+    assert_eq!(v.www(), i64vec3(4_i64, 4_i64, 4_i64));
+    assert_eq!(v.xx(), i64vec2(1_i64, 1_i64));
+    assert_eq!(v.xy(), i64vec2(1_i64, 2_i64));
+    assert_eq!(v.xz(), i64vec2(1_i64, 3_i64));
+    assert_eq!(v.xw(), i64vec2(1_i64, 4_i64));
+    assert_eq!(v.yx(), i64vec2(2_i64, 1_i64));
+    assert_eq!(v.yy(), i64vec2(2_i64, 2_i64));
+    assert_eq!(v.yz(), i64vec2(2_i64, 3_i64));
+    assert_eq!(v.yw(), i64vec2(2_i64, 4_i64));
+    assert_eq!(v.zx(), i64vec2(3_i64, 1_i64));
+    assert_eq!(v.zy(), i64vec2(3_i64, 2_i64));
+    assert_eq!(v.zz(), i64vec2(3_i64, 3_i64));
+    assert_eq!(v.zw(), i64vec2(3_i64, 4_i64));
+    assert_eq!(v.wx(), i64vec2(4_i64, 1_i64));
+    assert_eq!(v.wy(), i64vec2(4_i64, 2_i64));
+    assert_eq!(v.wz(), i64vec2(4_i64, 3_i64));
+    assert_eq!(v.ww(), i64vec2(4_i64, 4_i64));
+});
+
+glam_test!(test_i64vec3_swizzles, {
+    let v = i64vec3(1_i64, 2_i64, 3_i64);
+    assert_eq!(v, v.xyz());
+    assert_eq!(v.xxxx(), i64vec4(1_i64, 1_i64, 1_i64, 1_i64));
+    assert_eq!(v.xxxy(), i64vec4(1_i64, 1_i64, 1_i64, 2_i64));
+    assert_eq!(v.xxxz(), i64vec4(1_i64, 1_i64, 1_i64, 3_i64));
+    assert_eq!(v.xxyx(), i64vec4(1_i64, 1_i64, 2_i64, 1_i64));
+    assert_eq!(v.xxyy(), i64vec4(1_i64, 1_i64, 2_i64, 2_i64));
+    assert_eq!(v.xxyz(), i64vec4(1_i64, 1_i64, 2_i64, 3_i64));
+    assert_eq!(v.xxzx(), i64vec4(1_i64, 1_i64, 3_i64, 1_i64));
+    assert_eq!(v.xxzy(), i64vec4(1_i64, 1_i64, 3_i64, 2_i64));
+    assert_eq!(v.xxzz(), i64vec4(1_i64, 1_i64, 3_i64, 3_i64));
+    assert_eq!(v.xyxx(), i64vec4(1_i64, 2_i64, 1_i64, 1_i64));
+    assert_eq!(v.xyxy(), i64vec4(1_i64, 2_i64, 1_i64, 2_i64));
+    assert_eq!(v.xyxz(), i64vec4(1_i64, 2_i64, 1_i64, 3_i64));
+    assert_eq!(v.xyyx(), i64vec4(1_i64, 2_i64, 2_i64, 1_i64));
+    assert_eq!(v.xyyy(), i64vec4(1_i64, 2_i64, 2_i64, 2_i64));
+    assert_eq!(v.xyyz(), i64vec4(1_i64, 2_i64, 2_i64, 3_i64));
+    assert_eq!(v.xyzx(), i64vec4(1_i64, 2_i64, 3_i64, 1_i64));
+    assert_eq!(v.xyzy(), i64vec4(1_i64, 2_i64, 3_i64, 2_i64));
+    assert_eq!(v.xyzz(), i64vec4(1_i64, 2_i64, 3_i64, 3_i64));
+    assert_eq!(v.xzxx(), i64vec4(1_i64, 3_i64, 1_i64, 1_i64));
+    assert_eq!(v.xzxy(), i64vec4(1_i64, 3_i64, 1_i64, 2_i64));
+    assert_eq!(v.xzxz(), i64vec4(1_i64, 3_i64, 1_i64, 3_i64));
+    assert_eq!(v.xzyx(), i64vec4(1_i64, 3_i64, 2_i64, 1_i64));
+    assert_eq!(v.xzyy(), i64vec4(1_i64, 3_i64, 2_i64, 2_i64));
+    assert_eq!(v.xzyz(), i64vec4(1_i64, 3_i64, 2_i64, 3_i64));
+    assert_eq!(v.xzzx(), i64vec4(1_i64, 3_i64, 3_i64, 1_i64));
+    assert_eq!(v.xzzy(), i64vec4(1_i64, 3_i64, 3_i64, 2_i64));
+    assert_eq!(v.xzzz(), i64vec4(1_i64, 3_i64, 3_i64, 3_i64));
+    assert_eq!(v.yxxx(), i64vec4(2_i64, 1_i64, 1_i64, 1_i64));
+    assert_eq!(v.yxxy(), i64vec4(2_i64, 1_i64, 1_i64, 2_i64));
+    assert_eq!(v.yxxz(), i64vec4(2_i64, 1_i64, 1_i64, 3_i64));
+    assert_eq!(v.yxyx(), i64vec4(2_i64, 1_i64, 2_i64, 1_i64));
+    assert_eq!(v.yxyy(), i64vec4(2_i64, 1_i64, 2_i64, 2_i64));
+    assert_eq!(v.yxyz(), i64vec4(2_i64, 1_i64, 2_i64, 3_i64));
+    assert_eq!(v.yxzx(), i64vec4(2_i64, 1_i64, 3_i64, 1_i64));
+    assert_eq!(v.yxzy(), i64vec4(2_i64, 1_i64, 3_i64, 2_i64));
+    assert_eq!(v.yxzz(), i64vec4(2_i64, 1_i64, 3_i64, 3_i64));
+    assert_eq!(v.yyxx(), i64vec4(2_i64, 2_i64, 1_i64, 1_i64));
+    assert_eq!(v.yyxy(), i64vec4(2_i64, 2_i64, 1_i64, 2_i64));
+    assert_eq!(v.yyxz(), i64vec4(2_i64, 2_i64, 1_i64, 3_i64));
+    assert_eq!(v.yyyx(), i64vec4(2_i64, 2_i64, 2_i64, 1_i64));
+    assert_eq!(v.yyyy(), i64vec4(2_i64, 2_i64, 2_i64, 2_i64));
+    assert_eq!(v.yyyz(), i64vec4(2_i64, 2_i64, 2_i64, 3_i64));
+    assert_eq!(v.yyzx(), i64vec4(2_i64, 2_i64, 3_i64, 1_i64));
+    assert_eq!(v.yyzy(), i64vec4(2_i64, 2_i64, 3_i64, 2_i64));
+    assert_eq!(v.yyzz(), i64vec4(2_i64, 2_i64, 3_i64, 3_i64));
+    assert_eq!(v.yzxx(), i64vec4(2_i64, 3_i64, 1_i64, 1_i64));
+    assert_eq!(v.yzxy(), i64vec4(2_i64, 3_i64, 1_i64, 2_i64));
+    assert_eq!(v.yzxz(), i64vec4(2_i64, 3_i64, 1_i64, 3_i64));
+    assert_eq!(v.yzyx(), i64vec4(2_i64, 3_i64, 2_i64, 1_i64));
+    assert_eq!(v.yzyy(), i64vec4(2_i64, 3_i64, 2_i64, 2_i64));
+    assert_eq!(v.yzyz(), i64vec4(2_i64, 3_i64, 2_i64, 3_i64));
+    assert_eq!(v.yzzx(), i64vec4(2_i64, 3_i64, 3_i64, 1_i64));
+    assert_eq!(v.yzzy(), i64vec4(2_i64, 3_i64, 3_i64, 2_i64));
+    assert_eq!(v.yzzz(), i64vec4(2_i64, 3_i64, 3_i64, 3_i64));
+    assert_eq!(v.zxxx(), i64vec4(3_i64, 1_i64, 1_i64, 1_i64));
+    assert_eq!(v.zxxy(), i64vec4(3_i64, 1_i64, 1_i64, 2_i64));
+    assert_eq!(v.zxxz(), i64vec4(3_i64, 1_i64, 1_i64, 3_i64));
+    assert_eq!(v.zxyx(), i64vec4(3_i64, 1_i64, 2_i64, 1_i64));
+    assert_eq!(v.zxyy(), i64vec4(3_i64, 1_i64, 2_i64, 2_i64));
+    assert_eq!(v.zxyz(), i64vec4(3_i64, 1_i64, 2_i64, 3_i64));
+    assert_eq!(v.zxzx(), i64vec4(3_i64, 1_i64, 3_i64, 1_i64));
+    assert_eq!(v.zxzy(), i64vec4(3_i64, 1_i64, 3_i64, 2_i64));
+    assert_eq!(v.zxzz(), i64vec4(3_i64, 1_i64, 3_i64, 3_i64));
+    assert_eq!(v.zyxx(), i64vec4(3_i64, 2_i64, 1_i64, 1_i64));
+    assert_eq!(v.zyxy(), i64vec4(3_i64, 2_i64, 1_i64, 2_i64));
+    assert_eq!(v.zyxz(), i64vec4(3_i64, 2_i64, 1_i64, 3_i64));
+    assert_eq!(v.zyyx(), i64vec4(3_i64, 2_i64, 2_i64, 1_i64));
+    assert_eq!(v.zyyy(), i64vec4(3_i64, 2_i64, 2_i64, 2_i64));
+    assert_eq!(v.zyyz(), i64vec4(3_i64, 2_i64, 2_i64, 3_i64));
+    assert_eq!(v.zyzx(), i64vec4(3_i64, 2_i64, 3_i64, 1_i64));
+    assert_eq!(v.zyzy(), i64vec4(3_i64, 2_i64, 3_i64, 2_i64));
+    assert_eq!(v.zyzz(), i64vec4(3_i64, 2_i64, 3_i64, 3_i64));
+    assert_eq!(v.zzxx(), i64vec4(3_i64, 3_i64, 1_i64, 1_i64));
+    assert_eq!(v.zzxy(), i64vec4(3_i64, 3_i64, 1_i64, 2_i64));
+    assert_eq!(v.zzxz(), i64vec4(3_i64, 3_i64, 1_i64, 3_i64));
+    assert_eq!(v.zzyx(), i64vec4(3_i64, 3_i64, 2_i64, 1_i64));
+    assert_eq!(v.zzyy(), i64vec4(3_i64, 3_i64, 2_i64, 2_i64));
+    assert_eq!(v.zzyz(), i64vec4(3_i64, 3_i64, 2_i64, 3_i64));
+    assert_eq!(v.zzzx(), i64vec4(3_i64, 3_i64, 3_i64, 1_i64));
+    assert_eq!(v.zzzy(), i64vec4(3_i64, 3_i64, 3_i64, 2_i64));
+    assert_eq!(v.zzzz(), i64vec4(3_i64, 3_i64, 3_i64, 3_i64));
+    assert_eq!(v.xxx(), i64vec3(1_i64, 1_i64, 1_i64));
+    assert_eq!(v.xxy(), i64vec3(1_i64, 1_i64, 2_i64));
+    assert_eq!(v.xxz(), i64vec3(1_i64, 1_i64, 3_i64));
+    assert_eq!(v.xyx(), i64vec3(1_i64, 2_i64, 1_i64));
+    assert_eq!(v.xyy(), i64vec3(1_i64, 2_i64, 2_i64));
+    assert_eq!(v.xzx(), i64vec3(1_i64, 3_i64, 1_i64));
+    assert_eq!(v.xzy(), i64vec3(1_i64, 3_i64, 2_i64));
+    assert_eq!(v.xzz(), i64vec3(1_i64, 3_i64, 3_i64));
+    assert_eq!(v.yxx(), i64vec3(2_i64, 1_i64, 1_i64));
+    assert_eq!(v.yxy(), i64vec3(2_i64, 1_i64, 2_i64));
+    assert_eq!(v.yxz(), i64vec3(2_i64, 1_i64, 3_i64));
+    assert_eq!(v.yyx(), i64vec3(2_i64, 2_i64, 1_i64));
+    assert_eq!(v.yyy(), i64vec3(2_i64, 2_i64, 2_i64));
+    assert_eq!(v.yyz(), i64vec3(2_i64, 2_i64, 3_i64));
+    assert_eq!(v.yzx(), i64vec3(2_i64, 3_i64, 1_i64));
+    assert_eq!(v.yzy(), i64vec3(2_i64, 3_i64, 2_i64));
+    assert_eq!(v.yzz(), i64vec3(2_i64, 3_i64, 3_i64));
+    assert_eq!(v.zxx(), i64vec3(3_i64, 1_i64, 1_i64));
+    assert_eq!(v.zxy(), i64vec3(3_i64, 1_i64, 2_i64));
+    assert_eq!(v.zxz(), i64vec3(3_i64, 1_i64, 3_i64));
+    assert_eq!(v.zyx(), i64vec3(3_i64, 2_i64, 1_i64));
+    assert_eq!(v.zyy(), i64vec3(3_i64, 2_i64, 2_i64));
+    assert_eq!(v.zyz(), i64vec3(3_i64, 2_i64, 3_i64));
+    assert_eq!(v.zzx(), i64vec3(3_i64, 3_i64, 1_i64));
+    assert_eq!(v.zzy(), i64vec3(3_i64, 3_i64, 2_i64));
+    assert_eq!(v.zzz(), i64vec3(3_i64, 3_i64, 3_i64));
+    assert_eq!(v.xx(), i64vec2(1_i64, 1_i64));
+    assert_eq!(v.xy(), i64vec2(1_i64, 2_i64));
+    assert_eq!(v.xz(), i64vec2(1_i64, 3_i64));
+    assert_eq!(v.yx(), i64vec2(2_i64, 1_i64));
+    assert_eq!(v.yy(), i64vec2(2_i64, 2_i64));
+    assert_eq!(v.yz(), i64vec2(2_i64, 3_i64));
+    assert_eq!(v.zx(), i64vec2(3_i64, 1_i64));
+    assert_eq!(v.zy(), i64vec2(3_i64, 2_i64));
+    assert_eq!(v.zz(), i64vec2(3_i64, 3_i64));
+});
+
+glam_test!(test_i64vec2_swizzles, {
+    let v = i64vec2(1_i64, 2_i64);
+    assert_eq!(v, v.xy());
+    assert_eq!(v.xxxx(), i64vec4(1_i64, 1_i64, 1_i64, 1_i64));
+    assert_eq!(v.xxxy(), i64vec4(1_i64, 1_i64, 1_i64, 2_i64));
+    assert_eq!(v.xxyx(), i64vec4(1_i64, 1_i64, 2_i64, 1_i64));
+    assert_eq!(v.xxyy(), i64vec4(1_i64, 1_i64, 2_i64, 2_i64));
+    assert_eq!(v.xyxx(), i64vec4(1_i64, 2_i64, 1_i64, 1_i64));
+    assert_eq!(v.xyxy(), i64vec4(1_i64, 2_i64, 1_i64, 2_i64));
+    assert_eq!(v.xyyx(), i64vec4(1_i64, 2_i64, 2_i64, 1_i64));
+    assert_eq!(v.xyyy(), i64vec4(1_i64, 2_i64, 2_i64, 2_i64));
+    assert_eq!(v.yxxx(), i64vec4(2_i64, 1_i64, 1_i64, 1_i64));
+    assert_eq!(v.yxxy(), i64vec4(2_i64, 1_i64, 1_i64, 2_i64));
+    assert_eq!(v.yxyx(), i64vec4(2_i64, 1_i64, 2_i64, 1_i64));
+    assert_eq!(v.yxyy(), i64vec4(2_i64, 1_i64, 2_i64, 2_i64));
+    assert_eq!(v.yyxx(), i64vec4(2_i64, 2_i64, 1_i64, 1_i64));
+    assert_eq!(v.yyxy(), i64vec4(2_i64, 2_i64, 1_i64, 2_i64));
+    assert_eq!(v.yyyx(), i64vec4(2_i64, 2_i64, 2_i64, 1_i64));
+    assert_eq!(v.yyyy(), i64vec4(2_i64, 2_i64, 2_i64, 2_i64));
+    assert_eq!(v.xxx(), i64vec3(1_i64, 1_i64, 1_i64));
+    assert_eq!(v.xxy(), i64vec3(1_i64, 1_i64, 2_i64));
+    assert_eq!(v.xyx(), i64vec3(1_i64, 2_i64, 1_i64));
+    assert_eq!(v.xyy(), i64vec3(1_i64, 2_i64, 2_i64));
+    assert_eq!(v.yxx(), i64vec3(2_i64, 1_i64, 1_i64));
+    assert_eq!(v.yxy(), i64vec3(2_i64, 1_i64, 2_i64));
+    assert_eq!(v.yyx(), i64vec3(2_i64, 2_i64, 1_i64));
+    assert_eq!(v.yyy(), i64vec3(2_i64, 2_i64, 2_i64));
+    assert_eq!(v.xx(), i64vec2(1_i64, 1_i64));
+    assert_eq!(v.yx(), i64vec2(2_i64, 1_i64));
+    assert_eq!(v.yy(), i64vec2(2_i64, 2_i64));
+});

vendor/glam/tests/swizzles_i8.rs

@@ -0,0 +1,497 @@
+// Generated by swizzlegen. Do not edit.
+#[macro_use]
+mod support;
+use glam::*;
+
+glam_test!(test_i8vec4_swizzles, {
+    let v = i8vec4(1_i8, 2_i8, 3_i8, 4_i8);
+    assert_eq!(v, v.xyzw());
+    assert_eq!(v.xxxx(), i8vec4(1_i8, 1_i8, 1_i8, 1_i8));
+    assert_eq!(v.xxxy(), i8vec4(1_i8, 1_i8, 1_i8, 2_i8));
+    assert_eq!(v.xxxz(), i8vec4(1_i8, 1_i8, 1_i8, 3_i8));
+    assert_eq!(v.xxxw(), i8vec4(1_i8, 1_i8, 1_i8, 4_i8));
+    assert_eq!(v.xxyx(), i8vec4(1_i8, 1_i8, 2_i8, 1_i8));
+    assert_eq!(v.xxyy(), i8vec4(1_i8, 1_i8, 2_i8, 2_i8));
+    assert_eq!(v.xxyz(), i8vec4(1_i8, 1_i8, 2_i8, 3_i8));
+    assert_eq!(v.xxyw(), i8vec4(1_i8, 1_i8, 2_i8, 4_i8));
+    assert_eq!(v.xxzx(), i8vec4(1_i8, 1_i8, 3_i8, 1_i8));
+    assert_eq!(v.xxzy(), i8vec4(1_i8, 1_i8, 3_i8, 2_i8));
+    assert_eq!(v.xxzz(), i8vec4(1_i8, 1_i8, 3_i8, 3_i8));
+    assert_eq!(v.xxzw(), i8vec4(1_i8, 1_i8, 3_i8, 4_i8));
+    assert_eq!(v.xxwx(), i8vec4(1_i8, 1_i8, 4_i8, 1_i8));
+    assert_eq!(v.xxwy(), i8vec4(1_i8, 1_i8, 4_i8, 2_i8));
+    assert_eq!(v.xxwz(), i8vec4(1_i8, 1_i8, 4_i8, 3_i8));
+    assert_eq!(v.xxww(), i8vec4(1_i8, 1_i8, 4_i8, 4_i8));
+    assert_eq!(v.xyxx(), i8vec4(1_i8, 2_i8, 1_i8, 1_i8));
+    assert_eq!(v.xyxy(), i8vec4(1_i8, 2_i8, 1_i8, 2_i8));
+    assert_eq!(v.xyxz(), i8vec4(1_i8, 2_i8, 1_i8, 3_i8));
+    assert_eq!(v.xyxw(), i8vec4(1_i8, 2_i8, 1_i8, 4_i8));
+    assert_eq!(v.xyyx(), i8vec4(1_i8, 2_i8, 2_i8, 1_i8));
+    assert_eq!(v.xyyy(), i8vec4(1_i8, 2_i8, 2_i8, 2_i8));
+    assert_eq!(v.xyyz(), i8vec4(1_i8, 2_i8, 2_i8, 3_i8));
+    assert_eq!(v.xyyw(), i8vec4(1_i8, 2_i8, 2_i8, 4_i8));
+    assert_eq!(v.xyzx(), i8vec4(1_i8, 2_i8, 3_i8, 1_i8));
+    assert_eq!(v.xyzy(), i8vec4(1_i8, 2_i8, 3_i8, 2_i8));
+    assert_eq!(v.xyzz(), i8vec4(1_i8, 2_i8, 3_i8, 3_i8));
+    assert_eq!(v.xywx(), i8vec4(1_i8, 2_i8, 4_i8, 1_i8));
+    assert_eq!(v.xywy(), i8vec4(1_i8, 2_i8, 4_i8, 2_i8));
+    assert_eq!(v.xywz(), i8vec4(1_i8, 2_i8, 4_i8, 3_i8));
+    assert_eq!(v.xyww(), i8vec4(1_i8, 2_i8, 4_i8, 4_i8));
+    assert_eq!(v.xzxx(), i8vec4(1_i8, 3_i8, 1_i8, 1_i8));
+    assert_eq!(v.xzxy(), i8vec4(1_i8, 3_i8, 1_i8, 2_i8));
+    assert_eq!(v.xzxz(), i8vec4(1_i8, 3_i8, 1_i8, 3_i8));
+    assert_eq!(v.xzxw(), i8vec4(1_i8, 3_i8, 1_i8, 4_i8));
+    assert_eq!(v.xzyx(), i8vec4(1_i8, 3_i8, 2_i8, 1_i8));
+    assert_eq!(v.xzyy(), i8vec4(1_i8, 3_i8, 2_i8, 2_i8));
+    assert_eq!(v.xzyz(), i8vec4(1_i8, 3_i8, 2_i8, 3_i8));
+    assert_eq!(v.xzyw(), i8vec4(1_i8, 3_i8, 2_i8, 4_i8));
+    assert_eq!(v.xzzx(), i8vec4(1_i8, 3_i8, 3_i8, 1_i8));
+    assert_eq!(v.xzzy(), i8vec4(1_i8, 3_i8, 3_i8, 2_i8));
+    assert_eq!(v.xzzz(), i8vec4(1_i8, 3_i8, 3_i8, 3_i8));
+    assert_eq!(v.xzzw(), i8vec4(1_i8, 3_i8, 3_i8, 4_i8));
+    assert_eq!(v.xzwx(), i8vec4(1_i8, 3_i8, 4_i8, 1_i8));
+    assert_eq!(v.xzwy(), i8vec4(1_i8, 3_i8, 4_i8, 2_i8));
+    assert_eq!(v.xzwz(), i8vec4(1_i8, 3_i8, 4_i8, 3_i8));
+    assert_eq!(v.xzww(), i8vec4(1_i8, 3_i8, 4_i8, 4_i8));
+    assert_eq!(v.xwxx(), i8vec4(1_i8, 4_i8, 1_i8, 1_i8));
+    assert_eq!(v.xwxy(), i8vec4(1_i8, 4_i8, 1_i8, 2_i8));
+    assert_eq!(v.xwxz(), i8vec4(1_i8, 4_i8, 1_i8, 3_i8));
+    assert_eq!(v.xwxw(), i8vec4(1_i8, 4_i8, 1_i8, 4_i8));
+    assert_eq!(v.xwyx(), i8vec4(1_i8, 4_i8, 2_i8, 1_i8));
+    assert_eq!(v.xwyy(), i8vec4(1_i8, 4_i8, 2_i8, 2_i8));
+    assert_eq!(v.xwyz(), i8vec4(1_i8, 4_i8, 2_i8, 3_i8));
+    assert_eq!(v.xwyw(), i8vec4(1_i8, 4_i8, 2_i8, 4_i8));
+    assert_eq!(v.xwzx(), i8vec4(1_i8, 4_i8, 3_i8, 1_i8));
+    assert_eq!(v.xwzy(), i8vec4(1_i8, 4_i8, 3_i8, 2_i8));
+    assert_eq!(v.xwzz(), i8vec4(1_i8, 4_i8, 3_i8, 3_i8));
+    assert_eq!(v.xwzw(), i8vec4(1_i8, 4_i8, 3_i8, 4_i8));
+    assert_eq!(v.xwwx(), i8vec4(1_i8, 4_i8, 4_i8, 1_i8));
+    assert_eq!(v.xwwy(), i8vec4(1_i8, 4_i8, 4_i8, 2_i8));
+    assert_eq!(v.xwwz(), i8vec4(1_i8, 4_i8, 4_i8, 3_i8));
+    assert_eq!(v.xwww(), i8vec4(1_i8, 4_i8, 4_i8, 4_i8));
+    assert_eq!(v.yxxx(), i8vec4(2_i8, 1_i8, 1_i8, 1_i8));
+    assert_eq!(v.yxxy(), i8vec4(2_i8, 1_i8, 1_i8, 2_i8));
+    assert_eq!(v.yxxz(), i8vec4(2_i8, 1_i8, 1_i8, 3_i8));
+    assert_eq!(v.yxxw(), i8vec4(2_i8, 1_i8, 1_i8, 4_i8));
+    assert_eq!(v.yxyx(), i8vec4(2_i8, 1_i8, 2_i8, 1_i8));
+    assert_eq!(v.yxyy(), i8vec4(2_i8, 1_i8, 2_i8, 2_i8));
+    assert_eq!(v.yxyz(), i8vec4(2_i8, 1_i8, 2_i8, 3_i8));
+    assert_eq!(v.yxyw(), i8vec4(2_i8, 1_i8, 2_i8, 4_i8));
+    assert_eq!(v.yxzx(), i8vec4(2_i8, 1_i8, 3_i8, 1_i8));
+    assert_eq!(v.yxzy(), i8vec4(2_i8, 1_i8, 3_i8, 2_i8));
+    assert_eq!(v.yxzz(), i8vec4(2_i8, 1_i8, 3_i8, 3_i8));
+    assert_eq!(v.yxzw(), i8vec4(2_i8, 1_i8, 3_i8, 4_i8));
+    assert_eq!(v.yxwx(), i8vec4(2_i8, 1_i8, 4_i8, 1_i8));
+    assert_eq!(v.yxwy(), i8vec4(2_i8, 1_i8, 4_i8, 2_i8));
+    assert_eq!(v.yxwz(), i8vec4(2_i8, 1_i8, 4_i8, 3_i8));
+    assert_eq!(v.yxww(), i8vec4(2_i8, 1_i8, 4_i8, 4_i8));
+    assert_eq!(v.yyxx(), i8vec4(2_i8, 2_i8, 1_i8, 1_i8));
+    assert_eq!(v.yyxy(), i8vec4(2_i8, 2_i8, 1_i8, 2_i8));
+    assert_eq!(v.yyxz(), i8vec4(2_i8, 2_i8, 1_i8, 3_i8));
+    assert_eq!(v.yyxw(), i8vec4(2_i8, 2_i8, 1_i8, 4_i8));
+    assert_eq!(v.yyyx(), i8vec4(2_i8, 2_i8, 2_i8, 1_i8));
+    assert_eq!(v.yyyy(), i8vec4(2_i8, 2_i8, 2_i8, 2_i8));
+    assert_eq!(v.yyyz(), i8vec4(2_i8, 2_i8, 2_i8, 3_i8));
+    assert_eq!(v.yyyw(), i8vec4(2_i8, 2_i8, 2_i8, 4_i8));
+    assert_eq!(v.yyzx(), i8vec4(2_i8, 2_i8, 3_i8, 1_i8));
+    assert_eq!(v.yyzy(), i8vec4(2_i8, 2_i8, 3_i8, 2_i8));
+    assert_eq!(v.yyzz(), i8vec4(2_i8, 2_i8, 3_i8, 3_i8));
+    assert_eq!(v.yyzw(), i8vec4(2_i8, 2_i8, 3_i8, 4_i8));
+    assert_eq!(v.yywx(), i8vec4(2_i8, 2_i8, 4_i8, 1_i8));
+    assert_eq!(v.yywy(), i8vec4(2_i8, 2_i8, 4_i8, 2_i8));
+    assert_eq!(v.yywz(), i8vec4(2_i8, 2_i8, 4_i8, 3_i8));
+    assert_eq!(v.yyww(), i8vec4(2_i8, 2_i8, 4_i8, 4_i8));
+    assert_eq!(v.yzxx(), i8vec4(2_i8, 3_i8, 1_i8, 1_i8));
+    assert_eq!(v.yzxy(), i8vec4(2_i8, 3_i8, 1_i8, 2_i8));
+    assert_eq!(v.yzxz(), i8vec4(2_i8, 3_i8, 1_i8, 3_i8));
+    assert_eq!(v.yzxw(), i8vec4(2_i8, 3_i8, 1_i8, 4_i8));
+    assert_eq!(v.yzyx(), i8vec4(2_i8, 3_i8, 2_i8, 1_i8));
+    assert_eq!(v.yzyy(), i8vec4(2_i8, 3_i8, 2_i8, 2_i8));
+    assert_eq!(v.yzyz(), i8vec4(2_i8, 3_i8, 2_i8, 3_i8));
+    assert_eq!(v.yzyw(), i8vec4(2_i8, 3_i8, 2_i8, 4_i8));
+    assert_eq!(v.yzzx(), i8vec4(2_i8, 3_i8, 3_i8, 1_i8));
+    assert_eq!(v.yzzy(), i8vec4(2_i8, 3_i8, 3_i8, 2_i8));
+    assert_eq!(v.yzzz(), i8vec4(2_i8, 3_i8, 3_i8, 3_i8));
+    assert_eq!(v.yzzw(), i8vec4(2_i8, 3_i8, 3_i8, 4_i8));
+    assert_eq!(v.yzwx(), i8vec4(2_i8, 3_i8, 4_i8, 1_i8));
+    assert_eq!(v.yzwy(), i8vec4(2_i8, 3_i8, 4_i8, 2_i8));
+    assert_eq!(v.yzwz(), i8vec4(2_i8, 3_i8, 4_i8, 3_i8));
+    assert_eq!(v.yzww(), i8vec4(2_i8, 3_i8, 4_i8, 4_i8));
+    assert_eq!(v.ywxx(), i8vec4(2_i8, 4_i8, 1_i8, 1_i8));
+    assert_eq!(v.ywxy(), i8vec4(2_i8, 4_i8, 1_i8, 2_i8));
+    assert_eq!(v.ywxz(), i8vec4(2_i8, 4_i8, 1_i8, 3_i8));
+    assert_eq!(v.ywxw(), i8vec4(2_i8, 4_i8, 1_i8, 4_i8));
+    assert_eq!(v.ywyx(), i8vec4(2_i8, 4_i8, 2_i8, 1_i8));
+    assert_eq!(v.ywyy(), i8vec4(2_i8, 4_i8, 2_i8, 2_i8));
+    assert_eq!(v.ywyz(), i8vec4(2_i8, 4_i8, 2_i8, 3_i8));
+    assert_eq!(v.ywyw(), i8vec4(2_i8, 4_i8, 2_i8, 4_i8));
+    assert_eq!(v.ywzx(), i8vec4(2_i8, 4_i8, 3_i8, 1_i8));
+    assert_eq!(v.ywzy(), i8vec4(2_i8, 4_i8, 3_i8, 2_i8));
+    assert_eq!(v.ywzz(), i8vec4(2_i8, 4_i8, 3_i8, 3_i8));
+    assert_eq!(v.ywzw(), i8vec4(2_i8, 4_i8, 3_i8, 4_i8));
+    assert_eq!(v.ywwx(), i8vec4(2_i8, 4_i8, 4_i8, 1_i8));
+    assert_eq!(v.ywwy(), i8vec4(2_i8, 4_i8, 4_i8, 2_i8));
+    assert_eq!(v.ywwz(), i8vec4(2_i8, 4_i8, 4_i8, 3_i8));
+    assert_eq!(v.ywww(), i8vec4(2_i8, 4_i8, 4_i8, 4_i8));
+    assert_eq!(v.zxxx(), i8vec4(3_i8, 1_i8, 1_i8, 1_i8));
+    assert_eq!(v.zxxy(), i8vec4(3_i8, 1_i8, 1_i8, 2_i8));
+    assert_eq!(v.zxxz(), i8vec4(3_i8, 1_i8, 1_i8, 3_i8));
+    assert_eq!(v.zxxw(), i8vec4(3_i8, 1_i8, 1_i8, 4_i8));
+    assert_eq!(v.zxyx(), i8vec4(3_i8, 1_i8, 2_i8, 1_i8));
+    assert_eq!(v.zxyy(), i8vec4(3_i8, 1_i8, 2_i8, 2_i8));
+    assert_eq!(v.zxyz(), i8vec4(3_i8, 1_i8, 2_i8, 3_i8));
+    assert_eq!(v.zxyw(), i8vec4(3_i8, 1_i8, 2_i8, 4_i8));
+    assert_eq!(v.zxzx(), i8vec4(3_i8, 1_i8, 3_i8, 1_i8));
+    assert_eq!(v.zxzy(), i8vec4(3_i8, 1_i8, 3_i8, 2_i8));
+    assert_eq!(v.zxzz(), i8vec4(3_i8, 1_i8, 3_i8, 3_i8));
+    assert_eq!(v.zxzw(), i8vec4(3_i8, 1_i8, 3_i8, 4_i8));
+    assert_eq!(v.zxwx(), i8vec4(3_i8, 1_i8, 4_i8, 1_i8));
+    assert_eq!(v.zxwy(), i8vec4(3_i8, 1_i8, 4_i8, 2_i8));
+    assert_eq!(v.zxwz(), i8vec4(3_i8, 1_i8, 4_i8, 3_i8));
+    assert_eq!(v.zxww(), i8vec4(3_i8, 1_i8, 4_i8, 4_i8));
+    assert_eq!(v.zyxx(), i8vec4(3_i8, 2_i8, 1_i8, 1_i8));
+    assert_eq!(v.zyxy(), i8vec4(3_i8, 2_i8, 1_i8, 2_i8));
+    assert_eq!(v.zyxz(), i8vec4(3_i8, 2_i8, 1_i8, 3_i8));
+    assert_eq!(v.zyxw(), i8vec4(3_i8, 2_i8, 1_i8, 4_i8));
+    assert_eq!(v.zyyx(), i8vec4(3_i8, 2_i8, 2_i8, 1_i8));
+    assert_eq!(v.zyyy(), i8vec4(3_i8, 2_i8, 2_i8, 2_i8));
+    assert_eq!(v.zyyz(), i8vec4(3_i8, 2_i8, 2_i8, 3_i8));
+    assert_eq!(v.zyyw(), i8vec4(3_i8, 2_i8, 2_i8, 4_i8));
+    assert_eq!(v.zyzx(), i8vec4(3_i8, 2_i8, 3_i8, 1_i8));
+    assert_eq!(v.zyzy(), i8vec4(3_i8, 2_i8, 3_i8, 2_i8));
+    assert_eq!(v.zyzz(), i8vec4(3_i8, 2_i8, 3_i8, 3_i8));
+    assert_eq!(v.zyzw(), i8vec4(3_i8, 2_i8, 3_i8, 4_i8));
+    assert_eq!(v.zywx(), i8vec4(3_i8, 2_i8, 4_i8, 1_i8));
+    assert_eq!(v.zywy(), i8vec4(3_i8, 2_i8, 4_i8, 2_i8));
+    assert_eq!(v.zywz(), i8vec4(3_i8, 2_i8, 4_i8, 3_i8));
+    assert_eq!(v.zyww(), i8vec4(3_i8, 2_i8, 4_i8, 4_i8));
+    assert_eq!(v.zzxx(), i8vec4(3_i8, 3_i8, 1_i8, 1_i8));
+    assert_eq!(v.zzxy(), i8vec4(3_i8, 3_i8, 1_i8, 2_i8));
+    assert_eq!(v.zzxz(), i8vec4(3_i8, 3_i8, 1_i8, 3_i8));
+    assert_eq!(v.zzxw(), i8vec4(3_i8, 3_i8, 1_i8, 4_i8));
+    assert_eq!(v.zzyx(), i8vec4(3_i8, 3_i8, 2_i8, 1_i8));
+    assert_eq!(v.zzyy(), i8vec4(3_i8, 3_i8, 2_i8, 2_i8));
+    assert_eq!(v.zzyz(), i8vec4(3_i8, 3_i8, 2_i8, 3_i8));
+    assert_eq!(v.zzyw(), i8vec4(3_i8, 3_i8, 2_i8, 4_i8));
+    assert_eq!(v.zzzx(), i8vec4(3_i8, 3_i8, 3_i8, 1_i8));
+    assert_eq!(v.zzzy(), i8vec4(3_i8, 3_i8, 3_i8, 2_i8));
+    assert_eq!(v.zzzz(), i8vec4(3_i8, 3_i8, 3_i8, 3_i8));
+    assert_eq!(v.zzzw(), i8vec4(3_i8, 3_i8, 3_i8, 4_i8));
+    assert_eq!(v.zzwx(), i8vec4(3_i8, 3_i8, 4_i8, 1_i8));
+    assert_eq!(v.zzwy(), i8vec4(3_i8, 3_i8, 4_i8, 2_i8));
+    assert_eq!(v.zzwz(), i8vec4(3_i8, 3_i8, 4_i8, 3_i8));
+    assert_eq!(v.zzww(), i8vec4(3_i8, 3_i8, 4_i8, 4_i8));
+    assert_eq!(v.zwxx(), i8vec4(3_i8, 4_i8, 1_i8, 1_i8));
+    assert_eq!(v.zwxy(), i8vec4(3_i8, 4_i8, 1_i8, 2_i8));
+    assert_eq!(v.zwxz(), i8vec4(3_i8, 4_i8, 1_i8, 3_i8));
+    assert_eq!(v.zwxw(), i8vec4(3_i8, 4_i8, 1_i8, 4_i8));
+    assert_eq!(v.zwyx(), i8vec4(3_i8, 4_i8, 2_i8, 1_i8));
+    assert_eq!(v.zwyy(), i8vec4(3_i8, 4_i8, 2_i8, 2_i8));
+    assert_eq!(v.zwyz(), i8vec4(3_i8, 4_i8, 2_i8, 3_i8));
+    assert_eq!(v.zwyw(), i8vec4(3_i8, 4_i8, 2_i8, 4_i8));
+    assert_eq!(v.zwzx(), i8vec4(3_i8, 4_i8, 3_i8, 1_i8));
+    assert_eq!(v.zwzy(), i8vec4(3_i8, 4_i8, 3_i8, 2_i8));
+    assert_eq!(v.zwzz(), i8vec4(3_i8, 4_i8, 3_i8, 3_i8));
+    assert_eq!(v.zwzw(), i8vec4(3_i8, 4_i8, 3_i8, 4_i8));
+    assert_eq!(v.zwwx(), i8vec4(3_i8, 4_i8, 4_i8, 1_i8));
+    assert_eq!(v.zwwy(), i8vec4(3_i8, 4_i8, 4_i8, 2_i8));
+    assert_eq!(v.zwwz(), i8vec4(3_i8, 4_i8, 4_i8, 3_i8));
+    assert_eq!(v.zwww(), i8vec4(3_i8, 4_i8, 4_i8, 4_i8));
+    assert_eq!(v.wxxx(), i8vec4(4_i8, 1_i8, 1_i8, 1_i8));
+    assert_eq!(v.wxxy(), i8vec4(4_i8, 1_i8, 1_i8, 2_i8));
+    assert_eq!(v.wxxz(), i8vec4(4_i8, 1_i8, 1_i8, 3_i8));
+    assert_eq!(v.wxxw(), i8vec4(4_i8, 1_i8, 1_i8, 4_i8));
+    assert_eq!(v.wxyx(), i8vec4(4_i8, 1_i8, 2_i8, 1_i8));
+    assert_eq!(v.wxyy(), i8vec4(4_i8, 1_i8, 2_i8, 2_i8));
+    assert_eq!(v.wxyz(), i8vec4(4_i8, 1_i8, 2_i8, 3_i8));
+    assert_eq!(v.wxyw(), i8vec4(4_i8, 1_i8, 2_i8, 4_i8));
+    assert_eq!(v.wxzx(), i8vec4(4_i8, 1_i8, 3_i8, 1_i8));
+    assert_eq!(v.wxzy(), i8vec4(4_i8, 1_i8, 3_i8, 2_i8));
+    assert_eq!(v.wxzz(), i8vec4(4_i8, 1_i8, 3_i8, 3_i8));
+    assert_eq!(v.wxzw(), i8vec4(4_i8, 1_i8, 3_i8, 4_i8));
+    assert_eq!(v.wxwx(), i8vec4(4_i8, 1_i8, 4_i8, 1_i8));
+    assert_eq!(v.wxwy(), i8vec4(4_i8, 1_i8, 4_i8, 2_i8));
+    assert_eq!(v.wxwz(), i8vec4(4_i8, 1_i8, 4_i8, 3_i8));
+    assert_eq!(v.wxww(), i8vec4(4_i8, 1_i8, 4_i8, 4_i8));
+    assert_eq!(v.wyxx(), i8vec4(4_i8, 2_i8, 1_i8, 1_i8));
+    assert_eq!(v.wyxy(), i8vec4(4_i8, 2_i8, 1_i8, 2_i8));
+    assert_eq!(v.wyxz(), i8vec4(4_i8, 2_i8, 1_i8, 3_i8));
+    assert_eq!(v.wyxw(), i8vec4(4_i8, 2_i8, 1_i8, 4_i8));
+    assert_eq!(v.wyyx(), i8vec4(4_i8, 2_i8, 2_i8, 1_i8));
+    assert_eq!(v.wyyy(), i8vec4(4_i8, 2_i8, 2_i8, 2_i8));
+    assert_eq!(v.wyyz(), i8vec4(4_i8, 2_i8, 2_i8, 3_i8));
+    assert_eq!(v.wyyw(), i8vec4(4_i8, 2_i8, 2_i8, 4_i8));
+    assert_eq!(v.wyzx(), i8vec4(4_i8, 2_i8, 3_i8, 1_i8));
+    assert_eq!(v.wyzy(), i8vec4(4_i8, 2_i8, 3_i8, 2_i8));
+    assert_eq!(v.wyzz(), i8vec4(4_i8, 2_i8, 3_i8, 3_i8));
+    assert_eq!(v.wyzw(), i8vec4(4_i8, 2_i8, 3_i8, 4_i8));
+    assert_eq!(v.wywx(), i8vec4(4_i8, 2_i8, 4_i8, 1_i8));
+    assert_eq!(v.wywy(), i8vec4(4_i8, 2_i8, 4_i8, 2_i8));
+    assert_eq!(v.wywz(), i8vec4(4_i8, 2_i8, 4_i8, 3_i8));
+    assert_eq!(v.wyww(), i8vec4(4_i8, 2_i8, 4_i8, 4_i8));
+    assert_eq!(v.wzxx(), i8vec4(4_i8, 3_i8, 1_i8, 1_i8));
+    assert_eq!(v.wzxy(), i8vec4(4_i8, 3_i8, 1_i8, 2_i8));
+    assert_eq!(v.wzxz(), i8vec4(4_i8, 3_i8, 1_i8, 3_i8));
+    assert_eq!(v.wzxw(), i8vec4(4_i8, 3_i8, 1_i8, 4_i8));
+    assert_eq!(v.wzyx(), i8vec4(4_i8, 3_i8, 2_i8, 1_i8));
+    assert_eq!(v.wzyy(), i8vec4(4_i8, 3_i8, 2_i8, 2_i8));
+    assert_eq!(v.wzyz(), i8vec4(4_i8, 3_i8, 2_i8, 3_i8));
+    assert_eq!(v.wzyw(), i8vec4(4_i8, 3_i8, 2_i8, 4_i8));
+    assert_eq!(v.wzzx(), i8vec4(4_i8, 3_i8, 3_i8, 1_i8));
+    assert_eq!(v.wzzy(), i8vec4(4_i8, 3_i8, 3_i8, 2_i8));
+    assert_eq!(v.wzzz(), i8vec4(4_i8, 3_i8, 3_i8, 3_i8));
+    assert_eq!(v.wzzw(), i8vec4(4_i8, 3_i8, 3_i8, 4_i8));
+    assert_eq!(v.wzwx(), i8vec4(4_i8, 3_i8, 4_i8, 1_i8));
+    assert_eq!(v.wzwy(), i8vec4(4_i8, 3_i8, 4_i8, 2_i8));
+    assert_eq!(v.wzwz(), i8vec4(4_i8, 3_i8, 4_i8, 3_i8));
+    assert_eq!(v.wzww(), i8vec4(4_i8, 3_i8, 4_i8, 4_i8));
+    assert_eq!(v.wwxx(), i8vec4(4_i8, 4_i8, 1_i8, 1_i8));
+    assert_eq!(v.wwxy(), i8vec4(4_i8, 4_i8, 1_i8, 2_i8));
+    assert_eq!(v.wwxz(), i8vec4(4_i8, 4_i8, 1_i8, 3_i8));
+    assert_eq!(v.wwxw(), i8vec4(4_i8, 4_i8, 1_i8, 4_i8));
+    assert_eq!(v.wwyx(), i8vec4(4_i8, 4_i8, 2_i8, 1_i8));
+    assert_eq!(v.wwyy(), i8vec4(4_i8, 4_i8, 2_i8, 2_i8));
+    assert_eq!(v.wwyz(), i8vec4(4_i8, 4_i8, 2_i8, 3_i8));
+    assert_eq!(v.wwyw(), i8vec4(4_i8, 4_i8, 2_i8, 4_i8));
+    assert_eq!(v.wwzx(), i8vec4(4_i8, 4_i8, 3_i8, 1_i8));
+    assert_eq!(v.wwzy(), i8vec4(4_i8, 4_i8, 3_i8, 2_i8));
+    assert_eq!(v.wwzz(), i8vec4(4_i8, 4_i8, 3_i8, 3_i8));
+    assert_eq!(v.wwzw(), i8vec4(4_i8, 4_i8, 3_i8, 4_i8));
+    assert_eq!(v.wwwx(), i8vec4(4_i8, 4_i8, 4_i8, 1_i8));
+    assert_eq!(v.wwwy(), i8vec4(4_i8, 4_i8, 4_i8, 2_i8));
+    assert_eq!(v.wwwz(), i8vec4(4_i8, 4_i8, 4_i8, 3_i8));
+    assert_eq!(v.wwww(), i8vec4(4_i8, 4_i8, 4_i8, 4_i8));
+    assert_eq!(v.xxx(), i8vec3(1_i8, 1_i8, 1_i8));
+    assert_eq!(v.xxy(), i8vec3(1_i8, 1_i8, 2_i8));
+    assert_eq!(v.xxz(), i8vec3(1_i8, 1_i8, 3_i8));
+    assert_eq!(v.xxw(), i8vec3(1_i8, 1_i8, 4_i8));
+    assert_eq!(v.xyx(), i8vec3(1_i8, 2_i8, 1_i8));
+    assert_eq!(v.xyy(), i8vec3(1_i8, 2_i8, 2_i8));
+    assert_eq!(v.xyz(), i8vec3(1_i8, 2_i8, 3_i8));
+    assert_eq!(v.xyw(), i8vec3(1_i8, 2_i8, 4_i8));
+    assert_eq!(v.xzx(), i8vec3(1_i8, 3_i8, 1_i8));
+    assert_eq!(v.xzy(), i8vec3(1_i8, 3_i8, 2_i8));
+    assert_eq!(v.xzz(), i8vec3(1_i8, 3_i8, 3_i8));
+    assert_eq!(v.xzw(), i8vec3(1_i8, 3_i8, 4_i8));
+    assert_eq!(v.xwx(), i8vec3(1_i8, 4_i8, 1_i8));
+    assert_eq!(v.xwy(), i8vec3(1_i8, 4_i8, 2_i8));
+    assert_eq!(v.xwz(), i8vec3(1_i8, 4_i8, 3_i8));
+    assert_eq!(v.xww(), i8vec3(1_i8, 4_i8, 4_i8));
+    assert_eq!(v.yxx(), i8vec3(2_i8, 1_i8, 1_i8));
+    assert_eq!(v.yxy(), i8vec3(2_i8, 1_i8, 2_i8));
+    assert_eq!(v.yxz(), i8vec3(2_i8, 1_i8, 3_i8));
+    assert_eq!(v.yxw(), i8vec3(2_i8, 1_i8, 4_i8));
+    assert_eq!(v.yyx(), i8vec3(2_i8, 2_i8, 1_i8));
+    assert_eq!(v.yyy(), i8vec3(2_i8, 2_i8, 2_i8));
+    assert_eq!(v.yyz(), i8vec3(2_i8, 2_i8, 3_i8));
+    assert_eq!(v.yyw(), i8vec3(2_i8, 2_i8, 4_i8));
+    assert_eq!(v.yzx(), i8vec3(2_i8, 3_i8, 1_i8));
+    assert_eq!(v.yzy(), i8vec3(2_i8, 3_i8, 2_i8));
+    assert_eq!(v.yzz(), i8vec3(2_i8, 3_i8, 3_i8));
+    assert_eq!(v.yzw(), i8vec3(2_i8, 3_i8, 4_i8));
+    assert_eq!(v.ywx(), i8vec3(2_i8, 4_i8, 1_i8));
+    assert_eq!(v.ywy(), i8vec3(2_i8, 4_i8, 2_i8));
+    assert_eq!(v.ywz(), i8vec3(2_i8, 4_i8, 3_i8));
+    assert_eq!(v.yww(), i8vec3(2_i8, 4_i8, 4_i8));
+    assert_eq!(v.zxx(), i8vec3(3_i8, 1_i8, 1_i8));
+    assert_eq!(v.zxy(), i8vec3(3_i8, 1_i8, 2_i8));
+    assert_eq!(v.zxz(), i8vec3(3_i8, 1_i8, 3_i8));
+    assert_eq!(v.zxw(), i8vec3(3_i8, 1_i8, 4_i8));
+    assert_eq!(v.zyx(), i8vec3(3_i8, 2_i8, 1_i8));
+    assert_eq!(v.zyy(), i8vec3(3_i8, 2_i8, 2_i8));
+    assert_eq!(v.zyz(), i8vec3(3_i8, 2_i8, 3_i8));
+    assert_eq!(v.zyw(), i8vec3(3_i8, 2_i8, 4_i8));
+    assert_eq!(v.zzx(), i8vec3(3_i8, 3_i8, 1_i8));
+    assert_eq!(v.zzy(), i8vec3(3_i8, 3_i8, 2_i8));
+    assert_eq!(v.zzz(), i8vec3(3_i8, 3_i8, 3_i8));
+    assert_eq!(v.zzw(), i8vec3(3_i8, 3_i8, 4_i8));
+    assert_eq!(v.zwx(), i8vec3(3_i8, 4_i8, 1_i8));
+    assert_eq!(v.zwy(), i8vec3(3_i8, 4_i8, 2_i8));
+    assert_eq!(v.zwz(), i8vec3(3_i8, 4_i8, 3_i8));
+    assert_eq!(v.zww(), i8vec3(3_i8, 4_i8, 4_i8));
+    assert_eq!(v.wxx(), i8vec3(4_i8, 1_i8, 1_i8));
+    assert_eq!(v.wxy(), i8vec3(4_i8, 1_i8, 2_i8));
+    assert_eq!(v.wxz(), i8vec3(4_i8, 1_i8, 3_i8));
+    assert_eq!(v.wxw(), i8vec3(4_i8, 1_i8, 4_i8));
+    assert_eq!(v.wyx(), i8vec3(4_i8, 2_i8, 1_i8));
+    assert_eq!(v.wyy(), i8vec3(4_i8, 2_i8, 2_i8));
+    assert_eq!(v.wyz(), i8vec3(4_i8, 2_i8, 3_i8));
+    assert_eq!(v.wyw(), i8vec3(4_i8, 2_i8, 4_i8));
+    assert_eq!(v.wzx(), i8vec3(4_i8, 3_i8, 1_i8));
+    assert_eq!(v.wzy(), i8vec3(4_i8, 3_i8, 2_i8));
+    assert_eq!(v.wzz(), i8vec3(4_i8, 3_i8, 3_i8));
+    assert_eq!(v.wzw(), i8vec3(4_i8, 3_i8, 4_i8));
+    assert_eq!(v.wwx(), i8vec3(4_i8, 4_i8, 1_i8));
+    assert_eq!(v.wwy(), i8vec3(4_i8, 4_i8, 2_i8));
+    assert_eq!(v.wwz(), i8vec3(4_i8, 4_i8, 3_i8));
+    assert_eq!(v.www(), i8vec3(4_i8, 4_i8, 4_i8));
+    assert_eq!(v.xx(), i8vec2(1_i8, 1_i8));
+    assert_eq!(v.xy(), i8vec2(1_i8, 2_i8));
+    assert_eq!(v.xz(), i8vec2(1_i8, 3_i8));
+    assert_eq!(v.xw(), i8vec2(1_i8, 4_i8));
+    assert_eq!(v.yx(), i8vec2(2_i8, 1_i8));
+    assert_eq!(v.yy(), i8vec2(2_i8, 2_i8));
+    assert_eq!(v.yz(), i8vec2(2_i8, 3_i8));
+    assert_eq!(v.yw(), i8vec2(2_i8, 4_i8));
+    assert_eq!(v.zx(), i8vec2(3_i8, 1_i8));
+    assert_eq!(v.zy(), i8vec2(3_i8, 2_i8));
+    assert_eq!(v.zz(), i8vec2(3_i8, 3_i8));
+    assert_eq!(v.zw(), i8vec2(3_i8, 4_i8));
+    assert_eq!(v.wx(), i8vec2(4_i8, 1_i8));
+    assert_eq!(v.wy(), i8vec2(4_i8, 2_i8));
+    assert_eq!(v.wz(), i8vec2(4_i8, 3_i8));
+    assert_eq!(v.ww(), i8vec2(4_i8, 4_i8));
+});
+
+glam_test!(test_i8vec3_swizzles, {
+    let v = i8vec3(1_i8, 2_i8, 3_i8);
+    assert_eq!(v, v.xyz());
+    assert_eq!(v.xxxx(), i8vec4(1_i8, 1_i8, 1_i8, 1_i8));
+    assert_eq!(v.xxxy(), i8vec4(1_i8, 1_i8, 1_i8, 2_i8));
+    assert_eq!(v.xxxz(), i8vec4(1_i8, 1_i8, 1_i8, 3_i8));
+    assert_eq!(v.xxyx(), i8vec4(1_i8, 1_i8, 2_i8, 1_i8));
+    assert_eq!(v.xxyy(), i8vec4(1_i8, 1_i8, 2_i8, 2_i8));
+    assert_eq!(v.xxyz(), i8vec4(1_i8, 1_i8, 2_i8, 3_i8));
+    assert_eq!(v.xxzx(), i8vec4(1_i8, 1_i8, 3_i8, 1_i8));
+    assert_eq!(v.xxzy(), i8vec4(1_i8, 1_i8, 3_i8, 2_i8));
+    assert_eq!(v.xxzz(), i8vec4(1_i8, 1_i8, 3_i8, 3_i8));
+    assert_eq!(v.xyxx(), i8vec4(1_i8, 2_i8, 1_i8, 1_i8));
+    assert_eq!(v.xyxy(), i8vec4(1_i8, 2_i8, 1_i8, 2_i8));
+    assert_eq!(v.xyxz(), i8vec4(1_i8, 2_i8, 1_i8, 3_i8));
+    assert_eq!(v.xyyx(), i8vec4(1_i8, 2_i8, 2_i8, 1_i8));
+    assert_eq!(v.xyyy(), i8vec4(1_i8, 2_i8, 2_i8, 2_i8));
+    assert_eq!(v.xyyz(), i8vec4(1_i8, 2_i8, 2_i8, 3_i8));
+    assert_eq!(v.xyzx(), i8vec4(1_i8, 2_i8, 3_i8, 1_i8));
+    assert_eq!(v.xyzy(), i8vec4(1_i8, 2_i8, 3_i8, 2_i8));
+    assert_eq!(v.xyzz(), i8vec4(1_i8, 2_i8, 3_i8, 3_i8));
+    assert_eq!(v.xzxx(), i8vec4(1_i8, 3_i8, 1_i8, 1_i8));
+    assert_eq!(v.xzxy(), i8vec4(1_i8, 3_i8, 1_i8, 2_i8));
+    assert_eq!(v.xzxz(), i8vec4(1_i8, 3_i8, 1_i8, 3_i8));
+    assert_eq!(v.xzyx(), i8vec4(1_i8, 3_i8, 2_i8, 1_i8));
+    assert_eq!(v.xzyy(), i8vec4(1_i8, 3_i8, 2_i8, 2_i8));
+    assert_eq!(v.xzyz(), i8vec4(1_i8, 3_i8, 2_i8, 3_i8));
+    assert_eq!(v.xzzx(), i8vec4(1_i8, 3_i8, 3_i8, 1_i8));
+    assert_eq!(v.xzzy(), i8vec4(1_i8, 3_i8, 3_i8, 2_i8));
+    assert_eq!(v.xzzz(), i8vec4(1_i8, 3_i8, 3_i8, 3_i8));
+    assert_eq!(v.yxxx(), i8vec4(2_i8, 1_i8, 1_i8, 1_i8));
+    assert_eq!(v.yxxy(), i8vec4(2_i8, 1_i8, 1_i8, 2_i8));
+    assert_eq!(v.yxxz(), i8vec4(2_i8, 1_i8, 1_i8, 3_i8));
+    assert_eq!(v.yxyx(), i8vec4(2_i8, 1_i8, 2_i8, 1_i8));
+    assert_eq!(v.yxyy(), i8vec4(2_i8, 1_i8, 2_i8, 2_i8));
+    assert_eq!(v.yxyz(), i8vec4(2_i8, 1_i8, 2_i8, 3_i8));
+    assert_eq!(v.yxzx(), i8vec4(2_i8, 1_i8, 3_i8, 1_i8));
+    assert_eq!(v.yxzy(), i8vec4(2_i8, 1_i8, 3_i8, 2_i8));
+    assert_eq!(v.yxzz(), i8vec4(2_i8, 1_i8, 3_i8, 3_i8));
+    assert_eq!(v.yyxx(), i8vec4(2_i8, 2_i8, 1_i8, 1_i8));
+    assert_eq!(v.yyxy(), i8vec4(2_i8, 2_i8, 1_i8, 2_i8));
+    assert_eq!(v.yyxz(), i8vec4(2_i8, 2_i8, 1_i8, 3_i8));
+    assert_eq!(v.yyyx(), i8vec4(2_i8, 2_i8, 2_i8, 1_i8));
+    assert_eq!(v.yyyy(), i8vec4(2_i8, 2_i8, 2_i8, 2_i8));
+    assert_eq!(v.yyyz(), i8vec4(2_i8, 2_i8, 2_i8, 3_i8));
+    assert_eq!(v.yyzx(), i8vec4(2_i8, 2_i8, 3_i8, 1_i8));
+    assert_eq!(v.yyzy(), i8vec4(2_i8, 2_i8, 3_i8, 2_i8));
+    assert_eq!(v.yyzz(), i8vec4(2_i8, 2_i8, 3_i8, 3_i8));
+    assert_eq!(v.yzxx(), i8vec4(2_i8, 3_i8, 1_i8, 1_i8));
+    assert_eq!(v.yzxy(), i8vec4(2_i8, 3_i8, 1_i8, 2_i8));
+    assert_eq!(v.yzxz(), i8vec4(2_i8, 3_i8, 1_i8, 3_i8));
+    assert_eq!(v.yzyx(), i8vec4(2_i8, 3_i8, 2_i8, 1_i8));
+    assert_eq!(v.yzyy(), i8vec4(2_i8, 3_i8, 2_i8, 2_i8));
+    assert_eq!(v.yzyz(), i8vec4(2_i8, 3_i8, 2_i8, 3_i8));
+    assert_eq!(v.yzzx(), i8vec4(2_i8, 3_i8, 3_i8, 1_i8));
+    assert_eq!(v.yzzy(), i8vec4(2_i8, 3_i8, 3_i8, 2_i8));
+    assert_eq!(v.yzzz(), i8vec4(2_i8, 3_i8, 3_i8, 3_i8));
+    assert_eq!(v.zxxx(), i8vec4(3_i8, 1_i8, 1_i8, 1_i8));
+    assert_eq!(v.zxxy(), i8vec4(3_i8, 1_i8, 1_i8, 2_i8));
+    assert_eq!(v.zxxz(), i8vec4(3_i8, 1_i8, 1_i8, 3_i8));
+    assert_eq!(v.zxyx(), i8vec4(3_i8, 1_i8, 2_i8, 1_i8));
+    assert_eq!(v.zxyy(), i8vec4(3_i8, 1_i8, 2_i8, 2_i8));
+    assert_eq!(v.zxyz(), i8vec4(3_i8, 1_i8, 2_i8, 3_i8));
+    assert_eq!(v.zxzx(), i8vec4(3_i8, 1_i8, 3_i8, 1_i8));
+    assert_eq!(v.zxzy(), i8vec4(3_i8, 1_i8, 3_i8, 2_i8));
+    assert_eq!(v.zxzz(), i8vec4(3_i8, 1_i8, 3_i8, 3_i8));
+    assert_eq!(v.zyxx(), i8vec4(3_i8, 2_i8, 1_i8, 1_i8));
+    assert_eq!(v.zyxy(), i8vec4(3_i8, 2_i8, 1_i8, 2_i8));
+    assert_eq!(v.zyxz(), i8vec4(3_i8, 2_i8, 1_i8, 3_i8));
+    assert_eq!(v.zyyx(), i8vec4(3_i8, 2_i8, 2_i8, 1_i8));
+    assert_eq!(v.zyyy(), i8vec4(3_i8, 2_i8, 2_i8, 2_i8));
+    assert_eq!(v.zyyz(), i8vec4(3_i8, 2_i8, 2_i8, 3_i8));
+    assert_eq!(v.zyzx(), i8vec4(3_i8, 2_i8, 3_i8, 1_i8));
+    assert_eq!(v.zyzy(), i8vec4(3_i8, 2_i8, 3_i8, 2_i8));
+    assert_eq!(v.zyzz(), i8vec4(3_i8, 2_i8, 3_i8, 3_i8));
+    assert_eq!(v.zzxx(), i8vec4(3_i8, 3_i8, 1_i8, 1_i8));
+    assert_eq!(v.zzxy(), i8vec4(3_i8, 3_i8, 1_i8, 2_i8));
+    assert_eq!(v.zzxz(), i8vec4(3_i8, 3_i8, 1_i8, 3_i8));
+    assert_eq!(v.zzyx(), i8vec4(3_i8, 3_i8, 2_i8, 1_i8));
+    assert_eq!(v.zzyy(), i8vec4(3_i8, 3_i8, 2_i8, 2_i8));
+    assert_eq!(v.zzyz(), i8vec4(3_i8, 3_i8, 2_i8, 3_i8));
+    assert_eq!(v.zzzx(), i8vec4(3_i8, 3_i8, 3_i8, 1_i8));
+    assert_eq!(v.zzzy(), i8vec4(3_i8, 3_i8, 3_i8, 2_i8));
+    assert_eq!(v.zzzz(), i8vec4(3_i8, 3_i8, 3_i8, 3_i8));
+    assert_eq!(v.xxx(), i8vec3(1_i8, 1_i8, 1_i8));
+    assert_eq!(v.xxy(), i8vec3(1_i8, 1_i8, 2_i8));
+    assert_eq!(v.xxz(), i8vec3(1_i8, 1_i8, 3_i8));
+    assert_eq!(v.xyx(), i8vec3(1_i8, 2_i8, 1_i8));
+    assert_eq!(v.xyy(), i8vec3(1_i8, 2_i8, 2_i8));
+    assert_eq!(v.xzx(), i8vec3(1_i8, 3_i8, 1_i8));
+    assert_eq!(v.xzy(), i8vec3(1_i8, 3_i8, 2_i8));
+    assert_eq!(v.xzz(), i8vec3(1_i8, 3_i8, 3_i8));
+    assert_eq!(v.yxx(), i8vec3(2_i8, 1_i8, 1_i8));
+    assert_eq!(v.yxy(), i8vec3(2_i8, 1_i8, 2_i8));
+    assert_eq!(v.yxz(), i8vec3(2_i8, 1_i8, 3_i8));
+    assert_eq!(v.yyx(), i8vec3(2_i8, 2_i8, 1_i8));
+    assert_eq!(v.yyy(), i8vec3(2_i8, 2_i8, 2_i8));
+    assert_eq!(v.yyz(), i8vec3(2_i8, 2_i8, 3_i8));
+    assert_eq!(v.yzx(), i8vec3(2_i8, 3_i8, 1_i8));
+    assert_eq!(v.yzy(), i8vec3(2_i8, 3_i8, 2_i8));
+    assert_eq!(v.yzz(), i8vec3(2_i8, 3_i8, 3_i8));
+    assert_eq!(v.zxx(), i8vec3(3_i8, 1_i8, 1_i8));
+    assert_eq!(v.zxy(), i8vec3(3_i8, 1_i8, 2_i8));
+    assert_eq!(v.zxz(), i8vec3(3_i8, 1_i8, 3_i8));
+    assert_eq!(v.zyx(), i8vec3(3_i8, 2_i8, 1_i8));
+    assert_eq!(v.zyy(), i8vec3(3_i8, 2_i8, 2_i8));
+    assert_eq!(v.zyz(), i8vec3(3_i8, 2_i8, 3_i8));
+    assert_eq!(v.zzx(), i8vec3(3_i8, 3_i8, 1_i8));
+    assert_eq!(v.zzy(), i8vec3(3_i8, 3_i8, 2_i8));
+    assert_eq!(v.zzz(), i8vec3(3_i8, 3_i8, 3_i8));
+    assert_eq!(v.xx(), i8vec2(1_i8, 1_i8));
+    assert_eq!(v.xy(), i8vec2(1_i8, 2_i8));
+    assert_eq!(v.xz(), i8vec2(1_i8, 3_i8));
+    assert_eq!(v.yx(), i8vec2(2_i8, 1_i8));
+    assert_eq!(v.yy(), i8vec2(2_i8, 2_i8));
+    assert_eq!(v.yz(), i8vec2(2_i8, 3_i8));
+    assert_eq!(v.zx(), i8vec2(3_i8, 1_i8));
+    assert_eq!(v.zy(), i8vec2(3_i8, 2_i8));
+    assert_eq!(v.zz(), i8vec2(3_i8, 3_i8));
+});
+
+glam_test!(test_i8vec2_swizzles, {
+    let v = i8vec2(1_i8, 2_i8);
+    assert_eq!(v, v.xy());
+    assert_eq!(v.xxxx(), i8vec4(1_i8, 1_i8, 1_i8, 1_i8));
+    assert_eq!(v.xxxy(), i8vec4(1_i8, 1_i8, 1_i8, 2_i8));
+    assert_eq!(v.xxyx(), i8vec4(1_i8, 1_i8, 2_i8, 1_i8));
+    assert_eq!(v.xxyy(), i8vec4(1_i8, 1_i8, 2_i8, 2_i8));
+    assert_eq!(v.xyxx(), i8vec4(1_i8, 2_i8, 1_i8, 1_i8));
+    assert_eq!(v.xyxy(), i8vec4(1_i8, 2_i8, 1_i8, 2_i8));
+    assert_eq!(v.xyyx(), i8vec4(1_i8, 2_i8, 2_i8, 1_i8));
+    assert_eq!(v.xyyy(), i8vec4(1_i8, 2_i8, 2_i8, 2_i8));
+    assert_eq!(v.yxxx(), i8vec4(2_i8, 1_i8, 1_i8, 1_i8));
+    assert_eq!(v.yxxy(), i8vec4(2_i8, 1_i8, 1_i8, 2_i8));
+    assert_eq!(v.yxyx(), i8vec4(2_i8, 1_i8, 2_i8, 1_i8));
+    assert_eq!(v.yxyy(), i8vec4(2_i8, 1_i8, 2_i8, 2_i8));
+    assert_eq!(v.yyxx(), i8vec4(2_i8, 2_i8, 1_i8, 1_i8));
+    assert_eq!(v.yyxy(), i8vec4(2_i8, 2_i8, 1_i8, 2_i8));
+    assert_eq!(v.yyyx(), i8vec4(2_i8, 2_i8, 2_i8, 1_i8));
+    assert_eq!(v.yyyy(), i8vec4(2_i8, 2_i8, 2_i8, 2_i8));
+    assert_eq!(v.xxx(), i8vec3(1_i8, 1_i8, 1_i8));
+    assert_eq!(v.xxy(), i8vec3(1_i8, 1_i8, 2_i8));
+    assert_eq!(v.xyx(), i8vec3(1_i8, 2_i8, 1_i8));
+    assert_eq!(v.xyy(), i8vec3(1_i8, 2_i8, 2_i8));
+    assert_eq!(v.yxx(), i8vec3(2_i8, 1_i8, 1_i8));
+    assert_eq!(v.yxy(), i8vec3(2_i8, 1_i8, 2_i8));
+    assert_eq!(v.yyx(), i8vec3(2_i8, 2_i8, 1_i8));
+    assert_eq!(v.yyy(), i8vec3(2_i8, 2_i8, 2_i8));
+    assert_eq!(v.xx(), i8vec2(1_i8, 1_i8));
+    assert_eq!(v.yx(), i8vec2(2_i8, 1_i8));
+    assert_eq!(v.yy(), i8vec2(2_i8, 2_i8));
+});

vendor/glam/tests/swizzles_u16.rs

@@ -0,0 +1,497 @@
+// Generated by swizzlegen. Do not edit.
+#[macro_use]
+mod support;
+use glam::*;
+
+glam_test!(test_u16vec4_swizzles, {
+    let v = u16vec4(1_u16, 2_u16, 3_u16, 4_u16);
+    assert_eq!(v, v.xyzw());
+    assert_eq!(v.xxxx(), u16vec4(1_u16, 1_u16, 1_u16, 1_u16));
+    assert_eq!(v.xxxy(), u16vec4(1_u16, 1_u16, 1_u16, 2_u16));
+    assert_eq!(v.xxxz(), u16vec4(1_u16, 1_u16, 1_u16, 3_u16));
+    assert_eq!(v.xxxw(), u16vec4(1_u16, 1_u16, 1_u16, 4_u16));
+    assert_eq!(v.xxyx(), u16vec4(1_u16, 1_u16, 2_u16, 1_u16));
+    assert_eq!(v.xxyy(), u16vec4(1_u16, 1_u16, 2_u16, 2_u16));
+    assert_eq!(v.xxyz(), u16vec4(1_u16, 1_u16, 2_u16, 3_u16));
+    assert_eq!(v.xxyw(), u16vec4(1_u16, 1_u16, 2_u16, 4_u16));
+    assert_eq!(v.xxzx(), u16vec4(1_u16, 1_u16, 3_u16, 1_u16));
+    assert_eq!(v.xxzy(), u16vec4(1_u16, 1_u16, 3_u16, 2_u16));
+    assert_eq!(v.xxzz(), u16vec4(1_u16, 1_u16, 3_u16, 3_u16));
+    assert_eq!(v.xxzw(), u16vec4(1_u16, 1_u16, 3_u16, 4_u16));
+    assert_eq!(v.xxwx(), u16vec4(1_u16, 1_u16, 4_u16, 1_u16));
+    assert_eq!(v.xxwy(), u16vec4(1_u16, 1_u16, 4_u16, 2_u16));
+    assert_eq!(v.xxwz(), u16vec4(1_u16, 1_u16, 4_u16, 3_u16));
+    assert_eq!(v.xxww(), u16vec4(1_u16, 1_u16, 4_u16, 4_u16));
+    assert_eq!(v.xyxx(), u16vec4(1_u16, 2_u16, 1_u16, 1_u16));
+    assert_eq!(v.xyxy(), u16vec4(1_u16, 2_u16, 1_u16, 2_u16));
+    assert_eq!(v.xyxz(), u16vec4(1_u16, 2_u16, 1_u16, 3_u16));
+    assert_eq!(v.xyxw(), u16vec4(1_u16, 2_u16, 1_u16, 4_u16));
+    assert_eq!(v.xyyx(), u16vec4(1_u16, 2_u16, 2_u16, 1_u16));
+    assert_eq!(v.xyyy(), u16vec4(1_u16, 2_u16, 2_u16, 2_u16));
+    assert_eq!(v.xyyz(), u16vec4(1_u16, 2_u16, 2_u16, 3_u16));
+    assert_eq!(v.xyyw(), u16vec4(1_u16, 2_u16, 2_u16, 4_u16));
+    assert_eq!(v.xyzx(), u16vec4(1_u16, 2_u16, 3_u16, 1_u16));
+    assert_eq!(v.xyzy(), u16vec4(1_u16, 2_u16, 3_u16, 2_u16));
+    assert_eq!(v.xyzz(), u16vec4(1_u16, 2_u16, 3_u16, 3_u16));
+    assert_eq!(v.xywx(), u16vec4(1_u16, 2_u16, 4_u16, 1_u16));
+    assert_eq!(v.xywy(), u16vec4(1_u16, 2_u16, 4_u16, 2_u16));
+    assert_eq!(v.xywz(), u16vec4(1_u16, 2_u16, 4_u16, 3_u16));
+    assert_eq!(v.xyww(), u16vec4(1_u16, 2_u16, 4_u16, 4_u16));
+    assert_eq!(v.xzxx(), u16vec4(1_u16, 3_u16, 1_u16, 1_u16));
+    assert_eq!(v.xzxy(), u16vec4(1_u16, 3_u16, 1_u16, 2_u16));
+    assert_eq!(v.xzxz(), u16vec4(1_u16, 3_u16, 1_u16, 3_u16));
+    assert_eq!(v.xzxw(), u16vec4(1_u16, 3_u16, 1_u16, 4_u16));
+    assert_eq!(v.xzyx(), u16vec4(1_u16, 3_u16, 2_u16, 1_u16));
+    assert_eq!(v.xzyy(), u16vec4(1_u16, 3_u16, 2_u16, 2_u16));
+    assert_eq!(v.xzyz(), u16vec4(1_u16, 3_u16, 2_u16, 3_u16));
+    assert_eq!(v.xzyw(), u16vec4(1_u16, 3_u16, 2_u16, 4_u16));
+    assert_eq!(v.xzzx(), u16vec4(1_u16, 3_u16, 3_u16, 1_u16));
+    assert_eq!(v.xzzy(), u16vec4(1_u16, 3_u16, 3_u16, 2_u16));
+    assert_eq!(v.xzzz(), u16vec4(1_u16, 3_u16, 3_u16, 3_u16));
+    assert_eq!(v.xzzw(), u16vec4(1_u16, 3_u16, 3_u16, 4_u16));
+    assert_eq!(v.xzwx(), u16vec4(1_u16, 3_u16, 4_u16, 1_u16));
+    assert_eq!(v.xzwy(), u16vec4(1_u16, 3_u16, 4_u16, 2_u16));
+    assert_eq!(v.xzwz(), u16vec4(1_u16, 3_u16, 4_u16, 3_u16));
+    assert_eq!(v.xzww(), u16vec4(1_u16, 3_u16, 4_u16, 4_u16));
+    assert_eq!(v.xwxx(), u16vec4(1_u16, 4_u16, 1_u16, 1_u16));
+    assert_eq!(v.xwxy(), u16vec4(1_u16, 4_u16, 1_u16, 2_u16));
+    assert_eq!(v.xwxz(), u16vec4(1_u16, 4_u16, 1_u16, 3_u16));
+    assert_eq!(v.xwxw(), u16vec4(1_u16, 4_u16, 1_u16, 4_u16));
+    assert_eq!(v.xwyx(), u16vec4(1_u16, 4_u16, 2_u16, 1_u16));
+    assert_eq!(v.xwyy(), u16vec4(1_u16, 4_u16, 2_u16, 2_u16));
+    assert_eq!(v.xwyz(), u16vec4(1_u16, 4_u16, 2_u16, 3_u16));
+    assert_eq!(v.xwyw(), u16vec4(1_u16, 4_u16, 2_u16, 4_u16));
+    assert_eq!(v.xwzx(), u16vec4(1_u16, 4_u16, 3_u16, 1_u16));
+    assert_eq!(v.xwzy(), u16vec4(1_u16, 4_u16, 3_u16, 2_u16));
+    assert_eq!(v.xwzz(), u16vec4(1_u16, 4_u16, 3_u16, 3_u16));
+    assert_eq!(v.xwzw(), u16vec4(1_u16, 4_u16, 3_u16, 4_u16));
+    assert_eq!(v.xwwx(), u16vec4(1_u16, 4_u16, 4_u16, 1_u16));
+    assert_eq!(v.xwwy(), u16vec4(1_u16, 4_u16, 4_u16, 2_u16));
+    assert_eq!(v.xwwz(), u16vec4(1_u16, 4_u16, 4_u16, 3_u16));
+    assert_eq!(v.xwww(), u16vec4(1_u16, 4_u16, 4_u16, 4_u16));
+    assert_eq!(v.yxxx(), u16vec4(2_u16, 1_u16, 1_u16, 1_u16));
+    assert_eq!(v.yxxy(), u16vec4(2_u16, 1_u16, 1_u16, 2_u16));
+    assert_eq!(v.yxxz(), u16vec4(2_u16, 1_u16, 1_u16, 3_u16));
+    assert_eq!(v.yxxw(), u16vec4(2_u16, 1_u16, 1_u16, 4_u16));
+    assert_eq!(v.yxyx(), u16vec4(2_u16, 1_u16, 2_u16, 1_u16));
+    assert_eq!(v.yxyy(), u16vec4(2_u16, 1_u16, 2_u16, 2_u16));
+    assert_eq!(v.yxyz(), u16vec4(2_u16, 1_u16, 2_u16, 3_u16));
+    assert_eq!(v.yxyw(), u16vec4(2_u16, 1_u16, 2_u16, 4_u16));
+    assert_eq!(v.yxzx(), u16vec4(2_u16, 1_u16, 3_u16, 1_u16));
+    assert_eq!(v.yxzy(), u16vec4(2_u16, 1_u16, 3_u16, 2_u16));
+    assert_eq!(v.yxzz(), u16vec4(2_u16, 1_u16, 3_u16, 3_u16));
+    assert_eq!(v.yxzw(), u16vec4(2_u16, 1_u16, 3_u16, 4_u16));
+    assert_eq!(v.yxwx(), u16vec4(2_u16, 1_u16, 4_u16, 1_u16));
+    assert_eq!(v.yxwy(), u16vec4(2_u16, 1_u16, 4_u16, 2_u16));
+    assert_eq!(v.yxwz(), u16vec4(2_u16, 1_u16, 4_u16, 3_u16));
+    assert_eq!(v.yxww(), u16vec4(2_u16, 1_u16, 4_u16, 4_u16));
+    assert_eq!(v.yyxx(), u16vec4(2_u16, 2_u16, 1_u16, 1_u16));
+    assert_eq!(v.yyxy(), u16vec4(2_u16, 2_u16, 1_u16, 2_u16));
+    assert_eq!(v.yyxz(), u16vec4(2_u16, 2_u16, 1_u16, 3_u16));
+    assert_eq!(v.yyxw(), u16vec4(2_u16, 2_u16, 1_u16, 4_u16));
+    assert_eq!(v.yyyx(), u16vec4(2_u16, 2_u16, 2_u16, 1_u16));
+    assert_eq!(v.yyyy(), u16vec4(2_u16, 2_u16, 2_u16, 2_u16));
+    assert_eq!(v.yyyz(), u16vec4(2_u16, 2_u16, 2_u16, 3_u16));
+    assert_eq!(v.yyyw(), u16vec4(2_u16, 2_u16, 2_u16, 4_u16));
+    assert_eq!(v.yyzx(), u16vec4(2_u16, 2_u16, 3_u16, 1_u16));
+    assert_eq!(v.yyzy(), u16vec4(2_u16, 2_u16, 3_u16, 2_u16));
+    assert_eq!(v.yyzz(), u16vec4(2_u16, 2_u16, 3_u16, 3_u16));
+    assert_eq!(v.yyzw(), u16vec4(2_u16, 2_u16, 3_u16, 4_u16));
+    assert_eq!(v.yywx(), u16vec4(2_u16, 2_u16, 4_u16, 1_u16));
+    assert_eq!(v.yywy(), u16vec4(2_u16, 2_u16, 4_u16, 2_u16));
+    assert_eq!(v.yywz(), u16vec4(2_u16, 2_u16, 4_u16, 3_u16));
+    assert_eq!(v.yyww(), u16vec4(2_u16, 2_u16, 4_u16, 4_u16));
+    assert_eq!(v.yzxx(), u16vec4(2_u16, 3_u16, 1_u16, 1_u16));
+    assert_eq!(v.yzxy(), u16vec4(2_u16, 3_u16, 1_u16, 2_u16));
+    assert_eq!(v.yzxz(), u16vec4(2_u16, 3_u16, 1_u16, 3_u16));
+    assert_eq!(v.yzxw(), u16vec4(2_u16, 3_u16, 1_u16, 4_u16));
+    assert_eq!(v.yzyx(), u16vec4(2_u16, 3_u16, 2_u16, 1_u16));
+    assert_eq!(v.yzyy(), u16vec4(2_u16, 3_u16, 2_u16, 2_u16));
+    assert_eq!(v.yzyz(), u16vec4(2_u16, 3_u16, 2_u16, 3_u16));
+    assert_eq!(v.yzyw(), u16vec4(2_u16, 3_u16, 2_u16, 4_u16));
+    assert_eq!(v.yzzx(), u16vec4(2_u16, 3_u16, 3_u16, 1_u16));
+    assert_eq!(v.yzzy(), u16vec4(2_u16, 3_u16, 3_u16, 2_u16));
+    assert_eq!(v.yzzz(), u16vec4(2_u16, 3_u16, 3_u16, 3_u16));
+    assert_eq!(v.yzzw(), u16vec4(2_u16, 3_u16, 3_u16, 4_u16));
+    assert_eq!(v.yzwx(), u16vec4(2_u16, 3_u16, 4_u16, 1_u16));
+    assert_eq!(v.yzwy(), u16vec4(2_u16, 3_u16, 4_u16, 2_u16));
+    assert_eq!(v.yzwz(), u16vec4(2_u16, 3_u16, 4_u16, 3_u16));
+    assert_eq!(v.yzww(), u16vec4(2_u16, 3_u16, 4_u16, 4_u16));
+    assert_eq!(v.ywxx(), u16vec4(2_u16, 4_u16, 1_u16, 1_u16));
+    assert_eq!(v.ywxy(), u16vec4(2_u16, 4_u16, 1_u16, 2_u16));
+    assert_eq!(v.ywxz(), u16vec4(2_u16, 4_u16, 1_u16, 3_u16));
+    assert_eq!(v.ywxw(), u16vec4(2_u16, 4_u16, 1_u16, 4_u16));
+    assert_eq!(v.ywyx(), u16vec4(2_u16, 4_u16, 2_u16, 1_u16));
+    assert_eq!(v.ywyy(), u16vec4(2_u16, 4_u16, 2_u16, 2_u16));
+    assert_eq!(v.ywyz(), u16vec4(2_u16, 4_u16, 2_u16, 3_u16));
+    assert_eq!(v.ywyw(), u16vec4(2_u16, 4_u16, 2_u16, 4_u16));
+    assert_eq!(v.ywzx(), u16vec4(2_u16, 4_u16, 3_u16, 1_u16));
+    assert_eq!(v.ywzy(), u16vec4(2_u16, 4_u16, 3_u16, 2_u16));
+    assert_eq!(v.ywzz(), u16vec4(2_u16, 4_u16, 3_u16, 3_u16));
+    assert_eq!(v.ywzw(), u16vec4(2_u16, 4_u16, 3_u16, 4_u16));
+    assert_eq!(v.ywwx(), u16vec4(2_u16, 4_u16, 4_u16, 1_u16));
+    assert_eq!(v.ywwy(), u16vec4(2_u16, 4_u16, 4_u16, 2_u16));
+    assert_eq!(v.ywwz(), u16vec4(2_u16, 4_u16, 4_u16, 3_u16));
+    assert_eq!(v.ywww(), u16vec4(2_u16, 4_u16, 4_u16, 4_u16));
+    assert_eq!(v.zxxx(), u16vec4(3_u16, 1_u16, 1_u16, 1_u16));
+    assert_eq!(v.zxxy(), u16vec4(3_u16, 1_u16, 1_u16, 2_u16));
+    assert_eq!(v.zxxz(), u16vec4(3_u16, 1_u16, 1_u16, 3_u16));
+    assert_eq!(v.zxxw(), u16vec4(3_u16, 1_u16, 1_u16, 4_u16));
+    assert_eq!(v.zxyx(), u16vec4(3_u16, 1_u16, 2_u16, 1_u16));
+    assert_eq!(v.zxyy(), u16vec4(3_u16, 1_u16, 2_u16, 2_u16));
+    assert_eq!(v.zxyz(), u16vec4(3_u16, 1_u16, 2_u16, 3_u16));
+    assert_eq!(v.zxyw(), u16vec4(3_u16, 1_u16, 2_u16, 4_u16));
+    assert_eq!(v.zxzx(), u16vec4(3_u16, 1_u16, 3_u16, 1_u16));
+    assert_eq!(v.zxzy(), u16vec4(3_u16, 1_u16, 3_u16, 2_u16));
+    assert_eq!(v.zxzz(), u16vec4(3_u16, 1_u16, 3_u16, 3_u16));
+    assert_eq!(v.zxzw(), u16vec4(3_u16, 1_u16, 3_u16, 4_u16));
+    assert_eq!(v.zxwx(), u16vec4(3_u16, 1_u16, 4_u16, 1_u16));
+    assert_eq!(v.zxwy(), u16vec4(3_u16, 1_u16, 4_u16, 2_u16));
+    assert_eq!(v.zxwz(), u16vec4(3_u16, 1_u16, 4_u16, 3_u16));
+    assert_eq!(v.zxww(), u16vec4(3_u16, 1_u16, 4_u16, 4_u16));
+    assert_eq!(v.zyxx(), u16vec4(3_u16, 2_u16, 1_u16, 1_u16));
+    assert_eq!(v.zyxy(), u16vec4(3_u16, 2_u16, 1_u16, 2_u16));
+    assert_eq!(v.zyxz(), u16vec4(3_u16, 2_u16, 1_u16, 3_u16));
+    assert_eq!(v.zyxw(), u16vec4(3_u16, 2_u16, 1_u16, 4_u16));
+    assert_eq!(v.zyyx(), u16vec4(3_u16, 2_u16, 2_u16, 1_u16));
+    assert_eq!(v.zyyy(), u16vec4(3_u16, 2_u16, 2_u16, 2_u16));
+    assert_eq!(v.zyyz(), u16vec4(3_u16, 2_u16, 2_u16, 3_u16));
+    assert_eq!(v.zyyw(), u16vec4(3_u16, 2_u16, 2_u16, 4_u16));
+    assert_eq!(v.zyzx(), u16vec4(3_u16, 2_u16, 3_u16, 1_u16));
+    assert_eq!(v.zyzy(), u16vec4(3_u16, 2_u16, 3_u16, 2_u16));
+    assert_eq!(v.zyzz(), u16vec4(3_u16, 2_u16, 3_u16, 3_u16));
+    assert_eq!(v.zyzw(), u16vec4(3_u16, 2_u16, 3_u16, 4_u16));
+    assert_eq!(v.zywx(), u16vec4(3_u16, 2_u16, 4_u16, 1_u16));
+    assert_eq!(v.zywy(), u16vec4(3_u16, 2_u16, 4_u16, 2_u16));
+    assert_eq!(v.zywz(), u16vec4(3_u16, 2_u16, 4_u16, 3_u16));
+    assert_eq!(v.zyww(), u16vec4(3_u16, 2_u16, 4_u16, 4_u16));
+    assert_eq!(v.zzxx(), u16vec4(3_u16, 3_u16, 1_u16, 1_u16));
+    assert_eq!(v.zzxy(), u16vec4(3_u16, 3_u16, 1_u16, 2_u16));
+    assert_eq!(v.zzxz(), u16vec4(3_u16, 3_u16, 1_u16, 3_u16));
+    assert_eq!(v.zzxw(), u16vec4(3_u16, 3_u16, 1_u16, 4_u16));
+    assert_eq!(v.zzyx(), u16vec4(3_u16, 3_u16, 2_u16, 1_u16));
+    assert_eq!(v.zzyy(), u16vec4(3_u16, 3_u16, 2_u16, 2_u16));
+    assert_eq!(v.zzyz(), u16vec4(3_u16, 3_u16, 2_u16, 3_u16));
+    assert_eq!(v.zzyw(), u16vec4(3_u16, 3_u16, 2_u16, 4_u16));
+    assert_eq!(v.zzzx(), u16vec4(3_u16, 3_u16, 3_u16, 1_u16));
+    assert_eq!(v.zzzy(), u16vec4(3_u16, 3_u16, 3_u16, 2_u16));
+    assert_eq!(v.zzzz(), u16vec4(3_u16, 3_u16, 3_u16, 3_u16));
+    assert_eq!(v.zzzw(), u16vec4(3_u16, 3_u16, 3_u16, 4_u16));
+    assert_eq!(v.zzwx(), u16vec4(3_u16, 3_u16, 4_u16, 1_u16));
+    assert_eq!(v.zzwy(), u16vec4(3_u16, 3_u16, 4_u16, 2_u16));
+    assert_eq!(v.zzwz(), u16vec4(3_u16, 3_u16, 4_u16, 3_u16));
+    assert_eq!(v.zzww(), u16vec4(3_u16, 3_u16, 4_u16, 4_u16));
+    assert_eq!(v.zwxx(), u16vec4(3_u16, 4_u16, 1_u16, 1_u16));
+    assert_eq!(v.zwxy(), u16vec4(3_u16, 4_u16, 1_u16, 2_u16));
+    assert_eq!(v.zwxz(), u16vec4(3_u16, 4_u16, 1_u16, 3_u16));
+    assert_eq!(v.zwxw(), u16vec4(3_u16, 4_u16, 1_u16, 4_u16));
+    assert_eq!(v.zwyx(), u16vec4(3_u16, 4_u16, 2_u16, 1_u16));
+    assert_eq!(v.zwyy(), u16vec4(3_u16, 4_u16, 2_u16, 2_u16));
+    assert_eq!(v.zwyz(), u16vec4(3_u16, 4_u16, 2_u16, 3_u16));
+    assert_eq!(v.zwyw(), u16vec4(3_u16, 4_u16, 2_u16, 4_u16));
+    assert_eq!(v.zwzx(), u16vec4(3_u16, 4_u16, 3_u16, 1_u16));
+    assert_eq!(v.zwzy(), u16vec4(3_u16, 4_u16, 3_u16, 2_u16));
+    assert_eq!(v.zwzz(), u16vec4(3_u16, 4_u16, 3_u16, 3_u16));
+    assert_eq!(v.zwzw(), u16vec4(3_u16, 4_u16, 3_u16, 4_u16));
+    assert_eq!(v.zwwx(), u16vec4(3_u16, 4_u16, 4_u16, 1_u16));
+    assert_eq!(v.zwwy(), u16vec4(3_u16, 4_u16, 4_u16, 2_u16));
+    assert_eq!(v.zwwz(), u16vec4(3_u16, 4_u16, 4_u16, 3_u16));
+    assert_eq!(v.zwww(), u16vec4(3_u16, 4_u16, 4_u16, 4_u16));
+    assert_eq!(v.wxxx(), u16vec4(4_u16, 1_u16, 1_u16, 1_u16));
+    assert_eq!(v.wxxy(), u16vec4(4_u16, 1_u16, 1_u16, 2_u16));
+    assert_eq!(v.wxxz(), u16vec4(4_u16, 1_u16, 1_u16, 3_u16));
+    assert_eq!(v.wxxw(), u16vec4(4_u16, 1_u16, 1_u16, 4_u16));
+    assert_eq!(v.wxyx(), u16vec4(4_u16, 1_u16, 2_u16, 1_u16));
+    assert_eq!(v.wxyy(), u16vec4(4_u16, 1_u16, 2_u16, 2_u16));
+    assert_eq!(v.wxyz(), u16vec4(4_u16, 1_u16, 2_u16, 3_u16));
+    assert_eq!(v.wxyw(), u16vec4(4_u16, 1_u16, 2_u16, 4_u16));
+    assert_eq!(v.wxzx(), u16vec4(4_u16, 1_u16, 3_u16, 1_u16));
+    assert_eq!(v.wxzy(), u16vec4(4_u16, 1_u16, 3_u16, 2_u16));
+    assert_eq!(v.wxzz(), u16vec4(4_u16, 1_u16, 3_u16, 3_u16));
+    assert_eq!(v.wxzw(), u16vec4(4_u16, 1_u16, 3_u16, 4_u16));
+    assert_eq!(v.wxwx(), u16vec4(4_u16, 1_u16, 4_u16, 1_u16));
+    assert_eq!(v.wxwy(), u16vec4(4_u16, 1_u16, 4_u16, 2_u16));
+    assert_eq!(v.wxwz(), u16vec4(4_u16, 1_u16, 4_u16, 3_u16));
+    assert_eq!(v.wxww(), u16vec4(4_u16, 1_u16, 4_u16, 4_u16));
+    assert_eq!(v.wyxx(), u16vec4(4_u16, 2_u16, 1_u16, 1_u16));
+    assert_eq!(v.wyxy(), u16vec4(4_u16, 2_u16, 1_u16, 2_u16));
+    assert_eq!(v.wyxz(), u16vec4(4_u16, 2_u16, 1_u16, 3_u16));
+    assert_eq!(v.wyxw(), u16vec4(4_u16, 2_u16, 1_u16, 4_u16));
+    assert_eq!(v.wyyx(), u16vec4(4_u16, 2_u16, 2_u16, 1_u16));
+    assert_eq!(v.wyyy(), u16vec4(4_u16, 2_u16, 2_u16, 2_u16));
+    assert_eq!(v.wyyz(), u16vec4(4_u16, 2_u16, 2_u16, 3_u16));
+    assert_eq!(v.wyyw(), u16vec4(4_u16, 2_u16, 2_u16, 4_u16));
+    assert_eq!(v.wyzx(), u16vec4(4_u16, 2_u16, 3_u16, 1_u16));
+    assert_eq!(v.wyzy(), u16vec4(4_u16, 2_u16, 3_u16, 2_u16));
+    assert_eq!(v.wyzz(), u16vec4(4_u16, 2_u16, 3_u16, 3_u16));
+    assert_eq!(v.wyzw(), u16vec4(4_u16, 2_u16, 3_u16, 4_u16));
+    assert_eq!(v.wywx(), u16vec4(4_u16, 2_u16, 4_u16, 1_u16));
+    assert_eq!(v.wywy(), u16vec4(4_u16, 2_u16, 4_u16, 2_u16));
+    assert_eq!(v.wywz(), u16vec4(4_u16, 2_u16, 4_u16, 3_u16));
+    assert_eq!(v.wyww(), u16vec4(4_u16, 2_u16, 4_u16, 4_u16));
+    assert_eq!(v.wzxx(), u16vec4(4_u16, 3_u16, 1_u16, 1_u16));
+    assert_eq!(v.wzxy(), u16vec4(4_u16, 3_u16, 1_u16, 2_u16));
+    assert_eq!(v.wzxz(), u16vec4(4_u16, 3_u16, 1_u16, 3_u16));
+    assert_eq!(v.wzxw(), u16vec4(4_u16, 3_u16, 1_u16, 4_u16));
+    assert_eq!(v.wzyx(), u16vec4(4_u16, 3_u16, 2_u16, 1_u16));
+    assert_eq!(v.wzyy(), u16vec4(4_u16, 3_u16, 2_u16, 2_u16));
+    assert_eq!(v.wzyz(), u16vec4(4_u16, 3_u16, 2_u16, 3_u16));
+    assert_eq!(v.wzyw(), u16vec4(4_u16, 3_u16, 2_u16, 4_u16));
+    assert_eq!(v.wzzx(), u16vec4(4_u16, 3_u16, 3_u16, 1_u16));
+    assert_eq!(v.wzzy(), u16vec4(4_u16, 3_u16, 3_u16, 2_u16));
+    assert_eq!(v.wzzz(), u16vec4(4_u16, 3_u16, 3_u16, 3_u16));
+    assert_eq!(v.wzzw(), u16vec4(4_u16, 3_u16, 3_u16, 4_u16));
+    assert_eq!(v.wzwx(), u16vec4(4_u16, 3_u16, 4_u16, 1_u16));
+    assert_eq!(v.wzwy(), u16vec4(4_u16, 3_u16, 4_u16, 2_u16));
+    assert_eq!(v.wzwz(), u16vec4(4_u16, 3_u16, 4_u16, 3_u16));
+    assert_eq!(v.wzww(), u16vec4(4_u16, 3_u16, 4_u16, 4_u16));
+    assert_eq!(v.wwxx(), u16vec4(4_u16, 4_u16, 1_u16, 1_u16));
+    assert_eq!(v.wwxy(), u16vec4(4_u16, 4_u16, 1_u16, 2_u16));
+    assert_eq!(v.wwxz(), u16vec4(4_u16, 4_u16, 1_u16, 3_u16));
+    assert_eq!(v.wwxw(), u16vec4(4_u16, 4_u16, 1_u16, 4_u16));
+    assert_eq!(v.wwyx(), u16vec4(4_u16, 4_u16, 2_u16, 1_u16));
+    assert_eq!(v.wwyy(), u16vec4(4_u16, 4_u16, 2_u16, 2_u16));
+    assert_eq!(v.wwyz(), u16vec4(4_u16, 4_u16, 2_u16, 3_u16));
+    assert_eq!(v.wwyw(), u16vec4(4_u16, 4_u16, 2_u16, 4_u16));
+    assert_eq!(v.wwzx(), u16vec4(4_u16, 4_u16, 3_u16, 1_u16));
+    assert_eq!(v.wwzy(), u16vec4(4_u16, 4_u16, 3_u16, 2_u16));
+    assert_eq!(v.wwzz(), u16vec4(4_u16, 4_u16, 3_u16, 3_u16));
+    assert_eq!(v.wwzw(), u16vec4(4_u16, 4_u16, 3_u16, 4_u16));
+    assert_eq!(v.wwwx(), u16vec4(4_u16, 4_u16, 4_u16, 1_u16));
+    assert_eq!(v.wwwy(), u16vec4(4_u16, 4_u16, 4_u16, 2_u16));
+    assert_eq!(v.wwwz(), u16vec4(4_u16, 4_u16, 4_u16, 3_u16));
+    assert_eq!(v.wwww(), u16vec4(4_u16, 4_u16, 4_u16, 4_u16));
+    assert_eq!(v.xxx(), u16vec3(1_u16, 1_u16, 1_u16));
+    assert_eq!(v.xxy(), u16vec3(1_u16, 1_u16, 2_u16));
+    assert_eq!(v.xxz(), u16vec3(1_u16, 1_u16, 3_u16));
+    assert_eq!(v.xxw(), u16vec3(1_u16, 1_u16, 4_u16));
+    assert_eq!(v.xyx(), u16vec3(1_u16, 2_u16, 1_u16));
+    assert_eq!(v.xyy(), u16vec3(1_u16, 2_u16, 2_u16));
+    assert_eq!(v.xyz(), u16vec3(1_u16, 2_u16, 3_u16));
+    assert_eq!(v.xyw(), u16vec3(1_u16, 2_u16, 4_u16));
+    assert_eq!(v.xzx(), u16vec3(1_u16, 3_u16, 1_u16));
+    assert_eq!(v.xzy(), u16vec3(1_u16, 3_u16, 2_u16));
+    assert_eq!(v.xzz(), u16vec3(1_u16, 3_u16, 3_u16));
+    assert_eq!(v.xzw(), u16vec3(1_u16, 3_u16, 4_u16));
+    assert_eq!(v.xwx(), u16vec3(1_u16, 4_u16, 1_u16));
+    assert_eq!(v.xwy(), u16vec3(1_u16, 4_u16, 2_u16));
+    assert_eq!(v.xwz(), u16vec3(1_u16, 4_u16, 3_u16));
+    assert_eq!(v.xww(), u16vec3(1_u16, 4_u16, 4_u16));
+    assert_eq!(v.yxx(), u16vec3(2_u16, 1_u16, 1_u16));
+    assert_eq!(v.yxy(), u16vec3(2_u16, 1_u16, 2_u16));
+    assert_eq!(v.yxz(), u16vec3(2_u16, 1_u16, 3_u16));
+    assert_eq!(v.yxw(), u16vec3(2_u16, 1_u16, 4_u16));
+    assert_eq!(v.yyx(), u16vec3(2_u16, 2_u16, 1_u16));
+    assert_eq!(v.yyy(), u16vec3(2_u16, 2_u16, 2_u16));
+    assert_eq!(v.yyz(), u16vec3(2_u16, 2_u16, 3_u16));
+    assert_eq!(v.yyw(), u16vec3(2_u16, 2_u16, 4_u16));
+    assert_eq!(v.yzx(), u16vec3(2_u16, 3_u16, 1_u16));
+    assert_eq!(v.yzy(), u16vec3(2_u16, 3_u16, 2_u16));
+    assert_eq!(v.yzz(), u16vec3(2_u16, 3_u16, 3_u16));
+    assert_eq!(v.yzw(), u16vec3(2_u16, 3_u16, 4_u16));
+    assert_eq!(v.ywx(), u16vec3(2_u16, 4_u16, 1_u16));
+    assert_eq!(v.ywy(), u16vec3(2_u16, 4_u16, 2_u16));
+    assert_eq!(v.ywz(), u16vec3(2_u16, 4_u16, 3_u16));
+    assert_eq!(v.yww(), u16vec3(2_u16, 4_u16, 4_u16));
+    assert_eq!(v.zxx(), u16vec3(3_u16, 1_u16, 1_u16));
+    assert_eq!(v.zxy(), u16vec3(3_u16, 1_u16, 2_u16));
+    assert_eq!(v.zxz(), u16vec3(3_u16, 1_u16, 3_u16));
+    assert_eq!(v.zxw(), u16vec3(3_u16, 1_u16, 4_u16));
+    assert_eq!(v.zyx(), u16vec3(3_u16, 2_u16, 1_u16));
+    assert_eq!(v.zyy(), u16vec3(3_u16, 2_u16, 2_u16));
+    assert_eq!(v.zyz(), u16vec3(3_u16, 2_u16, 3_u16));
+    assert_eq!(v.zyw(), u16vec3(3_u16, 2_u16, 4_u16));
+    assert_eq!(v.zzx(), u16vec3(3_u16, 3_u16, 1_u16));
+    assert_eq!(v.zzy(), u16vec3(3_u16, 3_u16, 2_u16));
+    assert_eq!(v.zzz(), u16vec3(3_u16, 3_u16, 3_u16));
+    assert_eq!(v.zzw(), u16vec3(3_u16, 3_u16, 4_u16));
+    assert_eq!(v.zwx(), u16vec3(3_u16, 4_u16, 1_u16));
+    assert_eq!(v.zwy(), u16vec3(3_u16, 4_u16, 2_u16));
+    assert_eq!(v.zwz(), u16vec3(3_u16, 4_u16, 3_u16));
+    assert_eq!(v.zww(), u16vec3(3_u16, 4_u16, 4_u16));
+    assert_eq!(v.wxx(), u16vec3(4_u16, 1_u16, 1_u16));
+    assert_eq!(v.wxy(), u16vec3(4_u16, 1_u16, 2_u16));
+    assert_eq!(v.wxz(), u16vec3(4_u16, 1_u16, 3_u16));
+    assert_eq!(v.wxw(), u16vec3(4_u16, 1_u16, 4_u16));
+    assert_eq!(v.wyx(), u16vec3(4_u16, 2_u16, 1_u16));
+    assert_eq!(v.wyy(), u16vec3(4_u16, 2_u16, 2_u16));
+    assert_eq!(v.wyz(), u16vec3(4_u16, 2_u16, 3_u16));
+    assert_eq!(v.wyw(), u16vec3(4_u16, 2_u16, 4_u16));
+    assert_eq!(v.wzx(), u16vec3(4_u16, 3_u16, 1_u16));
+    assert_eq!(v.wzy(), u16vec3(4_u16, 3_u16, 2_u16));
+    assert_eq!(v.wzz(), u16vec3(4_u16, 3_u16, 3_u16));
+    assert_eq!(v.wzw(), u16vec3(4_u16, 3_u16, 4_u16));
+    assert_eq!(v.wwx(), u16vec3(4_u16, 4_u16, 1_u16));
+    assert_eq!(v.wwy(), u16vec3(4_u16, 4_u16, 2_u16));
+    assert_eq!(v.wwz(), u16vec3(4_u16, 4_u16, 3_u16));
+    assert_eq!(v.www(), u16vec3(4_u16, 4_u16, 4_u16));
+    assert_eq!(v.xx(), u16vec2(1_u16, 1_u16));
+    assert_eq!(v.xy(), u16vec2(1_u16, 2_u16));
+    assert_eq!(v.xz(), u16vec2(1_u16, 3_u16));
+    assert_eq!(v.xw(), u16vec2(1_u16, 4_u16));
+    assert_eq!(v.yx(), u16vec2(2_u16, 1_u16));
+    assert_eq!(v.yy(), u16vec2(2_u16, 2_u16));
+    assert_eq!(v.yz(), u16vec2(2_u16, 3_u16));
+    assert_eq!(v.yw(), u16vec2(2_u16, 4_u16));
+    assert_eq!(v.zx(), u16vec2(3_u16, 1_u16));
+    assert_eq!(v.zy(), u16vec2(3_u16, 2_u16));
+    assert_eq!(v.zz(), u16vec2(3_u16, 3_u16));
+    assert_eq!(v.zw(), u16vec2(3_u16, 4_u16));
+    assert_eq!(v.wx(), u16vec2(4_u16, 1_u16));
+    assert_eq!(v.wy(), u16vec2(4_u16, 2_u16));
+    assert_eq!(v.wz(), u16vec2(4_u16, 3_u16));
+    assert_eq!(v.ww(), u16vec2(4_u16, 4_u16));
+});
+
+glam_test!(test_u16vec3_swizzles, {
+    let v = u16vec3(1_u16, 2_u16, 3_u16);
+    assert_eq!(v, v.xyz());
+    assert_eq!(v.xxxx(), u16vec4(1_u16, 1_u16, 1_u16, 1_u16));
+    assert_eq!(v.xxxy(), u16vec4(1_u16, 1_u16, 1_u16, 2_u16));
+    assert_eq!(v.xxxz(), u16vec4(1_u16, 1_u16, 1_u16, 3_u16));
+    assert_eq!(v.xxyx(), u16vec4(1_u16, 1_u16, 2_u16, 1_u16));
+    assert_eq!(v.xxyy(), u16vec4(1_u16, 1_u16, 2_u16, 2_u16));
+    assert_eq!(v.xxyz(), u16vec4(1_u16, 1_u16, 2_u16, 3_u16));
+    assert_eq!(v.xxzx(), u16vec4(1_u16, 1_u16, 3_u16, 1_u16));
+    assert_eq!(v.xxzy(), u16vec4(1_u16, 1_u16, 3_u16, 2_u16));
+    assert_eq!(v.xxzz(), u16vec4(1_u16, 1_u16, 3_u16, 3_u16));
+    assert_eq!(v.xyxx(), u16vec4(1_u16, 2_u16, 1_u16, 1_u16));
+    assert_eq!(v.xyxy(), u16vec4(1_u16, 2_u16, 1_u16, 2_u16));
+    assert_eq!(v.xyxz(), u16vec4(1_u16, 2_u16, 1_u16, 3_u16));
+    assert_eq!(v.xyyx(), u16vec4(1_u16, 2_u16, 2_u16, 1_u16));
+    assert_eq!(v.xyyy(), u16vec4(1_u16, 2_u16, 2_u16, 2_u16));
+    assert_eq!(v.xyyz(), u16vec4(1_u16, 2_u16, 2_u16, 3_u16));
+    assert_eq!(v.xyzx(), u16vec4(1_u16, 2_u16, 3_u16, 1_u16));
+    assert_eq!(v.xyzy(), u16vec4(1_u16, 2_u16, 3_u16, 2_u16));
+    assert_eq!(v.xyzz(), u16vec4(1_u16, 2_u16, 3_u16, 3_u16));
+    assert_eq!(v.xzxx(), u16vec4(1_u16, 3_u16, 1_u16, 1_u16));
+    assert_eq!(v.xzxy(), u16vec4(1_u16, 3_u16, 1_u16, 2_u16));
+    assert_eq!(v.xzxz(), u16vec4(1_u16, 3_u16, 1_u16, 3_u16));
+    assert_eq!(v.xzyx(), u16vec4(1_u16, 3_u16, 2_u16, 1_u16));
+    assert_eq!(v.xzyy(), u16vec4(1_u16, 3_u16, 2_u16, 2_u16));
+    assert_eq!(v.xzyz(), u16vec4(1_u16, 3_u16, 2_u16, 3_u16));
+    assert_eq!(v.xzzx(), u16vec4(1_u16, 3_u16, 3_u16, 1_u16));
+    assert_eq!(v.xzzy(), u16vec4(1_u16, 3_u16, 3_u16, 2_u16));
+    assert_eq!(v.xzzz(), u16vec4(1_u16, 3_u16, 3_u16, 3_u16));
+    assert_eq!(v.yxxx(), u16vec4(2_u16, 1_u16, 1_u16, 1_u16));
+    assert_eq!(v.yxxy(), u16vec4(2_u16, 1_u16, 1_u16, 2_u16));
+    assert_eq!(v.yxxz(), u16vec4(2_u16, 1_u16, 1_u16, 3_u16));
+    assert_eq!(v.yxyx(), u16vec4(2_u16, 1_u16, 2_u16, 1_u16));
+    assert_eq!(v.yxyy(), u16vec4(2_u16, 1_u16, 2_u16, 2_u16));
+    assert_eq!(v.yxyz(), u16vec4(2_u16, 1_u16, 2_u16, 3_u16));
+    assert_eq!(v.yxzx(), u16vec4(2_u16, 1_u16, 3_u16, 1_u16));
+    assert_eq!(v.yxzy(), u16vec4(2_u16, 1_u16, 3_u16, 2_u16));
+    assert_eq!(v.yxzz(), u16vec4(2_u16, 1_u16, 3_u16, 3_u16));
+    assert_eq!(v.yyxx(), u16vec4(2_u16, 2_u16, 1_u16, 1_u16));
+    assert_eq!(v.yyxy(), u16vec4(2_u16, 2_u16, 1_u16, 2_u16));
+    assert_eq!(v.yyxz(), u16vec4(2_u16, 2_u16, 1_u16, 3_u16));
+    assert_eq!(v.yyyx(), u16vec4(2_u16, 2_u16, 2_u16, 1_u16));
+    assert_eq!(v.yyyy(), u16vec4(2_u16, 2_u16, 2_u16, 2_u16));
+    assert_eq!(v.yyyz(), u16vec4(2_u16, 2_u16, 2_u16, 3_u16));
+    assert_eq!(v.yyzx(), u16vec4(2_u16, 2_u16, 3_u16, 1_u16));
+    assert_eq!(v.yyzy(), u16vec4(2_u16, 2_u16, 3_u16, 2_u16));
+    assert_eq!(v.yyzz(), u16vec4(2_u16, 2_u16, 3_u16, 3_u16));
+    assert_eq!(v.yzxx(), u16vec4(2_u16, 3_u16, 1_u16, 1_u16));
+    assert_eq!(v.yzxy(), u16vec4(2_u16, 3_u16, 1_u16, 2_u16));
+    assert_eq!(v.yzxz(), u16vec4(2_u16, 3_u16, 1_u16, 3_u16));
+    assert_eq!(v.yzyx(), u16vec4(2_u16, 3_u16, 2_u16, 1_u16));
+    assert_eq!(v.yzyy(), u16vec4(2_u16, 3_u16, 2_u16, 2_u16));
+    assert_eq!(v.yzyz(), u16vec4(2_u16, 3_u16, 2_u16, 3_u16));
+    assert_eq!(v.yzzx(), u16vec4(2_u16, 3_u16, 3_u16, 1_u16));
+    assert_eq!(v.yzzy(), u16vec4(2_u16, 3_u16, 3_u16, 2_u16));
+    assert_eq!(v.yzzz(), u16vec4(2_u16, 3_u16, 3_u16, 3_u16));
+    assert_eq!(v.zxxx(), u16vec4(3_u16, 1_u16, 1_u16, 1_u16));
+    assert_eq!(v.zxxy(), u16vec4(3_u16, 1_u16, 1_u16, 2_u16));
+    assert_eq!(v.zxxz(), u16vec4(3_u16, 1_u16, 1_u16, 3_u16));
+    assert_eq!(v.zxyx(), u16vec4(3_u16, 1_u16, 2_u16, 1_u16));
+    assert_eq!(v.zxyy(), u16vec4(3_u16, 1_u16, 2_u16, 2_u16));
+    assert_eq!(v.zxyz(), u16vec4(3_u16, 1_u16, 2_u16, 3_u16));
+    assert_eq!(v.zxzx(), u16vec4(3_u16, 1_u16, 3_u16, 1_u16));
+    assert_eq!(v.zxzy(), u16vec4(3_u16, 1_u16, 3_u16, 2_u16));
+    assert_eq!(v.zxzz(), u16vec4(3_u16, 1_u16, 3_u16, 3_u16));
+    assert_eq!(v.zyxx(), u16vec4(3_u16, 2_u16, 1_u16, 1_u16));
+    assert_eq!(v.zyxy(), u16vec4(3_u16, 2_u16, 1_u16, 2_u16));
+    assert_eq!(v.zyxz(), u16vec4(3_u16, 2_u16, 1_u16, 3_u16));
+    assert_eq!(v.zyyx(), u16vec4(3_u16, 2_u16, 2_u16, 1_u16));
+    assert_eq!(v.zyyy(), u16vec4(3_u16, 2_u16, 2_u16, 2_u16));
+    assert_eq!(v.zyyz(), u16vec4(3_u16, 2_u16, 2_u16, 3_u16));
+    assert_eq!(v.zyzx(), u16vec4(3_u16, 2_u16, 3_u16, 1_u16));
+    assert_eq!(v.zyzy(), u16vec4(3_u16, 2_u16, 3_u16, 2_u16));
+    assert_eq!(v.zyzz(), u16vec4(3_u16, 2_u16, 3_u16, 3_u16));
+    assert_eq!(v.zzxx(), u16vec4(3_u16, 3_u16, 1_u16, 1_u16));
+    assert_eq!(v.zzxy(), u16vec4(3_u16, 3_u16, 1_u16, 2_u16));
+    assert_eq!(v.zzxz(), u16vec4(3_u16, 3_u16, 1_u16, 3_u16));
+    assert_eq!(v.zzyx(), u16vec4(3_u16, 3_u16, 2_u16, 1_u16));
+    assert_eq!(v.zzyy(), u16vec4(3_u16, 3_u16, 2_u16, 2_u16));
+    assert_eq!(v.zzyz(), u16vec4(3_u16, 3_u16, 2_u16, 3_u16));
+    assert_eq!(v.zzzx(), u16vec4(3_u16, 3_u16, 3_u16, 1_u16));
+    assert_eq!(v.zzzy(), u16vec4(3_u16, 3_u16, 3_u16, 2_u16));
+    assert_eq!(v.zzzz(), u16vec4(3_u16, 3_u16, 3_u16, 3_u16));
+    assert_eq!(v.xxx(), u16vec3(1_u16, 1_u16, 1_u16));
+    assert_eq!(v.xxy(), u16vec3(1_u16, 1_u16, 2_u16));
+    assert_eq!(v.xxz(), u16vec3(1_u16, 1_u16, 3_u16));
+    assert_eq!(v.xyx(), u16vec3(1_u16, 2_u16, 1_u16));
+    assert_eq!(v.xyy(), u16vec3(1_u16, 2_u16, 2_u16));
+    assert_eq!(v.xzx(), u16vec3(1_u16, 3_u16, 1_u16));
+    assert_eq!(v.xzy(), u16vec3(1_u16, 3_u16, 2_u16));
+    assert_eq!(v.xzz(), u16vec3(1_u16, 3_u16, 3_u16));
+    assert_eq!(v.yxx(), u16vec3(2_u16, 1_u16, 1_u16));
+    assert_eq!(v.yxy(), u16vec3(2_u16, 1_u16, 2_u16));
+    assert_eq!(v.yxz(), u16vec3(2_u16, 1_u16, 3_u16));
+    assert_eq!(v.yyx(), u16vec3(2_u16, 2_u16, 1_u16));
+    assert_eq!(v.yyy(), u16vec3(2_u16, 2_u16, 2_u16));
+    assert_eq!(v.yyz(), u16vec3(2_u16, 2_u16, 3_u16));
+    assert_eq!(v.yzx(), u16vec3(2_u16, 3_u16, 1_u16));
+    assert_eq!(v.yzy(), u16vec3(2_u16, 3_u16, 2_u16));
+    assert_eq!(v.yzz(), u16vec3(2_u16, 3_u16, 3_u16));
+    assert_eq!(v.zxx(), u16vec3(3_u16, 1_u16, 1_u16));
+    assert_eq!(v.zxy(), u16vec3(3_u16, 1_u16, 2_u16));
+    assert_eq!(v.zxz(), u16vec3(3_u16, 1_u16, 3_u16));
+    assert_eq!(v.zyx(), u16vec3(3_u16, 2_u16, 1_u16));
+    assert_eq!(v.zyy(), u16vec3(3_u16, 2_u16, 2_u16));
+    assert_eq!(v.zyz(), u16vec3(3_u16, 2_u16, 3_u16));
+    assert_eq!(v.zzx(), u16vec3(3_u16, 3_u16, 1_u16));
+    assert_eq!(v.zzy(), u16vec3(3_u16, 3_u16, 2_u16));
+    assert_eq!(v.zzz(), u16vec3(3_u16, 3_u16, 3_u16));
+    assert_eq!(v.xx(), u16vec2(1_u16, 1_u16));
+    assert_eq!(v.xy(), u16vec2(1_u16, 2_u16));
+    assert_eq!(v.xz(), u16vec2(1_u16, 3_u16));
+    assert_eq!(v.yx(), u16vec2(2_u16, 1_u16));
+    assert_eq!(v.yy(), u16vec2(2_u16, 2_u16));
+    assert_eq!(v.yz(), u16vec2(2_u16, 3_u16));
+    assert_eq!(v.zx(), u16vec2(3_u16, 1_u16));
+    assert_eq!(v.zy(), u16vec2(3_u16, 2_u16));
+    assert_eq!(v.zz(), u16vec2(3_u16, 3_u16));
+});
+
+glam_test!(test_u16vec2_swizzles, {
+    let v = u16vec2(1_u16, 2_u16);
+    assert_eq!(v, v.xy());
+    assert_eq!(v.xxxx(), u16vec4(1_u16, 1_u16, 1_u16, 1_u16));
+    assert_eq!(v.xxxy(), u16vec4(1_u16, 1_u16, 1_u16, 2_u16));
+    assert_eq!(v.xxyx(), u16vec4(1_u16, 1_u16, 2_u16, 1_u16));
+    assert_eq!(v.xxyy(), u16vec4(1_u16, 1_u16, 2_u16, 2_u16));
+    assert_eq!(v.xyxx(), u16vec4(1_u16, 2_u16, 1_u16, 1_u16));
+    assert_eq!(v.xyxy(), u16vec4(1_u16, 2_u16, 1_u16, 2_u16));
+    assert_eq!(v.xyyx(), u16vec4(1_u16, 2_u16, 2_u16, 1_u16));
+    assert_eq!(v.xyyy(), u16vec4(1_u16, 2_u16, 2_u16, 2_u16));
+    assert_eq!(v.yxxx(), u16vec4(2_u16, 1_u16, 1_u16, 1_u16));
+    assert_eq!(v.yxxy(), u16vec4(2_u16, 1_u16, 1_u16, 2_u16));
+    assert_eq!(v.yxyx(), u16vec4(2_u16, 1_u16, 2_u16, 1_u16));
+    assert_eq!(v.yxyy(), u16vec4(2_u16, 1_u16, 2_u16, 2_u16));
+    assert_eq!(v.yyxx(), u16vec4(2_u16, 2_u16, 1_u16, 1_u16));
+    assert_eq!(v.yyxy(), u16vec4(2_u16, 2_u16, 1_u16, 2_u16));
+    assert_eq!(v.yyyx(), u16vec4(2_u16, 2_u16, 2_u16, 1_u16));
+    assert_eq!(v.yyyy(), u16vec4(2_u16, 2_u16, 2_u16, 2_u16));
+    assert_eq!(v.xxx(), u16vec3(1_u16, 1_u16, 1_u16));
+    assert_eq!(v.xxy(), u16vec3(1_u16, 1_u16, 2_u16));
+    assert_eq!(v.xyx(), u16vec3(1_u16, 2_u16, 1_u16));
+    assert_eq!(v.xyy(), u16vec3(1_u16, 2_u16, 2_u16));
+    assert_eq!(v.yxx(), u16vec3(2_u16, 1_u16, 1_u16));
+    assert_eq!(v.yxy(), u16vec3(2_u16, 1_u16, 2_u16));
+    assert_eq!(v.yyx(), u16vec3(2_u16, 2_u16, 1_u16));
+    assert_eq!(v.yyy(), u16vec3(2_u16, 2_u16, 2_u16));
+    assert_eq!(v.xx(), u16vec2(1_u16, 1_u16));
+    assert_eq!(v.yx(), u16vec2(2_u16, 1_u16));
+    assert_eq!(v.yy(), u16vec2(2_u16, 2_u16));
+});

vendor/glam/tests/swizzles_u32.rs

@@ -0,0 +1,497 @@
+// Generated by swizzlegen. Do not edit.
+#[macro_use]
+mod support;
+use glam::*;
+
+glam_test!(test_uvec4_swizzles, {
+    let v = uvec4(1_u32, 2_u32, 3_u32, 4_u32);
+    assert_eq!(v, v.xyzw());
+    assert_eq!(v.xxxx(), uvec4(1_u32, 1_u32, 1_u32, 1_u32));
+    assert_eq!(v.xxxy(), uvec4(1_u32, 1_u32, 1_u32, 2_u32));
+    assert_eq!(v.xxxz(), uvec4(1_u32, 1_u32, 1_u32, 3_u32));
+    assert_eq!(v.xxxw(), uvec4(1_u32, 1_u32, 1_u32, 4_u32));
+    assert_eq!(v.xxyx(), uvec4(1_u32, 1_u32, 2_u32, 1_u32));
+    assert_eq!(v.xxyy(), uvec4(1_u32, 1_u32, 2_u32, 2_u32));
+    assert_eq!(v.xxyz(), uvec4(1_u32, 1_u32, 2_u32, 3_u32));
+    assert_eq!(v.xxyw(), uvec4(1_u32, 1_u32, 2_u32, 4_u32));
+    assert_eq!(v.xxzx(), uvec4(1_u32, 1_u32, 3_u32, 1_u32));
+    assert_eq!(v.xxzy(), uvec4(1_u32, 1_u32, 3_u32, 2_u32));
+    assert_eq!(v.xxzz(), uvec4(1_u32, 1_u32, 3_u32, 3_u32));
+    assert_eq!(v.xxzw(), uvec4(1_u32, 1_u32, 3_u32, 4_u32));
+    assert_eq!(v.xxwx(), uvec4(1_u32, 1_u32, 4_u32, 1_u32));
+    assert_eq!(v.xxwy(), uvec4(1_u32, 1_u32, 4_u32, 2_u32));
+    assert_eq!(v.xxwz(), uvec4(1_u32, 1_u32, 4_u32, 3_u32));
+    assert_eq!(v.xxww(), uvec4(1_u32, 1_u32, 4_u32, 4_u32));
+    assert_eq!(v.xyxx(), uvec4(1_u32, 2_u32, 1_u32, 1_u32));
+    assert_eq!(v.xyxy(), uvec4(1_u32, 2_u32, 1_u32, 2_u32));
+    assert_eq!(v.xyxz(), uvec4(1_u32, 2_u32, 1_u32, 3_u32));
+    assert_eq!(v.xyxw(), uvec4(1_u32, 2_u32, 1_u32, 4_u32));
+    assert_eq!(v.xyyx(), uvec4(1_u32, 2_u32, 2_u32, 1_u32));
+    assert_eq!(v.xyyy(), uvec4(1_u32, 2_u32, 2_u32, 2_u32));
+    assert_eq!(v.xyyz(), uvec4(1_u32, 2_u32, 2_u32, 3_u32));
+    assert_eq!(v.xyyw(), uvec4(1_u32, 2_u32, 2_u32, 4_u32));
+    assert_eq!(v.xyzx(), uvec4(1_u32, 2_u32, 3_u32, 1_u32));
+    assert_eq!(v.xyzy(), uvec4(1_u32, 2_u32, 3_u32, 2_u32));
+    assert_eq!(v.xyzz(), uvec4(1_u32, 2_u32, 3_u32, 3_u32));
+    assert_eq!(v.xywx(), uvec4(1_u32, 2_u32, 4_u32, 1_u32));
+    assert_eq!(v.xywy(), uvec4(1_u32, 2_u32, 4_u32, 2_u32));
+    assert_eq!(v.xywz(), uvec4(1_u32, 2_u32, 4_u32, 3_u32));
+    assert_eq!(v.xyww(), uvec4(1_u32, 2_u32, 4_u32, 4_u32));
+    assert_eq!(v.xzxx(), uvec4(1_u32, 3_u32, 1_u32, 1_u32));
+    assert_eq!(v.xzxy(), uvec4(1_u32, 3_u32, 1_u32, 2_u32));
+    assert_eq!(v.xzxz(), uvec4(1_u32, 3_u32, 1_u32, 3_u32));
+    assert_eq!(v.xzxw(), uvec4(1_u32, 3_u32, 1_u32, 4_u32));
+    assert_eq!(v.xzyx(), uvec4(1_u32, 3_u32, 2_u32, 1_u32));
+    assert_eq!(v.xzyy(), uvec4(1_u32, 3_u32, 2_u32, 2_u32));
+    assert_eq!(v.xzyz(), uvec4(1_u32, 3_u32, 2_u32, 3_u32));
+    assert_eq!(v.xzyw(), uvec4(1_u32, 3_u32, 2_u32, 4_u32));
+    assert_eq!(v.xzzx(), uvec4(1_u32, 3_u32, 3_u32, 1_u32));
+    assert_eq!(v.xzzy(), uvec4(1_u32, 3_u32, 3_u32, 2_u32));
+    assert_eq!(v.xzzz(), uvec4(1_u32, 3_u32, 3_u32, 3_u32));
+    assert_eq!(v.xzzw(), uvec4(1_u32, 3_u32, 3_u32, 4_u32));
+    assert_eq!(v.xzwx(), uvec4(1_u32, 3_u32, 4_u32, 1_u32));
+    assert_eq!(v.xzwy(), uvec4(1_u32, 3_u32, 4_u32, 2_u32));
+    assert_eq!(v.xzwz(), uvec4(1_u32, 3_u32, 4_u32, 3_u32));
+    assert_eq!(v.xzww(), uvec4(1_u32, 3_u32, 4_u32, 4_u32));
+    assert_eq!(v.xwxx(), uvec4(1_u32, 4_u32, 1_u32, 1_u32));
+    assert_eq!(v.xwxy(), uvec4(1_u32, 4_u32, 1_u32, 2_u32));
+    assert_eq!(v.xwxz(), uvec4(1_u32, 4_u32, 1_u32, 3_u32));
+    assert_eq!(v.xwxw(), uvec4(1_u32, 4_u32, 1_u32, 4_u32));
+    assert_eq!(v.xwyx(), uvec4(1_u32, 4_u32, 2_u32, 1_u32));
+    assert_eq!(v.xwyy(), uvec4(1_u32, 4_u32, 2_u32, 2_u32));
+    assert_eq!(v.xwyz(), uvec4(1_u32, 4_u32, 2_u32, 3_u32));
+    assert_eq!(v.xwyw(), uvec4(1_u32, 4_u32, 2_u32, 4_u32));
+    assert_eq!(v.xwzx(), uvec4(1_u32, 4_u32, 3_u32, 1_u32));
+    assert_eq!(v.xwzy(), uvec4(1_u32, 4_u32, 3_u32, 2_u32));
+    assert_eq!(v.xwzz(), uvec4(1_u32, 4_u32, 3_u32, 3_u32));
+    assert_eq!(v.xwzw(), uvec4(1_u32, 4_u32, 3_u32, 4_u32));
+    assert_eq!(v.xwwx(), uvec4(1_u32, 4_u32, 4_u32, 1_u32));
+    assert_eq!(v.xwwy(), uvec4(1_u32, 4_u32, 4_u32, 2_u32));
+    assert_eq!(v.xwwz(), uvec4(1_u32, 4_u32, 4_u32, 3_u32));
+    assert_eq!(v.xwww(), uvec4(1_u32, 4_u32, 4_u32, 4_u32));
+    assert_eq!(v.yxxx(), uvec4(2_u32, 1_u32, 1_u32, 1_u32));
+    assert_eq!(v.yxxy(), uvec4(2_u32, 1_u32, 1_u32, 2_u32));
+    assert_eq!(v.yxxz(), uvec4(2_u32, 1_u32, 1_u32, 3_u32));
+    assert_eq!(v.yxxw(), uvec4(2_u32, 1_u32, 1_u32, 4_u32));
+    assert_eq!(v.yxyx(), uvec4(2_u32, 1_u32, 2_u32, 1_u32));
+    assert_eq!(v.yxyy(), uvec4(2_u32, 1_u32, 2_u32, 2_u32));
+    assert_eq!(v.yxyz(), uvec4(2_u32, 1_u32, 2_u32, 3_u32));
+    assert_eq!(v.yxyw(), uvec4(2_u32, 1_u32, 2_u32, 4_u32));
+    assert_eq!(v.yxzx(), uvec4(2_u32, 1_u32, 3_u32, 1_u32));
+    assert_eq!(v.yxzy(), uvec4(2_u32, 1_u32, 3_u32, 2_u32));
+    assert_eq!(v.yxzz(), uvec4(2_u32, 1_u32, 3_u32, 3_u32));
+    assert_eq!(v.yxzw(), uvec4(2_u32, 1_u32, 3_u32, 4_u32));
+    assert_eq!(v.yxwx(), uvec4(2_u32, 1_u32, 4_u32, 1_u32));
+    assert_eq!(v.yxwy(), uvec4(2_u32, 1_u32, 4_u32, 2_u32));
+    assert_eq!(v.yxwz(), uvec4(2_u32, 1_u32, 4_u32, 3_u32));
+    assert_eq!(v.yxww(), uvec4(2_u32, 1_u32, 4_u32, 4_u32));
+    assert_eq!(v.yyxx(), uvec4(2_u32, 2_u32, 1_u32, 1_u32));
+    assert_eq!(v.yyxy(), uvec4(2_u32, 2_u32, 1_u32, 2_u32));
+    assert_eq!(v.yyxz(), uvec4(2_u32, 2_u32, 1_u32, 3_u32));
+    assert_eq!(v.yyxw(), uvec4(2_u32, 2_u32, 1_u32, 4_u32));
+    assert_eq!(v.yyyx(), uvec4(2_u32, 2_u32, 2_u32, 1_u32));
+    assert_eq!(v.yyyy(), uvec4(2_u32, 2_u32, 2_u32, 2_u32));
+    assert_eq!(v.yyyz(), uvec4(2_u32, 2_u32, 2_u32, 3_u32));
+    assert_eq!(v.yyyw(), uvec4(2_u32, 2_u32, 2_u32, 4_u32));
+    assert_eq!(v.yyzx(), uvec4(2_u32, 2_u32, 3_u32, 1_u32));
+    assert_eq!(v.yyzy(), uvec4(2_u32, 2_u32, 3_u32, 2_u32));
+    assert_eq!(v.yyzz(), uvec4(2_u32, 2_u32, 3_u32, 3_u32));
+    assert_eq!(v.yyzw(), uvec4(2_u32, 2_u32, 3_u32, 4_u32));
+    assert_eq!(v.yywx(), uvec4(2_u32, 2_u32, 4_u32, 1_u32));
+    assert_eq!(v.yywy(), uvec4(2_u32, 2_u32, 4_u32, 2_u32));
+    assert_eq!(v.yywz(), uvec4(2_u32, 2_u32, 4_u32, 3_u32));
+    assert_eq!(v.yyww(), uvec4(2_u32, 2_u32, 4_u32, 4_u32));
+    assert_eq!(v.yzxx(), uvec4(2_u32, 3_u32, 1_u32, 1_u32));
+    assert_eq!(v.yzxy(), uvec4(2_u32, 3_u32, 1_u32, 2_u32));
+    assert_eq!(v.yzxz(), uvec4(2_u32, 3_u32, 1_u32, 3_u32));
+    assert_eq!(v.yzxw(), uvec4(2_u32, 3_u32, 1_u32, 4_u32));
+    assert_eq!(v.yzyx(), uvec4(2_u32, 3_u32, 2_u32, 1_u32));
+    assert_eq!(v.yzyy(), uvec4(2_u32, 3_u32, 2_u32, 2_u32));
+    assert_eq!(v.yzyz(), uvec4(2_u32, 3_u32, 2_u32, 3_u32));
+    assert_eq!(v.yzyw(), uvec4(2_u32, 3_u32, 2_u32, 4_u32));
+    assert_eq!(v.yzzx(), uvec4(2_u32, 3_u32, 3_u32, 1_u32));
+    assert_eq!(v.yzzy(), uvec4(2_u32, 3_u32, 3_u32, 2_u32));
+    assert_eq!(v.yzzz(), uvec4(2_u32, 3_u32, 3_u32, 3_u32));
+    assert_eq!(v.yzzw(), uvec4(2_u32, 3_u32, 3_u32, 4_u32));
+    assert_eq!(v.yzwx(), uvec4(2_u32, 3_u32, 4_u32, 1_u32));
+    assert_eq!(v.yzwy(), uvec4(2_u32, 3_u32, 4_u32, 2_u32));
+    assert_eq!(v.yzwz(), uvec4(2_u32, 3_u32, 4_u32, 3_u32));
+    assert_eq!(v.yzww(), uvec4(2_u32, 3_u32, 4_u32, 4_u32));
+    assert_eq!(v.ywxx(), uvec4(2_u32, 4_u32, 1_u32, 1_u32));
+    assert_eq!(v.ywxy(), uvec4(2_u32, 4_u32, 1_u32, 2_u32));
+    assert_eq!(v.ywxz(), uvec4(2_u32, 4_u32, 1_u32, 3_u32));
+    assert_eq!(v.ywxw(), uvec4(2_u32, 4_u32, 1_u32, 4_u32));
+    assert_eq!(v.ywyx(), uvec4(2_u32, 4_u32, 2_u32, 1_u32));
+    assert_eq!(v.ywyy(), uvec4(2_u32, 4_u32, 2_u32, 2_u32));
+    assert_eq!(v.ywyz(), uvec4(2_u32, 4_u32, 2_u32, 3_u32));
+    assert_eq!(v.ywyw(), uvec4(2_u32, 4_u32, 2_u32, 4_u32));
+    assert_eq!(v.ywzx(), uvec4(2_u32, 4_u32, 3_u32, 1_u32));
+    assert_eq!(v.ywzy(), uvec4(2_u32, 4_u32, 3_u32, 2_u32));
+    assert_eq!(v.ywzz(), uvec4(2_u32, 4_u32, 3_u32, 3_u32));
+    assert_eq!(v.ywzw(), uvec4(2_u32, 4_u32, 3_u32, 4_u32));
+    assert_eq!(v.ywwx(), uvec4(2_u32, 4_u32, 4_u32, 1_u32));
+    assert_eq!(v.ywwy(), uvec4(2_u32, 4_u32, 4_u32, 2_u32));
+    assert_eq!(v.ywwz(), uvec4(2_u32, 4_u32, 4_u32, 3_u32));
+    assert_eq!(v.ywww(), uvec4(2_u32, 4_u32, 4_u32, 4_u32));
+    assert_eq!(v.zxxx(), uvec4(3_u32, 1_u32, 1_u32, 1_u32));
+    assert_eq!(v.zxxy(), uvec4(3_u32, 1_u32, 1_u32, 2_u32));
+    assert_eq!(v.zxxz(), uvec4(3_u32, 1_u32, 1_u32, 3_u32));
+    assert_eq!(v.zxxw(), uvec4(3_u32, 1_u32, 1_u32, 4_u32));
+    assert_eq!(v.zxyx(), uvec4(3_u32, 1_u32, 2_u32, 1_u32));
+    assert_eq!(v.zxyy(), uvec4(3_u32, 1_u32, 2_u32, 2_u32));
+    assert_eq!(v.zxyz(), uvec4(3_u32, 1_u32, 2_u32, 3_u32));
+    assert_eq!(v.zxyw(), uvec4(3_u32, 1_u32, 2_u32, 4_u32));
+    assert_eq!(v.zxzx(), uvec4(3_u32, 1_u32, 3_u32, 1_u32));
+    assert_eq!(v.zxzy(), uvec4(3_u32, 1_u32, 3_u32, 2_u32));
+    assert_eq!(v.zxzz(), uvec4(3_u32, 1_u32, 3_u32, 3_u32));
+    assert_eq!(v.zxzw(), uvec4(3_u32, 1_u32, 3_u32, 4_u32));
+    assert_eq!(v.zxwx(), uvec4(3_u32, 1_u32, 4_u32, 1_u32));
+    assert_eq!(v.zxwy(), uvec4(3_u32, 1_u32, 4_u32, 2_u32));
+    assert_eq!(v.zxwz(), uvec4(3_u32, 1_u32, 4_u32, 3_u32));
+    assert_eq!(v.zxww(), uvec4(3_u32, 1_u32, 4_u32, 4_u32));
+    assert_eq!(v.zyxx(), uvec4(3_u32, 2_u32, 1_u32, 1_u32));
+    assert_eq!(v.zyxy(), uvec4(3_u32, 2_u32, 1_u32, 2_u32));
+    assert_eq!(v.zyxz(), uvec4(3_u32, 2_u32, 1_u32, 3_u32));
+    assert_eq!(v.zyxw(), uvec4(3_u32, 2_u32, 1_u32, 4_u32));
+    assert_eq!(v.zyyx(), uvec4(3_u32, 2_u32, 2_u32, 1_u32));
+    assert_eq!(v.zyyy(), uvec4(3_u32, 2_u32, 2_u32, 2_u32));
+    assert_eq!(v.zyyz(), uvec4(3_u32, 2_u32, 2_u32, 3_u32));
+    assert_eq!(v.zyyw(), uvec4(3_u32, 2_u32, 2_u32, 4_u32));
+    assert_eq!(v.zyzx(), uvec4(3_u32, 2_u32, 3_u32, 1_u32));
+    assert_eq!(v.zyzy(), uvec4(3_u32, 2_u32, 3_u32, 2_u32));
+    assert_eq!(v.zyzz(), uvec4(3_u32, 2_u32, 3_u32, 3_u32));
+    assert_eq!(v.zyzw(), uvec4(3_u32, 2_u32, 3_u32, 4_u32));
+    assert_eq!(v.zywx(), uvec4(3_u32, 2_u32, 4_u32, 1_u32));
+    assert_eq!(v.zywy(), uvec4(3_u32, 2_u32, 4_u32, 2_u32));
+    assert_eq!(v.zywz(), uvec4(3_u32, 2_u32, 4_u32, 3_u32));
+    assert_eq!(v.zyww(), uvec4(3_u32, 2_u32, 4_u32, 4_u32));
+    assert_eq!(v.zzxx(), uvec4(3_u32, 3_u32, 1_u32, 1_u32));
+    assert_eq!(v.zzxy(), uvec4(3_u32, 3_u32, 1_u32, 2_u32));
+    assert_eq!(v.zzxz(), uvec4(3_u32, 3_u32, 1_u32, 3_u32));
+    assert_eq!(v.zzxw(), uvec4(3_u32, 3_u32, 1_u32, 4_u32));
+    assert_eq!(v.zzyx(), uvec4(3_u32, 3_u32, 2_u32, 1_u32));
+    assert_eq!(v.zzyy(), uvec4(3_u32, 3_u32, 2_u32, 2_u32));
+    assert_eq!(v.zzyz(), uvec4(3_u32, 3_u32, 2_u32, 3_u32));
+    assert_eq!(v.zzyw(), uvec4(3_u32, 3_u32, 2_u32, 4_u32));
+    assert_eq!(v.zzzx(), uvec4(3_u32, 3_u32, 3_u32, 1_u32));
+    assert_eq!(v.zzzy(), uvec4(3_u32, 3_u32, 3_u32, 2_u32));
+    assert_eq!(v.zzzz(), uvec4(3_u32, 3_u32, 3_u32, 3_u32));
+    assert_eq!(v.zzzw(), uvec4(3_u32, 3_u32, 3_u32, 4_u32));
+    assert_eq!(v.zzwx(), uvec4(3_u32, 3_u32, 4_u32, 1_u32));
+    assert_eq!(v.zzwy(), uvec4(3_u32, 3_u32, 4_u32, 2_u32));
+    assert_eq!(v.zzwz(), uvec4(3_u32, 3_u32, 4_u32, 3_u32));
+    assert_eq!(v.zzww(), uvec4(3_u32, 3_u32, 4_u32, 4_u32));
+    assert_eq!(v.zwxx(), uvec4(3_u32, 4_u32, 1_u32, 1_u32));
+    assert_eq!(v.zwxy(), uvec4(3_u32, 4_u32, 1_u32, 2_u32));
+    assert_eq!(v.zwxz(), uvec4(3_u32, 4_u32, 1_u32, 3_u32));
+    assert_eq!(v.zwxw(), uvec4(3_u32, 4_u32, 1_u32, 4_u32));
+    assert_eq!(v.zwyx(), uvec4(3_u32, 4_u32, 2_u32, 1_u32));
+    assert_eq!(v.zwyy(), uvec4(3_u32, 4_u32, 2_u32, 2_u32));
+    assert_eq!(v.zwyz(), uvec4(3_u32, 4_u32, 2_u32, 3_u32));
+    assert_eq!(v.zwyw(), uvec4(3_u32, 4_u32, 2_u32, 4_u32));
+    assert_eq!(v.zwzx(), uvec4(3_u32, 4_u32, 3_u32, 1_u32));
+    assert_eq!(v.zwzy(), uvec4(3_u32, 4_u32, 3_u32, 2_u32));
+    assert_eq!(v.zwzz(), uvec4(3_u32, 4_u32, 3_u32, 3_u32));
+    assert_eq!(v.zwzw(), uvec4(3_u32, 4_u32, 3_u32, 4_u32));
+    assert_eq!(v.zwwx(), uvec4(3_u32, 4_u32, 4_u32, 1_u32));
+    assert_eq!(v.zwwy(), uvec4(3_u32, 4_u32, 4_u32, 2_u32));
+    assert_eq!(v.zwwz(), uvec4(3_u32, 4_u32, 4_u32, 3_u32));
+    assert_eq!(v.zwww(), uvec4(3_u32, 4_u32, 4_u32, 4_u32));
+    assert_eq!(v.wxxx(), uvec4(4_u32, 1_u32, 1_u32, 1_u32));
+    assert_eq!(v.wxxy(), uvec4(4_u32, 1_u32, 1_u32, 2_u32));
+    assert_eq!(v.wxxz(), uvec4(4_u32, 1_u32, 1_u32, 3_u32));
+    assert_eq!(v.wxxw(), uvec4(4_u32, 1_u32, 1_u32, 4_u32));
+    assert_eq!(v.wxyx(), uvec4(4_u32, 1_u32, 2_u32, 1_u32));
+    assert_eq!(v.wxyy(), uvec4(4_u32, 1_u32, 2_u32, 2_u32));
+    assert_eq!(v.wxyz(), uvec4(4_u32, 1_u32, 2_u32, 3_u32));
+    assert_eq!(v.wxyw(), uvec4(4_u32, 1_u32, 2_u32, 4_u32));
+    assert_eq!(v.wxzx(), uvec4(4_u32, 1_u32, 3_u32, 1_u32));
+    assert_eq!(v.wxzy(), uvec4(4_u32, 1_u32, 3_u32, 2_u32));
+    assert_eq!(v.wxzz(), uvec4(4_u32, 1_u32, 3_u32, 3_u32));
+    assert_eq!(v.wxzw(), uvec4(4_u32, 1_u32, 3_u32, 4_u32));
+    assert_eq!(v.wxwx(), uvec4(4_u32, 1_u32, 4_u32, 1_u32));
+    assert_eq!(v.wxwy(), uvec4(4_u32, 1_u32, 4_u32, 2_u32));
+    assert_eq!(v.wxwz(), uvec4(4_u32, 1_u32, 4_u32, 3_u32));
+    assert_eq!(v.wxww(), uvec4(4_u32, 1_u32, 4_u32, 4_u32));
+    assert_eq!(v.wyxx(), uvec4(4_u32, 2_u32, 1_u32, 1_u32));
+    assert_eq!(v.wyxy(), uvec4(4_u32, 2_u32, 1_u32, 2_u32));
+    assert_eq!(v.wyxz(), uvec4(4_u32, 2_u32, 1_u32, 3_u32));
+    assert_eq!(v.wyxw(), uvec4(4_u32, 2_u32, 1_u32, 4_u32));
+    assert_eq!(v.wyyx(), uvec4(4_u32, 2_u32, 2_u32, 1_u32));
+    assert_eq!(v.wyyy(), uvec4(4_u32, 2_u32, 2_u32, 2_u32));
+    assert_eq!(v.wyyz(), uvec4(4_u32, 2_u32, 2_u32, 3_u32));
+    assert_eq!(v.wyyw(), uvec4(4_u32, 2_u32, 2_u32, 4_u32));
+    assert_eq!(v.wyzx(), uvec4(4_u32, 2_u32, 3_u32, 1_u32));
+    assert_eq!(v.wyzy(), uvec4(4_u32, 2_u32, 3_u32, 2_u32));
+    assert_eq!(v.wyzz(), uvec4(4_u32, 2_u32, 3_u32, 3_u32));
+    assert_eq!(v.wyzw(), uvec4(4_u32, 2_u32, 3_u32, 4_u32));
+    assert_eq!(v.wywx(), uvec4(4_u32, 2_u32, 4_u32, 1_u32));
+    assert_eq!(v.wywy(), uvec4(4_u32, 2_u32, 4_u32, 2_u32));
+    assert_eq!(v.wywz(), uvec4(4_u32, 2_u32, 4_u32, 3_u32));
+    assert_eq!(v.wyww(), uvec4(4_u32, 2_u32, 4_u32, 4_u32));
+    assert_eq!(v.wzxx(), uvec4(4_u32, 3_u32, 1_u32, 1_u32));
+    assert_eq!(v.wzxy(), uvec4(4_u32, 3_u32, 1_u32, 2_u32));
+    assert_eq!(v.wzxz(), uvec4(4_u32, 3_u32, 1_u32, 3_u32));
+    assert_eq!(v.wzxw(), uvec4(4_u32, 3_u32, 1_u32, 4_u32));
+    assert_eq!(v.wzyx(), uvec4(4_u32, 3_u32, 2_u32, 1_u32));
+    assert_eq!(v.wzyy(), uvec4(4_u32, 3_u32, 2_u32, 2_u32));
+    assert_eq!(v.wzyz(), uvec4(4_u32, 3_u32, 2_u32, 3_u32));
+    assert_eq!(v.wzyw(), uvec4(4_u32, 3_u32, 2_u32, 4_u32));
+    assert_eq!(v.wzzx(), uvec4(4_u32, 3_u32, 3_u32, 1_u32));
+    assert_eq!(v.wzzy(), uvec4(4_u32, 3_u32, 3_u32, 2_u32));
+    assert_eq!(v.wzzz(), uvec4(4_u32, 3_u32, 3_u32, 3_u32));
+    assert_eq!(v.wzzw(), uvec4(4_u32, 3_u32, 3_u32, 4_u32));
+    assert_eq!(v.wzwx(), uvec4(4_u32, 3_u32, 4_u32, 1_u32));
+    assert_eq!(v.wzwy(), uvec4(4_u32, 3_u32, 4_u32, 2_u32));
+    assert_eq!(v.wzwz(), uvec4(4_u32, 3_u32, 4_u32, 3_u32));
+    assert_eq!(v.wzww(), uvec4(4_u32, 3_u32, 4_u32, 4_u32));
+    assert_eq!(v.wwxx(), uvec4(4_u32, 4_u32, 1_u32, 1_u32));
+    assert_eq!(v.wwxy(), uvec4(4_u32, 4_u32, 1_u32, 2_u32));
+    assert_eq!(v.wwxz(), uvec4(4_u32, 4_u32, 1_u32, 3_u32));
+    assert_eq!(v.wwxw(), uvec4(4_u32, 4_u32, 1_u32, 4_u32));
+    assert_eq!(v.wwyx(), uvec4(4_u32, 4_u32, 2_u32, 1_u32));
+    assert_eq!(v.wwyy(), uvec4(4_u32, 4_u32, 2_u32, 2_u32));
+    assert_eq!(v.wwyz(), uvec4(4_u32, 4_u32, 2_u32, 3_u32));
+    assert_eq!(v.wwyw(), uvec4(4_u32, 4_u32, 2_u32, 4_u32));
+    assert_eq!(v.wwzx(), uvec4(4_u32, 4_u32, 3_u32, 1_u32));
+    assert_eq!(v.wwzy(), uvec4(4_u32, 4_u32, 3_u32, 2_u32));
+    assert_eq!(v.wwzz(), uvec4(4_u32, 4_u32, 3_u32, 3_u32));
+    assert_eq!(v.wwzw(), uvec4(4_u32, 4_u32, 3_u32, 4_u32));
+    assert_eq!(v.wwwx(), uvec4(4_u32, 4_u32, 4_u32, 1_u32));
+    assert_eq!(v.wwwy(), uvec4(4_u32, 4_u32, 4_u32, 2_u32));
+    assert_eq!(v.wwwz(), uvec4(4_u32, 4_u32, 4_u32, 3_u32));
+    assert_eq!(v.wwww(), uvec4(4_u32, 4_u32, 4_u32, 4_u32));
+    assert_eq!(v.xxx(), uvec3(1_u32, 1_u32, 1_u32));
+    assert_eq!(v.xxy(), uvec3(1_u32, 1_u32, 2_u32));
+    assert_eq!(v.xxz(), uvec3(1_u32, 1_u32, 3_u32));
+    assert_eq!(v.xxw(), uvec3(1_u32, 1_u32, 4_u32));
+    assert_eq!(v.xyx(), uvec3(1_u32, 2_u32, 1_u32));
+    assert_eq!(v.xyy(), uvec3(1_u32, 2_u32, 2_u32));
+    assert_eq!(v.xyz(), uvec3(1_u32, 2_u32, 3_u32));
+    assert_eq!(v.xyw(), uvec3(1_u32, 2_u32, 4_u32));
+    assert_eq!(v.xzx(), uvec3(1_u32, 3_u32, 1_u32));
+    assert_eq!(v.xzy(), uvec3(1_u32, 3_u32, 2_u32));
+    assert_eq!(v.xzz(), uvec3(1_u32, 3_u32, 3_u32));
+    assert_eq!(v.xzw(), uvec3(1_u32, 3_u32, 4_u32));
+    assert_eq!(v.xwx(), uvec3(1_u32, 4_u32, 1_u32));
+    assert_eq!(v.xwy(), uvec3(1_u32, 4_u32, 2_u32));
+    assert_eq!(v.xwz(), uvec3(1_u32, 4_u32, 3_u32));
+    assert_eq!(v.xww(), uvec3(1_u32, 4_u32, 4_u32));
+    assert_eq!(v.yxx(), uvec3(2_u32, 1_u32, 1_u32));
+    assert_eq!(v.yxy(), uvec3(2_u32, 1_u32, 2_u32));
+    assert_eq!(v.yxz(), uvec3(2_u32, 1_u32, 3_u32));
+    assert_eq!(v.yxw(), uvec3(2_u32, 1_u32, 4_u32));
+    assert_eq!(v.yyx(), uvec3(2_u32, 2_u32, 1_u32));
+    assert_eq!(v.yyy(), uvec3(2_u32, 2_u32, 2_u32));
+    assert_eq!(v.yyz(), uvec3(2_u32, 2_u32, 3_u32));
+    assert_eq!(v.yyw(), uvec3(2_u32, 2_u32, 4_u32));
+    assert_eq!(v.yzx(), uvec3(2_u32, 3_u32, 1_u32));
+    assert_eq!(v.yzy(), uvec3(2_u32, 3_u32, 2_u32));
+    assert_eq!(v.yzz(), uvec3(2_u32, 3_u32, 3_u32));
+    assert_eq!(v.yzw(), uvec3(2_u32, 3_u32, 4_u32));
+    assert_eq!(v.ywx(), uvec3(2_u32, 4_u32, 1_u32));
+    assert_eq!(v.ywy(), uvec3(2_u32, 4_u32, 2_u32));
+    assert_eq!(v.ywz(), uvec3(2_u32, 4_u32, 3_u32));
+    assert_eq!(v.yww(), uvec3(2_u32, 4_u32, 4_u32));
+    assert_eq!(v.zxx(), uvec3(3_u32, 1_u32, 1_u32));
+    assert_eq!(v.zxy(), uvec3(3_u32, 1_u32, 2_u32));
+    assert_eq!(v.zxz(), uvec3(3_u32, 1_u32, 3_u32));
+    assert_eq!(v.zxw(), uvec3(3_u32, 1_u32, 4_u32));
+    assert_eq!(v.zyx(), uvec3(3_u32, 2_u32, 1_u32));
+    assert_eq!(v.zyy(), uvec3(3_u32, 2_u32, 2_u32));
+    assert_eq!(v.zyz(), uvec3(3_u32, 2_u32, 3_u32));
+    assert_eq!(v.zyw(), uvec3(3_u32, 2_u32, 4_u32));
+    assert_eq!(v.zzx(), uvec3(3_u32, 3_u32, 1_u32));
+    assert_eq!(v.zzy(), uvec3(3_u32, 3_u32, 2_u32));
+    assert_eq!(v.zzz(), uvec3(3_u32, 3_u32, 3_u32));
+    assert_eq!(v.zzw(), uvec3(3_u32, 3_u32, 4_u32));
+    assert_eq!(v.zwx(), uvec3(3_u32, 4_u32, 1_u32));
+    assert_eq!(v.zwy(), uvec3(3_u32, 4_u32, 2_u32));
+    assert_eq!(v.zwz(), uvec3(3_u32, 4_u32, 3_u32));
+    assert_eq!(v.zww(), uvec3(3_u32, 4_u32, 4_u32));
+    assert_eq!(v.wxx(), uvec3(4_u32, 1_u32, 1_u32));
+    assert_eq!(v.wxy(), uvec3(4_u32, 1_u32, 2_u32));
+    assert_eq!(v.wxz(), uvec3(4_u32, 1_u32, 3_u32));
+    assert_eq!(v.wxw(), uvec3(4_u32, 1_u32, 4_u32));
+    assert_eq!(v.wyx(), uvec3(4_u32, 2_u32, 1_u32));
+    assert_eq!(v.wyy(), uvec3(4_u32, 2_u32, 2_u32));
+    assert_eq!(v.wyz(), uvec3(4_u32, 2_u32, 3_u32));
+    assert_eq!(v.wyw(), uvec3(4_u32, 2_u32, 4_u32));
+    assert_eq!(v.wzx(), uvec3(4_u32, 3_u32, 1_u32));
+    assert_eq!(v.wzy(), uvec3(4_u32, 3_u32, 2_u32));
+    assert_eq!(v.wzz(), uvec3(4_u32, 3_u32, 3_u32));
+    assert_eq!(v.wzw(), uvec3(4_u32, 3_u32, 4_u32));
+    assert_eq!(v.wwx(), uvec3(4_u32, 4_u32, 1_u32));
+    assert_eq!(v.wwy(), uvec3(4_u32, 4_u32, 2_u32));
+    assert_eq!(v.wwz(), uvec3(4_u32, 4_u32, 3_u32));
+    assert_eq!(v.www(), uvec3(4_u32, 4_u32, 4_u32));
+    assert_eq!(v.xx(), uvec2(1_u32, 1_u32));
+    assert_eq!(v.xy(), uvec2(1_u32, 2_u32));
+    assert_eq!(v.xz(), uvec2(1_u32, 3_u32));
+    assert_eq!(v.xw(), uvec2(1_u32, 4_u32));
+    assert_eq!(v.yx(), uvec2(2_u32, 1_u32));
+    assert_eq!(v.yy(), uvec2(2_u32, 2_u32));
+    assert_eq!(v.yz(), uvec2(2_u32, 3_u32));
+    assert_eq!(v.yw(), uvec2(2_u32, 4_u32));
+    assert_eq!(v.zx(), uvec2(3_u32, 1_u32));
+    assert_eq!(v.zy(), uvec2(3_u32, 2_u32));
+    assert_eq!(v.zz(), uvec2(3_u32, 3_u32));
+    assert_eq!(v.zw(), uvec2(3_u32, 4_u32));
+    assert_eq!(v.wx(), uvec2(4_u32, 1_u32));
+    assert_eq!(v.wy(), uvec2(4_u32, 2_u32));
+    assert_eq!(v.wz(), uvec2(4_u32, 3_u32));
+    assert_eq!(v.ww(), uvec2(4_u32, 4_u32));
+});
+
+glam_test!(test_uvec3_swizzles, {
+    let v = uvec3(1_u32, 2_u32, 3_u32);
+    assert_eq!(v, v.xyz());
+    assert_eq!(v.xxxx(), uvec4(1_u32, 1_u32, 1_u32, 1_u32));
+    assert_eq!(v.xxxy(), uvec4(1_u32, 1_u32, 1_u32, 2_u32));
+    assert_eq!(v.xxxz(), uvec4(1_u32, 1_u32, 1_u32, 3_u32));
+    assert_eq!(v.xxyx(), uvec4(1_u32, 1_u32, 2_u32, 1_u32));
+    assert_eq!(v.xxyy(), uvec4(1_u32, 1_u32, 2_u32, 2_u32));
+    assert_eq!(v.xxyz(), uvec4(1_u32, 1_u32, 2_u32, 3_u32));
+    assert_eq!(v.xxzx(), uvec4(1_u32, 1_u32, 3_u32, 1_u32));
+    assert_eq!(v.xxzy(), uvec4(1_u32, 1_u32, 3_u32, 2_u32));
+    assert_eq!(v.xxzz(), uvec4(1_u32, 1_u32, 3_u32, 3_u32));
+    assert_eq!(v.xyxx(), uvec4(1_u32, 2_u32, 1_u32, 1_u32));
+    assert_eq!(v.xyxy(), uvec4(1_u32, 2_u32, 1_u32, 2_u32));
+    assert_eq!(v.xyxz(), uvec4(1_u32, 2_u32, 1_u32, 3_u32));
+    assert_eq!(v.xyyx(), uvec4(1_u32, 2_u32, 2_u32, 1_u32));
+    assert_eq!(v.xyyy(), uvec4(1_u32, 2_u32, 2_u32, 2_u32));
+    assert_eq!(v.xyyz(), uvec4(1_u32, 2_u32, 2_u32, 3_u32));
+    assert_eq!(v.xyzx(), uvec4(1_u32, 2_u32, 3_u32, 1_u32));
+    assert_eq!(v.xyzy(), uvec4(1_u32, 2_u32, 3_u32, 2_u32));
+    assert_eq!(v.xyzz(), uvec4(1_u32, 2_u32, 3_u32, 3_u32));
+    assert_eq!(v.xzxx(), uvec4(1_u32, 3_u32, 1_u32, 1_u32));
+    assert_eq!(v.xzxy(), uvec4(1_u32, 3_u32, 1_u32, 2_u32));
+    assert_eq!(v.xzxz(), uvec4(1_u32, 3_u32, 1_u32, 3_u32));
+    assert_eq!(v.xzyx(), uvec4(1_u32, 3_u32, 2_u32, 1_u32));
+    assert_eq!(v.xzyy(), uvec4(1_u32, 3_u32, 2_u32, 2_u32));
+    assert_eq!(v.xzyz(), uvec4(1_u32, 3_u32, 2_u32, 3_u32));
+    assert_eq!(v.xzzx(), uvec4(1_u32, 3_u32, 3_u32, 1_u32));
+    assert_eq!(v.xzzy(), uvec4(1_u32, 3_u32, 3_u32, 2_u32));
+    assert_eq!(v.xzzz(), uvec4(1_u32, 3_u32, 3_u32, 3_u32));
+    assert_eq!(v.yxxx(), uvec4(2_u32, 1_u32, 1_u32, 1_u32));
+    assert_eq!(v.yxxy(), uvec4(2_u32, 1_u32, 1_u32, 2_u32));
+    assert_eq!(v.yxxz(), uvec4(2_u32, 1_u32, 1_u32, 3_u32));
+    assert_eq!(v.yxyx(), uvec4(2_u32, 1_u32, 2_u32, 1_u32));
+    assert_eq!(v.yxyy(), uvec4(2_u32, 1_u32, 2_u32, 2_u32));
+    assert_eq!(v.yxyz(), uvec4(2_u32, 1_u32, 2_u32, 3_u32));
+    assert_eq!(v.yxzx(), uvec4(2_u32, 1_u32, 3_u32, 1_u32));
+    assert_eq!(v.yxzy(), uvec4(2_u32, 1_u32, 3_u32, 2_u32));
+    assert_eq!(v.yxzz(), uvec4(2_u32, 1_u32, 3_u32, 3_u32));
+    assert_eq!(v.yyxx(), uvec4(2_u32, 2_u32, 1_u32, 1_u32));
+    assert_eq!(v.yyxy(), uvec4(2_u32, 2_u32, 1_u32, 2_u32));
+    assert_eq!(v.yyxz(), uvec4(2_u32, 2_u32, 1_u32, 3_u32));
+    assert_eq!(v.yyyx(), uvec4(2_u32, 2_u32, 2_u32, 1_u32));
+    assert_eq!(v.yyyy(), uvec4(2_u32, 2_u32, 2_u32, 2_u32));
+    assert_eq!(v.yyyz(), uvec4(2_u32, 2_u32, 2_u32, 3_u32));
+    assert_eq!(v.yyzx(), uvec4(2_u32, 2_u32, 3_u32, 1_u32));
+    assert_eq!(v.yyzy(), uvec4(2_u32, 2_u32, 3_u32, 2_u32));
+    assert_eq!(v.yyzz(), uvec4(2_u32, 2_u32, 3_u32, 3_u32));
+    assert_eq!(v.yzxx(), uvec4(2_u32, 3_u32, 1_u32, 1_u32));
+    assert_eq!(v.yzxy(), uvec4(2_u32, 3_u32, 1_u32, 2_u32));
+    assert_eq!(v.yzxz(), uvec4(2_u32, 3_u32, 1_u32, 3_u32));
+    assert_eq!(v.yzyx(), uvec4(2_u32, 3_u32, 2_u32, 1_u32));
+    assert_eq!(v.yzyy(), uvec4(2_u32, 3_u32, 2_u32, 2_u32));
+    assert_eq!(v.yzyz(), uvec4(2_u32, 3_u32, 2_u32, 3_u32));
+    assert_eq!(v.yzzx(), uvec4(2_u32, 3_u32, 3_u32, 1_u32));
+    assert_eq!(v.yzzy(), uvec4(2_u32, 3_u32, 3_u32, 2_u32));
+    assert_eq!(v.yzzz(), uvec4(2_u32, 3_u32, 3_u32, 3_u32));
+    assert_eq!(v.zxxx(), uvec4(3_u32, 1_u32, 1_u32, 1_u32));
+    assert_eq!(v.zxxy(), uvec4(3_u32, 1_u32, 1_u32, 2_u32));
+    assert_eq!(v.zxxz(), uvec4(3_u32, 1_u32, 1_u32, 3_u32));
+    assert_eq!(v.zxyx(), uvec4(3_u32, 1_u32, 2_u32, 1_u32));
+    assert_eq!(v.zxyy(), uvec4(3_u32, 1_u32, 2_u32, 2_u32));
+    assert_eq!(v.zxyz(), uvec4(3_u32, 1_u32, 2_u32, 3_u32));
+    assert_eq!(v.zxzx(), uvec4(3_u32, 1_u32, 3_u32, 1_u32));
+    assert_eq!(v.zxzy(), uvec4(3_u32, 1_u32, 3_u32, 2_u32));
+    assert_eq!(v.zxzz(), uvec4(3_u32, 1_u32, 3_u32, 3_u32));
+    assert_eq!(v.zyxx(), uvec4(3_u32, 2_u32, 1_u32, 1_u32));
+    assert_eq!(v.zyxy(), uvec4(3_u32, 2_u32, 1_u32, 2_u32));
+    assert_eq!(v.zyxz(), uvec4(3_u32, 2_u32, 1_u32, 3_u32));
+    assert_eq!(v.zyyx(), uvec4(3_u32, 2_u32, 2_u32, 1_u32));
+    assert_eq!(v.zyyy(), uvec4(3_u32, 2_u32, 2_u32, 2_u32));
+    assert_eq!(v.zyyz(), uvec4(3_u32, 2_u32, 2_u32, 3_u32));
+    assert_eq!(v.zyzx(), uvec4(3_u32, 2_u32, 3_u32, 1_u32));
+    assert_eq!(v.zyzy(), uvec4(3_u32, 2_u32, 3_u32, 2_u32));
+    assert_eq!(v.zyzz(), uvec4(3_u32, 2_u32, 3_u32, 3_u32));
+    assert_eq!(v.zzxx(), uvec4(3_u32, 3_u32, 1_u32, 1_u32));
+    assert_eq!(v.zzxy(), uvec4(3_u32, 3_u32, 1_u32, 2_u32));
+    assert_eq!(v.zzxz(), uvec4(3_u32, 3_u32, 1_u32, 3_u32));
+    assert_eq!(v.zzyx(), uvec4(3_u32, 3_u32, 2_u32, 1_u32));
+    assert_eq!(v.zzyy(), uvec4(3_u32, 3_u32, 2_u32, 2_u32));
+    assert_eq!(v.zzyz(), uvec4(3_u32, 3_u32, 2_u32, 3_u32));
+    assert_eq!(v.zzzx(), uvec4(3_u32, 3_u32, 3_u32, 1_u32));
+    assert_eq!(v.zzzy(), uvec4(3_u32, 3_u32, 3_u32, 2_u32));
+    assert_eq!(v.zzzz(), uvec4(3_u32, 3_u32, 3_u32, 3_u32));
+    assert_eq!(v.xxx(), uvec3(1_u32, 1_u32, 1_u32));
+    assert_eq!(v.xxy(), uvec3(1_u32, 1_u32, 2_u32));
+    assert_eq!(v.xxz(), uvec3(1_u32, 1_u32, 3_u32));
+    assert_eq!(v.xyx(), uvec3(1_u32, 2_u32, 1_u32));
+    assert_eq!(v.xyy(), uvec3(1_u32, 2_u32, 2_u32));
+    assert_eq!(v.xzx(), uvec3(1_u32, 3_u32, 1_u32));
+    assert_eq!(v.xzy(), uvec3(1_u32, 3_u32, 2_u32));
+    assert_eq!(v.xzz(), uvec3(1_u32, 3_u32, 3_u32));
+    assert_eq!(v.yxx(), uvec3(2_u32, 1_u32, 1_u32));
+    assert_eq!(v.yxy(), uvec3(2_u32, 1_u32, 2_u32));
+    assert_eq!(v.yxz(), uvec3(2_u32, 1_u32, 3_u32));
+    assert_eq!(v.yyx(), uvec3(2_u32, 2_u32, 1_u32));
+    assert_eq!(v.yyy(), uvec3(2_u32, 2_u32, 2_u32));
+    assert_eq!(v.yyz(), uvec3(2_u32, 2_u32, 3_u32));
+    assert_eq!(v.yzx(), uvec3(2_u32, 3_u32, 1_u32));
+    assert_eq!(v.yzy(), uvec3(2_u32, 3_u32, 2_u32));
+    assert_eq!(v.yzz(), uvec3(2_u32, 3_u32, 3_u32));
+    assert_eq!(v.zxx(), uvec3(3_u32, 1_u32, 1_u32));
+    assert_eq!(v.zxy(), uvec3(3_u32, 1_u32, 2_u32));
+    assert_eq!(v.zxz(), uvec3(3_u32, 1_u32, 3_u32));
+    assert_eq!(v.zyx(), uvec3(3_u32, 2_u32, 1_u32));
+    assert_eq!(v.zyy(), uvec3(3_u32, 2_u32, 2_u32));
+    assert_eq!(v.zyz(), uvec3(3_u32, 2_u32, 3_u32));
+    assert_eq!(v.zzx(), uvec3(3_u32, 3_u32, 1_u32));
+    assert_eq!(v.zzy(), uvec3(3_u32, 3_u32, 2_u32));
+    assert_eq!(v.zzz(), uvec3(3_u32, 3_u32, 3_u32));
+    assert_eq!(v.xx(), uvec2(1_u32, 1_u32));
+    assert_eq!(v.xy(), uvec2(1_u32, 2_u32));
+    assert_eq!(v.xz(), uvec2(1_u32, 3_u32));
+    assert_eq!(v.yx(), uvec2(2_u32, 1_u32));
+    assert_eq!(v.yy(), uvec2(2_u32, 2_u32));
+    assert_eq!(v.yz(), uvec2(2_u32, 3_u32));
+    assert_eq!(v.zx(), uvec2(3_u32, 1_u32));
+    assert_eq!(v.zy(), uvec2(3_u32, 2_u32));
+    assert_eq!(v.zz(), uvec2(3_u32, 3_u32));
+});
+
+glam_test!(test_uvec2_swizzles, {
+    let v = uvec2(1_u32, 2_u32);
+    assert_eq!(v, v.xy());
+    assert_eq!(v.xxxx(), uvec4(1_u32, 1_u32, 1_u32, 1_u32));
+    assert_eq!(v.xxxy(), uvec4(1_u32, 1_u32, 1_u32, 2_u32));
+    assert_eq!(v.xxyx(), uvec4(1_u32, 1_u32, 2_u32, 1_u32));
+    assert_eq!(v.xxyy(), uvec4(1_u32, 1_u32, 2_u32, 2_u32));
+    assert_eq!(v.xyxx(), uvec4(1_u32, 2_u32, 1_u32, 1_u32));
+    assert_eq!(v.xyxy(), uvec4(1_u32, 2_u32, 1_u32, 2_u32));
+    assert_eq!(v.xyyx(), uvec4(1_u32, 2_u32, 2_u32, 1_u32));
+    assert_eq!(v.xyyy(), uvec4(1_u32, 2_u32, 2_u32, 2_u32));
+    assert_eq!(v.yxxx(), uvec4(2_u32, 1_u32, 1_u32, 1_u32));
+    assert_eq!(v.yxxy(), uvec4(2_u32, 1_u32, 1_u32, 2_u32));
+    assert_eq!(v.yxyx(), uvec4(2_u32, 1_u32, 2_u32, 1_u32));
+    assert_eq!(v.yxyy(), uvec4(2_u32, 1_u32, 2_u32, 2_u32));
+    assert_eq!(v.yyxx(), uvec4(2_u32, 2_u32, 1_u32, 1_u32));
+    assert_eq!(v.yyxy(), uvec4(2_u32, 2_u32, 1_u32, 2_u32));
+    assert_eq!(v.yyyx(), uvec4(2_u32, 2_u32, 2_u32, 1_u32));
+    assert_eq!(v.yyyy(), uvec4(2_u32, 2_u32, 2_u32, 2_u32));
+    assert_eq!(v.xxx(), uvec3(1_u32, 1_u32, 1_u32));
+    assert_eq!(v.xxy(), uvec3(1_u32, 1_u32, 2_u32));
+    assert_eq!(v.xyx(), uvec3(1_u32, 2_u32, 1_u32));
+    assert_eq!(v.xyy(), uvec3(1_u32, 2_u32, 2_u32));
+    assert_eq!(v.yxx(), uvec3(2_u32, 1_u32, 1_u32));
+    assert_eq!(v.yxy(), uvec3(2_u32, 1_u32, 2_u32));
+    assert_eq!(v.yyx(), uvec3(2_u32, 2_u32, 1_u32));
+    assert_eq!(v.yyy(), uvec3(2_u32, 2_u32, 2_u32));
+    assert_eq!(v.xx(), uvec2(1_u32, 1_u32));
+    assert_eq!(v.yx(), uvec2(2_u32, 1_u32));
+    assert_eq!(v.yy(), uvec2(2_u32, 2_u32));
+});

vendor/glam/tests/swizzles_u64.rs

@@ -0,0 +1,497 @@
+// Generated by swizzlegen. Do not edit.
+#[macro_use]
+mod support;
+use glam::*;
+
+glam_test!(test_u64vec4_swizzles, {
+    let v = u64vec4(1_u64, 2_u64, 3_u64, 4_u64);
+    assert_eq!(v, v.xyzw());
+    assert_eq!(v.xxxx(), u64vec4(1_u64, 1_u64, 1_u64, 1_u64));
+    assert_eq!(v.xxxy(), u64vec4(1_u64, 1_u64, 1_u64, 2_u64));
+    assert_eq!(v.xxxz(), u64vec4(1_u64, 1_u64, 1_u64, 3_u64));
+    assert_eq!(v.xxxw(), u64vec4(1_u64, 1_u64, 1_u64, 4_u64));
+    assert_eq!(v.xxyx(), u64vec4(1_u64, 1_u64, 2_u64, 1_u64));
+    assert_eq!(v.xxyy(), u64vec4(1_u64, 1_u64, 2_u64, 2_u64));
+    assert_eq!(v.xxyz(), u64vec4(1_u64, 1_u64, 2_u64, 3_u64));
+    assert_eq!(v.xxyw(), u64vec4(1_u64, 1_u64, 2_u64, 4_u64));
+    assert_eq!(v.xxzx(), u64vec4(1_u64, 1_u64, 3_u64, 1_u64));
+    assert_eq!(v.xxzy(), u64vec4(1_u64, 1_u64, 3_u64, 2_u64));
+    assert_eq!(v.xxzz(), u64vec4(1_u64, 1_u64, 3_u64, 3_u64));
+    assert_eq!(v.xxzw(), u64vec4(1_u64, 1_u64, 3_u64, 4_u64));
+    assert_eq!(v.xxwx(), u64vec4(1_u64, 1_u64, 4_u64, 1_u64));
+    assert_eq!(v.xxwy(), u64vec4(1_u64, 1_u64, 4_u64, 2_u64));
+    assert_eq!(v.xxwz(), u64vec4(1_u64, 1_u64, 4_u64, 3_u64));
+    assert_eq!(v.xxww(), u64vec4(1_u64, 1_u64, 4_u64, 4_u64));
+    assert_eq!(v.xyxx(), u64vec4(1_u64, 2_u64, 1_u64, 1_u64));
+    assert_eq!(v.xyxy(), u64vec4(1_u64, 2_u64, 1_u64, 2_u64));
+    assert_eq!(v.xyxz(), u64vec4(1_u64, 2_u64, 1_u64, 3_u64));
+    assert_eq!(v.xyxw(), u64vec4(1_u64, 2_u64, 1_u64, 4_u64));
+    assert_eq!(v.xyyx(), u64vec4(1_u64, 2_u64, 2_u64, 1_u64));
+    assert_eq!(v.xyyy(), u64vec4(1_u64, 2_u64, 2_u64, 2_u64));
+    assert_eq!(v.xyyz(), u64vec4(1_u64, 2_u64, 2_u64, 3_u64));
+    assert_eq!(v.xyyw(), u64vec4(1_u64, 2_u64, 2_u64, 4_u64));
+    assert_eq!(v.xyzx(), u64vec4(1_u64, 2_u64, 3_u64, 1_u64));
+    assert_eq!(v.xyzy(), u64vec4(1_u64, 2_u64, 3_u64, 2_u64));
+    assert_eq!(v.xyzz(), u64vec4(1_u64, 2_u64, 3_u64, 3_u64));
+    assert_eq!(v.xywx(), u64vec4(1_u64, 2_u64, 4_u64, 1_u64));
+    assert_eq!(v.xywy(), u64vec4(1_u64, 2_u64, 4_u64, 2_u64));
+    assert_eq!(v.xywz(), u64vec4(1_u64, 2_u64, 4_u64, 3_u64));
+    assert_eq!(v.xyww(), u64vec4(1_u64, 2_u64, 4_u64, 4_u64));
+    assert_eq!(v.xzxx(), u64vec4(1_u64, 3_u64, 1_u64, 1_u64));
+    assert_eq!(v.xzxy(), u64vec4(1_u64, 3_u64, 1_u64, 2_u64));
+    assert_eq!(v.xzxz(), u64vec4(1_u64, 3_u64, 1_u64, 3_u64));
+    assert_eq!(v.xzxw(), u64vec4(1_u64, 3_u64, 1_u64, 4_u64));
+    assert_eq!(v.xzyx(), u64vec4(1_u64, 3_u64, 2_u64, 1_u64));
+    assert_eq!(v.xzyy(), u64vec4(1_u64, 3_u64, 2_u64, 2_u64));
+    assert_eq!(v.xzyz(), u64vec4(1_u64, 3_u64, 2_u64, 3_u64));
+    assert_eq!(v.xzyw(), u64vec4(1_u64, 3_u64, 2_u64, 4_u64));
+    assert_eq!(v.xzzx(), u64vec4(1_u64, 3_u64, 3_u64, 1_u64));
+    assert_eq!(v.xzzy(), u64vec4(1_u64, 3_u64, 3_u64, 2_u64));
+    assert_eq!(v.xzzz(), u64vec4(1_u64, 3_u64, 3_u64, 3_u64));
+    assert_eq!(v.xzzw(), u64vec4(1_u64, 3_u64, 3_u64, 4_u64));
+    assert_eq!(v.xzwx(), u64vec4(1_u64, 3_u64, 4_u64, 1_u64));
+    assert_eq!(v.xzwy(), u64vec4(1_u64, 3_u64, 4_u64, 2_u64));
+    assert_eq!(v.xzwz(), u64vec4(1_u64, 3_u64, 4_u64, 3_u64));
+    assert_eq!(v.xzww(), u64vec4(1_u64, 3_u64, 4_u64, 4_u64));
+    assert_eq!(v.xwxx(), u64vec4(1_u64, 4_u64, 1_u64, 1_u64));
+    assert_eq!(v.xwxy(), u64vec4(1_u64, 4_u64, 1_u64, 2_u64));
+    assert_eq!(v.xwxz(), u64vec4(1_u64, 4_u64, 1_u64, 3_u64));
+    assert_eq!(v.xwxw(), u64vec4(1_u64, 4_u64, 1_u64, 4_u64));
+    assert_eq!(v.xwyx(), u64vec4(1_u64, 4_u64, 2_u64, 1_u64));
+    assert_eq!(v.xwyy(), u64vec4(1_u64, 4_u64, 2_u64, 2_u64));
+    assert_eq!(v.xwyz(), u64vec4(1_u64, 4_u64, 2_u64, 3_u64));
+    assert_eq!(v.xwyw(), u64vec4(1_u64, 4_u64, 2_u64, 4_u64));
+    assert_eq!(v.xwzx(), u64vec4(1_u64, 4_u64, 3_u64, 1_u64));
+    assert_eq!(v.xwzy(), u64vec4(1_u64, 4_u64, 3_u64, 2_u64));
+    assert_eq!(v.xwzz(), u64vec4(1_u64, 4_u64, 3_u64, 3_u64));
+    assert_eq!(v.xwzw(), u64vec4(1_u64, 4_u64, 3_u64, 4_u64));
+    assert_eq!(v.xwwx(), u64vec4(1_u64, 4_u64, 4_u64, 1_u64));
+    assert_eq!(v.xwwy(), u64vec4(1_u64, 4_u64, 4_u64, 2_u64));
+    assert_eq!(v.xwwz(), u64vec4(1_u64, 4_u64, 4_u64, 3_u64));
+    assert_eq!(v.xwww(), u64vec4(1_u64, 4_u64, 4_u64, 4_u64));
+    assert_eq!(v.yxxx(), u64vec4(2_u64, 1_u64, 1_u64, 1_u64));
+    assert_eq!(v.yxxy(), u64vec4(2_u64, 1_u64, 1_u64, 2_u64));
+    assert_eq!(v.yxxz(), u64vec4(2_u64, 1_u64, 1_u64, 3_u64));
+    assert_eq!(v.yxxw(), u64vec4(2_u64, 1_u64, 1_u64, 4_u64));
+    assert_eq!(v.yxyx(), u64vec4(2_u64, 1_u64, 2_u64, 1_u64));
+    assert_eq!(v.yxyy(), u64vec4(2_u64, 1_u64, 2_u64, 2_u64));
+    assert_eq!(v.yxyz(), u64vec4(2_u64, 1_u64, 2_u64, 3_u64));
+    assert_eq!(v.yxyw(), u64vec4(2_u64, 1_u64, 2_u64, 4_u64));
+    assert_eq!(v.yxzx(), u64vec4(2_u64, 1_u64, 3_u64, 1_u64));
+    assert_eq!(v.yxzy(), u64vec4(2_u64, 1_u64, 3_u64, 2_u64));
+    assert_eq!(v.yxzz(), u64vec4(2_u64, 1_u64, 3_u64, 3_u64));
+    assert_eq!(v.yxzw(), u64vec4(2_u64, 1_u64, 3_u64, 4_u64));
+    assert_eq!(v.yxwx(), u64vec4(2_u64, 1_u64, 4_u64, 1_u64));
+    assert_eq!(v.yxwy(), u64vec4(2_u64, 1_u64, 4_u64, 2_u64));
+    assert_eq!(v.yxwz(), u64vec4(2_u64, 1_u64, 4_u64, 3_u64));
+    assert_eq!(v.yxww(), u64vec4(2_u64, 1_u64, 4_u64, 4_u64));
+    assert_eq!(v.yyxx(), u64vec4(2_u64, 2_u64, 1_u64, 1_u64));
+    assert_eq!(v.yyxy(), u64vec4(2_u64, 2_u64, 1_u64, 2_u64));
+    assert_eq!(v.yyxz(), u64vec4(2_u64, 2_u64, 1_u64, 3_u64));
+    assert_eq!(v.yyxw(), u64vec4(2_u64, 2_u64, 1_u64, 4_u64));
+    assert_eq!(v.yyyx(), u64vec4(2_u64, 2_u64, 2_u64, 1_u64));
+    assert_eq!(v.yyyy(), u64vec4(2_u64, 2_u64, 2_u64, 2_u64));
+    assert_eq!(v.yyyz(), u64vec4(2_u64, 2_u64, 2_u64, 3_u64));
+    assert_eq!(v.yyyw(), u64vec4(2_u64, 2_u64, 2_u64, 4_u64));
+    assert_eq!(v.yyzx(), u64vec4(2_u64, 2_u64, 3_u64, 1_u64));
+    assert_eq!(v.yyzy(), u64vec4(2_u64, 2_u64, 3_u64, 2_u64));
+    assert_eq!(v.yyzz(), u64vec4(2_u64, 2_u64, 3_u64, 3_u64));
+    assert_eq!(v.yyzw(), u64vec4(2_u64, 2_u64, 3_u64, 4_u64));
+    assert_eq!(v.yywx(), u64vec4(2_u64, 2_u64, 4_u64, 1_u64));
+    assert_eq!(v.yywy(), u64vec4(2_u64, 2_u64, 4_u64, 2_u64));
+    assert_eq!(v.yywz(), u64vec4(2_u64, 2_u64, 4_u64, 3_u64));
+    assert_eq!(v.yyww(), u64vec4(2_u64, 2_u64, 4_u64, 4_u64));
+    assert_eq!(v.yzxx(), u64vec4(2_u64, 3_u64, 1_u64, 1_u64));
+    assert_eq!(v.yzxy(), u64vec4(2_u64, 3_u64, 1_u64, 2_u64));
+    assert_eq!(v.yzxz(), u64vec4(2_u64, 3_u64, 1_u64, 3_u64));
+    assert_eq!(v.yzxw(), u64vec4(2_u64, 3_u64, 1_u64, 4_u64));
+    assert_eq!(v.yzyx(), u64vec4(2_u64, 3_u64, 2_u64, 1_u64));
+    assert_eq!(v.yzyy(), u64vec4(2_u64, 3_u64, 2_u64, 2_u64));
+    assert_eq!(v.yzyz(), u64vec4(2_u64, 3_u64, 2_u64, 3_u64));
+    assert_eq!(v.yzyw(), u64vec4(2_u64, 3_u64, 2_u64, 4_u64));
+    assert_eq!(v.yzzx(), u64vec4(2_u64, 3_u64, 3_u64, 1_u64));
+    assert_eq!(v.yzzy(), u64vec4(2_u64, 3_u64, 3_u64, 2_u64));
+    assert_eq!(v.yzzz(), u64vec4(2_u64, 3_u64, 3_u64, 3_u64));
+    assert_eq!(v.yzzw(), u64vec4(2_u64, 3_u64, 3_u64, 4_u64));
+    assert_eq!(v.yzwx(), u64vec4(2_u64, 3_u64, 4_u64, 1_u64));
+    assert_eq!(v.yzwy(), u64vec4(2_u64, 3_u64, 4_u64, 2_u64));
+    assert_eq!(v.yzwz(), u64vec4(2_u64, 3_u64, 4_u64, 3_u64));
+    assert_eq!(v.yzww(), u64vec4(2_u64, 3_u64, 4_u64, 4_u64));
+    assert_eq!(v.ywxx(), u64vec4(2_u64, 4_u64, 1_u64, 1_u64));
+    assert_eq!(v.ywxy(), u64vec4(2_u64, 4_u64, 1_u64, 2_u64));
+    assert_eq!(v.ywxz(), u64vec4(2_u64, 4_u64, 1_u64, 3_u64));
+    assert_eq!(v.ywxw(), u64vec4(2_u64, 4_u64, 1_u64, 4_u64));
+    assert_eq!(v.ywyx(), u64vec4(2_u64, 4_u64, 2_u64, 1_u64));
+    assert_eq!(v.ywyy(), u64vec4(2_u64, 4_u64, 2_u64, 2_u64));
+    assert_eq!(v.ywyz(), u64vec4(2_u64, 4_u64, 2_u64, 3_u64));
+    assert_eq!(v.ywyw(), u64vec4(2_u64, 4_u64, 2_u64, 4_u64));
+    assert_eq!(v.ywzx(), u64vec4(2_u64, 4_u64, 3_u64, 1_u64));
+    assert_eq!(v.ywzy(), u64vec4(2_u64, 4_u64, 3_u64, 2_u64));
+    assert_eq!(v.ywzz(), u64vec4(2_u64, 4_u64, 3_u64, 3_u64));
+    assert_eq!(v.ywzw(), u64vec4(2_u64, 4_u64, 3_u64, 4_u64));
+    assert_eq!(v.ywwx(), u64vec4(2_u64, 4_u64, 4_u64, 1_u64));
+    assert_eq!(v.ywwy(), u64vec4(2_u64, 4_u64, 4_u64, 2_u64));
+    assert_eq!(v.ywwz(), u64vec4(2_u64, 4_u64, 4_u64, 3_u64));
+    assert_eq!(v.ywww(), u64vec4(2_u64, 4_u64, 4_u64, 4_u64));
+    assert_eq!(v.zxxx(), u64vec4(3_u64, 1_u64, 1_u64, 1_u64));
+    assert_eq!(v.zxxy(), u64vec4(3_u64, 1_u64, 1_u64, 2_u64));
+    assert_eq!(v.zxxz(), u64vec4(3_u64, 1_u64, 1_u64, 3_u64));
+    assert_eq!(v.zxxw(), u64vec4(3_u64, 1_u64, 1_u64, 4_u64));
+    assert_eq!(v.zxyx(), u64vec4(3_u64, 1_u64, 2_u64, 1_u64));
+    assert_eq!(v.zxyy(), u64vec4(3_u64, 1_u64, 2_u64, 2_u64));
+    assert_eq!(v.zxyz(), u64vec4(3_u64, 1_u64, 2_u64, 3_u64));
+    assert_eq!(v.zxyw(), u64vec4(3_u64, 1_u64, 2_u64, 4_u64));
+    assert_eq!(v.zxzx(), u64vec4(3_u64, 1_u64, 3_u64, 1_u64));
+    assert_eq!(v.zxzy(), u64vec4(3_u64, 1_u64, 3_u64, 2_u64));
+    assert_eq!(v.zxzz(), u64vec4(3_u64, 1_u64, 3_u64, 3_u64));
+    assert_eq!(v.zxzw(), u64vec4(3_u64, 1_u64, 3_u64, 4_u64));
+    assert_eq!(v.zxwx(), u64vec4(3_u64, 1_u64, 4_u64, 1_u64));
+    assert_eq!(v.zxwy(), u64vec4(3_u64, 1_u64, 4_u64, 2_u64));
+    assert_eq!(v.zxwz(), u64vec4(3_u64, 1_u64, 4_u64, 3_u64));
+    assert_eq!(v.zxww(), u64vec4(3_u64, 1_u64, 4_u64, 4_u64));
+    assert_eq!(v.zyxx(), u64vec4(3_u64, 2_u64, 1_u64, 1_u64));
+    assert_eq!(v.zyxy(), u64vec4(3_u64, 2_u64, 1_u64, 2_u64));
+    assert_eq!(v.zyxz(), u64vec4(3_u64, 2_u64, 1_u64, 3_u64));
+    assert_eq!(v.zyxw(), u64vec4(3_u64, 2_u64, 1_u64, 4_u64));
+    assert_eq!(v.zyyx(), u64vec4(3_u64, 2_u64, 2_u64, 1_u64));
+    assert_eq!(v.zyyy(), u64vec4(3_u64, 2_u64, 2_u64, 2_u64));
+    assert_eq!(v.zyyz(), u64vec4(3_u64, 2_u64, 2_u64, 3_u64));
+    assert_eq!(v.zyyw(), u64vec4(3_u64, 2_u64, 2_u64, 4_u64));
+    assert_eq!(v.zyzx(), u64vec4(3_u64, 2_u64, 3_u64, 1_u64));
+    assert_eq!(v.zyzy(), u64vec4(3_u64, 2_u64, 3_u64, 2_u64));
+    assert_eq!(v.zyzz(), u64vec4(3_u64, 2_u64, 3_u64, 3_u64));
+    assert_eq!(v.zyzw(), u64vec4(3_u64, 2_u64, 3_u64, 4_u64));
+    assert_eq!(v.zywx(), u64vec4(3_u64, 2_u64, 4_u64, 1_u64));
+    assert_eq!(v.zywy(), u64vec4(3_u64, 2_u64, 4_u64, 2_u64));
+    assert_eq!(v.zywz(), u64vec4(3_u64, 2_u64, 4_u64, 3_u64));
+    assert_eq!(v.zyww(), u64vec4(3_u64, 2_u64, 4_u64, 4_u64));
+    assert_eq!(v.zzxx(), u64vec4(3_u64, 3_u64, 1_u64, 1_u64));
+    assert_eq!(v.zzxy(), u64vec4(3_u64, 3_u64, 1_u64, 2_u64));
+    assert_eq!(v.zzxz(), u64vec4(3_u64, 3_u64, 1_u64, 3_u64));
+    assert_eq!(v.zzxw(), u64vec4(3_u64, 3_u64, 1_u64, 4_u64));
+    assert_eq!(v.zzyx(), u64vec4(3_u64, 3_u64, 2_u64, 1_u64));
+    assert_eq!(v.zzyy(), u64vec4(3_u64, 3_u64, 2_u64, 2_u64));
+    assert_eq!(v.zzyz(), u64vec4(3_u64, 3_u64, 2_u64, 3_u64));
+    assert_eq!(v.zzyw(), u64vec4(3_u64, 3_u64, 2_u64, 4_u64));
+    assert_eq!(v.zzzx(), u64vec4(3_u64, 3_u64, 3_u64, 1_u64));
+    assert_eq!(v.zzzy(), u64vec4(3_u64, 3_u64, 3_u64, 2_u64));
+    assert_eq!(v.zzzz(), u64vec4(3_u64, 3_u64, 3_u64, 3_u64));
+    assert_eq!(v.zzzw(), u64vec4(3_u64, 3_u64, 3_u64, 4_u64));
+    assert_eq!(v.zzwx(), u64vec4(3_u64, 3_u64, 4_u64, 1_u64));
+    assert_eq!(v.zzwy(), u64vec4(3_u64, 3_u64, 4_u64, 2_u64));
+    assert_eq!(v.zzwz(), u64vec4(3_u64, 3_u64, 4_u64, 3_u64));
+    assert_eq!(v.zzww(), u64vec4(3_u64, 3_u64, 4_u64, 4_u64));
+    assert_eq!(v.zwxx(), u64vec4(3_u64, 4_u64, 1_u64, 1_u64));
+    assert_eq!(v.zwxy(), u64vec4(3_u64, 4_u64, 1_u64, 2_u64));
+    assert_eq!(v.zwxz(), u64vec4(3_u64, 4_u64, 1_u64, 3_u64));
+    assert_eq!(v.zwxw(), u64vec4(3_u64, 4_u64, 1_u64, 4_u64));
+    assert_eq!(v.zwyx(), u64vec4(3_u64, 4_u64, 2_u64, 1_u64));
+    assert_eq!(v.zwyy(), u64vec4(3_u64, 4_u64, 2_u64, 2_u64));
+    assert_eq!(v.zwyz(), u64vec4(3_u64, 4_u64, 2_u64, 3_u64));
+    assert_eq!(v.zwyw(), u64vec4(3_u64, 4_u64, 2_u64, 4_u64));
+    assert_eq!(v.zwzx(), u64vec4(3_u64, 4_u64, 3_u64, 1_u64));
+    assert_eq!(v.zwzy(), u64vec4(3_u64, 4_u64, 3_u64, 2_u64));
+    assert_eq!(v.zwzz(), u64vec4(3_u64, 4_u64, 3_u64, 3_u64));
+    assert_eq!(v.zwzw(), u64vec4(3_u64, 4_u64, 3_u64, 4_u64));
+    assert_eq!(v.zwwx(), u64vec4(3_u64, 4_u64, 4_u64, 1_u64));
+    assert_eq!(v.zwwy(), u64vec4(3_u64, 4_u64, 4_u64, 2_u64));
+    assert_eq!(v.zwwz(), u64vec4(3_u64, 4_u64, 4_u64, 3_u64));
+    assert_eq!(v.zwww(), u64vec4(3_u64, 4_u64, 4_u64, 4_u64));
+    assert_eq!(v.wxxx(), u64vec4(4_u64, 1_u64, 1_u64, 1_u64));
+    assert_eq!(v.wxxy(), u64vec4(4_u64, 1_u64, 1_u64, 2_u64));
+    assert_eq!(v.wxxz(), u64vec4(4_u64, 1_u64, 1_u64, 3_u64));
+    assert_eq!(v.wxxw(), u64vec4(4_u64, 1_u64, 1_u64, 4_u64));
+    assert_eq!(v.wxyx(), u64vec4(4_u64, 1_u64, 2_u64, 1_u64));
+    assert_eq!(v.wxyy(), u64vec4(4_u64, 1_u64, 2_u64, 2_u64));
+    assert_eq!(v.wxyz(), u64vec4(4_u64, 1_u64, 2_u64, 3_u64));
+    assert_eq!(v.wxyw(), u64vec4(4_u64, 1_u64, 2_u64, 4_u64));
+    assert_eq!(v.wxzx(), u64vec4(4_u64, 1_u64, 3_u64, 1_u64));
+    assert_eq!(v.wxzy(), u64vec4(4_u64, 1_u64, 3_u64, 2_u64));
+    assert_eq!(v.wxzz(), u64vec4(4_u64, 1_u64, 3_u64, 3_u64));
+    assert_eq!(v.wxzw(), u64vec4(4_u64, 1_u64, 3_u64, 4_u64));
+    assert_eq!(v.wxwx(), u64vec4(4_u64, 1_u64, 4_u64, 1_u64));
+    assert_eq!(v.wxwy(), u64vec4(4_u64, 1_u64, 4_u64, 2_u64));
+    assert_eq!(v.wxwz(), u64vec4(4_u64, 1_u64, 4_u64, 3_u64));
+    assert_eq!(v.wxww(), u64vec4(4_u64, 1_u64, 4_u64, 4_u64));
+    assert_eq!(v.wyxx(), u64vec4(4_u64, 2_u64, 1_u64, 1_u64));
+    assert_eq!(v.wyxy(), u64vec4(4_u64, 2_u64, 1_u64, 2_u64));
+    assert_eq!(v.wyxz(), u64vec4(4_u64, 2_u64, 1_u64, 3_u64));
+    assert_eq!(v.wyxw(), u64vec4(4_u64, 2_u64, 1_u64, 4_u64));
+    assert_eq!(v.wyyx(), u64vec4(4_u64, 2_u64, 2_u64, 1_u64));
+    assert_eq!(v.wyyy(), u64vec4(4_u64, 2_u64, 2_u64, 2_u64));
+    assert_eq!(v.wyyz(), u64vec4(4_u64, 2_u64, 2_u64, 3_u64));
+    assert_eq!(v.wyyw(), u64vec4(4_u64, 2_u64, 2_u64, 4_u64));
+    assert_eq!(v.wyzx(), u64vec4(4_u64, 2_u64, 3_u64, 1_u64));
+    assert_eq!(v.wyzy(), u64vec4(4_u64, 2_u64, 3_u64, 2_u64));
+    assert_eq!(v.wyzz(), u64vec4(4_u64, 2_u64, 3_u64, 3_u64));
+    assert_eq!(v.wyzw(), u64vec4(4_u64, 2_u64, 3_u64, 4_u64));
+    assert_eq!(v.wywx(), u64vec4(4_u64, 2_u64, 4_u64, 1_u64));
+    assert_eq!(v.wywy(), u64vec4(4_u64, 2_u64, 4_u64, 2_u64));
+    assert_eq!(v.wywz(), u64vec4(4_u64, 2_u64, 4_u64, 3_u64));
+    assert_eq!(v.wyww(), u64vec4(4_u64, 2_u64, 4_u64, 4_u64));
+    assert_eq!(v.wzxx(), u64vec4(4_u64, 3_u64, 1_u64, 1_u64));
+    assert_eq!(v.wzxy(), u64vec4(4_u64, 3_u64, 1_u64, 2_u64));
+    assert_eq!(v.wzxz(), u64vec4(4_u64, 3_u64, 1_u64, 3_u64));
+    assert_eq!(v.wzxw(), u64vec4(4_u64, 3_u64, 1_u64, 4_u64));
+    assert_eq!(v.wzyx(), u64vec4(4_u64, 3_u64, 2_u64, 1_u64));
+    assert_eq!(v.wzyy(), u64vec4(4_u64, 3_u64, 2_u64, 2_u64));
+    assert_eq!(v.wzyz(), u64vec4(4_u64, 3_u64, 2_u64, 3_u64));
+    assert_eq!(v.wzyw(), u64vec4(4_u64, 3_u64, 2_u64, 4_u64));
+    assert_eq!(v.wzzx(), u64vec4(4_u64, 3_u64, 3_u64, 1_u64));
+    assert_eq!(v.wzzy(), u64vec4(4_u64, 3_u64, 3_u64, 2_u64));
+    assert_eq!(v.wzzz(), u64vec4(4_u64, 3_u64, 3_u64, 3_u64));
+    assert_eq!(v.wzzw(), u64vec4(4_u64, 3_u64, 3_u64, 4_u64));
+    assert_eq!(v.wzwx(), u64vec4(4_u64, 3_u64, 4_u64, 1_u64));
+    assert_eq!(v.wzwy(), u64vec4(4_u64, 3_u64, 4_u64, 2_u64));
+    assert_eq!(v.wzwz(), u64vec4(4_u64, 3_u64, 4_u64, 3_u64));
+    assert_eq!(v.wzww(), u64vec4(4_u64, 3_u64, 4_u64, 4_u64));
+    assert_eq!(v.wwxx(), u64vec4(4_u64, 4_u64, 1_u64, 1_u64));
+    assert_eq!(v.wwxy(), u64vec4(4_u64, 4_u64, 1_u64, 2_u64));
+    assert_eq!(v.wwxz(), u64vec4(4_u64, 4_u64, 1_u64, 3_u64));
+    assert_eq!(v.wwxw(), u64vec4(4_u64, 4_u64, 1_u64, 4_u64));
+    assert_eq!(v.wwyx(), u64vec4(4_u64, 4_u64, 2_u64, 1_u64));
+    assert_eq!(v.wwyy(), u64vec4(4_u64, 4_u64, 2_u64, 2_u64));
+    assert_eq!(v.wwyz(), u64vec4(4_u64, 4_u64, 2_u64, 3_u64));
+    assert_eq!(v.wwyw(), u64vec4(4_u64, 4_u64, 2_u64, 4_u64));
+    assert_eq!(v.wwzx(), u64vec4(4_u64, 4_u64, 3_u64, 1_u64));
+    assert_eq!(v.wwzy(), u64vec4(4_u64, 4_u64, 3_u64, 2_u64));
+    assert_eq!(v.wwzz(), u64vec4(4_u64, 4_u64, 3_u64, 3_u64));
+    assert_eq!(v.wwzw(), u64vec4(4_u64, 4_u64, 3_u64, 4_u64));
+    assert_eq!(v.wwwx(), u64vec4(4_u64, 4_u64, 4_u64, 1_u64));
+    assert_eq!(v.wwwy(), u64vec4(4_u64, 4_u64, 4_u64, 2_u64));
+    assert_eq!(v.wwwz(), u64vec4(4_u64, 4_u64, 4_u64, 3_u64));
+    assert_eq!(v.wwww(), u64vec4(4_u64, 4_u64, 4_u64, 4_u64));
+    assert_eq!(v.xxx(), u64vec3(1_u64, 1_u64, 1_u64));
+    assert_eq!(v.xxy(), u64vec3(1_u64, 1_u64, 2_u64));
+    assert_eq!(v.xxz(), u64vec3(1_u64, 1_u64, 3_u64));
+    assert_eq!(v.xxw(), u64vec3(1_u64, 1_u64, 4_u64));
+    assert_eq!(v.xyx(), u64vec3(1_u64, 2_u64, 1_u64));
+    assert_eq!(v.xyy(), u64vec3(1_u64, 2_u64, 2_u64));
+    assert_eq!(v.xyz(), u64vec3(1_u64, 2_u64, 3_u64));
+    assert_eq!(v.xyw(), u64vec3(1_u64, 2_u64, 4_u64));
+    assert_eq!(v.xzx(), u64vec3(1_u64, 3_u64, 1_u64));
+    assert_eq!(v.xzy(), u64vec3(1_u64, 3_u64, 2_u64));
+    assert_eq!(v.xzz(), u64vec3(1_u64, 3_u64, 3_u64));
+    assert_eq!(v.xzw(), u64vec3(1_u64, 3_u64, 4_u64));
+    assert_eq!(v.xwx(), u64vec3(1_u64, 4_u64, 1_u64));
+    assert_eq!(v.xwy(), u64vec3(1_u64, 4_u64, 2_u64));
+    assert_eq!(v.xwz(), u64vec3(1_u64, 4_u64, 3_u64));
+    assert_eq!(v.xww(), u64vec3(1_u64, 4_u64, 4_u64));
+    assert_eq!(v.yxx(), u64vec3(2_u64, 1_u64, 1_u64));
+    assert_eq!(v.yxy(), u64vec3(2_u64, 1_u64, 2_u64));
+    assert_eq!(v.yxz(), u64vec3(2_u64, 1_u64, 3_u64));
+    assert_eq!(v.yxw(), u64vec3(2_u64, 1_u64, 4_u64));
+    assert_eq!(v.yyx(), u64vec3(2_u64, 2_u64, 1_u64));
+    assert_eq!(v.yyy(), u64vec3(2_u64, 2_u64, 2_u64));
+    assert_eq!(v.yyz(), u64vec3(2_u64, 2_u64, 3_u64));
+    assert_eq!(v.yyw(), u64vec3(2_u64, 2_u64, 4_u64));
+    assert_eq!(v.yzx(), u64vec3(2_u64, 3_u64, 1_u64));
+    assert_eq!(v.yzy(), u64vec3(2_u64, 3_u64, 2_u64));
+    assert_eq!(v.yzz(), u64vec3(2_u64, 3_u64, 3_u64));
+    assert_eq!(v.yzw(), u64vec3(2_u64, 3_u64, 4_u64));
+    assert_eq!(v.ywx(), u64vec3(2_u64, 4_u64, 1_u64));
+    assert_eq!(v.ywy(), u64vec3(2_u64, 4_u64, 2_u64));
+    assert_eq!(v.ywz(), u64vec3(2_u64, 4_u64, 3_u64));
+    assert_eq!(v.yww(), u64vec3(2_u64, 4_u64, 4_u64));
+    assert_eq!(v.zxx(), u64vec3(3_u64, 1_u64, 1_u64));
+    assert_eq!(v.zxy(), u64vec3(3_u64, 1_u64, 2_u64));
+    assert_eq!(v.zxz(), u64vec3(3_u64, 1_u64, 3_u64));
+    assert_eq!(v.zxw(), u64vec3(3_u64, 1_u64, 4_u64));
+    assert_eq!(v.zyx(), u64vec3(3_u64, 2_u64, 1_u64));
+    assert_eq!(v.zyy(), u64vec3(3_u64, 2_u64, 2_u64));
+    assert_eq!(v.zyz(), u64vec3(3_u64, 2_u64, 3_u64));
+    assert_eq!(v.zyw(), u64vec3(3_u64, 2_u64, 4_u64));
+    assert_eq!(v.zzx(), u64vec3(3_u64, 3_u64, 1_u64));
+    assert_eq!(v.zzy(), u64vec3(3_u64, 3_u64, 2_u64));
+    assert_eq!(v.zzz(), u64vec3(3_u64, 3_u64, 3_u64));
+    assert_eq!(v.zzw(), u64vec3(3_u64, 3_u64, 4_u64));
+    assert_eq!(v.zwx(), u64vec3(3_u64, 4_u64, 1_u64));
+    assert_eq!(v.zwy(), u64vec3(3_u64, 4_u64, 2_u64));
+    assert_eq!(v.zwz(), u64vec3(3_u64, 4_u64, 3_u64));
+    assert_eq!(v.zww(), u64vec3(3_u64, 4_u64, 4_u64));
+    assert_eq!(v.wxx(), u64vec3(4_u64, 1_u64, 1_u64));
+    assert_eq!(v.wxy(), u64vec3(4_u64, 1_u64, 2_u64));
+    assert_eq!(v.wxz(), u64vec3(4_u64, 1_u64, 3_u64));
+    assert_eq!(v.wxw(), u64vec3(4_u64, 1_u64, 4_u64));
+    assert_eq!(v.wyx(), u64vec3(4_u64, 2_u64, 1_u64));
+    assert_eq!(v.wyy(), u64vec3(4_u64, 2_u64, 2_u64));
+    assert_eq!(v.wyz(), u64vec3(4_u64, 2_u64, 3_u64));
+    assert_eq!(v.wyw(), u64vec3(4_u64, 2_u64, 4_u64));
+    assert_eq!(v.wzx(), u64vec3(4_u64, 3_u64, 1_u64));
+    assert_eq!(v.wzy(), u64vec3(4_u64, 3_u64, 2_u64));
+    assert_eq!(v.wzz(), u64vec3(4_u64, 3_u64, 3_u64));
+    assert_eq!(v.wzw(), u64vec3(4_u64, 3_u64, 4_u64));
+    assert_eq!(v.wwx(), u64vec3(4_u64, 4_u64, 1_u64));
+    assert_eq!(v.wwy(), u64vec3(4_u64, 4_u64, 2_u64));
+    assert_eq!(v.wwz(), u64vec3(4_u64, 4_u64, 3_u64));
+    assert_eq!(v.www(), u64vec3(4_u64, 4_u64, 4_u64));
+    assert_eq!(v.xx(), u64vec2(1_u64, 1_u64));
+    assert_eq!(v.xy(), u64vec2(1_u64, 2_u64));
+    assert_eq!(v.xz(), u64vec2(1_u64, 3_u64));
+    assert_eq!(v.xw(), u64vec2(1_u64, 4_u64));
+    assert_eq!(v.yx(), u64vec2(2_u64, 1_u64));
+    assert_eq!(v.yy(), u64vec2(2_u64, 2_u64));
+    assert_eq!(v.yz(), u64vec2(2_u64, 3_u64));
+    assert_eq!(v.yw(), u64vec2(2_u64, 4_u64));
+    assert_eq!(v.zx(), u64vec2(3_u64, 1_u64));
+    assert_eq!(v.zy(), u64vec2(3_u64, 2_u64));
+    assert_eq!(v.zz(), u64vec2(3_u64, 3_u64));
+    assert_eq!(v.zw(), u64vec2(3_u64, 4_u64));
+    assert_eq!(v.wx(), u64vec2(4_u64, 1_u64));
+    assert_eq!(v.wy(), u64vec2(4_u64, 2_u64));
+    assert_eq!(v.wz(), u64vec2(4_u64, 3_u64));
+    assert_eq!(v.ww(), u64vec2(4_u64, 4_u64));
+});
+
+glam_test!(test_u64vec3_swizzles, {
+    let v = u64vec3(1_u64, 2_u64, 3_u64);
+    assert_eq!(v, v.xyz());
+    assert_eq!(v.xxxx(), u64vec4(1_u64, 1_u64, 1_u64, 1_u64));
+    assert_eq!(v.xxxy(), u64vec4(1_u64, 1_u64, 1_u64, 2_u64));
+    assert_eq!(v.xxxz(), u64vec4(1_u64, 1_u64, 1_u64, 3_u64));
+    assert_eq!(v.xxyx(), u64vec4(1_u64, 1_u64, 2_u64, 1_u64));
+    assert_eq!(v.xxyy(), u64vec4(1_u64, 1_u64, 2_u64, 2_u64));
+    assert_eq!(v.xxyz(), u64vec4(1_u64, 1_u64, 2_u64, 3_u64));
+    assert_eq!(v.xxzx(), u64vec4(1_u64, 1_u64, 3_u64, 1_u64));
+    assert_eq!(v.xxzy(), u64vec4(1_u64, 1_u64, 3_u64, 2_u64));
+    assert_eq!(v.xxzz(), u64vec4(1_u64, 1_u64, 3_u64, 3_u64));
+    assert_eq!(v.xyxx(), u64vec4(1_u64, 2_u64, 1_u64, 1_u64));
+    assert_eq!(v.xyxy(), u64vec4(1_u64, 2_u64, 1_u64, 2_u64));
+    assert_eq!(v.xyxz(), u64vec4(1_u64, 2_u64, 1_u64, 3_u64));
+    assert_eq!(v.xyyx(), u64vec4(1_u64, 2_u64, 2_u64, 1_u64));
+    assert_eq!(v.xyyy(), u64vec4(1_u64, 2_u64, 2_u64, 2_u64));
+    assert_eq!(v.xyyz(), u64vec4(1_u64, 2_u64, 2_u64, 3_u64));
+    assert_eq!(v.xyzx(), u64vec4(1_u64, 2_u64, 3_u64, 1_u64));
+    assert_eq!(v.xyzy(), u64vec4(1_u64, 2_u64, 3_u64, 2_u64));
+    assert_eq!(v.xyzz(), u64vec4(1_u64, 2_u64, 3_u64, 3_u64));
+    assert_eq!(v.xzxx(), u64vec4(1_u64, 3_u64, 1_u64, 1_u64));
+    assert_eq!(v.xzxy(), u64vec4(1_u64, 3_u64, 1_u64, 2_u64));
+    assert_eq!(v.xzxz(), u64vec4(1_u64, 3_u64, 1_u64, 3_u64));
+    assert_eq!(v.xzyx(), u64vec4(1_u64, 3_u64, 2_u64, 1_u64));
+    assert_eq!(v.xzyy(), u64vec4(1_u64, 3_u64, 2_u64, 2_u64));
+    assert_eq!(v.xzyz(), u64vec4(1_u64, 3_u64, 2_u64, 3_u64));
+    assert_eq!(v.xzzx(), u64vec4(1_u64, 3_u64, 3_u64, 1_u64));
+    assert_eq!(v.xzzy(), u64vec4(1_u64, 3_u64, 3_u64, 2_u64));
+    assert_eq!(v.xzzz(), u64vec4(1_u64, 3_u64, 3_u64, 3_u64));
+    assert_eq!(v.yxxx(), u64vec4(2_u64, 1_u64, 1_u64, 1_u64));
+    assert_eq!(v.yxxy(), u64vec4(2_u64, 1_u64, 1_u64, 2_u64));
+    assert_eq!(v.yxxz(), u64vec4(2_u64, 1_u64, 1_u64, 3_u64));
+    assert_eq!(v.yxyx(), u64vec4(2_u64, 1_u64, 2_u64, 1_u64));
+    assert_eq!(v.yxyy(), u64vec4(2_u64, 1_u64, 2_u64, 2_u64));
+    assert_eq!(v.yxyz(), u64vec4(2_u64, 1_u64, 2_u64, 3_u64));
+    assert_eq!(v.yxzx(), u64vec4(2_u64, 1_u64, 3_u64, 1_u64));
+    assert_eq!(v.yxzy(), u64vec4(2_u64, 1_u64, 3_u64, 2_u64));
+    assert_eq!(v.yxzz(), u64vec4(2_u64, 1_u64, 3_u64, 3_u64));
+    assert_eq!(v.yyxx(), u64vec4(2_u64, 2_u64, 1_u64, 1_u64));
+    assert_eq!(v.yyxy(), u64vec4(2_u64, 2_u64, 1_u64, 2_u64));
+    assert_eq!(v.yyxz(), u64vec4(2_u64, 2_u64, 1_u64, 3_u64));
+    assert_eq!(v.yyyx(), u64vec4(2_u64, 2_u64, 2_u64, 1_u64));
+    assert_eq!(v.yyyy(), u64vec4(2_u64, 2_u64, 2_u64, 2_u64));
+    assert_eq!(v.yyyz(), u64vec4(2_u64, 2_u64, 2_u64, 3_u64));
+    assert_eq!(v.yyzx(), u64vec4(2_u64, 2_u64, 3_u64, 1_u64));
+    assert_eq!(v.yyzy(), u64vec4(2_u64, 2_u64, 3_u64, 2_u64));
+    assert_eq!(v.yyzz(), u64vec4(2_u64, 2_u64, 3_u64, 3_u64));
+    assert_eq!(v.yzxx(), u64vec4(2_u64, 3_u64, 1_u64, 1_u64));
+    assert_eq!(v.yzxy(), u64vec4(2_u64, 3_u64, 1_u64, 2_u64));
+    assert_eq!(v.yzxz(), u64vec4(2_u64, 3_u64, 1_u64, 3_u64));
+    assert_eq!(v.yzyx(), u64vec4(2_u64, 3_u64, 2_u64, 1_u64));
+    assert_eq!(v.yzyy(), u64vec4(2_u64, 3_u64, 2_u64, 2_u64));
+    assert_eq!(v.yzyz(), u64vec4(2_u64, 3_u64, 2_u64, 3_u64));
+    assert_eq!(v.yzzx(), u64vec4(2_u64, 3_u64, 3_u64, 1_u64));
+    assert_eq!(v.yzzy(), u64vec4(2_u64, 3_u64, 3_u64, 2_u64));
+    assert_eq!(v.yzzz(), u64vec4(2_u64, 3_u64, 3_u64, 3_u64));
+    assert_eq!(v.zxxx(), u64vec4(3_u64, 1_u64, 1_u64, 1_u64));
+    assert_eq!(v.zxxy(), u64vec4(3_u64, 1_u64, 1_u64, 2_u64));
+    assert_eq!(v.zxxz(), u64vec4(3_u64, 1_u64, 1_u64, 3_u64));
+    assert_eq!(v.zxyx(), u64vec4(3_u64, 1_u64, 2_u64, 1_u64));
+    assert_eq!(v.zxyy(), u64vec4(3_u64, 1_u64, 2_u64, 2_u64));
+    assert_eq!(v.zxyz(), u64vec4(3_u64, 1_u64, 2_u64, 3_u64));
+    assert_eq!(v.zxzx(), u64vec4(3_u64, 1_u64, 3_u64, 1_u64));
+    assert_eq!(v.zxzy(), u64vec4(3_u64, 1_u64, 3_u64, 2_u64));
+    assert_eq!(v.zxzz(), u64vec4(3_u64, 1_u64, 3_u64, 3_u64));
+    assert_eq!(v.zyxx(), u64vec4(3_u64, 2_u64, 1_u64, 1_u64));
+    assert_eq!(v.zyxy(), u64vec4(3_u64, 2_u64, 1_u64, 2_u64));
+    assert_eq!(v.zyxz(), u64vec4(3_u64, 2_u64, 1_u64, 3_u64));
+    assert_eq!(v.zyyx(), u64vec4(3_u64, 2_u64, 2_u64, 1_u64));
+    assert_eq!(v.zyyy(), u64vec4(3_u64, 2_u64, 2_u64, 2_u64));
+    assert_eq!(v.zyyz(), u64vec4(3_u64, 2_u64, 2_u64, 3_u64));
+    assert_eq!(v.zyzx(), u64vec4(3_u64, 2_u64, 3_u64, 1_u64));
+    assert_eq!(v.zyzy(), u64vec4(3_u64, 2_u64, 3_u64, 2_u64));
+    assert_eq!(v.zyzz(), u64vec4(3_u64, 2_u64, 3_u64, 3_u64));
+    assert_eq!(v.zzxx(), u64vec4(3_u64, 3_u64, 1_u64, 1_u64));
+    assert_eq!(v.zzxy(), u64vec4(3_u64, 3_u64, 1_u64, 2_u64));
+    assert_eq!(v.zzxz(), u64vec4(3_u64, 3_u64, 1_u64, 3_u64));
+    assert_eq!(v.zzyx(), u64vec4(3_u64, 3_u64, 2_u64, 1_u64));
+    assert_eq!(v.zzyy(), u64vec4(3_u64, 3_u64, 2_u64, 2_u64));
+    assert_eq!(v.zzyz(), u64vec4(3_u64, 3_u64, 2_u64, 3_u64));
+    assert_eq!(v.zzzx(), u64vec4(3_u64, 3_u64, 3_u64, 1_u64));
+    assert_eq!(v.zzzy(), u64vec4(3_u64, 3_u64, 3_u64, 2_u64));
+    assert_eq!(v.zzzz(), u64vec4(3_u64, 3_u64, 3_u64, 3_u64));
+    assert_eq!(v.xxx(), u64vec3(1_u64, 1_u64, 1_u64));
+    assert_eq!(v.xxy(), u64vec3(1_u64, 1_u64, 2_u64));
+    assert_eq!(v.xxz(), u64vec3(1_u64, 1_u64, 3_u64));
+    assert_eq!(v.xyx(), u64vec3(1_u64, 2_u64, 1_u64));
+    assert_eq!(v.xyy(), u64vec3(1_u64, 2_u64, 2_u64));
+    assert_eq!(v.xzx(), u64vec3(1_u64, 3_u64, 1_u64));
+    assert_eq!(v.xzy(), u64vec3(1_u64, 3_u64, 2_u64));
+    assert_eq!(v.xzz(), u64vec3(1_u64, 3_u64, 3_u64));
+    assert_eq!(v.yxx(), u64vec3(2_u64, 1_u64, 1_u64));
+    assert_eq!(v.yxy(), u64vec3(2_u64, 1_u64, 2_u64));
+    assert_eq!(v.yxz(), u64vec3(2_u64, 1_u64, 3_u64));
+    assert_eq!(v.yyx(), u64vec3(2_u64, 2_u64, 1_u64));
+    assert_eq!(v.yyy(), u64vec3(2_u64, 2_u64, 2_u64));
+    assert_eq!(v.yyz(), u64vec3(2_u64, 2_u64, 3_u64));
+    assert_eq!(v.yzx(), u64vec3(2_u64, 3_u64, 1_u64));
+    assert_eq!(v.yzy(), u64vec3(2_u64, 3_u64, 2_u64));
+    assert_eq!(v.yzz(), u64vec3(2_u64, 3_u64, 3_u64));
+    assert_eq!(v.zxx(), u64vec3(3_u64, 1_u64, 1_u64));
+    assert_eq!(v.zxy(), u64vec3(3_u64, 1_u64, 2_u64));
+    assert_eq!(v.zxz(), u64vec3(3_u64, 1_u64, 3_u64));
+    assert_eq!(v.zyx(), u64vec3(3_u64, 2_u64, 1_u64));
+    assert_eq!(v.zyy(), u64vec3(3_u64, 2_u64, 2_u64));
+    assert_eq!(v.zyz(), u64vec3(3_u64, 2_u64, 3_u64));
+    assert_eq!(v.zzx(), u64vec3(3_u64, 3_u64, 1_u64));
+    assert_eq!(v.zzy(), u64vec3(3_u64, 3_u64, 2_u64));
+    assert_eq!(v.zzz(), u64vec3(3_u64, 3_u64, 3_u64));
+    assert_eq!(v.xx(), u64vec2(1_u64, 1_u64));
+    assert_eq!(v.xy(), u64vec2(1_u64, 2_u64));
+    assert_eq!(v.xz(), u64vec2(1_u64, 3_u64));
+    assert_eq!(v.yx(), u64vec2(2_u64, 1_u64));
+    assert_eq!(v.yy(), u64vec2(2_u64, 2_u64));
+    assert_eq!(v.yz(), u64vec2(2_u64, 3_u64));
+    assert_eq!(v.zx(), u64vec2(3_u64, 1_u64));
+    assert_eq!(v.zy(), u64vec2(3_u64, 2_u64));
+    assert_eq!(v.zz(), u64vec2(3_u64, 3_u64));
+});
+
+glam_test!(test_u64vec2_swizzles, {
+    let v = u64vec2(1_u64, 2_u64);
+    assert_eq!(v, v.xy());
+    assert_eq!(v.xxxx(), u64vec4(1_u64, 1_u64, 1_u64, 1_u64));
+    assert_eq!(v.xxxy(), u64vec4(1_u64, 1_u64, 1_u64, 2_u64));
+    assert_eq!(v.xxyx(), u64vec4(1_u64, 1_u64, 2_u64, 1_u64));
+    assert_eq!(v.xxyy(), u64vec4(1_u64, 1_u64, 2_u64, 2_u64));
+    assert_eq!(v.xyxx(), u64vec4(1_u64, 2_u64, 1_u64, 1_u64));
+    assert_eq!(v.xyxy(), u64vec4(1_u64, 2_u64, 1_u64, 2_u64));
+    assert_eq!(v.xyyx(), u64vec4(1_u64, 2_u64, 2_u64, 1_u64));
+    assert_eq!(v.xyyy(), u64vec4(1_u64, 2_u64, 2_u64, 2_u64));
+    assert_eq!(v.yxxx(), u64vec4(2_u64, 1_u64, 1_u64, 1_u64));
+    assert_eq!(v.yxxy(), u64vec4(2_u64, 1_u64, 1_u64, 2_u64));
+    assert_eq!(v.yxyx(), u64vec4(2_u64, 1_u64, 2_u64, 1_u64));
+    assert_eq!(v.yxyy(), u64vec4(2_u64, 1_u64, 2_u64, 2_u64));
+    assert_eq!(v.yyxx(), u64vec4(2_u64, 2_u64, 1_u64, 1_u64));
+    assert_eq!(v.yyxy(), u64vec4(2_u64, 2_u64, 1_u64, 2_u64));
+    assert_eq!(v.yyyx(), u64vec4(2_u64, 2_u64, 2_u64, 1_u64));
+    assert_eq!(v.yyyy(), u64vec4(2_u64, 2_u64, 2_u64, 2_u64));
+    assert_eq!(v.xxx(), u64vec3(1_u64, 1_u64, 1_u64));
+    assert_eq!(v.xxy(), u64vec3(1_u64, 1_u64, 2_u64));
+    assert_eq!(v.xyx(), u64vec3(1_u64, 2_u64, 1_u64));
+    assert_eq!(v.xyy(), u64vec3(1_u64, 2_u64, 2_u64));
+    assert_eq!(v.yxx(), u64vec3(2_u64, 1_u64, 1_u64));
+    assert_eq!(v.yxy(), u64vec3(2_u64, 1_u64, 2_u64));
+    assert_eq!(v.yyx(), u64vec3(2_u64, 2_u64, 1_u64));
+    assert_eq!(v.yyy(), u64vec3(2_u64, 2_u64, 2_u64));
+    assert_eq!(v.xx(), u64vec2(1_u64, 1_u64));
+    assert_eq!(v.yx(), u64vec2(2_u64, 1_u64));
+    assert_eq!(v.yy(), u64vec2(2_u64, 2_u64));
+});

vendor/glam/tests/swizzles_u8.rs

@@ -0,0 +1,497 @@
+// Generated by swizzlegen. Do not edit.
+#[macro_use]
+mod support;
+use glam::*;
+
+glam_test!(test_u8vec4_swizzles, {
+    let v = u8vec4(1_u8, 2_u8, 3_u8, 4_u8);
+    assert_eq!(v, v.xyzw());
+    assert_eq!(v.xxxx(), u8vec4(1_u8, 1_u8, 1_u8, 1_u8));
+    assert_eq!(v.xxxy(), u8vec4(1_u8, 1_u8, 1_u8, 2_u8));
+    assert_eq!(v.xxxz(), u8vec4(1_u8, 1_u8, 1_u8, 3_u8));
+    assert_eq!(v.xxxw(), u8vec4(1_u8, 1_u8, 1_u8, 4_u8));
+    assert_eq!(v.xxyx(), u8vec4(1_u8, 1_u8, 2_u8, 1_u8));
+    assert_eq!(v.xxyy(), u8vec4(1_u8, 1_u8, 2_u8, 2_u8));
+    assert_eq!(v.xxyz(), u8vec4(1_u8, 1_u8, 2_u8, 3_u8));
+    assert_eq!(v.xxyw(), u8vec4(1_u8, 1_u8, 2_u8, 4_u8));
+    assert_eq!(v.xxzx(), u8vec4(1_u8, 1_u8, 3_u8, 1_u8));
+    assert_eq!(v.xxzy(), u8vec4(1_u8, 1_u8, 3_u8, 2_u8));
+    assert_eq!(v.xxzz(), u8vec4(1_u8, 1_u8, 3_u8, 3_u8));
+    assert_eq!(v.xxzw(), u8vec4(1_u8, 1_u8, 3_u8, 4_u8));
+    assert_eq!(v.xxwx(), u8vec4(1_u8, 1_u8, 4_u8, 1_u8));
+    assert_eq!(v.xxwy(), u8vec4(1_u8, 1_u8, 4_u8, 2_u8));
+    assert_eq!(v.xxwz(), u8vec4(1_u8, 1_u8, 4_u8, 3_u8));
+    assert_eq!(v.xxww(), u8vec4(1_u8, 1_u8, 4_u8, 4_u8));
+    assert_eq!(v.xyxx(), u8vec4(1_u8, 2_u8, 1_u8, 1_u8));
+    assert_eq!(v.xyxy(), u8vec4(1_u8, 2_u8, 1_u8, 2_u8));
+    assert_eq!(v.xyxz(), u8vec4(1_u8, 2_u8, 1_u8, 3_u8));
+    assert_eq!(v.xyxw(), u8vec4(1_u8, 2_u8, 1_u8, 4_u8));
+    assert_eq!(v.xyyx(), u8vec4(1_u8, 2_u8, 2_u8, 1_u8));
+    assert_eq!(v.xyyy(), u8vec4(1_u8, 2_u8, 2_u8, 2_u8));
+    assert_eq!(v.xyyz(), u8vec4(1_u8, 2_u8, 2_u8, 3_u8));
+    assert_eq!(v.xyyw(), u8vec4(1_u8, 2_u8, 2_u8, 4_u8));
+    assert_eq!(v.xyzx(), u8vec4(1_u8, 2_u8, 3_u8, 1_u8));
+    assert_eq!(v.xyzy(), u8vec4(1_u8, 2_u8, 3_u8, 2_u8));
+    assert_eq!(v.xyzz(), u8vec4(1_u8, 2_u8, 3_u8, 3_u8));
+    assert_eq!(v.xywx(), u8vec4(1_u8, 2_u8, 4_u8, 1_u8));
+    assert_eq!(v.xywy(), u8vec4(1_u8, 2_u8, 4_u8, 2_u8));
+    assert_eq!(v.xywz(), u8vec4(1_u8, 2_u8, 4_u8, 3_u8));
+    assert_eq!(v.xyww(), u8vec4(1_u8, 2_u8, 4_u8, 4_u8));
+    assert_eq!(v.xzxx(), u8vec4(1_u8, 3_u8, 1_u8, 1_u8));
+    assert_eq!(v.xzxy(), u8vec4(1_u8, 3_u8, 1_u8, 2_u8));
+    assert_eq!(v.xzxz(), u8vec4(1_u8, 3_u8, 1_u8, 3_u8));
+    assert_eq!(v.xzxw(), u8vec4(1_u8, 3_u8, 1_u8, 4_u8));
+    assert_eq!(v.xzyx(), u8vec4(1_u8, 3_u8, 2_u8, 1_u8));
+    assert_eq!(v.xzyy(), u8vec4(1_u8, 3_u8, 2_u8, 2_u8));
+    assert_eq!(v.xzyz(), u8vec4(1_u8, 3_u8, 2_u8, 3_u8));
+    assert_eq!(v.xzyw(), u8vec4(1_u8, 3_u8, 2_u8, 4_u8));
+    assert_eq!(v.xzzx(), u8vec4(1_u8, 3_u8, 3_u8, 1_u8));
+    assert_eq!(v.xzzy(), u8vec4(1_u8, 3_u8, 3_u8, 2_u8));
+    assert_eq!(v.xzzz(), u8vec4(1_u8, 3_u8, 3_u8, 3_u8));
+    assert_eq!(v.xzzw(), u8vec4(1_u8, 3_u8, 3_u8, 4_u8));
+    assert_eq!(v.xzwx(), u8vec4(1_u8, 3_u8, 4_u8, 1_u8));
+    assert_eq!(v.xzwy(), u8vec4(1_u8, 3_u8, 4_u8, 2_u8));
+    assert_eq!(v.xzwz(), u8vec4(1_u8, 3_u8, 4_u8, 3_u8));
+    assert_eq!(v.xzww(), u8vec4(1_u8, 3_u8, 4_u8, 4_u8));
+    assert_eq!(v.xwxx(), u8vec4(1_u8, 4_u8, 1_u8, 1_u8));
+    assert_eq!(v.xwxy(), u8vec4(1_u8, 4_u8, 1_u8, 2_u8));
+    assert_eq!(v.xwxz(), u8vec4(1_u8, 4_u8, 1_u8, 3_u8));
+    assert_eq!(v.xwxw(), u8vec4(1_u8, 4_u8, 1_u8, 4_u8));
+    assert_eq!(v.xwyx(), u8vec4(1_u8, 4_u8, 2_u8, 1_u8));
+    assert_eq!(v.xwyy(), u8vec4(1_u8, 4_u8, 2_u8, 2_u8));
+    assert_eq!(v.xwyz(), u8vec4(1_u8, 4_u8, 2_u8, 3_u8));
+    assert_eq!(v.xwyw(), u8vec4(1_u8, 4_u8, 2_u8, 4_u8));
+    assert_eq!(v.xwzx(), u8vec4(1_u8, 4_u8, 3_u8, 1_u8));
+    assert_eq!(v.xwzy(), u8vec4(1_u8, 4_u8, 3_u8, 2_u8));
+    assert_eq!(v.xwzz(), u8vec4(1_u8, 4_u8, 3_u8, 3_u8));
+    assert_eq!(v.xwzw(), u8vec4(1_u8, 4_u8, 3_u8, 4_u8));
+    assert_eq!(v.xwwx(), u8vec4(1_u8, 4_u8, 4_u8, 1_u8));
+    assert_eq!(v.xwwy(), u8vec4(1_u8, 4_u8, 4_u8, 2_u8));
+    assert_eq!(v.xwwz(), u8vec4(1_u8, 4_u8, 4_u8, 3_u8));
+    assert_eq!(v.xwww(), u8vec4(1_u8, 4_u8, 4_u8, 4_u8));
+    assert_eq!(v.yxxx(), u8vec4(2_u8, 1_u8, 1_u8, 1_u8));
+    assert_eq!(v.yxxy(), u8vec4(2_u8, 1_u8, 1_u8, 2_u8));
+    assert_eq!(v.yxxz(), u8vec4(2_u8, 1_u8, 1_u8, 3_u8));
+    assert_eq!(v.yxxw(), u8vec4(2_u8, 1_u8, 1_u8, 4_u8));
+    assert_eq!(v.yxyx(), u8vec4(2_u8, 1_u8, 2_u8, 1_u8));
+    assert_eq!(v.yxyy(), u8vec4(2_u8, 1_u8, 2_u8, 2_u8));
+    assert_eq!(v.yxyz(), u8vec4(2_u8, 1_u8, 2_u8, 3_u8));
+    assert_eq!(v.yxyw(), u8vec4(2_u8, 1_u8, 2_u8, 4_u8));
+    assert_eq!(v.yxzx(), u8vec4(2_u8, 1_u8, 3_u8, 1_u8));
+    assert_eq!(v.yxzy(), u8vec4(2_u8, 1_u8, 3_u8, 2_u8));
+    assert_eq!(v.yxzz(), u8vec4(2_u8, 1_u8, 3_u8, 3_u8));
+    assert_eq!(v.yxzw(), u8vec4(2_u8, 1_u8, 3_u8, 4_u8));
+    assert_eq!(v.yxwx(), u8vec4(2_u8, 1_u8, 4_u8, 1_u8));
+    assert_eq!(v.yxwy(), u8vec4(2_u8, 1_u8, 4_u8, 2_u8));
+    assert_eq!(v.yxwz(), u8vec4(2_u8, 1_u8, 4_u8, 3_u8));
+    assert_eq!(v.yxww(), u8vec4(2_u8, 1_u8, 4_u8, 4_u8));
+    assert_eq!(v.yyxx(), u8vec4(2_u8, 2_u8, 1_u8, 1_u8));
+    assert_eq!(v.yyxy(), u8vec4(2_u8, 2_u8, 1_u8, 2_u8));
+    assert_eq!(v.yyxz(), u8vec4(2_u8, 2_u8, 1_u8, 3_u8));
+    assert_eq!(v.yyxw(), u8vec4(2_u8, 2_u8, 1_u8, 4_u8));
+    assert_eq!(v.yyyx(), u8vec4(2_u8, 2_u8, 2_u8, 1_u8));
+    assert_eq!(v.yyyy(), u8vec4(2_u8, 2_u8, 2_u8, 2_u8));
+    assert_eq!(v.yyyz(), u8vec4(2_u8, 2_u8, 2_u8, 3_u8));
+    assert_eq!(v.yyyw(), u8vec4(2_u8, 2_u8, 2_u8, 4_u8));
+    assert_eq!(v.yyzx(), u8vec4(2_u8, 2_u8, 3_u8, 1_u8));
+    assert_eq!(v.yyzy(), u8vec4(2_u8, 2_u8, 3_u8, 2_u8));
+    assert_eq!(v.yyzz(), u8vec4(2_u8, 2_u8, 3_u8, 3_u8));
+    assert_eq!(v.yyzw(), u8vec4(2_u8, 2_u8, 3_u8, 4_u8));
+    assert_eq!(v.yywx(), u8vec4(2_u8, 2_u8, 4_u8, 1_u8));
+    assert_eq!(v.yywy(), u8vec4(2_u8, 2_u8, 4_u8, 2_u8));
+    assert_eq!(v.yywz(), u8vec4(2_u8, 2_u8, 4_u8, 3_u8));
+    assert_eq!(v.yyww(), u8vec4(2_u8, 2_u8, 4_u8, 4_u8));
+    assert_eq!(v.yzxx(), u8vec4(2_u8, 3_u8, 1_u8, 1_u8));
+    assert_eq!(v.yzxy(), u8vec4(2_u8, 3_u8, 1_u8, 2_u8));
+    assert_eq!(v.yzxz(), u8vec4(2_u8, 3_u8, 1_u8, 3_u8));
+    assert_eq!(v.yzxw(), u8vec4(2_u8, 3_u8, 1_u8, 4_u8));
+    assert_eq!(v.yzyx(), u8vec4(2_u8, 3_u8, 2_u8, 1_u8));
+    assert_eq!(v.yzyy(), u8vec4(2_u8, 3_u8, 2_u8, 2_u8));
+    assert_eq!(v.yzyz(), u8vec4(2_u8, 3_u8, 2_u8, 3_u8));
+    assert_eq!(v.yzyw(), u8vec4(2_u8, 3_u8, 2_u8, 4_u8));
+    assert_eq!(v.yzzx(), u8vec4(2_u8, 3_u8, 3_u8, 1_u8));
+    assert_eq!(v.yzzy(), u8vec4(2_u8, 3_u8, 3_u8, 2_u8));
+    assert_eq!(v.yzzz(), u8vec4(2_u8, 3_u8, 3_u8, 3_u8));
+    assert_eq!(v.yzzw(), u8vec4(2_u8, 3_u8, 3_u8, 4_u8));
+    assert_eq!(v.yzwx(), u8vec4(2_u8, 3_u8, 4_u8, 1_u8));
+    assert_eq!(v.yzwy(), u8vec4(2_u8, 3_u8, 4_u8, 2_u8));
+    assert_eq!(v.yzwz(), u8vec4(2_u8, 3_u8, 4_u8, 3_u8));
+    assert_eq!(v.yzww(), u8vec4(2_u8, 3_u8, 4_u8, 4_u8));
+    assert_eq!(v.ywxx(), u8vec4(2_u8, 4_u8, 1_u8, 1_u8));
+    assert_eq!(v.ywxy(), u8vec4(2_u8, 4_u8, 1_u8, 2_u8));
+    assert_eq!(v.ywxz(), u8vec4(2_u8, 4_u8, 1_u8, 3_u8));
+    assert_eq!(v.ywxw(), u8vec4(2_u8, 4_u8, 1_u8, 4_u8));
+    assert_eq!(v.ywyx(), u8vec4(2_u8, 4_u8, 2_u8, 1_u8));
+    assert_eq!(v.ywyy(), u8vec4(2_u8, 4_u8, 2_u8, 2_u8));
+    assert_eq!(v.ywyz(), u8vec4(2_u8, 4_u8, 2_u8, 3_u8));
+    assert_eq!(v.ywyw(), u8vec4(2_u8, 4_u8, 2_u8, 4_u8));
+    assert_eq!(v.ywzx(), u8vec4(2_u8, 4_u8, 3_u8, 1_u8));
+    assert_eq!(v.ywzy(), u8vec4(2_u8, 4_u8, 3_u8, 2_u8));
+    assert_eq!(v.ywzz(), u8vec4(2_u8, 4_u8, 3_u8, 3_u8));
+    assert_eq!(v.ywzw(), u8vec4(2_u8, 4_u8, 3_u8, 4_u8));
+    assert_eq!(v.ywwx(), u8vec4(2_u8, 4_u8, 4_u8, 1_u8));
+    assert_eq!(v.ywwy(), u8vec4(2_u8, 4_u8, 4_u8, 2_u8));
+    assert_eq!(v.ywwz(), u8vec4(2_u8, 4_u8, 4_u8, 3_u8));
+    assert_eq!(v.ywww(), u8vec4(2_u8, 4_u8, 4_u8, 4_u8));
+    assert_eq!(v.zxxx(), u8vec4(3_u8, 1_u8, 1_u8, 1_u8));
+    assert_eq!(v.zxxy(), u8vec4(3_u8, 1_u8, 1_u8, 2_u8));
+    assert_eq!(v.zxxz(), u8vec4(3_u8, 1_u8, 1_u8, 3_u8));
+    assert_eq!(v.zxxw(), u8vec4(3_u8, 1_u8, 1_u8, 4_u8));
+    assert_eq!(v.zxyx(), u8vec4(3_u8, 1_u8, 2_u8, 1_u8));
+    assert_eq!(v.zxyy(), u8vec4(3_u8, 1_u8, 2_u8, 2_u8));
+    assert_eq!(v.zxyz(), u8vec4(3_u8, 1_u8, 2_u8, 3_u8));
+    assert_eq!(v.zxyw(), u8vec4(3_u8, 1_u8, 2_u8, 4_u8));
+    assert_eq!(v.zxzx(), u8vec4(3_u8, 1_u8, 3_u8, 1_u8));
+    assert_eq!(v.zxzy(), u8vec4(3_u8, 1_u8, 3_u8, 2_u8));
+    assert_eq!(v.zxzz(), u8vec4(3_u8, 1_u8, 3_u8, 3_u8));
+    assert_eq!(v.zxzw(), u8vec4(3_u8, 1_u8, 3_u8, 4_u8));
+    assert_eq!(v.zxwx(), u8vec4(3_u8, 1_u8, 4_u8, 1_u8));
+    assert_eq!(v.zxwy(), u8vec4(3_u8, 1_u8, 4_u8, 2_u8));
+    assert_eq!(v.zxwz(), u8vec4(3_u8, 1_u8, 4_u8, 3_u8));
+    assert_eq!(v.zxww(), u8vec4(3_u8, 1_u8, 4_u8, 4_u8));
+    assert_eq!(v.zyxx(), u8vec4(3_u8, 2_u8, 1_u8, 1_u8));
+    assert_eq!(v.zyxy(), u8vec4(3_u8, 2_u8, 1_u8, 2_u8));
+    assert_eq!(v.zyxz(), u8vec4(3_u8, 2_u8, 1_u8, 3_u8));
+    assert_eq!(v.zyxw(), u8vec4(3_u8, 2_u8, 1_u8, 4_u8));
+    assert_eq!(v.zyyx(), u8vec4(3_u8, 2_u8, 2_u8, 1_u8));
+    assert_eq!(v.zyyy(), u8vec4(3_u8, 2_u8, 2_u8, 2_u8));
+    assert_eq!(v.zyyz(), u8vec4(3_u8, 2_u8, 2_u8, 3_u8));
+    assert_eq!(v.zyyw(), u8vec4(3_u8, 2_u8, 2_u8, 4_u8));
+    assert_eq!(v.zyzx(), u8vec4(3_u8, 2_u8, 3_u8, 1_u8));
+    assert_eq!(v.zyzy(), u8vec4(3_u8, 2_u8, 3_u8, 2_u8));
+    assert_eq!(v.zyzz(), u8vec4(3_u8, 2_u8, 3_u8, 3_u8));
+    assert_eq!(v.zyzw(), u8vec4(3_u8, 2_u8, 3_u8, 4_u8));
+    assert_eq!(v.zywx(), u8vec4(3_u8, 2_u8, 4_u8, 1_u8));
+    assert_eq!(v.zywy(), u8vec4(3_u8, 2_u8, 4_u8, 2_u8));
+    assert_eq!(v.zywz(), u8vec4(3_u8, 2_u8, 4_u8, 3_u8));
+    assert_eq!(v.zyww(), u8vec4(3_u8, 2_u8, 4_u8, 4_u8));
+    assert_eq!(v.zzxx(), u8vec4(3_u8, 3_u8, 1_u8, 1_u8));
+    assert_eq!(v.zzxy(), u8vec4(3_u8, 3_u8, 1_u8, 2_u8));
+    assert_eq!(v.zzxz(), u8vec4(3_u8, 3_u8, 1_u8, 3_u8));
+    assert_eq!(v.zzxw(), u8vec4(3_u8, 3_u8, 1_u8, 4_u8));
+    assert_eq!(v.zzyx(), u8vec4(3_u8, 3_u8, 2_u8, 1_u8));
+    assert_eq!(v.zzyy(), u8vec4(3_u8, 3_u8, 2_u8, 2_u8));
+    assert_eq!(v.zzyz(), u8vec4(3_u8, 3_u8, 2_u8, 3_u8));
+    assert_eq!(v.zzyw(), u8vec4(3_u8, 3_u8, 2_u8, 4_u8));
+    assert_eq!(v.zzzx(), u8vec4(3_u8, 3_u8, 3_u8, 1_u8));
+    assert_eq!(v.zzzy(), u8vec4(3_u8, 3_u8, 3_u8, 2_u8));
+    assert_eq!(v.zzzz(), u8vec4(3_u8, 3_u8, 3_u8, 3_u8));
+    assert_eq!(v.zzzw(), u8vec4(3_u8, 3_u8, 3_u8, 4_u8));
+    assert_eq!(v.zzwx(), u8vec4(3_u8, 3_u8, 4_u8, 1_u8));
+    assert_eq!(v.zzwy(), u8vec4(3_u8, 3_u8, 4_u8, 2_u8));
+    assert_eq!(v.zzwz(), u8vec4(3_u8, 3_u8, 4_u8, 3_u8));
+    assert_eq!(v.zzww(), u8vec4(3_u8, 3_u8, 4_u8, 4_u8));
+    assert_eq!(v.zwxx(), u8vec4(3_u8, 4_u8, 1_u8, 1_u8));
+    assert_eq!(v.zwxy(), u8vec4(3_u8, 4_u8, 1_u8, 2_u8));
+    assert_eq!(v.zwxz(), u8vec4(3_u8, 4_u8, 1_u8, 3_u8));
+    assert_eq!(v.zwxw(), u8vec4(3_u8, 4_u8, 1_u8, 4_u8));
+    assert_eq!(v.zwyx(), u8vec4(3_u8, 4_u8, 2_u8, 1_u8));
+    assert_eq!(v.zwyy(), u8vec4(3_u8, 4_u8, 2_u8, 2_u8));
+    assert_eq!(v.zwyz(), u8vec4(3_u8, 4_u8, 2_u8, 3_u8));
+    assert_eq!(v.zwyw(), u8vec4(3_u8, 4_u8, 2_u8, 4_u8));
+    assert_eq!(v.zwzx(), u8vec4(3_u8, 4_u8, 3_u8, 1_u8));
+    assert_eq!(v.zwzy(), u8vec4(3_u8, 4_u8, 3_u8, 2_u8));
+    assert_eq!(v.zwzz(), u8vec4(3_u8, 4_u8, 3_u8, 3_u8));
+    assert_eq!(v.zwzw(), u8vec4(3_u8, 4_u8, 3_u8, 4_u8));
+    assert_eq!(v.zwwx(), u8vec4(3_u8, 4_u8, 4_u8, 1_u8));
+    assert_eq!(v.zwwy(), u8vec4(3_u8, 4_u8, 4_u8, 2_u8));
+    assert_eq!(v.zwwz(), u8vec4(3_u8, 4_u8, 4_u8, 3_u8));
+    assert_eq!(v.zwww(), u8vec4(3_u8, 4_u8, 4_u8, 4_u8));
+    assert_eq!(v.wxxx(), u8vec4(4_u8, 1_u8, 1_u8, 1_u8));
+    assert_eq!(v.wxxy(), u8vec4(4_u8, 1_u8, 1_u8, 2_u8));
+    assert_eq!(v.wxxz(), u8vec4(4_u8, 1_u8, 1_u8, 3_u8));
+    assert_eq!(v.wxxw(), u8vec4(4_u8, 1_u8, 1_u8, 4_u8));
+    assert_eq!(v.wxyx(), u8vec4(4_u8, 1_u8, 2_u8, 1_u8));
+    assert_eq!(v.wxyy(), u8vec4(4_u8, 1_u8, 2_u8, 2_u8));
+    assert_eq!(v.wxyz(), u8vec4(4_u8, 1_u8, 2_u8, 3_u8));
+    assert_eq!(v.wxyw(), u8vec4(4_u8, 1_u8, 2_u8, 4_u8));
+    assert_eq!(v.wxzx(), u8vec4(4_u8, 1_u8, 3_u8, 1_u8));
+    assert_eq!(v.wxzy(), u8vec4(4_u8, 1_u8, 3_u8, 2_u8));
+    assert_eq!(v.wxzz(), u8vec4(4_u8, 1_u8, 3_u8, 3_u8));
+    assert_eq!(v.wxzw(), u8vec4(4_u8, 1_u8, 3_u8, 4_u8));
+    assert_eq!(v.wxwx(), u8vec4(4_u8, 1_u8, 4_u8, 1_u8));
+    assert_eq!(v.wxwy(), u8vec4(4_u8, 1_u8, 4_u8, 2_u8));
+    assert_eq!(v.wxwz(), u8vec4(4_u8, 1_u8, 4_u8, 3_u8));
+    assert_eq!(v.wxww(), u8vec4(4_u8, 1_u8, 4_u8, 4_u8));
+    assert_eq!(v.wyxx(), u8vec4(4_u8, 2_u8, 1_u8, 1_u8));
+    assert_eq!(v.wyxy(), u8vec4(4_u8, 2_u8, 1_u8, 2_u8));
+    assert_eq!(v.wyxz(), u8vec4(4_u8, 2_u8, 1_u8, 3_u8));
+    assert_eq!(v.wyxw(), u8vec4(4_u8, 2_u8, 1_u8, 4_u8));
+    assert_eq!(v.wyyx(), u8vec4(4_u8, 2_u8, 2_u8, 1_u8));
+    assert_eq!(v.wyyy(), u8vec4(4_u8, 2_u8, 2_u8, 2_u8));
+    assert_eq!(v.wyyz(), u8vec4(4_u8, 2_u8, 2_u8, 3_u8));
+    assert_eq!(v.wyyw(), u8vec4(4_u8, 2_u8, 2_u8, 4_u8));
+    assert_eq!(v.wyzx(), u8vec4(4_u8, 2_u8, 3_u8, 1_u8));
+    assert_eq!(v.wyzy(), u8vec4(4_u8, 2_u8, 3_u8, 2_u8));
+    assert_eq!(v.wyzz(), u8vec4(4_u8, 2_u8, 3_u8, 3_u8));
+    assert_eq!(v.wyzw(), u8vec4(4_u8, 2_u8, 3_u8, 4_u8));
+    assert_eq!(v.wywx(), u8vec4(4_u8, 2_u8, 4_u8, 1_u8));
+    assert_eq!(v.wywy(), u8vec4(4_u8, 2_u8, 4_u8, 2_u8));
+    assert_eq!(v.wywz(), u8vec4(4_u8, 2_u8, 4_u8, 3_u8));
+    assert_eq!(v.wyww(), u8vec4(4_u8, 2_u8, 4_u8, 4_u8));
+    assert_eq!(v.wzxx(), u8vec4(4_u8, 3_u8, 1_u8, 1_u8));
+    assert_eq!(v.wzxy(), u8vec4(4_u8, 3_u8, 1_u8, 2_u8));
+    assert_eq!(v.wzxz(), u8vec4(4_u8, 3_u8, 1_u8, 3_u8));
+    assert_eq!(v.wzxw(), u8vec4(4_u8, 3_u8, 1_u8, 4_u8));
+    assert_eq!(v.wzyx(), u8vec4(4_u8, 3_u8, 2_u8, 1_u8));
+    assert_eq!(v.wzyy(), u8vec4(4_u8, 3_u8, 2_u8, 2_u8));
+    assert_eq!(v.wzyz(), u8vec4(4_u8, 3_u8, 2_u8, 3_u8));
+    assert_eq!(v.wzyw(), u8vec4(4_u8, 3_u8, 2_u8, 4_u8));
+    assert_eq!(v.wzzx(), u8vec4(4_u8, 3_u8, 3_u8, 1_u8));
+    assert_eq!(v.wzzy(), u8vec4(4_u8, 3_u8, 3_u8, 2_u8));
+    assert_eq!(v.wzzz(), u8vec4(4_u8, 3_u8, 3_u8, 3_u8));
+    assert_eq!(v.wzzw(), u8vec4(4_u8, 3_u8, 3_u8, 4_u8));
+    assert_eq!(v.wzwx(), u8vec4(4_u8, 3_u8, 4_u8, 1_u8));
+    assert_eq!(v.wzwy(), u8vec4(4_u8, 3_u8, 4_u8, 2_u8));
+    assert_eq!(v.wzwz(), u8vec4(4_u8, 3_u8, 4_u8, 3_u8));
+    assert_eq!(v.wzww(), u8vec4(4_u8, 3_u8, 4_u8, 4_u8));
+    assert_eq!(v.wwxx(), u8vec4(4_u8, 4_u8, 1_u8, 1_u8));
+    assert_eq!(v.wwxy(), u8vec4(4_u8, 4_u8, 1_u8, 2_u8));
+    assert_eq!(v.wwxz(), u8vec4(4_u8, 4_u8, 1_u8, 3_u8));
+    assert_eq!(v.wwxw(), u8vec4(4_u8, 4_u8, 1_u8, 4_u8));
+    assert_eq!(v.wwyx(), u8vec4(4_u8, 4_u8, 2_u8, 1_u8));
+    assert_eq!(v.wwyy(), u8vec4(4_u8, 4_u8, 2_u8, 2_u8));
+    assert_eq!(v.wwyz(), u8vec4(4_u8, 4_u8, 2_u8, 3_u8));
+    assert_eq!(v.wwyw(), u8vec4(4_u8, 4_u8, 2_u8, 4_u8));
+    assert_eq!(v.wwzx(), u8vec4(4_u8, 4_u8, 3_u8, 1_u8));
+    assert_eq!(v.wwzy(), u8vec4(4_u8, 4_u8, 3_u8, 2_u8));
+    assert_eq!(v.wwzz(), u8vec4(4_u8, 4_u8, 3_u8, 3_u8));
+    assert_eq!(v.wwzw(), u8vec4(4_u8, 4_u8, 3_u8, 4_u8));
+    assert_eq!(v.wwwx(), u8vec4(4_u8, 4_u8, 4_u8, 1_u8));
+    assert_eq!(v.wwwy(), u8vec4(4_u8, 4_u8, 4_u8, 2_u8));
+    assert_eq!(v.wwwz(), u8vec4(4_u8, 4_u8, 4_u8, 3_u8));
+    assert_eq!(v.wwww(), u8vec4(4_u8, 4_u8, 4_u8, 4_u8));
+    assert_eq!(v.xxx(), u8vec3(1_u8, 1_u8, 1_u8));
+    assert_eq!(v.xxy(), u8vec3(1_u8, 1_u8, 2_u8));
+    assert_eq!(v.xxz(), u8vec3(1_u8, 1_u8, 3_u8));
+    assert_eq!(v.xxw(), u8vec3(1_u8, 1_u8, 4_u8));
+    assert_eq!(v.xyx(), u8vec3(1_u8, 2_u8, 1_u8));
+    assert_eq!(v.xyy(), u8vec3(1_u8, 2_u8, 2_u8));
+    assert_eq!(v.xyz(), u8vec3(1_u8, 2_u8, 3_u8));
+    assert_eq!(v.xyw(), u8vec3(1_u8, 2_u8, 4_u8));
+    assert_eq!(v.xzx(), u8vec3(1_u8, 3_u8, 1_u8));
+    assert_eq!(v.xzy(), u8vec3(1_u8, 3_u8, 2_u8));
+    assert_eq!(v.xzz(), u8vec3(1_u8, 3_u8, 3_u8));
+    assert_eq!(v.xzw(), u8vec3(1_u8, 3_u8, 4_u8));
+    assert_eq!(v.xwx(), u8vec3(1_u8, 4_u8, 1_u8));
+    assert_eq!(v.xwy(), u8vec3(1_u8, 4_u8, 2_u8));
+    assert_eq!(v.xwz(), u8vec3(1_u8, 4_u8, 3_u8));
+    assert_eq!(v.xww(), u8vec3(1_u8, 4_u8, 4_u8));
+    assert_eq!(v.yxx(), u8vec3(2_u8, 1_u8, 1_u8));
+    assert_eq!(v.yxy(), u8vec3(2_u8, 1_u8, 2_u8));
+    assert_eq!(v.yxz(), u8vec3(2_u8, 1_u8, 3_u8));
+    assert_eq!(v.yxw(), u8vec3(2_u8, 1_u8, 4_u8));
+    assert_eq!(v.yyx(), u8vec3(2_u8, 2_u8, 1_u8));
+    assert_eq!(v.yyy(), u8vec3(2_u8, 2_u8, 2_u8));
+    assert_eq!(v.yyz(), u8vec3(2_u8, 2_u8, 3_u8));
+    assert_eq!(v.yyw(), u8vec3(2_u8, 2_u8, 4_u8));
+    assert_eq!(v.yzx(), u8vec3(2_u8, 3_u8, 1_u8));
+    assert_eq!(v.yzy(), u8vec3(2_u8, 3_u8, 2_u8));
+    assert_eq!(v.yzz(), u8vec3(2_u8, 3_u8, 3_u8));
+    assert_eq!(v.yzw(), u8vec3(2_u8, 3_u8, 4_u8));
+    assert_eq!(v.ywx(), u8vec3(2_u8, 4_u8, 1_u8));
+    assert_eq!(v.ywy(), u8vec3(2_u8, 4_u8, 2_u8));
+    assert_eq!(v.ywz(), u8vec3(2_u8, 4_u8, 3_u8));
+    assert_eq!(v.yww(), u8vec3(2_u8, 4_u8, 4_u8));
+    assert_eq!(v.zxx(), u8vec3(3_u8, 1_u8, 1_u8));
+    assert_eq!(v.zxy(), u8vec3(3_u8, 1_u8, 2_u8));
+    assert_eq!(v.zxz(), u8vec3(3_u8, 1_u8, 3_u8));
+    assert_eq!(v.zxw(), u8vec3(3_u8, 1_u8, 4_u8));
+    assert_eq!(v.zyx(), u8vec3(3_u8, 2_u8, 1_u8));
+    assert_eq!(v.zyy(), u8vec3(3_u8, 2_u8, 2_u8));
+    assert_eq!(v.zyz(), u8vec3(3_u8, 2_u8, 3_u8));
+    assert_eq!(v.zyw(), u8vec3(3_u8, 2_u8, 4_u8));
+    assert_eq!(v.zzx(), u8vec3(3_u8, 3_u8, 1_u8));
+    assert_eq!(v.zzy(), u8vec3(3_u8, 3_u8, 2_u8));
+    assert_eq!(v.zzz(), u8vec3(3_u8, 3_u8, 3_u8));
+    assert_eq!(v.zzw(), u8vec3(3_u8, 3_u8, 4_u8));
+    assert_eq!(v.zwx(), u8vec3(3_u8, 4_u8, 1_u8));
+    assert_eq!(v.zwy(), u8vec3(3_u8, 4_u8, 2_u8));
+    assert_eq!(v.zwz(), u8vec3(3_u8, 4_u8, 3_u8));
+    assert_eq!(v.zww(), u8vec3(3_u8, 4_u8, 4_u8));
+    assert_eq!(v.wxx(), u8vec3(4_u8, 1_u8, 1_u8));
+    assert_eq!(v.wxy(), u8vec3(4_u8, 1_u8, 2_u8));
+    assert_eq!(v.wxz(), u8vec3(4_u8, 1_u8, 3_u8));
+    assert_eq!(v.wxw(), u8vec3(4_u8, 1_u8, 4_u8));
+    assert_eq!(v.wyx(), u8vec3(4_u8, 2_u8, 1_u8));
+    assert_eq!(v.wyy(), u8vec3(4_u8, 2_u8, 2_u8));
+    assert_eq!(v.wyz(), u8vec3(4_u8, 2_u8, 3_u8));
+    assert_eq!(v.wyw(), u8vec3(4_u8, 2_u8, 4_u8));
+    assert_eq!(v.wzx(), u8vec3(4_u8, 3_u8, 1_u8));
+    assert_eq!(v.wzy(), u8vec3(4_u8, 3_u8, 2_u8));
+    assert_eq!(v.wzz(), u8vec3(4_u8, 3_u8, 3_u8));
+    assert_eq!(v.wzw(), u8vec3(4_u8, 3_u8, 4_u8));
+    assert_eq!(v.wwx(), u8vec3(4_u8, 4_u8, 1_u8));
+    assert_eq!(v.wwy(), u8vec3(4_u8, 4_u8, 2_u8));
+    assert_eq!(v.wwz(), u8vec3(4_u8, 4_u8, 3_u8));
+    assert_eq!(v.www(), u8vec3(4_u8, 4_u8, 4_u8));
+    assert_eq!(v.xx(), u8vec2(1_u8, 1_u8));
+    assert_eq!(v.xy(), u8vec2(1_u8, 2_u8));
+    assert_eq!(v.xz(), u8vec2(1_u8, 3_u8));
+    assert_eq!(v.xw(), u8vec2(1_u8, 4_u8));
+    assert_eq!(v.yx(), u8vec2(2_u8, 1_u8));
+    assert_eq!(v.yy(), u8vec2(2_u8, 2_u8));
+    assert_eq!(v.yz(), u8vec2(2_u8, 3_u8));
+    assert_eq!(v.yw(), u8vec2(2_u8, 4_u8));
+    assert_eq!(v.zx(), u8vec2(3_u8, 1_u8));
+    assert_eq!(v.zy(), u8vec2(3_u8, 2_u8));
+    assert_eq!(v.zz(), u8vec2(3_u8, 3_u8));
+    assert_eq!(v.zw(), u8vec2(3_u8, 4_u8));
+    assert_eq!(v.wx(), u8vec2(4_u8, 1_u8));
+    assert_eq!(v.wy(), u8vec2(4_u8, 2_u8));
+    assert_eq!(v.wz(), u8vec2(4_u8, 3_u8));
+    assert_eq!(v.ww(), u8vec2(4_u8, 4_u8));
+});
+
+glam_test!(test_u8vec3_swizzles, {
+    let v = u8vec3(1_u8, 2_u8, 3_u8);
+    assert_eq!(v, v.xyz());
+    assert_eq!(v.xxxx(), u8vec4(1_u8, 1_u8, 1_u8, 1_u8));
+    assert_eq!(v.xxxy(), u8vec4(1_u8, 1_u8, 1_u8, 2_u8));
+    assert_eq!(v.xxxz(), u8vec4(1_u8, 1_u8, 1_u8, 3_u8));
+    assert_eq!(v.xxyx(), u8vec4(1_u8, 1_u8, 2_u8, 1_u8));
+    assert_eq!(v.xxyy(), u8vec4(1_u8, 1_u8, 2_u8, 2_u8));
+    assert_eq!(v.xxyz(), u8vec4(1_u8, 1_u8, 2_u8, 3_u8));
+    assert_eq!(v.xxzx(), u8vec4(1_u8, 1_u8, 3_u8, 1_u8));
+    assert_eq!(v.xxzy(), u8vec4(1_u8, 1_u8, 3_u8, 2_u8));
+    assert_eq!(v.xxzz(), u8vec4(1_u8, 1_u8, 3_u8, 3_u8));
+    assert_eq!(v.xyxx(), u8vec4(1_u8, 2_u8, 1_u8, 1_u8));
+    assert_eq!(v.xyxy(), u8vec4(1_u8, 2_u8, 1_u8, 2_u8));
+    assert_eq!(v.xyxz(), u8vec4(1_u8, 2_u8, 1_u8, 3_u8));
+    assert_eq!(v.xyyx(), u8vec4(1_u8, 2_u8, 2_u8, 1_u8));
+    assert_eq!(v.xyyy(), u8vec4(1_u8, 2_u8, 2_u8, 2_u8));
+    assert_eq!(v.xyyz(), u8vec4(1_u8, 2_u8, 2_u8, 3_u8));
+    assert_eq!(v.xyzx(), u8vec4(1_u8, 2_u8, 3_u8, 1_u8));
+    assert_eq!(v.xyzy(), u8vec4(1_u8, 2_u8, 3_u8, 2_u8));
+    assert_eq!(v.xyzz(), u8vec4(1_u8, 2_u8, 3_u8, 3_u8));
+    assert_eq!(v.xzxx(), u8vec4(1_u8, 3_u8, 1_u8, 1_u8));
+    assert_eq!(v.xzxy(), u8vec4(1_u8, 3_u8, 1_u8, 2_u8));
+    assert_eq!(v.xzxz(), u8vec4(1_u8, 3_u8, 1_u8, 3_u8));
+    assert_eq!(v.xzyx(), u8vec4(1_u8, 3_u8, 2_u8, 1_u8));
+    assert_eq!(v.xzyy(), u8vec4(1_u8, 3_u8, 2_u8, 2_u8));
+    assert_eq!(v.xzyz(), u8vec4(1_u8, 3_u8, 2_u8, 3_u8));
+    assert_eq!(v.xzzx(), u8vec4(1_u8, 3_u8, 3_u8, 1_u8));
+    assert_eq!(v.xzzy(), u8vec4(1_u8, 3_u8, 3_u8, 2_u8));
+    assert_eq!(v.xzzz(), u8vec4(1_u8, 3_u8, 3_u8, 3_u8));
+    assert_eq!(v.yxxx(), u8vec4(2_u8, 1_u8, 1_u8, 1_u8));
+    assert_eq!(v.yxxy(), u8vec4(2_u8, 1_u8, 1_u8, 2_u8));
+    assert_eq!(v.yxxz(), u8vec4(2_u8, 1_u8, 1_u8, 3_u8));
+    assert_eq!(v.yxyx(), u8vec4(2_u8, 1_u8, 2_u8, 1_u8));
+    assert_eq!(v.yxyy(), u8vec4(2_u8, 1_u8, 2_u8, 2_u8));
+    assert_eq!(v.yxyz(), u8vec4(2_u8, 1_u8, 2_u8, 3_u8));
+    assert_eq!(v.yxzx(), u8vec4(2_u8, 1_u8, 3_u8, 1_u8));
+    assert_eq!(v.yxzy(), u8vec4(2_u8, 1_u8, 3_u8, 2_u8));
+    assert_eq!(v.yxzz(), u8vec4(2_u8, 1_u8, 3_u8, 3_u8));
+    assert_eq!(v.yyxx(), u8vec4(2_u8, 2_u8, 1_u8, 1_u8));
+    assert_eq!(v.yyxy(), u8vec4(2_u8, 2_u8, 1_u8, 2_u8));
+    assert_eq!(v.yyxz(), u8vec4(2_u8, 2_u8, 1_u8, 3_u8));
+    assert_eq!(v.yyyx(), u8vec4(2_u8, 2_u8, 2_u8, 1_u8));
+    assert_eq!(v.yyyy(), u8vec4(2_u8, 2_u8, 2_u8, 2_u8));
+    assert_eq!(v.yyyz(), u8vec4(2_u8, 2_u8, 2_u8, 3_u8));
+    assert_eq!(v.yyzx(), u8vec4(2_u8, 2_u8, 3_u8, 1_u8));
+    assert_eq!(v.yyzy(), u8vec4(2_u8, 2_u8, 3_u8, 2_u8));
+    assert_eq!(v.yyzz(), u8vec4(2_u8, 2_u8, 3_u8, 3_u8));
+    assert_eq!(v.yzxx(), u8vec4(2_u8, 3_u8, 1_u8, 1_u8));
+    assert_eq!(v.yzxy(), u8vec4(2_u8, 3_u8, 1_u8, 2_u8));
+    assert_eq!(v.yzxz(), u8vec4(2_u8, 3_u8, 1_u8, 3_u8));
+    assert_eq!(v.yzyx(), u8vec4(2_u8, 3_u8, 2_u8, 1_u8));
+    assert_eq!(v.yzyy(), u8vec4(2_u8, 3_u8, 2_u8, 2_u8));
+    assert_eq!(v.yzyz(), u8vec4(2_u8, 3_u8, 2_u8, 3_u8));
+    assert_eq!(v.yzzx(), u8vec4(2_u8, 3_u8, 3_u8, 1_u8));
+    assert_eq!(v.yzzy(), u8vec4(2_u8, 3_u8, 3_u8, 2_u8));
+    assert_eq!(v.yzzz(), u8vec4(2_u8, 3_u8, 3_u8, 3_u8));
+    assert_eq!(v.zxxx(), u8vec4(3_u8, 1_u8, 1_u8, 1_u8));
+    assert_eq!(v.zxxy(), u8vec4(3_u8, 1_u8, 1_u8, 2_u8));
+    assert_eq!(v.zxxz(), u8vec4(3_u8, 1_u8, 1_u8, 3_u8));
+    assert_eq!(v.zxyx(), u8vec4(3_u8, 1_u8, 2_u8, 1_u8));
+    assert_eq!(v.zxyy(), u8vec4(3_u8, 1_u8, 2_u8, 2_u8));
+    assert_eq!(v.zxyz(), u8vec4(3_u8, 1_u8, 2_u8, 3_u8));
+    assert_eq!(v.zxzx(), u8vec4(3_u8, 1_u8, 3_u8, 1_u8));
+    assert_eq!(v.zxzy(), u8vec4(3_u8, 1_u8, 3_u8, 2_u8));
+    assert_eq!(v.zxzz(), u8vec4(3_u8, 1_u8, 3_u8, 3_u8));
+    assert_eq!(v.zyxx(), u8vec4(3_u8, 2_u8, 1_u8, 1_u8));
+    assert_eq!(v.zyxy(), u8vec4(3_u8, 2_u8, 1_u8, 2_u8));
+    assert_eq!(v.zyxz(), u8vec4(3_u8, 2_u8, 1_u8, 3_u8));
+    assert_eq!(v.zyyx(), u8vec4(3_u8, 2_u8, 2_u8, 1_u8));
+    assert_eq!(v.zyyy(), u8vec4(3_u8, 2_u8, 2_u8, 2_u8));
+    assert_eq!(v.zyyz(), u8vec4(3_u8, 2_u8, 2_u8, 3_u8));
+    assert_eq!(v.zyzx(), u8vec4(3_u8, 2_u8, 3_u8, 1_u8));
+    assert_eq!(v.zyzy(), u8vec4(3_u8, 2_u8, 3_u8, 2_u8));
+    assert_eq!(v.zyzz(), u8vec4(3_u8, 2_u8, 3_u8, 3_u8));
+    assert_eq!(v.zzxx(), u8vec4(3_u8, 3_u8, 1_u8, 1_u8));
+    assert_eq!(v.zzxy(), u8vec4(3_u8, 3_u8, 1_u8, 2_u8));
+    assert_eq!(v.zzxz(), u8vec4(3_u8, 3_u8, 1_u8, 3_u8));
+    assert_eq!(v.zzyx(), u8vec4(3_u8, 3_u8, 2_u8, 1_u8));
+    assert_eq!(v.zzyy(), u8vec4(3_u8, 3_u8, 2_u8, 2_u8));
+    assert_eq!(v.zzyz(), u8vec4(3_u8, 3_u8, 2_u8, 3_u8));
+    assert_eq!(v.zzzx(), u8vec4(3_u8, 3_u8, 3_u8, 1_u8));
+    assert_eq!(v.zzzy(), u8vec4(3_u8, 3_u8, 3_u8, 2_u8));
+    assert_eq!(v.zzzz(), u8vec4(3_u8, 3_u8, 3_u8, 3_u8));
+    assert_eq!(v.xxx(), u8vec3(1_u8, 1_u8, 1_u8));
+    assert_eq!(v.xxy(), u8vec3(1_u8, 1_u8, 2_u8));
+    assert_eq!(v.xxz(), u8vec3(1_u8, 1_u8, 3_u8));
+    assert_eq!(v.xyx(), u8vec3(1_u8, 2_u8, 1_u8));
+    assert_eq!(v.xyy(), u8vec3(1_u8, 2_u8, 2_u8));
+    assert_eq!(v.xzx(), u8vec3(1_u8, 3_u8, 1_u8));
+    assert_eq!(v.xzy(), u8vec3(1_u8, 3_u8, 2_u8));
+    assert_eq!(v.xzz(), u8vec3(1_u8, 3_u8, 3_u8));
+    assert_eq!(v.yxx(), u8vec3(2_u8, 1_u8, 1_u8));
+    assert_eq!(v.yxy(), u8vec3(2_u8, 1_u8, 2_u8));
+    assert_eq!(v.yxz(), u8vec3(2_u8, 1_u8, 3_u8));
+    assert_eq!(v.yyx(), u8vec3(2_u8, 2_u8, 1_u8));
+    assert_eq!(v.yyy(), u8vec3(2_u8, 2_u8, 2_u8));
+    assert_eq!(v.yyz(), u8vec3(2_u8, 2_u8, 3_u8));
+    assert_eq!(v.yzx(), u8vec3(2_u8, 3_u8, 1_u8));
+    assert_eq!(v.yzy(), u8vec3(2_u8, 3_u8, 2_u8));
+    assert_eq!(v.yzz(), u8vec3(2_u8, 3_u8, 3_u8));
+    assert_eq!(v.zxx(), u8vec3(3_u8, 1_u8, 1_u8));
+    assert_eq!(v.zxy(), u8vec3(3_u8, 1_u8, 2_u8));
+    assert_eq!(v.zxz(), u8vec3(3_u8, 1_u8, 3_u8));
+    assert_eq!(v.zyx(), u8vec3(3_u8, 2_u8, 1_u8));
+    assert_eq!(v.zyy(), u8vec3(3_u8, 2_u8, 2_u8));
+    assert_eq!(v.zyz(), u8vec3(3_u8, 2_u8, 3_u8));
+    assert_eq!(v.zzx(), u8vec3(3_u8, 3_u8, 1_u8));
+    assert_eq!(v.zzy(), u8vec3(3_u8, 3_u8, 2_u8));
+    assert_eq!(v.zzz(), u8vec3(3_u8, 3_u8, 3_u8));
+    assert_eq!(v.xx(), u8vec2(1_u8, 1_u8));
+    assert_eq!(v.xy(), u8vec2(1_u8, 2_u8));
+    assert_eq!(v.xz(), u8vec2(1_u8, 3_u8));
+    assert_eq!(v.yx(), u8vec2(2_u8, 1_u8));
+    assert_eq!(v.yy(), u8vec2(2_u8, 2_u8));
+    assert_eq!(v.yz(), u8vec2(2_u8, 3_u8));
+    assert_eq!(v.zx(), u8vec2(3_u8, 1_u8));
+    assert_eq!(v.zy(), u8vec2(3_u8, 2_u8));
+    assert_eq!(v.zz(), u8vec2(3_u8, 3_u8));
+});
+
+glam_test!(test_u8vec2_swizzles, {
+    let v = u8vec2(1_u8, 2_u8);
+    assert_eq!(v, v.xy());
+    assert_eq!(v.xxxx(), u8vec4(1_u8, 1_u8, 1_u8, 1_u8));
+    assert_eq!(v.xxxy(), u8vec4(1_u8, 1_u8, 1_u8, 2_u8));
+    assert_eq!(v.xxyx(), u8vec4(1_u8, 1_u8, 2_u8, 1_u8));
+    assert_eq!(v.xxyy(), u8vec4(1_u8, 1_u8, 2_u8, 2_u8));
+    assert_eq!(v.xyxx(), u8vec4(1_u8, 2_u8, 1_u8, 1_u8));
+    assert_eq!(v.xyxy(), u8vec4(1_u8, 2_u8, 1_u8, 2_u8));
+    assert_eq!(v.xyyx(), u8vec4(1_u8, 2_u8, 2_u8, 1_u8));
+    assert_eq!(v.xyyy(), u8vec4(1_u8, 2_u8, 2_u8, 2_u8));
+    assert_eq!(v.yxxx(), u8vec4(2_u8, 1_u8, 1_u8, 1_u8));
+    assert_eq!(v.yxxy(), u8vec4(2_u8, 1_u8, 1_u8, 2_u8));
+    assert_eq!(v.yxyx(), u8vec4(2_u8, 1_u8, 2_u8, 1_u8));
+    assert_eq!(v.yxyy(), u8vec4(2_u8, 1_u8, 2_u8, 2_u8));
+    assert_eq!(v.yyxx(), u8vec4(2_u8, 2_u8, 1_u8, 1_u8));
+    assert_eq!(v.yyxy(), u8vec4(2_u8, 2_u8, 1_u8, 2_u8));
+    assert_eq!(v.yyyx(), u8vec4(2_u8, 2_u8, 2_u8, 1_u8));
+    assert_eq!(v.yyyy(), u8vec4(2_u8, 2_u8, 2_u8, 2_u8));
+    assert_eq!(v.xxx(), u8vec3(1_u8, 1_u8, 1_u8));
+    assert_eq!(v.xxy(), u8vec3(1_u8, 1_u8, 2_u8));
+    assert_eq!(v.xyx(), u8vec3(1_u8, 2_u8, 1_u8));
+    assert_eq!(v.xyy(), u8vec3(1_u8, 2_u8, 2_u8));
+    assert_eq!(v.yxx(), u8vec3(2_u8, 1_u8, 1_u8));
+    assert_eq!(v.yxy(), u8vec3(2_u8, 1_u8, 2_u8));
+    assert_eq!(v.yyx(), u8vec3(2_u8, 2_u8, 1_u8));
+    assert_eq!(v.yyy(), u8vec3(2_u8, 2_u8, 2_u8));
+    assert_eq!(v.xx(), u8vec2(1_u8, 1_u8));
+    assert_eq!(v.yx(), u8vec2(2_u8, 1_u8));
+    assert_eq!(v.yy(), u8vec2(2_u8, 2_u8));
+});