rustwasm/wasm-bindgen
1
0
Fork 0
mirror of https://github.com/rustwasm/wasm-bindgen.git synced 2024-12-29 13:06:06 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

Port TypedArray tests to wasm

Browse Source
This commit is contained in:
Alex Crichton 2018-07-20 16:31:29 -07:00
parent df3530a9c2
commit b667cafb63
5 changed files with 214 additions and 305 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

139
crates/js-sys/src/lib.rs
View File

@ -627,6 +627,21 @@ extern "C" {
/// types here.
#[wasm_bindgen(method, js_name = forEach)]
pub fn for_each(this: &Float32Array, callback: &mut FnMut(f32, u32, Float32Array));
/// The `length` accessor property represents the length (in elements) of a
/// typed array.
#[wasm_bindgen(method, getter)]
pub fn length(this: &Float32Array) -> u32;
/// The `byteLength` accessor property represents the length (in bytes) of a
/// typed array.
#[wasm_bindgen(method, getter, js_name = byteLength)]
pub fn byte_length(this: &Float32Array) -> u32;
/// The `byteOffset` accessor property represents the offset (in bytes) of a
/// typed array from the start of its `ArrayBuffer`.
#[wasm_bindgen(method, getter, js_name = byteOffset)]
pub fn byte_offset(this: &Float32Array) -> u32;
}
// Float64Array
@ -655,14 +670,29 @@ extern "C" {
/// The `subarray()` method stores multiple values in the typed array,
/// reading input values from a specified array.
#[wasm_bindgen(method)]
pub fn subarray(this: &Float64Array, begin: u64, end: u64) -> Float64Array;
pub fn subarray(this: &Float64Array, begin: u32, end: u32) -> Float64Array;
/// The `forEach()` method executes a provided function once per array
/// element. This method has the same algorithm as
/// `Array.prototype.forEach()`. `TypedArray` is one of the typed array
/// types here.
#[wasm_bindgen(method, js_name = forEach)]
pub fn for_each(this: &Float64Array, callback: &mut FnMut(f64, u64, Float64Array));
pub fn for_each(this: &Float64Array, callback: &mut FnMut(f64, u32, Float64Array));
/// The `length` accessor property represents the length (in elements) of a
/// typed array.
#[wasm_bindgen(method, getter)]
pub fn length(this: &Float64Array) -> u32;
/// The `byteLength` accessor property represents the length (in bytes) of a
/// typed array.
#[wasm_bindgen(method, getter, js_name = byteLength)]
pub fn byte_length(this: &Float64Array) -> u32;
/// The `byteOffset` accessor property represents the offset (in bytes) of a
/// typed array from the start of its `ArrayBuffer`.
#[wasm_bindgen(method, getter, js_name = byteOffset)]
pub fn byte_offset(this: &Float64Array) -> u32;
}
// Function
@ -780,6 +810,21 @@ extern "C" {
/// types here.
#[wasm_bindgen(method, js_name = forEach)]
pub fn for_each(this: &Int8Array, callback: &mut FnMut(i8, u32, Int8Array));
/// The `length` accessor property represents the length (in elements) of a
/// typed array.
#[wasm_bindgen(method, getter)]
pub fn length(this: &Int8Array) -> u32;
/// The `byteLength` accessor property represents the length (in bytes) of a
/// typed array.
#[wasm_bindgen(method, getter, js_name = byteLength)]
pub fn byte_length(this: &Int8Array) -> u32;
/// The `byteOffset` accessor property represents the offset (in bytes) of a
/// typed array from the start of its `ArrayBuffer`.
#[wasm_bindgen(method, getter, js_name = byteOffset)]
pub fn byte_offset(this: &Int8Array) -> u32;
}
// Int16Array
@ -816,6 +861,21 @@ extern "C" {
/// types here.
#[wasm_bindgen(method, js_name = forEach)]
pub fn for_each(this: &Int16Array, callback: &mut FnMut(i16, u32, Int16Array));
/// The `length` accessor property represents the length (in elements) of a
/// typed array.
#[wasm_bindgen(method, getter)]
pub fn length(this: &Int16Array) -> u32;
/// The `byteLength` accessor property represents the length (in bytes) of a
/// typed array.
#[wasm_bindgen(method, getter, js_name = byteLength)]
pub fn byte_length(this: &Int16Array) -> u32;
/// The `byteOffset` accessor property represents the offset (in bytes) of a
/// typed array from the start of its `ArrayBuffer`.
#[wasm_bindgen(method, getter, js_name = byteOffset)]
pub fn byte_offset(this: &Int16Array) -> u32;
}
// Int32Array
@ -852,6 +912,21 @@ extern "C" {
/// types here.
#[wasm_bindgen(method, js_name = forEach)]
pub fn for_each(this: &Int32Array, callback: &mut FnMut(i32, u32, Int32Array));
/// The `length` accessor property represents the length (in elements) of a
/// typed array.
#[wasm_bindgen(method, getter)]
pub fn length(this: &Int32Array) -> u32;
/// The `byteLength` accessor property represents the length (in bytes) of a
/// typed array.
#[wasm_bindgen(method, getter, js_name = byteLength)]
pub fn byte_length(this: &Int32Array) -> u32;
/// The `byteOffset` accessor property represents the offset (in bytes) of a
/// typed array from the start of its `ArrayBuffer`.
#[wasm_bindgen(method, getter, js_name = byteOffset)]
pub fn byte_offset(this: &Int32Array) -> u32;
}
// Map
@ -1988,6 +2063,21 @@ extern "C" {
/// types here.
#[wasm_bindgen(method, js_name = forEach)]
pub fn for_each(this: &Uint8Array, callback: &mut FnMut(u8, u32, Uint8Array));
/// The `length` accessor property represents the length (in elements) of a
/// typed array.
#[wasm_bindgen(method, getter)]
pub fn length(this: &Uint8Array) -> u32;
/// The `byteLength` accessor property represents the length (in bytes) of a
/// typed array.
#[wasm_bindgen(method, getter, js_name = byteLength)]
pub fn byte_length(this: &Uint8Array) -> u32;
/// The `byteOffset` accessor property represents the offset (in bytes) of a
/// typed array from the start of its `ArrayBuffer`.
#[wasm_bindgen(method, getter, js_name = byteOffset)]
pub fn byte_offset(this: &Uint8Array) -> u32;
}
// Uint8ClampedArray
@ -2026,6 +2116,21 @@ extern "C" {
/// types here.
#[wasm_bindgen(method, js_name = forEach)]
pub fn for_each(this: &Uint8ClampedArray, callback: &mut FnMut(u8, u32, Uint8ClampedArray));
/// The `length` accessor property represents the length (in elements) of a
/// typed array.
#[wasm_bindgen(method, getter)]
pub fn length(this: &Uint8ClampedArray) -> u32;
/// The `byteLength` accessor property represents the length (in bytes) of a
/// typed array.
#[wasm_bindgen(method, getter, js_name = byteLength)]
pub fn byte_length(this: &Uint8ClampedArray) -> u32;
/// The `byteOffset` accessor property represents the offset (in bytes) of a
/// typed array from the start of its `ArrayBuffer`.
#[wasm_bindgen(method, getter, js_name = byteOffset)]
pub fn byte_offset(this: &Uint8ClampedArray) -> u32;
}
// Uint16Array
@ -2062,6 +2167,21 @@ extern "C" {
/// types here.
#[wasm_bindgen(method, js_name = forEach)]
pub fn for_each(this: &Uint16Array, callback: &mut FnMut(u16, u32, Uint16Array));
/// The `length` accessor property represents the length (in elements) of a
/// typed array.
#[wasm_bindgen(method, getter)]
pub fn length(this: &Uint16Array) -> u32;
/// The `byteLength` accessor property represents the length (in bytes) of a
/// typed array.
#[wasm_bindgen(method, getter, js_name = byteLength)]
pub fn byte_length(this: &Uint16Array) -> u32;
/// The `byteOffset` accessor property represents the offset (in bytes) of a
/// typed array from the start of its `ArrayBuffer`.
#[wasm_bindgen(method, getter, js_name = byteOffset)]
pub fn byte_offset(this: &Uint16Array) -> u32;
}
// Uint32Array
@ -2098,6 +2218,21 @@ extern "C" {
/// types here.
#[wasm_bindgen(method, js_name = forEach)]
pub fn for_each(this: &Uint32Array, callback: &mut FnMut(u32, u32, Uint32Array));
/// The `length` accessor property represents the length (in elements) of a
/// typed array.
#[wasm_bindgen(method, getter)]
pub fn length(this: &Uint32Array) -> u32;
/// The `byteLength` accessor property represents the length (in bytes) of a
/// typed array.
#[wasm_bindgen(method, getter, js_name = byteLength)]
pub fn byte_length(this: &Uint32Array) -> u32;
/// The `byteOffset` accessor property represents the offset (in bytes) of a
/// typed array from the start of its `ArrayBuffer`.
#[wasm_bindgen(method, getter, js_name = byteOffset)]
pub fn byte_offset(this: &Uint32Array) -> u32;
}
// WeakMap

302
crates/js-sys/tests/all/TypedArray.rs
View File

@ -1,302 +0,0 @@
#![allow(non_snake_case)]
use project;
use std::string::String;
fn new_undefined_lib(array_type: &str) -> String {
format!(r#"
#![feature(use_extern_macros)]
extern crate wasm_bindgen;
extern crate js_sys;
use wasm_bindgen::prelude::*;
#[wasm_bindgen]
pub fn new_array() -> js_sys::{} {{
js_sys::{}::new(JsValue::undefined())
}}
"#, array_type, array_type)
}
fn new_undefined_test_js() -> &'static str {
r#"
import * as assert from "assert";
import * as wasm from "./out";
export function test() {
assert.equal(wasm.new_array().length, 0);
}
"#
}
#[test]
fn new_Uint8Array_undefined() {
project()
.file("src/lib.rs", &new_undefined_lib("Uint8Array"),)
.file("test.js", new_undefined_test_js(),)
.test()
}
#[test]
fn new_Uint8ClampedArray_undefined() {
project()
.file("src/lib.rs", &new_undefined_lib("Uint8ClampedArray"),)
.file("test.js", new_undefined_test_js(),)
.test()
}
#[test]
fn new_Uint16Array_undefined() {
project()
.file("src/lib.rs", &new_undefined_lib("Uint16Array"),)
.file("test.js", new_undefined_test_js(),)
.test()
}
#[test]
fn new_Uint32Array_undefined() {
project()
.file("src/lib.rs", &new_undefined_lib("Uint32Array"),)
.file("test.js", new_undefined_test_js(),)
.test()
}
#[test]
fn new_Int8Array_undefined() {
project()
.file("src/lib.rs", &new_undefined_lib("Int8Array"),)
.file("test.js", new_undefined_test_js(),)
.test()
}
#[test]
fn new_Int16Array_undefined() {
project()
.file("src/lib.rs", &new_undefined_lib("Int16Array"),)
.file("test.js", new_undefined_test_js(),)
.test()
}
#[test]
fn new_Int32Array_undefined() {
project()
.file("src/lib.rs", &new_undefined_lib("Int32Array"),)
.file("test.js", new_undefined_test_js(),)
.test()
}
#[test]
fn new_Float32Array_undefined() {
project()
.file("src/lib.rs", &new_undefined_lib("Float32Array"),)
.file("test.js", new_undefined_test_js(),)
.test()
}
#[test]
fn new_Float64Array_undefined() {
project()
.file("src/lib.rs", &new_undefined_lib("Float64Array"),)
.file("test.js", new_undefined_test_js(),)
.test()
}
fn new_length_lib(array_type: &str) -> String {
format!(r#"
#![feature(use_extern_macros)]
extern crate wasm_bindgen;
extern crate js_sys;
use wasm_bindgen::prelude::*;
#[wasm_bindgen]
pub fn new_array() -> js_sys::{} {{
js_sys::{}::new(JsValue::from_f64(4.0))
}}
"#, array_type, array_type)
}
fn new_length_test_js() -> &'static str {
r#"
import * as assert from "assert";
import * as wasm from "./out";
export function test() {
assert.equal(wasm.new_array().length, 4);
}
"#
}
#[test]
fn new_Uint8Array_length() {
project()
.file("src/lib.rs", &new_length_lib("Uint8Array"),)
.file("test.js", new_length_test_js(),)
.test()
}
#[test]
fn new_Uint8ClampedArray_length() {
project()
.file("src/lib.rs", &new_length_lib("Uint8ClampedArray"),)
.file("test.js", new_length_test_js(),)
.test()
}
#[test]
fn new_Uint16Array_length() {
project()
.file("src/lib.rs", &new_length_lib("Uint16Array"),)
.file("test.js", new_length_test_js(),)
.test()
}
#[test]
fn new_Uint32Array_length() {
project()
.file("src/lib.rs", &new_length_lib("Uint32Array"),)
.file("test.js", new_length_test_js(),)
.test()
}
#[test]
fn new_Int8Array_length() {
project()
.file("src/lib.rs", &new_length_lib("Int8Array"),)
.file("test.js", new_length_test_js(),)
.test()
}
#[test]
fn new_Int16Array_length() {
project()
.file("src/lib.rs", &new_length_lib("Int16Array"),)
.file("test.js", new_length_test_js(),)
.test()
}
#[test]
fn new_Int32Array_length() {
project()
.file("src/lib.rs", &new_length_lib("Int32Array"),)
.file("test.js", new_length_test_js(),)
.test()
}
#[test]
fn new_Float32Array_length() {
project()
.file("src/lib.rs", &new_length_lib("Float32Array"),)
.file("test.js", new_length_test_js(),)
.test()
}
#[test]
fn new_Float64Array_length() {
project()
.file("src/lib.rs", &new_length_lib("Float64Array"),)
.file("test.js", new_length_test_js(),)
.test()
}
fn fill_lib(array_type: &str, el_type: &str) -> String {
format!(r#"
#![feature(use_extern_macros)]
extern crate wasm_bindgen;
extern crate js_sys;
use wasm_bindgen::prelude::*;
#[wasm_bindgen]
pub fn fill_with(this: &js_sys::{}, value: {}, start: u32, end: u32) -> js_sys::{} {{
this.fill(value, start, end)
}}
"#, array_type, el_type, array_type)
}
fn fill_test_js(array_type: &str) -> String {
format!(r#"
import * as assert from "assert";
import * as wasm from "./out";
export function test() {{
let characters = new {}([0, 0, 0, 0, 0, 0]);
let subset = wasm.fill_with(characters, 1, 0, 3);
assert.equal(subset[0], 1);
assert.equal(subset[4], 0);
}}
"#, array_type)
}
#[test]
fn fill_Uint8Array() {
project()
.file("src/lib.rs", &fill_lib("Uint8Array", "u8"),)
.file("test.js", &fill_test_js("Uint8Array"))
.test()
}
#[test]
fn fill_Uint8ClampedArray() {
project()
.file("src/lib.rs", &fill_lib("Uint8ClampedArray", "u8"),)
.file("test.js", &fill_test_js("Uint8ClampedArray"))
.test()
}
#[test]
fn fill_Uint16Array() {
project()
.file("src/lib.rs", &fill_lib("Uint16Array", "u16"),)
.file("test.js", &fill_test_js("Uint16Array"))
.test()
}
#[test]
fn fill_Uint32Array() {
project()
.file("src/lib.rs", &fill_lib("Uint32Array", "u32"),)
.file("test.js", &fill_test_js("Uint32Array"))
.test()
}
#[test]
fn fill_Int8Array() {
project()
.file("src/lib.rs", &fill_lib("Int8Array", "i8"),)
.file("test.js", &fill_test_js("Int8Array"))
.test()
}
#[test]
fn fill_Int16Array() {
project()
.file("src/lib.rs", &fill_lib("Int16Array", "i16"),)
.file("test.js", &fill_test_js("Int16Array"))
.test()
}
#[test]
fn fill_Int32Array() {
project()
.file("src/lib.rs", &fill_lib("Int32Array", "i32"),)
.file("test.js", &fill_test_js("Int32Array"))
.test()
}
#[test]
fn fill_Float32Array() {
project()
.file("src/lib.rs", &fill_lib("Float32Array", "f32"),)
.file("test.js", &fill_test_js("Float32Array"))
.test()
}
#[test]
fn fill_Float64Array() {
project()
.file("src/lib.rs", &fill_lib("Float64Array", "f64"),)
.file("test.js", &fill_test_js("Float64Array"))
.test()
}

1
crates/js-sys/tests/all/main.rs
View File

@ -12,7 +12,6 @@ fn project() -> project_builder::Project {
mod ArrayIterator;
mod Reflect;
mod TypedArray;
mod WeakMap;
mod WeakSet;
mod WebAssembly;

76
crates/js-sys/tests/wasm/TypedArray.rs Normal file
View File

@ -0,0 +1,76 @@
use wasm_bindgen::prelude::*;
use wasm_bindgen_test::*;
use js_sys::*;
macro_rules! each {
($m:ident) => (
$m!(Uint8Array);
$m!(Uint8ClampedArray);
$m!(Uint16Array);
$m!(Uint32Array);
$m!(Int8Array);
$m!(Int16Array);
$m!(Int32Array);
$m!(Float32Array);
$m!(Float64Array);
)
}
macro_rules! test_undefined {
($arr:ident) => ({
let arr = $arr::new(JsValue::undefined());
assert_eq!(arr.length(), 0);
assert_eq!(arr.byte_length(), 0);
assert_eq!(arr.byte_offset(), 0);
assert!(JsValue::from(arr.buffer()).is_object());
})
}
#[wasm_bindgen_test]
fn new_undefined() {
each!(test_undefined);
}
macro_rules! test_length {
($arr:ident) => ({
let arr = $arr::new(4.into());
assert_eq!(arr.length(), 4);
assert!(arr.byte_length() != 0);
assert_eq!(arr.byte_offset(), 0);
assert!(JsValue::from(arr.buffer()).is_object());
})
}
#[wasm_bindgen_test]
fn new_length() {
each!(test_length);
}
macro_rules! test_subarray {
($arr:ident) => ({
assert_eq!($arr::new(4.into()).subarray(0, 1).length(), 1);
})
}
#[wasm_bindgen_test]
fn new_subarray() {
each!(test_subarray);
}
macro_rules! test_fill {
($arr:ident) => ({
let arr = $arr::new(4.into());
arr.for_each(&mut |x, _, _| {
assert_eq!(x as f64, 0.0);
});
arr.fill(2 as _, 0, 2);
arr.for_each(&mut |x, i, _| {
if i < 2 {
assert_eq!(x as f64, 2.0);
} else {
assert_eq!(x as f64, 0.0);
}
});
})
}
#[wasm_bindgen_test]
fn new_fill() {
each!(test_fill);
}

1
crates/js-sys/tests/wasm/main.rs
View File

@ -26,3 +26,4 @@ pub mod Proxy;
pub mod Set;
pub mod SetIterator;
pub mod Symbol;
pub mod TypedArray;