vendor/js-sys/tests/wasm/TypedArray.rs

   1 use js_sys::*;
   2 use wasm_bindgen::prelude::*;
   3 use wasm_bindgen::JsCast;
   4 use wasm_bindgen_test::*;
   5
   6 macro_rules! each {
   7     ($m:ident) => {
   8         $m!(Uint8Array);
   9         $m!(Uint8ClampedArray);
  10         $m!(Uint16Array);
  11         $m!(Uint32Array);
  12         $m!(Int8Array);
  13         $m!(Int16Array);
  14         $m!(Int32Array);
  15         $m!(Float32Array);
  16         $m!(Float64Array);
  17     };
  18 }
  19
  20 macro_rules! test_inheritence {
  21     ($arr:ident) => {{
  22         let arr = $arr::new(&JsValue::undefined());
  23         assert!(arr.is_instance_of::<$arr>());
  24         let _: &Object = arr.as_ref();
  25         assert!(arr.is_instance_of::<Object>());
  26     }};
  27 }
  28 #[wasm_bindgen_test]
  29 fn inheritence() {
  30     each!(test_inheritence);
  31 }
  32
  33 macro_rules! test_undefined {
  34     ($arr:ident) => {{
  35         let arr = $arr::new(&JsValue::undefined());
  36         assert_eq!(arr.length(), 0);
  37         assert_eq!(arr.byte_length(), 0);
  38         assert_eq!(arr.byte_offset(), 0);
  39         assert!(JsValue::from(arr.buffer()).is_object());
  40     }};
  41 }
  42 #[wasm_bindgen_test]
  43 fn new_undefined() {
  44     each!(test_undefined);
  45 }
  46
  47 macro_rules! test_length {
  48     ($arr:ident) => {{
  49         let arr = $arr::new(&4.into());
  50         assert_eq!(arr.length(), 4);
  51         assert!(arr.byte_length() != 0);
  52         assert_eq!(arr.byte_offset(), 0);
  53         assert!(JsValue::from(arr.buffer()).is_object());
  54     }};
  55 }
  56 #[wasm_bindgen_test]
  57 fn new_length() {
  58     each!(test_length);
  59 }
  60
  61 macro_rules! test_subarray {
  62     ($arr:ident) => {{
  63         assert_eq!($arr::new(&4.into()).subarray(0, 1).length(), 1);
  64     }};
  65 }
  66 #[wasm_bindgen_test]
  67 fn new_subarray() {
  68     each!(test_subarray);
  69 }
  70
  71 macro_rules! test_fill {
  72     ($arr:ident) => {{
  73         let arr = $arr::new(&4.into());
  74         arr.for_each(&mut |x, _, _| {
  75             assert_eq!(x as f64, 0.0);
  76         });
  77         arr.fill(2 as _, 0, 2);
  78         arr.for_each(&mut |x, i, _| {
  79             if i < 2 {
  80                 assert_eq!(x as f64, 2.0);
  81             } else {
  82                 assert_eq!(x as f64, 0.0);
  83             }
  84         });
  85     }};
  86 }
  87 #[wasm_bindgen_test]
  88 fn new_fill() {
  89     each!(test_fill);
  90 }
  91
  92 macro_rules! test_at {
  93     ($arr:ident) => {{
  94         let arr = $arr::new(&2.into());
  95         arr.set_index(1, 1 as _);
  96         assert_eq!(arr.at(-1).unwrap() as f64, 1 as f64);
  97     }};
  98 }
  99 #[wasm_bindgen_test]
 100 fn new_at() {
 101     each!(test_at);
 102 }
 103
 104 macro_rules! test_get_set {
 105     ($arr:ident) => {{
 106         let arr = $arr::new(&1.into());
 107         assert_eq!(arr.get_index(0) as f64, 0 as f64);
 108         arr.set_index(0, 1 as _);
 109         assert_eq!(arr.get_index(0) as f64, 1 as f64);
 110     }};
 111 }
 112 #[wasm_bindgen_test]
 113 fn new_get_set() {
 114     each!(test_get_set);
 115 }
 116
 117 macro_rules! test_slice {
 118     ($arr:ident) => {{
 119         let arr = $arr::new(&4.into());
 120         assert_eq!(arr.length(), 4);
 121         assert_eq!(arr.slice(1, 2).length(), 1);
 122     }};
 123 }
 124 #[wasm_bindgen_test]
 125 fn new_slice() {
 126     each!(test_slice);
 127 }
 128
 129 #[wasm_bindgen_test]
 130 fn view() {
 131     let x = [1, 2, 3];
 132     let array = unsafe { Int32Array::view(&x) };
 133     assert_eq!(array.length(), 3);
 134     array.for_each(&mut |x, i, _| {
 135         assert_eq!(x, (i + 1) as i32);
 136     });
 137 }
 138
 139 #[wasm_bindgen_test]
 140 fn from() {
 141     let x: Vec<i32> = vec![1, 2, 3];
 142     let array = Int32Array::from(x.as_slice());
 143     assert_eq!(array.length(), 3);
 144     array.for_each(&mut |x, i, _| {
 145         assert_eq!(x, (i + 1) as i32);
 146     });
 147 }
 148
 149 #[wasm_bindgen_test]
 150 fn copy_to() {
 151     let mut x = [0; 10];
 152     let array = Int32Array::new(&10.into());
 153     array.fill(5, 0, 10);
 154     array.copy_to(&mut x);
 155     for i in x.iter() {
 156         assert_eq!(*i, 5);
 157     }
 158 }
 159
 160 #[wasm_bindgen_test]
 161 fn copy_from() {
 162     let x = [1, 2, 3];
 163     let array = Int32Array::new(&3.into());
 164     array.copy_from(&x);
 165     array.for_each(&mut |x, i, _| {
 166         assert_eq!(x, (i + 1) as i32);
 167     });
 168 }
 169
 170 #[wasm_bindgen_test]
 171 fn to_vec() {
 172     let array = Int32Array::new(&10.into());
 173     array.fill(5, 0, 10);
 174     assert_eq!(array.to_vec(), vec![5, 5, 5, 5, 5, 5, 5, 5, 5, 5]);
 175 }