library/portable-simd/crates/core_simd/tests/mask_ops_impl/mask_macros.rs

   1 macro_rules! mask_tests {
   2     { $vector:ident, $lanes:literal } => {
   3         #[cfg(test)]
   4         mod $vector {
   5             use core_simd::$vector as Vector;
   6             const LANES: usize = $lanes;
   7
   8             #[cfg(target_arch = "wasm32")]
   9             use wasm_bindgen_test::*;
  10
  11             #[cfg(target_arch = "wasm32")]
  12             wasm_bindgen_test_configure!(run_in_browser);
  13
  14             fn from_slice(slice: &[bool]) -> Vector {
  15                 let mut value = Vector::default();
  16                 for (i, b) in slice.iter().take(LANES).enumerate() {
  17                     value.set(i, *b);
  18                 }
  19                 value
  20             }
  21
  22             fn apply_unary_lanewise(x: Vector, f: impl Fn(bool) -> bool) -> Vector {
  23                 let mut value = Vector::default();
  24                 for i in 0..LANES {
  25                     value.set(i, f(x.test(i)));
  26                 }
  27                 value
  28             }
  29
  30             fn apply_binary_lanewise(x: Vector, y: Vector, f: impl Fn(bool, bool) -> bool) -> Vector {
  31                 let mut value = Vector::default();
  32                 for i in 0..LANES {
  33                     value.set(i, f(x.test(i), y.test(i)));
  34                 }
  35                 value
  36             }
  37
  38             fn apply_binary_scalar_lhs_lanewise(x: bool, mut y: Vector, f: impl Fn(bool, bool) -> bool) -> Vector {
  39                 for i in 0..LANES {
  40                     y.set(i, f(x, y.test(i)));
  41                 }
  42                 y
  43             }
  44
  45             fn apply_binary_scalar_rhs_lanewise(mut x: Vector, y: bool, f: impl Fn(bool, bool) -> bool) -> Vector {
  46                 for i in 0..LANES {
  47                     x.set(i, f(x.test(i), y));
  48                 }
  49                 x
  50             }
  51
  52             const A: [bool; 64] = [
  53                 false, true, false, true, false, false, true, true,
  54                 false, true, false, true, false, false, true, true,
  55                 false, true, false, true, false, false, true, true,
  56                 false, true, false, true, false, false, true, true,
  57                 false, true, false, true, false, false, true, true,
  58                 false, true, false, true, false, false, true, true,
  59                 false, true, false, true, false, false, true, true,
  60                 false, true, false, true, false, false, true, true,
  61             ];
  62             const B: [bool; 64] = [
  63                 false, false, true, true, false, true, false, true,
  64                 false, false, true, true, false, true, false, true,
  65                 false, false, true, true, false, true, false, true,
  66                 false, false, true, true, false, true, false, true,
  67                 false, false, true, true, false, true, false, true,
  68                 false, false, true, true, false, true, false, true,
  69                 false, false, true, true, false, true, false, true,
  70                 false, false, true, true, false, true, false, true,
  71             ];
  72
  73             #[test]
  74             #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
  75             fn bitand() {
  76                 let a = from_slice(&A);
  77                 let b = from_slice(&B);
  78                 let expected = apply_binary_lanewise(a, b, core::ops::BitAnd::bitand);
  79                 assert_eq!(a & b, expected);
  80             }
  81
  82             #[test]
  83             #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
  84             fn bitand_assign() {
  85                 let mut a = from_slice(&A);
  86                 let b = from_slice(&B);
  87                 let expected = apply_binary_lanewise(a, b, core::ops::BitAnd::bitand);
  88                 a &= b;
  89                 assert_eq!(a, expected);
  90             }
  91
  92             #[test]
  93             #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
  94             fn bitand_scalar_rhs() {
  95                 let a = from_slice(&A);
  96                 let expected = a;
  97                 assert_eq!(a & true, expected);
  98                 assert_eq!(a & false, Vector::splat(false));
  99             }
 100
 101             #[test]
 102             #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
 103             fn bitand_scalar_lhs() {
 104                 let a = from_slice(&A);
 105                 let expected = a;
 106                 assert_eq!(true & a, expected);
 107                 assert_eq!(false & a, Vector::splat(false));
 108             }
 109
 110             #[test]
 111             #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
 112             fn bitand_assign_scalar() {
 113                 let mut a = from_slice(&A);
 114                 let expected = a;
 115                 a &= true;
 116                 assert_eq!(a, expected);
 117                 a &= false;
 118                 assert_eq!(a, Vector::splat(false));
 119             }
 120
 121             #[test]
 122             #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
 123             fn bitor() {
 124                 let a = from_slice(&A);
 125                 let b = from_slice(&B);
 126                 let expected = apply_binary_lanewise(a, b, core::ops::BitOr::bitor);
 127                 assert_eq!(a | b, expected);
 128             }
 129
 130             #[test]
 131             #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
 132             fn bitor_assign() {
 133                 let mut a = from_slice(&A);
 134                 let b = from_slice(&B);
 135                 let expected = apply_binary_lanewise(a, b, core::ops::BitOr::bitor);
 136                 a |= b;
 137                 assert_eq!(a, expected);
 138             }
 139
 140             #[test]
 141             #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
 142             fn bitor_scalar_rhs() {
 143                 let a = from_slice(&A);
 144                 assert_eq!(a | false, a);
 145                 assert_eq!(a | true, Vector::splat(true));
 146             }
 147
 148             #[test]
 149             #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
 150             fn bitor_scalar_lhs() {
 151                 let a = from_slice(&A);
 152                 assert_eq!(false | a, a);
 153                 assert_eq!(true | a, Vector::splat(true));
 154             }
 155
 156             #[test]
 157             #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
 158             fn bitor_assign_scalar() {
 159                 let mut a = from_slice(&A);
 160                 let expected = a;
 161                 a |= false;
 162                 assert_eq!(a, expected);
 163                 a |= true;
 164                 assert_eq!(a, Vector::splat(true));
 165             }
 166
 167             #[test]
 168             #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
 169             fn bitxor() {
 170                 let a = from_slice(&A);
 171                 let b = from_slice(&B);
 172                 let expected = apply_binary_lanewise(a, b, core::ops::BitXor::bitxor);
 173                 assert_eq!(a ^ b, expected);
 174             }
 175
 176             #[test]
 177             #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
 178             fn bitxor_assign() {
 179                 let mut a = from_slice(&A);
 180                 let b = from_slice(&B);
 181                 let expected = apply_binary_lanewise(a, b, core::ops::BitXor::bitxor);
 182                 a ^= b;
 183                 assert_eq!(a, expected);
 184             }
 185
 186             #[test]
 187             #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
 188             fn bitxor_scalar_rhs() {
 189                 let a = from_slice(&A);
 190                 let expected = apply_binary_scalar_rhs_lanewise(a, true, core::ops::BitXor::bitxor);
 191                 assert_eq!(a ^ false, a);
 192                 assert_eq!(a ^ true, expected);
 193             }
 194
 195             #[test]
 196             #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
 197             fn bitxor_scalar_lhs() {
 198                 let a = from_slice(&A);
 199                 let expected = apply_binary_scalar_lhs_lanewise(true, a, core::ops::BitXor::bitxor);
 200                 assert_eq!(false ^ a, a);
 201                 assert_eq!(true ^ a, expected);
 202             }
 203
 204             #[test]
 205             #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
 206             fn bitxor_assign_scalar() {
 207                 let mut a = from_slice(&A);
 208                 let expected_unset = a;
 209                 let expected_set = apply_binary_scalar_rhs_lanewise(a, true, core::ops::BitXor::bitxor);
 210                 a ^= false;
 211                 assert_eq!(a, expected_unset);
 212                 a ^= true;
 213                 assert_eq!(a, expected_set);
 214             }
 215
 216             #[test]
 217             #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
 218             fn not() {
 219                 let v = from_slice(&A);
 220                 let expected = apply_unary_lanewise(v, core::ops::Not::not);
 221                 assert_eq!(!v, expected);
 222             }
 223         }
 224     }
 225 }