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

   1 use js_sys::*;
   2 use std::iter::FromIterator;
   3 use wasm_bindgen::prelude::*;
   4 use wasm_bindgen::JsCast;
   5 use wasm_bindgen::JsValue;
   6 use wasm_bindgen_test::*;
   7
   8 macro_rules! js_array {
   9     ($($e:expr),*) => ({
  10         let __x = Array::new();
  11         $(__x.push(&JsValue::from($e));)*
  12         __x
  13     })
  14 }
  15
  16 macro_rules! array {
  17     ($($e:expr),*) => ({
  18         let mut __x = Vec::new();
  19         $(__x.push(JsValue::from($e));)*
  20         __x
  21     })
  22 }
  23
  24 fn to_rust(arr: &Array) -> Vec<JsValue> {
  25     let mut result = Vec::with_capacity(arr.length() as usize);
  26     arr.for_each(&mut |x, _, _| result.push(x));
  27     result
  28 }
  29
  30 #[wasm_bindgen_test]
  31 fn from_iter() {
  32     assert_eq!(
  33         to_rust(
  34             &vec![JsValue::from("a"), JsValue::from("b"), JsValue::from("c"),]
  35                 .into_iter()
  36                 .collect()
  37         ),
  38         vec!["a", "b", "c"],
  39     );
  40
  41     assert_eq!(
  42         to_rust(
  43             &vec![JsValue::from("a"), JsValue::from("b"), JsValue::from("c"),]
  44                 .iter()
  45                 .collect()
  46         ),
  47         vec!["a", "b", "c"],
  48     );
  49
  50     let array = js_array![1u32, 2u32, 3u32];
  51
  52     assert_eq!(
  53         to_rust(&vec![array.clone(),].into_iter().collect()),
  54         vec![JsValue::from(array.clone())],
  55     );
  56
  57     assert_eq!(
  58         to_rust(&vec![array.clone(),].iter().collect()),
  59         vec![JsValue::from(array)],
  60     );
  61
  62     assert_eq!(
  63         to_rust(&vec![5, 10, 20,].into_iter().map(JsValue::from).collect()),
  64         vec![5, 10, 20],
  65     );
  66
  67     assert_eq!(
  68         to_rust(&Array::from_iter(&[
  69             JsValue::from("a"),
  70             JsValue::from("b"),
  71             JsValue::from("c"),
  72         ])),
  73         vec!["a", "b", "c"],
  74     );
  75
  76     let v = vec!["a", "b", "c"];
  77
  78     assert_eq!(
  79         to_rust(&Array::from_iter(v.into_iter().map(|s| JsValue::from(s)))),
  80         vec!["a", "b", "c"],
  81     );
  82 }
  83
  84 #[wasm_bindgen_test]
  85 fn extend() {
  86     let mut array = array!["a", "b"];
  87     array.extend(vec![JsValue::from("c"), JsValue::from("d")]);
  88     assert_eq!(array, array!["a", "b", "c", "d"]);
  89 }
  90
  91 #[wasm_bindgen_test]
  92 fn to_vec() {
  93     let array = vec![JsValue::from("a"), JsValue::from("b"), JsValue::from("c")]
  94         .into_iter()
  95         .collect::<js_sys::Array>();
  96
  97     assert_eq!(
  98         array.to_vec(),
  99         vec![JsValue::from("a"), JsValue::from("b"), JsValue::from("c")]
 100     );
 101 }
 102
 103 #[wasm_bindgen_test]
 104 fn iter() {
 105     let array = vec![JsValue::from("a"), JsValue::from("b"), JsValue::from("c")]
 106         .into_iter()
 107         .collect::<js_sys::Array>();
 108
 109     assert_eq!(
 110         array.iter().collect::<Vec<JsValue>>(),
 111         vec![JsValue::from("a"), JsValue::from("b"), JsValue::from("c")]
 112     );
 113
 114     let mut iter = array.iter();
 115
 116     assert_eq!(iter.size_hint(), (3, Some(3)));
 117     assert_eq!(iter.next(), Some(JsValue::from("a")));
 118
 119     assert_eq!(iter.size_hint(), (2, Some(2)));
 120     assert_eq!(iter.next_back(), Some(JsValue::from("c")));
 121
 122     assert_eq!(iter.size_hint(), (1, Some(1)));
 123     assert_eq!(iter.next_back(), Some(JsValue::from("b")));
 124
 125     assert_eq!(iter.size_hint(), (0, Some(0)));
 126     assert_eq!(iter.next(), None);
 127
 128     assert_eq!(iter.size_hint(), (0, Some(0)));
 129     assert_eq!(iter.next_back(), None);
 130
 131     let mut iter = array.iter();
 132
 133     assert_eq!(iter.size_hint(), (3, Some(3)));
 134     assert_eq!(iter.next(), Some(JsValue::from("a")));
 135
 136     assert_eq!(iter.size_hint(), (2, Some(2)));
 137     assert_eq!(iter.next(), Some(JsValue::from("b")));
 138
 139     assert_eq!(iter.size_hint(), (1, Some(1)));
 140     assert_eq!(iter.next(), Some(JsValue::from("c")));
 141
 142     assert_eq!(iter.size_hint(), (0, Some(0)));
 143     assert_eq!(iter.next(), None);
 144
 145     let mut iter = array.iter();
 146
 147     assert_eq!(iter.size_hint(), (3, Some(3)));
 148     assert_eq!(iter.next_back(), Some(JsValue::from("c")));
 149
 150     assert_eq!(iter.size_hint(), (2, Some(2)));
 151     assert_eq!(iter.next_back(), Some(JsValue::from("b")));
 152
 153     assert_eq!(iter.size_hint(), (1, Some(1)));
 154     assert_eq!(iter.next_back(), Some(JsValue::from("a")));
 155
 156     assert_eq!(iter.size_hint(), (0, Some(0)));
 157     assert_eq!(iter.next_back(), None);
 158 }
 159
 160 #[wasm_bindgen_test]
 161 fn new_with_length() {
 162     let array = Array::new_with_length(5);
 163     assert_eq!(array.length(), 5);
 164     assert_eq!(array.get(4), JsValue::undefined());
 165     array.set(4, JsValue::from("a"));
 166     assert_eq!(array.get(4), "a");
 167     assert_eq!(array.length(), 5);
 168 }
 169
 170 #[wasm_bindgen_test]
 171 fn get() {
 172     let array = js_array!["a", "c", "x", "n"];
 173     assert_eq!(array.length(), 4);
 174     assert_eq!(array.get(0), "a");
 175     assert_eq!(array.get(3), "n");
 176     assert_eq!(array.get(4), JsValue::undefined());
 177 }
 178
 179 #[wasm_bindgen_test]
 180 fn set() {
 181     let array = js_array!["a", "c", "x", "n"];
 182     assert_eq!(array.length(), 4);
 183     assert_eq!(array.get(0), "a");
 184     array.set(0, JsValue::from("b"));
 185     assert_eq!(array.get(0), "b");
 186
 187     assert_eq!(array.get(4), JsValue::undefined());
 188     assert_eq!(array.length(), 4);
 189     array.set(4, JsValue::from("d"));
 190     assert_eq!(array.length(), 5);
 191     assert_eq!(array.get(4), "d");
 192
 193     assert_eq!(array.get(10), JsValue::undefined());
 194     assert_eq!(array.length(), 5);
 195     array.set(10, JsValue::from("z"));
 196     assert_eq!(array.length(), 11);
 197     assert_eq!(array.get(10), "z");
 198     assert_eq!(array.get(9), JsValue::undefined());
 199 }
 200
 201 #[wasm_bindgen_test]
 202 fn delete() {
 203     let array = js_array!["a", "c", "x", "n"];
 204     assert_eq!(array.length(), 4);
 205     assert_eq!(array.get(0), "a");
 206     array.delete(0);
 207     assert_eq!(array.get(0), JsValue::undefined());
 208 }
 209
 210 #[wasm_bindgen_test]
 211 fn filter() {
 212     let array = js_array!["a", "c", "x", "n"];
 213     assert!(array.filter(&mut |x, _, _| x.as_f64().is_some()).length() == 0);
 214
 215     let array = js_array![1, 2, 3, 4];
 216     assert_eq!(
 217         array.filter(&mut |x, _, _| x.as_f64().is_some()).length(),
 218         4
 219     );
 220
 221     let array = js_array!["a", 1, "b", 2];
 222     assert_eq!(
 223         array.filter(&mut |x, _, _| x.as_f64().is_some()).length(),
 224         2
 225     );
 226 }
 227
 228 #[wasm_bindgen_test]
 229 fn flat() {
 230     let array = js_array![
 231         js_array!["a", "b", "c"],
 232         "d",
 233         js_array!["e", js_array!["f", "g"]]
 234     ];
 235
 236     assert_eq!(
 237         to_rust(&array.flat(1).slice(0, 5)),
 238         vec!["a", "b", "c", "d", "e"]
 239     );
 240
 241     assert_eq!(array.flat(1).length(), 6);
 242
 243     assert_eq!(
 244         to_rust(&array.flat(2)),
 245         vec!["a", "b", "c", "d", "e", "f", "g"]
 246     );
 247 }
 248
 249 #[wasm_bindgen_test]
 250 fn flat_map() {
 251     let array = js_array![1, 2, 3, 1];
 252
 253     assert_eq!(
 254         to_rust(
 255             &array.flat_map(&mut |val, _, _| match val.as_f64().map(|v| v as i32) {
 256                 Some(1) => vec![JsString::from("x").into(), JsString::from("x").into()],
 257                 Some(2) => vec![],
 258                 Some(3) => vec![JsString::from("z").into()],
 259                 _ => panic!("Unexpected conversion"),
 260             })
 261         ),
 262         vec!["x", "x", "z", "x", "x"]
 263     );
 264 }
 265
 266 #[wasm_bindgen_test]
 267 fn index_of() {
 268     let chars = js_array!["a", "c", "x", "n"];
 269     assert_eq!(chars.index_of(&"x".into(), 0), 2);
 270     assert_eq!(chars.index_of(&"z".into(), 0), -1);
 271     assert_eq!(chars.index_of(&"x".into(), -3), 2);
 272     assert_eq!(chars.index_of(&"z".into(), -2), -1);
 273 }
 274
 275 #[wasm_bindgen_test]
 276 fn is_array() {
 277     assert!(Array::is_array(&Array::new().into()));
 278     assert!(Array::is_array(&js_array![1].into()));
 279     assert!(!Array::is_array(&JsValue::null()));
 280     assert!(!Array::is_array(&JsValue::undefined()));
 281     assert!(!Array::is_array(&10.into()));
 282     assert!(!Array::is_array(&"x".into()));
 283     assert!(!Array::is_array(&true.into()));
 284     assert!(!Array::is_array(&false.into()));
 285 }
 286
 287 #[wasm_bindgen_test]
 288 fn sort() {
 289     let array = js_array![3, 1, 6, 2];
 290     let sorted = array.sort();
 291     assert_eq!(to_rust(&sorted), array![1, 2, 3, 6]);
 292 }
 293
 294 #[wasm_bindgen_test]
 295 fn some() {
 296     let array = js_array!["z", 1, "y", 2];
 297     assert!(array.some(&mut |e| e == JsValue::from(2)));
 298     assert!(array.some(&mut |e| e == JsValue::from("y")));
 299     assert!(!array.some(&mut |e| e == JsValue::from("nope")));
 300 }
 301
 302 #[wasm_bindgen_test]
 303 fn last_index_of() {
 304     let characters = js_array!["a", "x", "c", "x", "n"];
 305     assert_eq!(characters.last_index_of(&"x".into(), 5), 3);
 306     assert_eq!(characters.last_index_of(&"z".into(), 5), -1);
 307     assert_eq!(characters.last_index_of(&"x".into(), 2), 1);
 308     assert_eq!(characters.last_index_of(&"x".into(), 0), -1);
 309 }
 310
 311 #[wasm_bindgen_test]
 312 fn join() {
 313     let characters = js_array!["a", "c", "x", "n"];
 314     assert_eq!(String::from(characters.join(", ")), "a, c, x, n");
 315     assert_eq!(String::from(characters.join("/")), "a/c/x/n");
 316 }
 317
 318 #[wasm_bindgen_test]
 319 fn slice() {
 320     let characters = js_array!["a", "c", "x", "n", 1, "8"];
 321     let subset = characters.slice(1, 3);
 322
 323     assert_eq!(to_rust(&subset), array!["c", "x"]);
 324 }
 325
 326 #[wasm_bindgen_test]
 327 fn splice() {
 328     let characters = js_array!["a", "c", "x", "n", 1, "8"];
 329     let removed = characters.splice(1, 3, &"b".into());
 330
 331     assert_eq!(to_rust(&removed), array!["c", "x", "n"]);
 332     assert_eq!(to_rust(&characters), array!["a", "b", 1, "8"]);
 333 }
 334
 335 #[wasm_bindgen_test]
 336 fn fill() {
 337     let characters = js_array!["a", "c", "x", "n", 1, "8"];
 338     let subset = characters.fill(&0.into(), 0, 3);
 339
 340     assert_eq!(to_rust(&subset), array![0, 0, 0, "n", 1, "8"]);
 341 }
 342
 343 #[wasm_bindgen_test]
 344 fn copy_within() {
 345     let characters = js_array![8, 5, 4, 3, 1, 2];
 346     characters.copy_within(1, 4, 5);
 347
 348     assert_eq!(to_rust(&characters)[1], JsValue::from(1));
 349
 350     // if negatives were used
 351     characters.copy_within(-1, -3, -2);
 352     assert_eq!(to_rust(&characters)[5], JsValue::from(3));
 353 }
 354
 355 #[wasm_bindgen_test]
 356 fn of() {
 357     let a = JsValue::from("a");
 358     let b = JsValue::from("b");
 359     let c = JsValue::from("c");
 360     let arr = Array::of3(&a, &b, &c);
 361     let vec = to_rust(&arr);
 362     assert_eq!(vec.len(), 3);
 363     assert_eq!(vec[0], a);
 364     assert_eq!(vec[1], b);
 365     assert_eq!(vec[2], c);
 366 }
 367
 368 #[wasm_bindgen_test]
 369 fn pop() {
 370     let characters = js_array![8, 5, 4, 3, 1, 2];
 371     let item = characters.pop();
 372     assert_eq!(item, JsValue::from(2));
 373     assert_eq!(characters.length(), 5);
 374 }
 375
 376 #[wasm_bindgen_test]
 377 fn push() {
 378     let characters = js_array![8, 5, 4, 3, 1, 2];
 379     let length = characters.push(&"a".into());
 380     assert_eq!(length, 7);
 381     assert_eq!(to_rust(&characters)[6], "a");
 382 }
 383
 384 #[wasm_bindgen_test]
 385 fn reverse() {
 386     let characters = js_array![8, 5, 4, 3, 1, 2];
 387     let reversed = characters.reverse();
 388     assert_eq!(to_rust(&reversed), array![2, 1, 3, 4, 5, 8]);
 389 }
 390
 391 #[wasm_bindgen_test]
 392 fn shift() {
 393     let characters = js_array![8, 5, 4, 3, 1, 2];
 394     let shiftedItem = characters.shift();
 395
 396     assert_eq!(shiftedItem, 8);
 397     assert_eq!(characters.length(), 5);
 398 }
 399
 400 #[wasm_bindgen_test]
 401 fn unshift() {
 402     let characters = js_array![8, 5, 4, 3, 1, 2];
 403     let length = characters.unshift(&"abba".into());
 404
 405     assert_eq!(length, 7);
 406     assert_eq!(to_rust(&characters)[0], "abba");
 407 }
 408
 409 #[wasm_bindgen_test]
 410 fn to_string() {
 411     let characters = js_array![8, 5, 4, 3, 1, 2];
 412     assert_eq!(String::from(characters.to_string()), "8,5,4,3,1,2");
 413 }
 414
 415 #[wasm_bindgen_test]
 416 fn includes() {
 417     let characters = js_array![8, 5, 4, 3, 1, 2];
 418     assert!(characters.includes(&2.into(), 0));
 419     assert!(!characters.includes(&9.into(), 0));
 420     assert!(!characters.includes(&3.into(), 4));
 421 }
 422
 423 #[wasm_bindgen_test]
 424 fn concat() {
 425     let arr1 = js_array![1, 2, 3];
 426     let arr2 = js_array![4, 5, 6];
 427
 428     let new_array = arr1.concat(&arr2);
 429     assert_eq!(to_rust(&new_array), array![1, 2, 3, 4, 5, 6]);
 430 }
 431
 432 #[wasm_bindgen_test]
 433 fn length() {
 434     let characters = js_array![8, 5, 4, 3, 1, 2];
 435     assert_eq!(characters.length(), 6);
 436     assert_eq!(Array::new().length(), 0);
 437 }
 438
 439 #[wasm_bindgen_test]
 440 fn every() {
 441     let even = js_array![2, 4, 6, 8];
 442     assert!(even.every(&mut |x, _, _| x.as_f64().unwrap() % 2.0 == 0.0));
 443     let odd = js_array![1, 3, 5, 7];
 444     assert!(!odd.every(&mut |x, _, _| x.as_f64().unwrap() % 2.0 == 0.0));
 445     let mixed = js_array![2, 3, 4, 5];
 446     assert!(!mixed.every(&mut |x, _, _| x.as_f64().unwrap() % 2.0 == 0.0));
 447 }
 448
 449 #[wasm_bindgen_test]
 450 fn find() {
 451     let even = js_array![2, 4, 6, 8];
 452     assert_eq!(
 453         even.find(&mut |x, _, _| x.as_f64().unwrap() % 2.0 == 0.0),
 454         2
 455     );
 456     let odd = js_array![1, 3, 5, 7];
 457     assert_eq!(
 458         odd.find(&mut |x, _, _| x.as_f64().unwrap() % 2.0 == 0.0),
 459         JsValue::undefined(),
 460     );
 461     let mixed = js_array![3, 5, 7, 10];
 462     assert_eq!(
 463         mixed.find(&mut |x, _, _| x.as_f64().unwrap() % 2.0 == 0.0),
 464         10
 465     );
 466 }
 467
 468 #[wasm_bindgen_test]
 469 fn map() {
 470     let numbers = js_array![1, 4, 9];
 471     let sqrt = numbers.map(&mut |x, _, _| x.as_f64().unwrap().sqrt().into());
 472     assert_eq!(to_rust(&sqrt), array![1, 2, 3]);
 473 }
 474
 475 #[wasm_bindgen_test]
 476 fn reduce() {
 477     let arr = js_array!["0", "1", "2", "3", "4"].reduce(
 478         &mut |ac, cr, _, _| {
 479             format!("{}{}", &ac.as_string().unwrap(), &cr.as_string().unwrap()).into()
 480         },
 481         &"".into(),
 482     );
 483     assert_eq!(arr, "01234");
 484 }
 485
 486 #[wasm_bindgen_test]
 487 fn reduce_right() {
 488     let arr = js_array!["0", "1", "2", "3", "4"].reduce_right(
 489         &mut |ac, cr, _, _| {
 490             format!("{}{}", &ac.as_string().unwrap(), &cr.as_string().unwrap()).into()
 491         },
 492         &"".into(),
 493     );
 494     assert_eq!(arr, "43210");
 495 }
 496
 497 #[wasm_bindgen_test]
 498 fn find_index() {
 499     let even = js_array![2, 4, 6, 8];
 500     assert_eq!(
 501         even.find_index(&mut |e, _, _| e.as_f64().unwrap() % 2. == 0.),
 502         0
 503     );
 504     let odd = js_array![1, 3, 5, 7];
 505     assert_eq!(
 506         odd.find_index(&mut |e, _, _| e.as_f64().unwrap() % 2. == 0.),
 507         -1
 508     );
 509     let mixed = js_array![3, 5, 7, 10];
 510     assert_eq!(
 511         mixed.find_index(&mut |e, _, _| e.as_f64().unwrap() % 2. == 0.),
 512         3
 513     );
 514 }
 515
 516 #[wasm_bindgen_test]
 517 fn to_locale_string() {
 518     let output = js_array![1, "a", Date::new(&"21 Dec 1997 14:12:00 UTC".into())]
 519         .to_locale_string(&"en".into(), &JsValue::undefined());
 520     assert!(String::from(output).len() > 0);
 521 }
 522
 523 #[wasm_bindgen_test]
 524 fn for_each() {
 525     fn sum_indices_of_evens(array: &Array) -> u32 {
 526         let mut res = 0;
 527         array.for_each(&mut |elem: JsValue, i, _| match elem.as_f64() {
 528             Some(val) if val % 2. == 0. => res += i,
 529             _ => {}
 530         });
 531         res
 532     }
 533
 534     assert_eq!(sum_indices_of_evens(&js_array![2, 4, 6, 8]), 0 + 1 + 2 + 3);
 535     assert_eq!(sum_indices_of_evens(&js_array![1, 3, 5, 7]), 0);
 536     assert_eq!(sum_indices_of_evens(&js_array![3, 5, 7, 10]), 3);
 537 }
 538
 539 #[wasm_bindgen_test]
 540 fn array_inheritance() {
 541     let array = Array::new();
 542     assert!(array.is_instance_of::<Array>());
 543     assert!(array.is_instance_of::<Object>());
 544     let _: &Object = array.as_ref();
 545 }
 546
 547 #[wasm_bindgen(module = "tests/wasm/Array.js")]
 548 extern "C" {
 549     fn populate_array(arr: JsValue, start: JsValue, len: JsValue) -> JsValue;
 550 }
 551
 552 fn test_array_view_mut_raw<ElemT: std::cmp::PartialEq + std::fmt::Debug, ArrT>(
 553     sut: unsafe fn(*mut ElemT, usize) -> ArrT,
 554     u8ToElem: fn(u8) -> ElemT,
 555     arrToJsValue: fn(ArrT) -> JsValue,
 556 ) {
 557     let start: u8 = 10;
 558     let len: usize = 32;
 559     let end: u8 = start + len as u8;
 560     let mut buffer: Vec<ElemT> = Vec::new();
 561     buffer.reserve(len);
 562     unsafe {
 563         let array: ArrT = sut(buffer.as_mut_ptr(), len);
 564         populate_array(
 565             arrToJsValue(array),
 566             JsValue::from(start),
 567             JsValue::from(len as u32),
 568         );
 569         buffer.set_len(len);
 570     }
 571     let expected: Vec<ElemT> = (start..end).map(u8ToElem).collect();
 572     assert_eq!(buffer, expected)
 573 }
 574
 575 #[wasm_bindgen_test]
 576 fn Int8Array_view_mut_raw() {
 577     fn u8Toi8_unsafe(x: u8) -> i8 {
 578         x as i8
 579     }
 580     test_array_view_mut_raw(
 581         js_sys::Int8Array::view_mut_raw,
 582         u8Toi8_unsafe,
 583         JsValue::from,
 584     );
 585 }
 586
 587 #[wasm_bindgen_test]
 588 fn Int16Array_view_mut_raw() {
 589     test_array_view_mut_raw(js_sys::Int16Array::view_mut_raw, i16::from, JsValue::from);
 590 }
 591
 592 #[wasm_bindgen_test]
 593 fn Int32Array_view_mut_raw() {
 594     test_array_view_mut_raw(js_sys::Int32Array::view_mut_raw, i32::from, JsValue::from);
 595 }
 596
 597 #[wasm_bindgen_test]
 598 fn BigInt64Array_view_mut_raw() {
 599     test_array_view_mut_raw(
 600         js_sys::BigInt64Array::view_mut_raw,
 601         i64::from,
 602         JsValue::from,
 603     );
 604 }
 605
 606 #[wasm_bindgen_test]
 607 fn Uint8Array_view_mut_raw() {
 608     test_array_view_mut_raw(js_sys::Uint8Array::view_mut_raw, u8::from, JsValue::from);
 609 }
 610
 611 #[wasm_bindgen_test]
 612 fn Uint8ClampedArray_view_mut_raw() {
 613     test_array_view_mut_raw(
 614         js_sys::Uint8ClampedArray::view_mut_raw,
 615         u8::from,
 616         JsValue::from,
 617     );
 618 }
 619
 620 #[wasm_bindgen_test]
 621 fn Uint16Array_view_mut_raw() {
 622     test_array_view_mut_raw(js_sys::Uint16Array::view_mut_raw, u16::from, JsValue::from);
 623 }
 624
 625 #[wasm_bindgen_test]
 626 fn Uint32Array_view_mut_raw() {
 627     test_array_view_mut_raw(js_sys::Uint32Array::view_mut_raw, u32::from, JsValue::from);
 628 }
 629
 630 #[wasm_bindgen_test]
 631 fn BigUint64Array_view_mut_raw() {
 632     test_array_view_mut_raw(
 633         js_sys::BigUint64Array::view_mut_raw,
 634         u64::from,
 635         JsValue::from,
 636     );
 637 }
 638
 639 #[wasm_bindgen_test]
 640 fn Float32Array_view_mut_raw() {
 641     test_array_view_mut_raw(js_sys::Float32Array::view_mut_raw, f32::from, JsValue::from);
 642 }
 643
 644 #[wasm_bindgen_test]
 645 fn Float64Array_view_mut_raw() {
 646     test_array_view_mut_raw(js_sys::Float64Array::view_mut_raw, f64::from, JsValue::from);
 647 }