arm/usr/lib/rustlib/src/rust/library/portable-simd/crates/core_simd/tests/mask_ops_impl/mask_macros.rs

macro_rules! mask_tests {
    { $vector:ident, $lanes:literal } => {
        #[cfg(test)]
        mod $vector {
            use core_simd::$vector as Vector;
            const LANES: usize = $lanes;

            #[cfg(target_arch = "wasm32")]
            use wasm_bindgen_test::*;

            #[cfg(target_arch = "wasm32")]
            wasm_bindgen_test_configure!(run_in_browser);

            fn from_slice(slice: &[bool]) -> Vector {
                let mut value = Vector::default();
                for (i, b) in slice.iter().take(LANES).enumerate() {
                    value.set(i, *b);
                }
                value
            }

            fn apply_unary_lanewise(x: Vector, f: impl Fn(bool) -> bool) -> Vector {
                let mut value = Vector::default();
                for i in 0..LANES {
                    value.set(i, f(x.test(i)));
                }
                value
            }

            fn apply_binary_lanewise(x: Vector, y: Vector, f: impl Fn(bool, bool) -> bool) -> Vector {
                let mut value = Vector::default();
                for i in 0..LANES {
                    value.set(i, f(x.test(i), y.test(i)));
                }
                value
            }

            fn apply_binary_scalar_lhs_lanewise(x: bool, mut y: Vector, f: impl Fn(bool, bool) -> bool) -> Vector {
                for i in 0..LANES {
                    y.set(i, f(x, y.test(i)));
                }
                y
            }

            fn apply_binary_scalar_rhs_lanewise(mut x: Vector, y: bool, f: impl Fn(bool, bool) -> bool) -> Vector {
                for i in 0..LANES {
                    x.set(i, f(x.test(i), y));
                }
                x
            }

            const A: [bool; 64] = [
                false, true, false, true, false, false, true, true,
                false, true, false, true, false, false, true, true,
                false, true, false, true, false, false, true, true,
                false, true, false, true, false, false, true, true,
                false, true, false, true, false, false, true, true,
                false, true, false, true, false, false, true, true,
                false, true, false, true, false, false, true, true,
                false, true, false, true, false, false, true, true,
            ];
            const B: [bool; 64] = [
                false, false, true, true, false, true, false, true,
                false, false, true, true, false, true, false, true,
                false, false, true, true, false, true, false, true,
                false, false, true, true, false, true, false, true,
                false, false, true, true, false, true, false, true,
                false, false, true, true, false, true, false, true,
                false, false, true, true, false, true, false, true,
                false, false, true, true, false, true, false, true,
            ];

            #[test]
            #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
            fn bitand() {
                let a = from_slice(&A);
                let b = from_slice(&B);
                let expected = apply_binary_lanewise(a, b, core::ops::BitAnd::bitand);
                assert_eq!(a & b, expected);
            }

            #[test]
            #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
            fn bitand_assign() {
                let mut a = from_slice(&A);
                let b = from_slice(&B);
                let expected = apply_binary_lanewise(a, b, core::ops::BitAnd::bitand);
                a &= b;
                assert_eq!(a, expected);
            }

            #[test]
            #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
            fn bitand_scalar_rhs() {
                let a = from_slice(&A);
                let expected = a;
                assert_eq!(a & true, expected);
                assert_eq!(a & false, Vector::splat(false));
            }

            #[test]
            #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
            fn bitand_scalar_lhs() {
                let a = from_slice(&A);
                let expected = a;
                assert_eq!(true & a, expected);
                assert_eq!(false & a, Vector::splat(false));
            }

            #[test]
            #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
            fn bitand_assign_scalar() {
                let mut a = from_slice(&A);
                let expected = a;
                a &= true;
                assert_eq!(a, expected);
                a &= false;
                assert_eq!(a, Vector::splat(false));
            }

            #[test]
            #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
            fn bitor() {
                let a = from_slice(&A);
                let b = from_slice(&B);
                let expected = apply_binary_lanewise(a, b, core::ops::BitOr::bitor);
                assert_eq!(a | b, expected);
            }

            #[test]
            #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
            fn bitor_assign() {
                let mut a = from_slice(&A);
                let b = from_slice(&B);
                let expected = apply_binary_lanewise(a, b, core::ops::BitOr::bitor);
                a |= b;
                assert_eq!(a, expected);
            }

            #[test]
            #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
            fn bitor_scalar_rhs() {
                let a = from_slice(&A);
                assert_eq!(a | false, a);
                assert_eq!(a | true, Vector::splat(true));
            }

            #[test]
            #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
            fn bitor_scalar_lhs() {
                let a = from_slice(&A);
                assert_eq!(false | a, a);
                assert_eq!(true | a, Vector::splat(true));
            }

            #[test]
            #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
            fn bitor_assign_scalar() {
                let mut a = from_slice(&A);
                let expected = a;
                a |= false;
                assert_eq!(a, expected);
                a |= true;
                assert_eq!(a, Vector::splat(true));
            }

            #[test]
            #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
            fn bitxor() {
                let a = from_slice(&A);
                let b = from_slice(&B);
                let expected = apply_binary_lanewise(a, b, core::ops::BitXor::bitxor);
                assert_eq!(a ^ b, expected);
            }

            #[test]
            #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
            fn bitxor_assign() {
                let mut a = from_slice(&A);
                let b = from_slice(&B);
                let expected = apply_binary_lanewise(a, b, core::ops::BitXor::bitxor);
                a ^= b;
                assert_eq!(a, expected);
            }

            #[test]
            #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
            fn bitxor_scalar_rhs() {
                let a = from_slice(&A);
                let expected = apply_binary_scalar_rhs_lanewise(a, true, core::ops::BitXor::bitxor);
                assert_eq!(a ^ false, a);
                assert_eq!(a ^ true, expected);
            }

            #[test]
            #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
            fn bitxor_scalar_lhs() {
                let a = from_slice(&A);
                let expected = apply_binary_scalar_lhs_lanewise(true, a, core::ops::BitXor::bitxor);
                assert_eq!(false ^ a, a);
                assert_eq!(true ^ a, expected);
            }

            #[test]
            #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
            fn bitxor_assign_scalar() {
                let mut a = from_slice(&A);
                let expected_unset = a;
                let expected_set = apply_binary_scalar_rhs_lanewise(a, true, core::ops::BitXor::bitxor);
                a ^= false;
                assert_eq!(a, expected_unset);
                a ^= true;
                assert_eq!(a, expected_set);
            }

            #[test]
            #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
            fn not() {
                let v = from_slice(&A);
                let expected = apply_unary_lanewise(v, core::ops::Not::not);
                assert_eq!(!v, expected);
            }
        }
    }
}