diff options
Diffstat (limited to 'vendor/wasm-bindgen/tests/wasm')
71 files changed, 7752 insertions, 0 deletions
diff --git a/vendor/wasm-bindgen/tests/wasm/api.js b/vendor/wasm-bindgen/tests/wasm/api.js new file mode 100644 index 000000000..ebbce0431 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/api.js @@ -0,0 +1,75 @@ +const wasm = require('wasm-bindgen-test.js'); +const assert = require('assert'); + +exports.assert_null = x => { + assert.strictEqual(x, null); +}; + +exports.js_works = () => { + assert.strictEqual(wasm.api_foo(), 'foo'); + assert.strictEqual(wasm.api_bar('a'), 'a'); + assert.strictEqual(wasm.api_baz(), 1); + wasm.api_baz2(2, 'a'); + + assert.strictEqual(wasm.api_js_null(), null); + assert.strictEqual(wasm.api_js_undefined(), undefined); + + wasm.api_test_is_null_undefined(null, undefined, 1.0); + + assert.strictEqual(wasm.api_get_true(), true); + assert.strictEqual(wasm.api_get_false(), false); + wasm.api_test_bool(true, false, 1.0); + + assert.strictEqual(typeof (wasm.api_mk_symbol()), 'symbol'); + assert.strictEqual(typeof (wasm.api_mk_symbol2('a')), 'symbol'); + assert.strictEqual(Symbol.keyFor(wasm.api_mk_symbol()), undefined); + assert.strictEqual(Symbol.keyFor(wasm.api_mk_symbol2('b')), undefined); + + wasm.api_assert_symbols(Symbol(), 'a'); + wasm.api_acquire_string('foo', null); + assert.strictEqual(wasm.api_acquire_string2(''), ''); + assert.strictEqual(wasm.api_acquire_string2('a'), 'a'); + + let arr = [1, 2, 3, 4, {}, ['a', 'b', 'c']] + wasm.api_completely_variadic(...arr).forEach((element, index) => { + assert.strictEqual(element, arr[index]); + }); + assert.strictEqual( + wasm.api_completely_variadic().length, + 0 + ); + wasm.api_variadic_with_prefixed_params([], {}, ...arr).forEach((element, index) => { + assert.strictEqual(element, arr[index]); + }); +}; + +exports.js_eq_works = () => { + assert.strictEqual(wasm.eq_test('a', 'a'), true); + assert.strictEqual(wasm.eq_test('a', 'b'), false); + assert.strictEqual(wasm.eq_test(NaN, NaN), false); + assert.strictEqual(wasm.eq_test({ a: 'a' }, { a: 'a' }), false); + assert.strictEqual(wasm.eq_test1(NaN), false); + let x = { a: 'a' }; + assert.strictEqual(wasm.eq_test(x, x), true); + assert.strictEqual(wasm.eq_test1(x), true); +}; + +exports.debug_values = () => ([ + null, + undefined, + 0, + 1.0, + true, + [1, 2, 3], + "string", + { test: "object" }, + [1.0, [2.0, 3.0]], + () => (null), + new Set(), +]); + +exports.assert_function_table = (x, i) => { + const rawWasm = require('wasm-bindgen-test.js').__wasm; + assert.ok(x instanceof WebAssembly.Table); + assert.strictEqual(x.get(i), rawWasm.function_table_lookup); +}; diff --git a/vendor/wasm-bindgen/tests/wasm/api.rs b/vendor/wasm-bindgen/tests/wasm/api.rs new file mode 100644 index 000000000..c1c542d67 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/api.rs @@ -0,0 +1,199 @@ +use js_sys::{Uint8Array, WebAssembly}; +use wasm_bindgen::prelude::*; +use wasm_bindgen::{self, JsCast}; +use wasm_bindgen_test::*; + +#[wasm_bindgen(module = "tests/wasm/api.js")] +extern "C" { + fn js_works(); + fn js_eq_works(); + fn assert_null(v: JsValue); + fn debug_values() -> JsValue; + fn assert_function_table(a: JsValue, b: usize); +} + +#[wasm_bindgen_test] +fn works() { + js_works(); +} + +#[wasm_bindgen] +pub fn api_foo() -> JsValue { + JsValue::from("foo") +} + +#[wasm_bindgen] +pub fn api_bar(s: &str) -> JsValue { + JsValue::from(s) +} + +#[wasm_bindgen] +pub fn api_baz() -> JsValue { + JsValue::from(1.0) +} + +#[wasm_bindgen] +pub fn api_baz2(a: &JsValue, b: &JsValue) { + assert_eq!(a.as_f64(), Some(2.0)); + assert_eq!(b.as_f64(), None); +} + +#[wasm_bindgen] +pub fn api_js_null() -> JsValue { + JsValue::null() +} + +#[wasm_bindgen] +pub fn api_js_undefined() -> JsValue { + JsValue::undefined() +} + +#[wasm_bindgen] +pub fn api_test_is_null_undefined(a: &JsValue, b: &JsValue, c: &JsValue) { + assert!(a.is_null()); + assert!(!a.is_undefined()); + + assert!(!b.is_null()); + assert!(b.is_undefined()); + + assert!(!c.is_null()); + assert!(!c.is_undefined()); +} + +#[wasm_bindgen] +pub fn api_get_true() -> JsValue { + JsValue::from(true) +} + +#[wasm_bindgen] +pub fn api_get_false() -> JsValue { + JsValue::from(false) +} + +#[wasm_bindgen] +pub fn api_test_bool(a: &JsValue, b: &JsValue, c: &JsValue) { + assert_eq!(a.as_bool(), Some(true)); + assert_eq!(format!("{:?}", a), "JsValue(true)"); + assert_eq!(b.as_bool(), Some(false)); + assert_eq!(c.as_bool(), None); +} + +#[wasm_bindgen] +pub fn api_mk_symbol() -> JsValue { + let a = JsValue::symbol(None); + assert!(a.is_symbol()); + assert_eq!(format!("{:?}", a), "JsValue(Symbol)"); + return a; +} + +#[wasm_bindgen] +pub fn api_mk_symbol2(s: &str) -> JsValue { + let a = JsValue::symbol(Some(s)); + assert!(a.is_symbol()); + return a; +} + +#[wasm_bindgen] +pub fn api_assert_symbols(a: &JsValue, b: &JsValue) { + assert!(a.is_symbol()); + assert!(!b.is_symbol()); +} + +#[wasm_bindgen] +pub fn api_acquire_string(a: &JsValue, b: &JsValue) { + assert_eq!(a.as_string().unwrap(), "foo"); + assert_eq!(format!("{:?}", a), "JsValue(\"foo\")"); + assert_eq!(b.as_string(), None); +} + +#[wasm_bindgen] +pub fn api_acquire_string2(a: &JsValue) -> String { + a.as_string().unwrap_or("wrong".to_string()) +} + +#[wasm_bindgen_test] +fn eq_works() { + js_eq_works(); +} + +#[wasm_bindgen] +pub fn eq_test(a: &JsValue, b: &JsValue) -> bool { + a == b +} + +#[wasm_bindgen] +pub fn eq_test1(a: &JsValue) -> bool { + a == a +} + +#[wasm_bindgen(variadic)] +pub fn api_completely_variadic(args: &JsValue) -> JsValue { + args.into() +} + +#[wasm_bindgen(variadic)] +pub fn api_variadic_with_prefixed_params( + first: &JsValue, + second: &JsValue, + args: &JsValue, +) -> JsValue { + args.into() +} + +#[wasm_bindgen_test] +fn null_keeps_working() { + assert_null(JsValue::null()); + assert_null(JsValue::null()); +} + +#[wasm_bindgen_test] +fn memory_accessor_appears_to_work() { + let data = 3u32; + let ptr = &data as *const u32 as u32; + + let my_mem = wasm_bindgen::memory(); + let mem = my_mem.dyn_into::<WebAssembly::Memory>().unwrap(); + let buf = mem.buffer(); + let slice = Uint8Array::new(&buf); + let mut v = Vec::new(); + slice + .subarray(ptr, ptr + 4) + .for_each(&mut |val, _, _| v.push(val)); + assert_eq!(v, [3, 0, 0, 0]); +} + +#[wasm_bindgen_test] +fn debug_output() { + let test_iter = debug_values() + .dyn_into::<js_sys::Array>() + .unwrap() + .values() + .into_iter(); + let expecteds = vec![ + "JsValue(null)", + "JsValue(undefined)", + "JsValue(0)", + "JsValue(1)", + "JsValue(true)", + "JsValue([1, 2, 3])", + "JsValue(\"string\")", + "JsValue(Object({\"test\":\"object\"}))", + "JsValue([1, [2, 3]])", + "JsValue(Function)", + "JsValue(Set)", + ]; + for (test, expected) in test_iter.zip(expecteds) { + assert_eq!(format!("{:?}", test.unwrap()), expected); + } +} + +#[wasm_bindgen_test] +fn function_table_is() { + assert_function_table( + wasm_bindgen::function_table(), + function_table_lookup as usize, + ); +} + +#[no_mangle] +pub extern "C" fn function_table_lookup() {} diff --git a/vendor/wasm-bindgen/tests/wasm/arg_names.js b/vendor/wasm-bindgen/tests/wasm/arg_names.js new file mode 100644 index 000000000..255604b3e --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/arg_names.js @@ -0,0 +1,16 @@ +const wasm = require('wasm-bindgen-test.js'); +const assert = require('assert'); + +const ARGUMENT_NAMES = /([^\s,]+)/g; +const STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg; + +// https://stackoverflow.com/q/1007981/210304 +function getArgNames(func) { + let fnStr = func.toString().replace(STRIP_COMMENTS, ''); + let result = fnStr.slice(fnStr.indexOf('(')+1, fnStr.indexOf(')')).match(ARGUMENT_NAMES); + return result === null ? [] : result; +} + +exports.js_arg_names = () => { + assert.deepEqual(getArgNames(wasm.fn_with_many_args), ['_a', '_b', '_c', '_d']); +}; diff --git a/vendor/wasm-bindgen/tests/wasm/arg_names.rs b/vendor/wasm-bindgen/tests/wasm/arg_names.rs new file mode 100644 index 000000000..e6f044ee1 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/arg_names.rs @@ -0,0 +1,15 @@ +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[wasm_bindgen(module = "tests/wasm/arg_names.js")] +extern "C" { + fn js_arg_names(); +} + +#[wasm_bindgen] +pub fn fn_with_many_args(_a: i32, _b: i32, _c: i32, _d: i32) {} + +#[wasm_bindgen_test] +fn rust_arg_names() { + js_arg_names(); +} diff --git a/vendor/wasm-bindgen/tests/wasm/bigint.js b/vendor/wasm-bindgen/tests/wasm/bigint.js new file mode 100644 index 000000000..3971d2279 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/bigint.js @@ -0,0 +1,53 @@ +const wasm = require('wasm-bindgen-test.js'); +const assert = require('assert'); + +exports.i64_js_identity = a => a; +exports.u64_js_identity = a => a; + +exports.js_works = () => { + assert.strictEqual(wasm.zero(), BigInt('0')); + assert.strictEqual(wasm.one(), BigInt('1')); + assert.strictEqual(wasm.neg_one(), BigInt('-1')); + assert.strictEqual(wasm.i32_min(), BigInt('-2147483648')); + assert.strictEqual(wasm.u32_max(), BigInt('4294967295')); + assert.strictEqual(wasm.i64_min(), BigInt('-9223372036854775808')); + assert.strictEqual(wasm.u64_max(), BigInt('18446744073709551615')); + + const i64_min = BigInt('-9223372036854775808'); + const u64_max = BigInt('18446744073709551615'); + + const identityTestI64Values = [ + BigInt('0'), + BigInt('1'), + BigInt('-1'), + i64_min, + ]; + for (const value of identityTestI64Values) { + assert.strictEqual(wasm.i64_rust_identity(value), value); + assert.strictEqual(wasm.i64_jsvalue_identity(value), value); + } + + const identityTestU64Values = [ + BigInt('0'), + BigInt('1'), + u64_max, + ]; + for (const value of identityTestU64Values) { + assert.strictEqual(wasm.u64_rust_identity(value), value); + assert.strictEqual(wasm.u64_jsvalue_identity(value), value); + } + + assert.strictEqual(wasm.u64_rust_identity(BigInt('1') << BigInt('64')), BigInt('0')); + assert.strictEqual(wasm.i128_min_jsvalue(), BigInt('-170141183460469231731687303715884105728')); + assert.strictEqual(wasm.u128_max_jsvalue(), BigInt('340282366920938463463374607431768211455')); + + assert.deepStrictEqual(wasm.u64_slice([]), new BigUint64Array()); + assert.deepStrictEqual(wasm.i64_slice([]), new BigInt64Array()); + const arr1 = new BigUint64Array([BigInt('1'), BigInt('2')]); + assert.deepStrictEqual(wasm.u64_slice([BigInt('1'), BigInt('2')]), arr1); + const arr2 = new BigInt64Array([BigInt('1'), BigInt('2')]); + assert.deepStrictEqual(wasm.i64_slice([BigInt('1'), BigInt('2')]), arr2); + + assert.deepStrictEqual(wasm.i64_slice([i64_min]), new BigInt64Array([i64_min])); + assert.deepStrictEqual(wasm.u64_slice([u64_max]), new BigUint64Array([u64_max])); +}; diff --git a/vendor/wasm-bindgen/tests/wasm/bigint.rs b/vendor/wasm-bindgen/tests/wasm/bigint.rs new file mode 100644 index 000000000..30eb5c5cf --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/bigint.rs @@ -0,0 +1,118 @@ +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[wasm_bindgen(module = "tests/wasm/bigint.js")] +extern "C" { + fn i64_js_identity(a: i64) -> i64; + fn u64_js_identity(a: u64) -> u64; + fn js_works(); +} + +#[wasm_bindgen] +pub fn zero() -> u64 { + 0 +} + +#[wasm_bindgen] +pub fn one() -> u64 { + 1 +} + +#[wasm_bindgen] +pub fn neg_one() -> i64 { + -1 +} + +#[wasm_bindgen] +pub fn i32_min() -> i64 { + i32::min_value() as i64 +} + +#[wasm_bindgen] +pub fn u32_max() -> u64 { + u32::max_value() as u64 +} + +#[wasm_bindgen] +pub fn i64_min() -> i64 { + i64::min_value() +} + +#[wasm_bindgen] +pub fn u64_max() -> u64 { + u64::max_value() +} + +#[wasm_bindgen] +pub fn i64_rust_identity(a: i64) -> i64 { + i64_js_identity(a) +} + +#[wasm_bindgen] +pub fn u64_rust_identity(a: u64) -> u64 { + u64_js_identity(a) +} + +#[wasm_bindgen] +pub fn i64_jsvalue_identity(a: i64) -> JsValue { + JsValue::from(a) +} + +#[wasm_bindgen] +pub fn u64_jsvalue_identity(a: u64) -> JsValue { + JsValue::from(a) +} + +#[wasm_bindgen] +pub fn i128_min_jsvalue() -> JsValue { + JsValue::from(i128::min_value()) +} + +#[wasm_bindgen] +pub fn u128_max_jsvalue() -> JsValue { + JsValue::from(u128::max_value()) +} + +#[wasm_bindgen] +pub fn i64_slice(a: &[i64]) -> Vec<i64> { + a.to_vec() +} + +#[wasm_bindgen] +pub fn u64_slice(a: &[u64]) -> Vec<u64> { + a.to_vec() +} + +#[wasm_bindgen_test] +fn works() { + js_works(); +} + +mod try_from_works { + use super::*; + use crate::JsValue; + use core::convert::TryFrom; + + macro_rules! test_type_boundaries { + ($($ty:ident)*) => { + $( + #[wasm_bindgen_test] + fn $ty() { + // Not a bigint. + assert!($ty::try_from(JsValue::NULL).is_err()); + assert!($ty::try_from(JsValue::from_f64(0.0)).is_err()); + // Within range. + assert_eq!($ty::try_from(JsValue::from($ty::MIN)), Ok($ty::MIN)); + // Too small. + assert!($ty::try_from(JsValue::from($ty::MIN) - JsValue::from(1_i64)).is_err()); + // Within range. + assert_eq!($ty::try_from(JsValue::from($ty::MAX)), Ok($ty::MAX)); + // Too large. + assert!($ty::try_from(JsValue::from($ty::MAX) + JsValue::from(1_i64)).is_err()); + } + )* + }; + } + + test_type_boundaries!(i64 u64 i128 u128); +} diff --git a/vendor/wasm-bindgen/tests/wasm/char.js b/vendor/wasm-bindgen/tests/wasm/char.js new file mode 100644 index 000000000..d145333e3 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/char.js @@ -0,0 +1,17 @@ +const wasm = require('wasm-bindgen-test.js'); +const assert = require('assert'); + +exports.js_identity = a => a; + +exports.js_works = () => { + assert.strictEqual(wasm.letter(), 'a'); + assert.strictEqual(wasm.face(), '😀'); + assert.strictEqual(wasm.rust_identity('Ղ'), 'Ղ'); + assert.strictEqual(wasm.rust_identity('ҝ'), 'ҝ'); + assert.strictEqual(wasm.rust_identity('Δ'), 'Δ'); + assert.strictEqual(wasm.rust_identity('䉨'), '䉨'); + assert.strictEqual(wasm.rust_js_identity('a'), 'a'); + assert.strictEqual(wasm.rust_js_identity('㊻'), '㊻'); + wasm.rust_letter('a'); + wasm.rust_face('😀'); +}; diff --git a/vendor/wasm-bindgen/tests/wasm/char.rs b/vendor/wasm-bindgen/tests/wasm/char.rs new file mode 100644 index 000000000..f852b8d81 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/char.rs @@ -0,0 +1,43 @@ +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[wasm_bindgen(module = "tests/wasm/char.js")] +extern "C" { + fn js_identity(c: char) -> char; + fn js_works(); +} + +#[wasm_bindgen] +pub fn rust_identity(c: char) -> char { + c +} + +#[wasm_bindgen] +pub fn rust_js_identity(c: char) -> char { + js_identity(c) +} + +#[wasm_bindgen] +pub fn letter() -> char { + 'a' +} + +#[wasm_bindgen] +pub fn face() -> char { + '😀' +} + +#[wasm_bindgen] +pub fn rust_letter(a: char) { + assert_eq!(a, 'a'); +} + +#[wasm_bindgen] +pub fn rust_face(p: char) { + assert_eq!(p, '😀'); +} + +#[wasm_bindgen_test] +fn works() { + js_works(); +} diff --git a/vendor/wasm-bindgen/tests/wasm/classes.js b/vendor/wasm-bindgen/tests/wasm/classes.js new file mode 100644 index 000000000..93a76107a --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/classes.js @@ -0,0 +1,239 @@ +const wasm = require('wasm-bindgen-test.js'); +const assert = require('assert'); + +exports.js_simple = () => { + const r = new wasm.ClassesSimple(); + assert.strictEqual(r.add(0), 0); + assert.strictEqual(r.add(1), 1); + assert.strictEqual(r.add(1), 2); + r.add(2); + assert.strictEqual(r.consume(), 4); + assert.throws(() => r.free(), /null pointer passed to rust/); + + const r2 = wasm.ClassesSimple.with_contents(10); + assert.strictEqual(r2.add(1), 11); + assert.strictEqual(r2.add(2), 13); + assert.strictEqual(r2.add(3), 16); + r2.free(); + + const r3 = new wasm.ClassesSimple(); + assert.strictEqual(r3.add(42), 42); + r3.free(); +}; + +exports.js_strings = () => { + const r = wasm.ClassesStrings1.new(); + r.set(3); + let bar = r.bar('baz'); + r.free(); + assert.strictEqual(bar.name(), 'foo-baz-3'); + bar.free(); +}; + +exports.js_exceptions = () => { + // this test only works when `--debug` is passed to `wasm-bindgen` (or the + // equivalent thereof) + if (require('process').env.WASM_BINDGEN_NO_DEBUG) + return; + assert.throws(() => new wasm.ClassesExceptions1(), /cannot invoke `new` directly/); + let a = wasm.ClassesExceptions1.new(); + a.free(); + assert.throws(() => a.free(), /null pointer passed to rust/); + + let b = wasm.ClassesExceptions1.new(); + b.foo(b); + assert.throws(() => b.bar(b), /recursive use of an object/); + + let c = wasm.ClassesExceptions1.new(); + let d = wasm.ClassesExceptions2.new(); + assert.throws(() => c.foo(d), /expected instance of ClassesExceptions1/); + d.free(); + c.free(); +}; + +exports.js_pass_one_to_another = () => { + let a = wasm.ClassesPassA.new(); + let b = wasm.ClassesPassB.new(); + a.foo(b); + a.bar(b); + a.free(); +}; + +exports.take_class = foo => { + assert.strictEqual(foo.inner(), 13); + foo.free(); + assert.throws(() => foo.free(), /null pointer passed to rust/); +}; + +exports.js_constructors = () => { + const foo = new wasm.ConstructorsFoo(1); + assert.strictEqual(foo.get_number(), 1); + foo.free(); + + assert.strictEqual(wasm.ConstructorsBar.new, undefined); + const foo2 = new wasm.ConstructorsFoo(2); + assert.strictEqual(foo2.get_number(), 2); + foo2.free(); + + const bar = new wasm.ConstructorsBar(3, 4); + assert.strictEqual(bar.get_sum(), 7); + bar.free(); + + assert.strictEqual(wasm.ConstructorsBar.other_name, undefined); + const bar2 = new wasm.ConstructorsBar(5, 6); + assert.strictEqual(bar2.get_sum(), 11); + bar2.free(); + + assert.strictEqual(wasm.cross_item_construction().get_sum(), 15); +}; + +exports.js_empty_structs = () => { + wasm.OtherEmpty.return_a_value(); +}; + +exports.js_public_fields = () => { + const a = wasm.PublicFields.new(); + assert.strictEqual(a.a, 0); + a.a = 3; + assert.strictEqual(a.a, 3); + + assert.strictEqual(a.b, 0); + a.b = 7; + assert.strictEqual(a.b, 7); + + assert.strictEqual(a.c, 0); + a.c = 8; + assert.strictEqual(a.c, 8); + + assert.strictEqual(a.d, 0); + a.d = 3.3; + assert.strictEqual(a.d, 3); + + assert.strictEqual(a.skipped, undefined); +}; + +exports.js_getter_with_clone = () => { + const a = wasm.GetterWithCloneStruct.new(); + assert.strictEqual(a.a, ''); + a.a = 'foo'; + assert.strictEqual(a.a, 'foo'); + + const b = wasm.GetterWithCloneStructField.new(); + assert.strictEqual(b.a, ''); + b.a = 'foo'; + assert.strictEqual(b.a, 'foo'); +}; + +exports.js_using_self = () => { + wasm.UseSelf.new().free(); +}; + +exports.js_readonly_fields = () => { + const a = wasm.Readonly.new(); + assert.strictEqual(a.a, 0); + a.a = 3; + assert.strictEqual(a.a, 0); + a.free(); +}; + +exports.js_double_consume = () => { + const r = new wasm.DoubleConsume(); + assert.throws(() => r.consume(r)); +}; + + +exports.js_js_rename = () => { + (new wasm.JsRename()).bar(); + wasm.classes_foo(); +}; + +exports.js_access_fields = () => { + assert.ok((new wasm.AccessFieldFoo()).bar instanceof wasm.AccessFieldBar); + assert.ok((new wasm.AccessField0())[0] instanceof wasm.AccessFieldBar); +}; + +exports.js_renamed_export = () => { + const x = new wasm.JsRenamedExport(); + assert.ok(x.x === 3); + x.foo(); + x.bar(x); +}; + +exports.js_renamed_field = () => { + const x = new wasm.RenamedField(); + assert.ok(x.bar === 3); + + x.foo(); +} + +exports.js_conditional_bindings = () => { + const x = new wasm.ConditionalBindings(); + x.free(); +}; + +exports.js_assert_none = x => { + assert.strictEqual(x, undefined); +}; +exports.js_assert_some = x => { + assert.ok(x instanceof wasm.OptionClass); +}; +exports.js_return_none1 = () => null; +exports.js_return_none2 = () => undefined; +exports.js_return_some = x => x; + +exports.js_test_option_classes = () => { + assert.strictEqual(wasm.option_class_none(), undefined); + wasm.option_class_assert_none(undefined); + wasm.option_class_assert_none(null); + const c = wasm.option_class_some(); + assert.ok(c instanceof wasm.OptionClass); + wasm.option_class_assert_some(c); +}; + +/** + * Invokes `console.log`, but logs to a string rather than stdout + * @param {any} data Data to pass to `console.log` + * @returns {string} Output from `console.log`, without color or trailing newlines + */ +const console_log_to_string = data => { + // Store the original stdout.write and create a console that logs without color + const original_write = process.stdout.write; + const colorless_console = new console.Console({ + stdout: process.stdout, + colorMode: false + }); + let output = ''; + + // Change stdout.write to append to our string, then restore the original function + process.stdout.write = chunk => output += chunk.trim(); + colorless_console.log(data); + process.stdout.write = original_write; + + return output; +}; + +exports.js_test_inspectable_classes = () => { + const inspectable = wasm.Inspectable.new(); + const not_inspectable = wasm.NotInspectable.new(); + // Inspectable classes have a toJSON and toString implementation generated + assert.deepStrictEqual(inspectable.toJSON(), { a: inspectable.a }); + assert.strictEqual(inspectable.toString(), `{"a":${inspectable.a}}`); + // Inspectable classes in Node.js have improved console.log formatting as well + assert(console_log_to_string(inspectable).endsWith(`{ a: ${inspectable.a} }`)); + // Non-inspectable classes do not have a toJSON or toString generated + assert.strictEqual(not_inspectable.toJSON, undefined); + assert.strictEqual(not_inspectable.toString(), '[object Object]'); + // Non-inspectable classes in Node.js have no special console.log formatting + assert.strictEqual(console_log_to_string(not_inspectable), `NotInspectable { ptr: ${not_inspectable.ptr} }`); + inspectable.free(); + not_inspectable.free(); +}; + +exports.js_test_inspectable_classes_can_override_generated_methods = () => { + const overridden_inspectable = wasm.OverriddenInspectable.new(); + // Inspectable classes can have the generated toJSON and toString overwritten + assert.strictEqual(overridden_inspectable.a, 0); + assert.deepStrictEqual(overridden_inspectable.toJSON(), 'JSON was overwritten'); + assert.strictEqual(overridden_inspectable.toString(), 'string was overwritten'); + overridden_inspectable.free(); +}; diff --git a/vendor/wasm-bindgen/tests/wasm/classes.rs b/vendor/wasm-bindgen/tests/wasm/classes.rs new file mode 100644 index 000000000..3588bb74c --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/classes.rs @@ -0,0 +1,610 @@ +#[allow(unused_imports)] // test for #919 +use std::borrow::BorrowMut; + +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[wasm_bindgen(module = "tests/wasm/classes.js")] +extern "C" { + fn js_simple(); + fn js_strings(); + fn js_exceptions(); + fn js_pass_one_to_another(); + fn take_class(foo: ClassesIntoJs); + #[wasm_bindgen(js_name = take_class)] + fn take_class_as_jsvalue(foo: JsValue); + fn js_constructors(); + fn js_empty_structs(); + fn js_public_fields(); + fn js_getter_with_clone(); + fn js_using_self(); + fn js_readonly_fields(); + fn js_double_consume(); + fn js_js_rename(); + fn js_access_fields(); + fn js_renamed_export(); + fn js_renamed_field(); + fn js_conditional_bindings(); + + fn js_assert_none(a: Option<OptionClass>); + fn js_assert_some(a: Option<OptionClass>); + fn js_return_none1() -> Option<OptionClass>; + fn js_return_none2() -> Option<OptionClass>; + fn js_return_some(a: OptionClass) -> Option<OptionClass>; + fn js_test_option_classes(); + fn js_test_inspectable_classes(); + fn js_test_inspectable_classes_can_override_generated_methods(); +} + +#[wasm_bindgen_test] +fn simple() { + js_simple(); +} + +#[wasm_bindgen] +pub struct ClassesSimple { + contents: u32, +} + +#[wasm_bindgen] +impl ClassesSimple { + #[wasm_bindgen(constructor)] + pub fn new() -> ClassesSimple { + ClassesSimple::with_contents(0) + } + + pub fn with_contents(a: u32) -> ClassesSimple { + ClassesSimple { contents: a } + } + + pub fn add(&mut self, amt: u32) -> u32 { + self.contents += amt; + self.contents + } + + pub fn consume(self) -> u32 { + self.contents + } +} + +#[wasm_bindgen_test] +fn strings() { + js_strings() +} + +#[wasm_bindgen] +pub struct ClassesStrings1 { + name: u32, +} + +#[wasm_bindgen] +pub struct ClassesStrings2 { + contents: String, +} + +#[wasm_bindgen] +impl ClassesStrings1 { + pub fn new() -> ClassesStrings1 { + ClassesStrings1 { name: 0 } + } + + pub fn set(&mut self, amt: u32) { + self.name = amt; + } + + pub fn bar(&self, mix: &str) -> ClassesStrings2 { + ClassesStrings2 { + contents: format!("foo-{}-{}", mix, self.name), + } + } +} + +#[wasm_bindgen] +impl ClassesStrings2 { + pub fn name(&self) -> String { + self.contents.clone() + } +} + +#[wasm_bindgen_test] +fn exceptions() { + js_exceptions(); +} + +#[wasm_bindgen] +pub struct ClassesExceptions1 {} + +#[wasm_bindgen] +impl ClassesExceptions1 { + pub fn new() -> ClassesExceptions1 { + ClassesExceptions1 {} + } + + pub fn foo(&self, _: &ClassesExceptions1) {} + + pub fn bar(&mut self, _: &mut ClassesExceptions1) {} +} + +#[wasm_bindgen] +pub struct ClassesExceptions2 {} + +#[wasm_bindgen] +impl ClassesExceptions2 { + pub fn new() -> ClassesExceptions2 { + ClassesExceptions2 {} + } +} + +#[wasm_bindgen_test] +fn pass_one_to_another() { + js_pass_one_to_another(); +} + +#[wasm_bindgen] +pub struct ClassesPassA {} + +#[wasm_bindgen] +impl ClassesPassA { + pub fn new() -> ClassesPassA { + ClassesPassA {} + } + + pub fn foo(&self, _other: &ClassesPassB) {} + + pub fn bar(&self, _other: ClassesPassB) {} +} + +#[wasm_bindgen] +pub struct ClassesPassB {} + +#[wasm_bindgen] +impl ClassesPassB { + pub fn new() -> ClassesPassB { + ClassesPassB {} + } +} + +#[wasm_bindgen_test] +fn pass_into_js() { + take_class(ClassesIntoJs(13)); +} + +#[wasm_bindgen] +pub struct ClassesIntoJs(i32); + +#[wasm_bindgen] +impl ClassesIntoJs { + pub fn inner(&self) -> i32 { + self.0 + } +} + +#[wasm_bindgen] +pub struct Issue27Context {} + +#[wasm_bindgen] +impl Issue27Context { + pub fn parse(&self, _expr: &str) -> Issue27Expr { + panic!() + } + pub fn eval(&self, _expr: &Issue27Expr) -> f64 { + panic!() + } + pub fn set(&mut self, _var: &str, _val: f64) { + panic!() + } +} + +#[wasm_bindgen] +pub struct Issue27Expr {} + +#[wasm_bindgen_test] +fn pass_into_js_as_js_class() { + take_class_as_jsvalue(ClassesIntoJs(13).into()); +} + +#[wasm_bindgen_test] +fn constructors() { + js_constructors(); +} + +#[wasm_bindgen] +pub fn cross_item_construction() -> ConstructorsBar { + ConstructorsBar::other_name(7, 8) +} + +#[wasm_bindgen] +pub struct ConstructorsFoo { + number: u32, +} + +#[wasm_bindgen] +impl ConstructorsFoo { + #[wasm_bindgen(constructor)] + pub fn new(number: u32) -> ConstructorsFoo { + ConstructorsFoo { number } + } + + pub fn get_number(&self) -> u32 { + self.number + } +} + +#[wasm_bindgen] +pub struct ConstructorsBar { + number: u32, + number2: u32, +} + +#[wasm_bindgen] +impl ConstructorsBar { + #[wasm_bindgen(constructor)] + pub fn other_name(number: u32, number2: u32) -> ConstructorsBar { + ConstructorsBar { number, number2 } + } + + pub fn get_sum(&self) -> u32 { + self.number + self.number2 + } +} + +#[wasm_bindgen_test] +fn empty_structs() { + js_empty_structs(); +} + +#[wasm_bindgen] +pub struct MissingClass {} + +#[wasm_bindgen] +pub struct OtherEmpty {} + +#[wasm_bindgen] +impl OtherEmpty { + pub fn return_a_value() -> MissingClass { + MissingClass {} + } +} + +#[wasm_bindgen_test] +fn public_fields() { + js_public_fields(); +} + +#[wasm_bindgen] +#[derive(Default)] +pub struct PublicFields { + pub a: u32, + pub b: f32, + pub c: f64, + pub d: i32, + #[wasm_bindgen(skip)] + pub skipped: u32, +} + +#[wasm_bindgen] +impl PublicFields { + pub fn new() -> PublicFields { + PublicFields::default() + } +} + +#[wasm_bindgen_test] +fn getter_with_clone() { + js_getter_with_clone(); +} + +#[wasm_bindgen(getter_with_clone)] +#[derive(Default)] +pub struct GetterWithCloneStruct { + pub a: String, +} + +#[wasm_bindgen] +impl GetterWithCloneStruct { + pub fn new() -> GetterWithCloneStruct { + GetterWithCloneStruct::default() + } +} + +#[wasm_bindgen] +#[derive(Default)] +pub struct GetterWithCloneStructField { + #[wasm_bindgen(getter_with_clone)] + pub a: String, +} + +#[wasm_bindgen] +impl GetterWithCloneStructField { + pub fn new() -> GetterWithCloneStructField { + GetterWithCloneStructField::default() + } +} + +#[wasm_bindgen_test] +fn using_self() { + js_using_self(); +} + +#[wasm_bindgen] +pub struct UseSelf {} + +#[wasm_bindgen] +impl UseSelf { + pub fn new() -> Self { + UseSelf {} + } +} + +#[wasm_bindgen_test] +fn readonly_fields() { + js_readonly_fields(); +} + +#[wasm_bindgen] +#[derive(Default)] +pub struct Readonly { + #[wasm_bindgen(readonly)] + pub a: u32, +} + +#[wasm_bindgen] +impl Readonly { + pub fn new() -> Readonly { + Readonly::default() + } +} + +#[wasm_bindgen_test] +fn double_consume() { + js_double_consume(); +} + +#[wasm_bindgen] +pub struct DoubleConsume {} + +#[wasm_bindgen] +impl DoubleConsume { + #[wasm_bindgen(constructor)] + pub fn new() -> DoubleConsume { + DoubleConsume {} + } + + pub fn consume(self, other: DoubleConsume) { + drop(other); + } +} + +#[wasm_bindgen_test] +fn rename_function_for_js() { + js_js_rename(); + foo(); +} + +#[wasm_bindgen] +pub struct JsRename {} + +#[wasm_bindgen] +impl JsRename { + #[wasm_bindgen(constructor)] + pub fn new() -> JsRename { + let f = JsRename {}; + f.foo(); + f + } + + #[wasm_bindgen(js_name = bar)] + pub fn foo(&self) {} +} + +#[wasm_bindgen(js_name = classes_foo)] +pub fn foo() {} + +#[wasm_bindgen] +pub struct AccessFieldFoo { + pub bar: AccessFieldBar, +} + +#[wasm_bindgen] +pub struct AccessField0(pub AccessFieldBar); + +#[wasm_bindgen] +#[derive(Copy, Clone)] +pub struct AccessFieldBar { + _value: u32, +} + +#[wasm_bindgen] +impl AccessFieldFoo { + #[wasm_bindgen(constructor)] + pub fn new() -> AccessFieldFoo { + AccessFieldFoo { + bar: AccessFieldBar { _value: 2 }, + } + } +} + +#[wasm_bindgen] +impl AccessField0 { + #[wasm_bindgen(constructor)] + pub fn new() -> AccessField0 { + AccessField0(AccessFieldBar { _value: 2 }) + } +} + +#[wasm_bindgen_test] +fn access_fields() { + js_access_fields(); +} + +#[wasm_bindgen(js_name = JsRenamedExport)] +pub struct RenamedExport { + pub x: u32, +} + +#[wasm_bindgen(js_class = JsRenamedExport)] +impl RenamedExport { + #[wasm_bindgen(constructor)] + pub fn new() -> RenamedExport { + RenamedExport { x: 3 } + } + pub fn foo(&self) {} + + pub fn bar(&self, other: &RenamedExport) { + drop(other); + } +} + +#[wasm_bindgen_test] +fn renamed_export() { + js_renamed_export(); +} + +#[wasm_bindgen] +pub struct RenamedField { + #[wasm_bindgen(js_name = bar)] + pub foo: u32, +} + +#[wasm_bindgen(js_class = RenamedField)] +impl RenamedField { + #[wasm_bindgen(constructor)] + pub fn new() -> RenamedField { + RenamedField { foo: 3 } + } + + pub fn foo(&self) {} +} + +#[wasm_bindgen_test] +fn renamed_field() { + js_renamed_field(); +} + +#[cfg_attr(target_arch = "wasm32", wasm_bindgen)] +pub struct ConditionalBindings {} + +#[cfg_attr(target_arch = "wasm32", wasm_bindgen)] +impl ConditionalBindings { + #[cfg_attr(target_arch = "wasm32", wasm_bindgen(constructor))] + pub fn new() -> ConditionalBindings { + ConditionalBindings {} + } +} + +#[wasm_bindgen_test] +fn conditional_bindings() { + js_conditional_bindings(); +} + +#[wasm_bindgen] +pub struct OptionClass(u32); + +#[wasm_bindgen_test] +fn option_class() { + js_assert_none(None); + js_assert_some(Some(OptionClass(1))); + assert!(js_return_none1().is_none()); + assert!(js_return_none2().is_none()); + assert_eq!(js_return_some(OptionClass(2)).unwrap().0, 2); + js_test_option_classes(); +} + +#[wasm_bindgen] +pub fn option_class_none() -> Option<OptionClass> { + None +} + +#[wasm_bindgen] +pub fn option_class_some() -> Option<OptionClass> { + Some(OptionClass(3)) +} + +#[wasm_bindgen] +pub fn option_class_assert_none(x: Option<OptionClass>) { + assert!(x.is_none()); +} + +#[wasm_bindgen] +pub fn option_class_assert_some(x: Option<OptionClass>) { + assert_eq!(x.unwrap().0, 3); +} + +mod works_in_module { + use wasm_bindgen::prelude::wasm_bindgen; + + #[wasm_bindgen] + pub struct WorksInModule(u32); + + #[wasm_bindgen] + impl WorksInModule { + #[wasm_bindgen(constructor)] + pub fn new() -> WorksInModule { + WorksInModule(1) + } + + pub fn foo(&self) {} + } +} + +#[wasm_bindgen_test] +fn inspectable_classes() { + js_test_inspectable_classes(); +} + +#[wasm_bindgen(inspectable)] +#[derive(Default)] +pub struct Inspectable { + pub a: u32, + // This private field will not be exposed unless a getter is provided for it + #[allow(dead_code)] + private: u32, +} + +#[wasm_bindgen] +impl Inspectable { + pub fn new() -> Self { + Self::default() + } +} + +#[wasm_bindgen] +#[derive(Default)] +pub struct NotInspectable { + pub a: u32, +} + +#[wasm_bindgen] +impl NotInspectable { + pub fn new() -> Self { + Self::default() + } +} + +#[wasm_bindgen_test] +fn inspectable_classes_can_override_generated_methods() { + js_test_inspectable_classes_can_override_generated_methods(); +} + +#[wasm_bindgen(inspectable)] +#[derive(Default)] +pub struct OverriddenInspectable { + pub a: u32, +} + +#[wasm_bindgen] +impl OverriddenInspectable { + pub fn new() -> Self { + Self::default() + } + + #[wasm_bindgen(js_name = toJSON)] + pub fn to_json(&self) -> String { + String::from("JSON was overwritten") + } + + #[wasm_bindgen(js_name = toString)] + pub fn to_string(&self) -> String { + String::from("string was overwritten") + } +} diff --git a/vendor/wasm-bindgen/tests/wasm/closures.js b/vendor/wasm-bindgen/tests/wasm/closures.js new file mode 100644 index 000000000..dfc3d871e --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/closures.js @@ -0,0 +1,164 @@ +const assert = require('assert'); +const wasm = require('wasm-bindgen-test'); + +exports.works_call = a => { + a(); +}; + +exports.works_thread = a => a(2); + +let CANNOT_REUSE_CACHE = null; + +exports.cannot_reuse_call = a => { + CANNOT_REUSE_CACHE = a; +}; + +exports.cannot_reuse_call_again = () => { + CANNOT_REUSE_CACHE(); +}; + +exports.long_lived_call1 = a => { + a(); +}; + +exports.long_lived_call2 = a => a(2); + +exports.many_arity_call1 = a => { + a(); +}; +exports.many_arity_call2 = a => { + a(1); +}; +exports.many_arity_call3 = a => { + a(1, 2); +}; +exports.many_arity_call4 = a => { + a(1, 2, 3); +}; +exports.many_arity_call5 = a => { + a(1, 2, 3, 4); +}; +exports.many_arity_call6 = a => { + a(1, 2, 3, 4, 5); +}; +exports.many_arity_call7 = a => { + a(1, 2, 3, 4, 5, 6); +}; +exports.many_arity_call8 = a => { + a(1, 2, 3, 4, 5, 6, 7); +}; +exports.many_arity_call9 = a => { + a(1, 2, 3, 4, 5, 6, 7, 8); +}; + +exports.option_call1 = a => { + if (a) { + a(); + } +}; +exports.option_call2 = a => { + if (a) { + return a(2); + } +}; +exports.option_call3 = a => a == undefined; + +let LONG_LIVED_DROPPING_CACHE = null; + +exports.long_lived_dropping_cache = a => { + LONG_LIVED_DROPPING_CACHE = a; +}; +exports.long_lived_dropping_call = () => { + LONG_LIVED_DROPPING_CACHE(); +}; + +let LONG_LIVED_OPTION_DROPPING_CACHE = null; + +exports.long_lived_option_dropping_cache = a => { + if (a) { + LONG_LIVED_OPTION_DROPPING_CACHE = a; + return true; + } else { + return false; + } +} +exports.long_lived_option_dropping_call = () => { + LONG_LIVED_OPTION_DROPPING_CACHE(); +} + +let LONG_FNMUT_RECURSIVE_CACHE = null; + +exports.long_fnmut_recursive_cache = a => { + LONG_FNMUT_RECURSIVE_CACHE = a; +}; +exports.long_fnmut_recursive_call = () => { + LONG_FNMUT_RECURSIVE_CACHE(); +}; + +exports.fnmut_call = a => { + a(); +}; + +exports.fnmut_thread = a => a(2); + +let FNMUT_BAD_F = null; + +exports.fnmut_bad_call = a => { + FNMUT_BAD_F = a; + a(); +}; + +exports.fnmut_bad_again = x => { + if (x) { + FNMUT_BAD_F(); + } +}; + +exports.string_arguments_call = a => { + a('foo'); +}; + +exports.string_ret_call = a => { + assert.strictEqual(a('foo'), 'foobar'); +}; + +let DROP_DURING_CALL = null; +exports.drop_during_call_save = f => { + DROP_DURING_CALL = f; +}; +exports.drop_during_call_call = () => DROP_DURING_CALL(); + +exports.js_test_closure_returner = () => { + wasm.closure_returner().someKey(); +}; + +exports.calling_it_throws = a => { + try { + a(); + return false; + } catch(_) { + return true; + } +}; + +exports.call_val = f => f(); + +exports.pass_reference_first_arg_twice = (a, b, c) => { + b(a); + c(a); + a.free(); +}; + +exports.call_destroyed = f => { + assert.throws(f, /invoked recursively or destroyed/); +}; + +let FORGOTTEN_CLOSURE = null; + +exports.js_store_forgotten_closure = f => { + FORGOTTEN_CLOSURE = f; +}; + +exports.js_call_forgotten_closure = () => { + FORGOTTEN_CLOSURE(); +}; diff --git a/vendor/wasm-bindgen/tests/wasm/closures.rs b/vendor/wasm-bindgen/tests/wasm/closures.rs new file mode 100644 index 000000000..dc88b43ad --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/closures.rs @@ -0,0 +1,645 @@ +use js_sys::Number; +use std::cell::{Cell, RefCell}; +use std::rc::Rc; +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[wasm_bindgen(module = "tests/wasm/closures.js")] +extern "C" { + fn works_call(a: &dyn Fn()); + fn works_thread(a: &dyn Fn(u32) -> u32) -> u32; + + fn cannot_reuse_call(a: &dyn Fn()); + #[wasm_bindgen(catch)] + fn cannot_reuse_call_again() -> Result<(), JsValue>; + + fn long_lived_call1(a: &Closure<dyn Fn()>); + fn long_lived_call2(a: &Closure<dyn FnMut(u32) -> u32>) -> u32; + + fn many_arity_call1(a: &Closure<dyn Fn()>); + fn many_arity_call2(a: &Closure<dyn Fn(u32)>); + fn many_arity_call3(a: &Closure<dyn Fn(u32, u32)>); + fn many_arity_call4(a: &Closure<dyn Fn(u32, u32, u32)>); + fn many_arity_call5(a: &Closure<dyn Fn(u32, u32, u32, u32)>); + fn many_arity_call6(a: &Closure<dyn Fn(u32, u32, u32, u32, u32)>); + fn many_arity_call7(a: &Closure<dyn Fn(u32, u32, u32, u32, u32, u32)>); + fn many_arity_call8(a: &Closure<dyn Fn(u32, u32, u32, u32, u32, u32, u32)>); + fn many_arity_call9(a: &Closure<dyn Fn(u32, u32, u32, u32, u32, u32, u32, u32)>); + + #[wasm_bindgen(js_name = many_arity_call1)] + fn many_arity_call_mut1(a: &Closure<dyn FnMut()>); + #[wasm_bindgen(js_name = many_arity_call2)] + fn many_arity_call_mut2(a: &Closure<dyn FnMut(u32)>); + #[wasm_bindgen(js_name = many_arity_call3)] + fn many_arity_call_mut3(a: &Closure<dyn FnMut(u32, u32)>); + #[wasm_bindgen(js_name = many_arity_call4)] + fn many_arity_call_mut4(a: &Closure<dyn FnMut(u32, u32, u32)>); + #[wasm_bindgen(js_name = many_arity_call5)] + fn many_arity_call_mut5(a: &Closure<dyn FnMut(u32, u32, u32, u32)>); + #[wasm_bindgen(js_name = many_arity_call6)] + fn many_arity_call_mut6(a: &Closure<dyn FnMut(u32, u32, u32, u32, u32)>); + #[wasm_bindgen(js_name = many_arity_call7)] + fn many_arity_call_mut7(a: &Closure<dyn FnMut(u32, u32, u32, u32, u32, u32)>); + #[wasm_bindgen(js_name = many_arity_call8)] + fn many_arity_call_mut8(a: &Closure<dyn FnMut(u32, u32, u32, u32, u32, u32, u32)>); + #[wasm_bindgen(js_name = many_arity_call9)] + fn many_arity_call_mut9(a: &Closure<dyn FnMut(u32, u32, u32, u32, u32, u32, u32, u32)>); + + fn option_call1(a: Option<&Closure<dyn Fn()>>); + fn option_call2(a: Option<&Closure<dyn FnMut(u32) -> u32>>) -> u32; + fn option_call3(a: Option<&Closure<dyn Fn()>>) -> bool; + + #[wasm_bindgen(js_name = many_arity_call1)] + fn many_arity_stack1(a: &dyn Fn()); + #[wasm_bindgen(js_name = many_arity_call2)] + fn many_arity_stack2(a: &dyn Fn(u32)); + #[wasm_bindgen(js_name = many_arity_call3)] + fn many_arity_stack3(a: &dyn Fn(u32, u32)); + #[wasm_bindgen(js_name = many_arity_call4)] + fn many_arity_stack4(a: &dyn Fn(u32, u32, u32)); + #[wasm_bindgen(js_name = many_arity_call5)] + fn many_arity_stack5(a: &dyn Fn(u32, u32, u32, u32)); + #[wasm_bindgen(js_name = many_arity_call6)] + fn many_arity_stack6(a: &dyn Fn(u32, u32, u32, u32, u32)); + #[wasm_bindgen(js_name = many_arity_call7)] + fn many_arity_stack7(a: &dyn Fn(u32, u32, u32, u32, u32, u32)); + #[wasm_bindgen(js_name = many_arity_call8)] + fn many_arity_stack8(a: &dyn Fn(u32, u32, u32, u32, u32, u32, u32)); + #[wasm_bindgen(js_name = many_arity_call9)] + fn many_arity_stack9(a: &dyn Fn(u32, u32, u32, u32, u32, u32, u32, u32)); + + fn long_lived_dropping_cache(a: &Closure<dyn Fn()>); + #[wasm_bindgen(catch)] + fn long_lived_dropping_call() -> Result<(), JsValue>; + + fn long_lived_option_dropping_cache(a: Option<&Closure<dyn Fn()>>) -> bool; + #[wasm_bindgen(catch)] + fn long_lived_option_dropping_call() -> Result<(), JsValue>; + + fn long_fnmut_recursive_cache(a: &Closure<dyn FnMut()>); + #[wasm_bindgen(catch)] + fn long_fnmut_recursive_call() -> Result<(), JsValue>; + + fn fnmut_call(a: &mut dyn FnMut()); + fn fnmut_thread(a: &mut dyn FnMut(u32) -> u32) -> u32; + + fn fnmut_bad_call(a: &mut dyn FnMut()); + #[wasm_bindgen(catch)] + fn fnmut_bad_again(a: bool) -> Result<(), JsValue>; + + fn string_arguments_call(a: &mut dyn FnMut(String)); + + fn string_ret_call(a: &mut dyn FnMut(String) -> String); + + fn drop_during_call_save(a: &Closure<dyn Fn()>); + fn drop_during_call_call(); + + fn js_test_closure_returner(); + + fn calling_it_throws(a: &Closure<dyn FnMut()>) -> bool; + + fn call_val(f: &JsValue); + + #[wasm_bindgen(js_name = calling_it_throws)] + fn call_val_throws(f: &JsValue) -> bool; + + fn pass_reference_first_arg_twice( + a: RefFirstArgument, + b: &Closure<dyn FnMut(&RefFirstArgument)>, + c: &Closure<dyn FnMut(&RefFirstArgument)>, + ); + #[wasm_bindgen(js_name = pass_reference_first_arg_twice)] + fn pass_reference_first_arg_twice2( + a: RefFirstArgument, + b: &mut dyn FnMut(&RefFirstArgument), + c: &mut dyn FnMut(&RefFirstArgument), + ); + fn call_destroyed(a: &JsValue); + + fn js_store_forgotten_closure(closure: &Closure<dyn Fn()>); + fn js_call_forgotten_closure(); + + #[wasm_bindgen(js_name = many_arity_call2)] + fn externref_call(a: &Closure<dyn Fn(JsValue)>); + #[wasm_bindgen(js_name = many_arity_call2)] + fn named_externref_call(a: &Closure<dyn Fn(Number)>); +} + +#[wasm_bindgen_test] +fn works() { + let a = Cell::new(false); + works_call(&|| a.set(true)); + assert!(a.get()); + + assert_eq!(works_thread(&|a| a + 1), 3); +} + +#[wasm_bindgen_test] +fn cannot_reuse() { + cannot_reuse_call(&|| {}); + assert!(cannot_reuse_call_again().is_err()); +} + +#[wasm_bindgen_test] +fn debug() { + let closure = Closure::wrap(Box::new(|| {}) as Box<dyn FnMut()>); + assert_eq!(&format!("{:?}", closure), "Closure { ... }"); +} + +#[wasm_bindgen_test] +fn long_lived() { + let hit = Rc::new(Cell::new(false)); + let hit2 = hit.clone(); + let a = Closure::new(move || hit2.set(true)); + assert!(!hit.get()); + long_lived_call1(&a); + assert!(hit.get()); + + let hit = Rc::new(Cell::new(false)); + { + let hit = hit.clone(); + let a = Closure::new(move |x| { + hit.set(true); + x + 3 + }); + assert_eq!(long_lived_call2(&a), 5); + } + assert!(hit.get()); +} + +#[wasm_bindgen_test] +fn many_arity() { + many_arity_call1(&Closure::new(|| {})); + many_arity_call2(&Closure::new(|a| assert_eq!(a, 1))); + many_arity_call3(&Closure::new(|a, b| assert_eq!((a, b), (1, 2)))); + many_arity_call4(&Closure::new(|a, b, c| assert_eq!((a, b, c), (1, 2, 3)))); + many_arity_call5(&Closure::new(|a, b, c, d| { + assert_eq!((a, b, c, d), (1, 2, 3, 4)) + })); + many_arity_call6(&Closure::new(|a, b, c, d, e| { + assert_eq!((a, b, c, d, e), (1, 2, 3, 4, 5)) + })); + many_arity_call7(&Closure::new(|a, b, c, d, e, f| { + assert_eq!((a, b, c, d, e, f), (1, 2, 3, 4, 5, 6)) + })); + many_arity_call8(&Closure::new(|a, b, c, d, e, f, g| { + assert_eq!((a, b, c, d, e, f, g), (1, 2, 3, 4, 5, 6, 7)) + })); + many_arity_call9(&Closure::new(|a, b, c, d, e, f, g, h| { + assert_eq!((a, b, c, d, e, f, g, h), (1, 2, 3, 4, 5, 6, 7, 8)) + })); + + let s = String::new(); + many_arity_call_mut1(&Closure::once(move || drop(s))); + let s = String::new(); + many_arity_call_mut2(&Closure::once(move |a| { + drop(s); + assert_eq!(a, 1); + })); + let s = String::new(); + many_arity_call_mut3(&Closure::once(move |a, b| { + drop(s); + assert_eq!((a, b), (1, 2)); + })); + let s = String::new(); + many_arity_call_mut4(&Closure::once(move |a, b, c| { + drop(s); + assert_eq!((a, b, c), (1, 2, 3)); + })); + let s = String::new(); + many_arity_call_mut5(&Closure::once(move |a, b, c, d| { + drop(s); + assert_eq!((a, b, c, d), (1, 2, 3, 4)); + })); + let s = String::new(); + many_arity_call_mut6(&Closure::once(move |a, b, c, d, e| { + drop(s); + assert_eq!((a, b, c, d, e), (1, 2, 3, 4, 5)); + })); + let s = String::new(); + many_arity_call_mut7(&Closure::once(move |a, b, c, d, e, f| { + drop(s); + assert_eq!((a, b, c, d, e, f), (1, 2, 3, 4, 5, 6)); + })); + let s = String::new(); + many_arity_call_mut8(&Closure::once(move |a, b, c, d, e, f, g| { + drop(s); + assert_eq!((a, b, c, d, e, f, g), (1, 2, 3, 4, 5, 6, 7)); + })); + let s = String::new(); + many_arity_call_mut9(&Closure::once(move |a, b, c, d, e, f, g, h| { + drop(s); + assert_eq!((a, b, c, d, e, f, g, h), (1, 2, 3, 4, 5, 6, 7, 8)); + })); + + many_arity_stack1(&(|| {})); + many_arity_stack2(&(|a| assert_eq!(a, 1))); + many_arity_stack3(&(|a, b| assert_eq!((a, b), (1, 2)))); + many_arity_stack4(&(|a, b, c| assert_eq!((a, b, c), (1, 2, 3)))); + many_arity_stack5(&(|a, b, c, d| assert_eq!((a, b, c, d), (1, 2, 3, 4)))); + many_arity_stack6(&(|a, b, c, d, e| assert_eq!((a, b, c, d, e), (1, 2, 3, 4, 5)))); + many_arity_stack7(&(|a, b, c, d, e, f| assert_eq!((a, b, c, d, e, f), (1, 2, 3, 4, 5, 6)))); + many_arity_stack8( + &(|a, b, c, d, e, f, g| assert_eq!((a, b, c, d, e, f, g), (1, 2, 3, 4, 5, 6, 7))), + ); + many_arity_stack9( + &(|a, b, c, d, e, f, g, h| assert_eq!((a, b, c, d, e, f, g, h), (1, 2, 3, 4, 5, 6, 7, 8))), + ); +} + +#[wasm_bindgen_test] +fn option() { + let hit = Rc::new(Cell::new(false)); + let hit2 = hit.clone(); + let a = Closure::new(move || hit2.set(true)); + assert!(!hit.get()); + option_call1(Some(&a)); + assert!(hit.get()); + + let hit = Rc::new(Cell::new(false)); + { + let hit = hit.clone(); + let a = Closure::new(move |x| { + hit.set(true); + x + 3 + }); + assert_eq!(option_call2(Some(&a)), 5); + } + assert!(hit.get()); + + assert!(option_call3(None)); +} + +struct Dropper(Rc<Cell<bool>>); +impl Drop for Dropper { + fn drop(&mut self) { + assert!(!self.0.get()); + self.0.set(true); + } +} + +#[wasm_bindgen_test] +fn call_fn_once_twice() { + let dropped = Rc::new(Cell::new(false)); + let dropper = Dropper(dropped.clone()); + let called = Rc::new(Cell::new(false)); + + let c = Closure::once({ + let called = called.clone(); + move || { + assert!(!called.get()); + called.set(true); + drop(dropper); + } + }); + + many_arity_call_mut1(&c); + assert!(called.get()); + assert!(dropped.get()); + + assert!(calling_it_throws(&c)); +} + +#[wasm_bindgen_test] +fn once_into_js() { + let dropped = Rc::new(Cell::new(false)); + let dropper = Dropper(dropped.clone()); + let called = Rc::new(Cell::new(false)); + + let f = Closure::once_into_js({ + let called = called.clone(); + move || { + assert!(!called.get()); + called.set(true); + drop(dropper); + } + }); + + call_val(&f); + assert!(called.get()); + assert!(dropped.get()); + + assert!(call_val_throws(&f)); +} + +#[wasm_bindgen_test] +fn long_lived_dropping() { + let hit = Rc::new(Cell::new(false)); + let hit2 = hit.clone(); + let a = Closure::new(move || hit2.set(true)); + long_lived_dropping_cache(&a); + assert!(!hit.get()); + assert!(long_lived_dropping_call().is_ok()); + assert!(hit.get()); + drop(a); + assert!(long_lived_dropping_call().is_err()); +} + +#[wasm_bindgen_test] +fn long_lived_option_dropping() { + let hit = Rc::new(Cell::new(false)); + let hit2 = hit.clone(); + + let a = Closure::new(move || hit2.set(true)); + + assert!(!long_lived_option_dropping_cache(None)); + assert!(long_lived_option_dropping_cache(Some(&a))); + + assert!(!hit.get()); + assert!(long_lived_option_dropping_call().is_ok()); + assert!(hit.get()); + + drop(a); + assert!(long_lived_option_dropping_call().is_err()); +} + +#[wasm_bindgen_test] +fn long_fnmut_recursive() { + let a = Closure::new(|| { + assert!(long_fnmut_recursive_call().is_err()); + }); + long_fnmut_recursive_cache(&a); + assert!(long_fnmut_recursive_call().is_ok()); +} + +#[wasm_bindgen_test] +fn fnmut() { + let mut a = false; + fnmut_call(&mut || a = true); + assert!(a); + + let mut x = false; + assert_eq!( + fnmut_thread(&mut |a| { + x = true; + a + 1 + }), + 3 + ); + assert!(x); +} + +#[wasm_bindgen_test] +fn fnmut_bad() { + let mut x = true; + let mut hits = 0; + fnmut_bad_call(&mut || { + hits += 1; + if fnmut_bad_again(hits == 1).is_err() { + return; + } + x = false; + }); + assert_eq!(hits, 1); + assert!(x); + + assert!(fnmut_bad_again(true).is_err()); +} + +#[wasm_bindgen_test] +fn string_arguments() { + let mut x = false; + string_arguments_call(&mut |s| { + assert_eq!(s, "foo"); + x = true; + }); + assert!(x); +} + +#[wasm_bindgen_test] +fn string_ret() { + let mut x = false; + string_ret_call(&mut |mut s| { + assert_eq!(s, "foo"); + s.push_str("bar"); + x = true; + s + }); + assert!(x); +} + +#[wasm_bindgen_test] +fn drop_drops() { + static mut HIT: bool = false; + + struct A; + + impl Drop for A { + fn drop(&mut self) { + unsafe { + HIT = true; + } + } + } + let a = A; + let x: Closure<dyn Fn()> = Closure::new(move || drop(&a)); + drop(x); + unsafe { + assert!(HIT); + } +} + +#[wasm_bindgen_test] +fn drop_during_call_ok() { + static mut HIT: bool = false; + struct A; + impl Drop for A { + fn drop(&mut self) { + unsafe { + HIT = true; + } + } + } + + let rc = Rc::new(RefCell::new(None)); + let rc2 = rc.clone(); + let x = 3; + let a = A; + let x: Closure<dyn Fn()> = Closure::new(move || { + // "drop ourselves" + drop(rc2.borrow_mut().take().unwrap()); + + // `A` should not have been destroyed as a result + unsafe { + assert!(!HIT); + } + + // allocate some heap memory to try to paper over our `3` + drop(String::from("1234567890")); + + // make sure our closure memory is still valid + assert_eq!(x, 3); + + // make sure `A` is bound to our closure environment. + drop(&a); + unsafe { + assert!(!HIT); + } + }); + drop_during_call_save(&x); + *rc.borrow_mut() = Some(x); + drop(rc); + unsafe { + assert!(!HIT); + } + drop_during_call_call(); + unsafe { + assert!(HIT); + } +} + +#[wasm_bindgen_test] +fn test_closure_returner() { + type ClosureType = dyn FnMut() -> BadStruct; + + use js_sys::{Object, Reflect}; + use wasm_bindgen::JsCast; + + js_test_closure_returner(); + + #[wasm_bindgen] + pub struct ClosureHandle(Closure<ClosureType>); + + #[wasm_bindgen] + pub struct BadStruct {} + + #[wasm_bindgen] + pub fn closure_returner() -> Result<Object, JsValue> { + let o = Object::new(); + + let some_fn = Closure::wrap(Box::new(move || BadStruct {}) as Box<ClosureType>); + Reflect::set( + &o, + &JsValue::from("someKey"), + &some_fn.as_ref().unchecked_ref(), + ) + .unwrap(); + Reflect::set( + &o, + &JsValue::from("handle"), + &JsValue::from(ClosureHandle(some_fn)), + ) + .unwrap(); + + Ok(o) + } +} + +#[wasm_bindgen] +pub struct RefFirstArgument { + contents: u32, +} + +#[wasm_bindgen_test] +fn reference_as_first_argument_builds_at_all() { + #[wasm_bindgen] + extern "C" { + fn ref_first_arg1(a: &dyn Fn(&JsValue)); + fn ref_first_arg2(a: &mut dyn FnMut(&JsValue)); + fn ref_first_arg3(a: &Closure<dyn Fn(&JsValue)>); + fn ref_first_arg4(a: &Closure<dyn FnMut(&JsValue)>); + fn ref_first_custom1(a: &dyn Fn(&RefFirstArgument)); + fn ref_first_custom2(a: &mut dyn FnMut(&RefFirstArgument)); + fn ref_first_custom3(a: &Closure<dyn Fn(&RefFirstArgument)>); + fn ref_first_custom4(a: &Closure<dyn FnMut(&RefFirstArgument)>); + } + + Closure::wrap(Box::new(|_: &JsValue| ()) as Box<dyn Fn(&JsValue)>); + Closure::wrap(Box::new(|_: &JsValue| ()) as Box<dyn FnMut(&JsValue)>); + Closure::once(|_: &JsValue| ()); + Closure::once_into_js(|_: &JsValue| ()); + Closure::wrap(Box::new(|_: &RefFirstArgument| ()) as Box<dyn Fn(&RefFirstArgument)>); + Closure::wrap(Box::new(|_: &RefFirstArgument| ()) as Box<dyn FnMut(&RefFirstArgument)>); + Closure::once(|_: &RefFirstArgument| ()); + Closure::once_into_js(|_: &RefFirstArgument| ()); +} + +#[wasm_bindgen_test] +fn reference_as_first_argument_works() { + let a = Rc::new(Cell::new(0)); + let b = { + let a = a.clone(); + Closure::once(move |x: &RefFirstArgument| { + assert_eq!(a.get(), 0); + assert_eq!(x.contents, 3); + a.set(a.get() + 1); + }) + }; + let c = { + let a = a.clone(); + Closure::once(move |x: &RefFirstArgument| { + assert_eq!(a.get(), 1); + assert_eq!(x.contents, 3); + a.set(a.get() + 1); + }) + }; + pass_reference_first_arg_twice(RefFirstArgument { contents: 3 }, &b, &c); + assert_eq!(a.get(), 2); +} + +#[wasm_bindgen_test] +fn reference_as_first_argument_works2() { + let a = Cell::new(0); + pass_reference_first_arg_twice2( + RefFirstArgument { contents: 3 }, + &mut |x: &RefFirstArgument| { + assert_eq!(a.get(), 0); + assert_eq!(x.contents, 3); + a.set(a.get() + 1); + }, + &mut |x: &RefFirstArgument| { + assert_eq!(a.get(), 1); + assert_eq!(x.contents, 3); + a.set(a.get() + 1); + }, + ); + assert_eq!(a.get(), 2); +} + +#[wasm_bindgen_test] +fn call_destroyed_doesnt_segfault() { + struct A(i32, i32); + impl Drop for A { + fn drop(&mut self) { + assert_eq!(self.0, self.1); + } + } + + let a = A(1, 1); + let a = Closure::wrap(Box::new(move || drop(&a)) as Box<dyn Fn()>); + let b = a.as_ref().clone(); + drop(a); + call_destroyed(&b); + + let a = A(2, 2); + let a = Closure::wrap(Box::new(move || drop(&a)) as Box<dyn FnMut()>); + let b = a.as_ref().clone(); + drop(a); + call_destroyed(&b); + + let a = A(1, 1); + let a = Closure::wrap(Box::new(move |_: &JsValue| drop(&a)) as Box<dyn Fn(&JsValue)>); + let b = a.as_ref().clone(); + drop(a); + call_destroyed(&b); + + let a = A(2, 2); + let a = Closure::wrap(Box::new(move |_: &JsValue| drop(&a)) as Box<dyn FnMut(&JsValue)>); + let b = a.as_ref().clone(); + drop(a); + call_destroyed(&b); +} + +#[wasm_bindgen_test] +fn forget_works() { + let a = Closure::wrap(Box::new(|| {}) as Box<dyn Fn()>); + js_store_forgotten_closure(&a); + a.forget(); + js_call_forgotten_closure(); +} + +#[wasm_bindgen_test] +fn named_externref_no_duplicate_adapter() { + externref_call(&Closure::new(|a| assert_eq!(a, 1))); + named_externref_call(&Closure::new(|a| assert_eq!(a, 1))); +} diff --git a/vendor/wasm-bindgen/tests/wasm/comments.js b/vendor/wasm-bindgen/tests/wasm/comments.js new file mode 100644 index 000000000..1443281b5 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/comments.js @@ -0,0 +1,19 @@ +const fs = require('fs'); +const assert = require('assert'); + +exports.assert_comments_exist = function() { + const bindings_file = require.resolve('wasm-bindgen-test'); + const contents = fs.readFileSync(bindings_file); + assert.ok(contents.includes("* annotated function ✔️ \" \\ ' {")); + assert.ok(contents.includes("* annotated struct type")); + assert.ok(contents.includes("* annotated struct field b")); + assert.ok(contents.includes("* annotated struct field c")); + assert.ok(contents.includes("* annotated struct constructor")); + assert.ok(contents.includes("* annotated struct method")); + assert.ok(contents.includes("* annotated struct getter")); + assert.ok(contents.includes("* annotated struct setter")); + assert.ok(contents.includes("* annotated struct static method")); + assert.ok(contents.includes("* annotated enum type")); + assert.ok(contents.includes("* annotated enum variant 1")); + assert.ok(contents.includes("* annotated enum variant 2")); +}; diff --git a/vendor/wasm-bindgen/tests/wasm/comments.rs b/vendor/wasm-bindgen/tests/wasm/comments.rs new file mode 100644 index 000000000..2d44e7b4a --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/comments.rs @@ -0,0 +1,73 @@ +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[wasm_bindgen(module = "tests/wasm/comments.js")] +extern "C" { + fn assert_comments_exist(); +} + +/// annotated function ✔️ " \ ' { +#[wasm_bindgen] +pub fn annotated() -> String { + String::new() +} + +/// annotated struct type +#[wasm_bindgen] +pub struct Annotated { + a: String, + /// annotated struct field b + pub b: u32, + /// annotated struct field c + #[wasm_bindgen(readonly)] + pub c: u32, + d: u32, +} + +#[wasm_bindgen] +impl Annotated { + /// annotated struct constructor + #[wasm_bindgen(constructor)] + pub fn new() -> Self { + Self { + a: String::new(), + b: 0, + c: 0, + d: 0, + } + } + + /// annotated struct method + pub fn get_a(&self) -> String { + self.a.clone() + } + + /// annotated struct getter + #[wasm_bindgen(getter)] + pub fn d(&self) -> u32 { + self.d + } + + /// annotated struct setter + #[wasm_bindgen(setter)] + pub fn set_d(&mut self, value: u32) { + self.d = value + } + + /// annotated struct static method + pub fn static_method() {} +} + +/// annotated enum type +#[wasm_bindgen] +pub enum AnnotatedEnum { + /// annotated enum variant 1 + Variant1, + /// annotated enum variant 2 + Variant2, +} + +#[wasm_bindgen_test] +fn works() { + assert_comments_exist(); +} diff --git a/vendor/wasm-bindgen/tests/wasm/duplicate_deps.js b/vendor/wasm-bindgen/tests/wasm/duplicate_deps.js new file mode 100644 index 000000000..b69139dfa --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/duplicate_deps.js @@ -0,0 +1,17 @@ +const assert = require('assert'); + +let next = null; + +exports.assert_next_undefined = function() { + next = undefined; +}; + +exports.assert_next_ten = function() { + next = 10; +}; + +exports.foo = function(a) { + console.log(a, next); + assert.strictEqual(a, next); + next = null; +}; diff --git a/vendor/wasm-bindgen/tests/wasm/duplicate_deps.rs b/vendor/wasm-bindgen/tests/wasm/duplicate_deps.rs new file mode 100644 index 000000000..4d3506b90 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/duplicate_deps.rs @@ -0,0 +1,18 @@ +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; +use wasm_bindgen_test_crate_a as a; +use wasm_bindgen_test_crate_b as b; + +#[wasm_bindgen(module = "tests/wasm/duplicate_deps.js")] +extern "C" { + fn assert_next_undefined(); + fn assert_next_ten(); +} + +#[wasm_bindgen_test] +fn works() { + assert_next_undefined(); + a::test(); + assert_next_ten(); + b::test(); +} diff --git a/vendor/wasm-bindgen/tests/wasm/duplicates.rs b/vendor/wasm-bindgen/tests/wasm/duplicates.rs new file mode 100644 index 000000000..206fede71 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/duplicates.rs @@ -0,0 +1,57 @@ +use wasm_bindgen_test::*; + +pub mod same_function_different_locations_a { + use wasm_bindgen::prelude::*; + + #[wasm_bindgen(module = "tests/wasm/duplicates_a.js")] + extern "C" { + pub fn foo(); + pub static bar: JsValue; + } +} + +pub mod same_function_different_locations_b { + use wasm_bindgen::prelude::*; + + #[wasm_bindgen(module = "tests/wasm/duplicates_a.js")] + extern "C" { + pub fn foo(); + pub static bar: JsValue; + } +} + +#[wasm_bindgen_test] +fn same_function_different_locations() { + same_function_different_locations_a::foo(); + same_function_different_locations_b::foo(); + assert_eq!(*same_function_different_locations_a::bar, 3); + assert_eq!(*same_function_different_locations_a::bar, 3); +} + +pub mod same_function_different_modules_a { + use wasm_bindgen::prelude::*; + + #[wasm_bindgen(module = "tests/wasm/duplicates_b.js")] + extern "C" { + pub fn foo() -> bool; + pub static bar: JsValue; + } +} + +pub mod same_function_different_modules_b { + use wasm_bindgen::prelude::*; + + #[wasm_bindgen(module = "tests/wasm/duplicates_c.js")] + extern "C" { + pub fn foo() -> bool; + pub static bar: JsValue; + } +} + +#[wasm_bindgen_test] +fn same_function_different_modules() { + assert!(same_function_different_modules_a::foo()); + assert!(!same_function_different_modules_b::foo()); + assert_eq!(*same_function_different_modules_a::bar, 4); + assert_eq!(*same_function_different_modules_b::bar, 5); +} diff --git a/vendor/wasm-bindgen/tests/wasm/duplicates_a.js b/vendor/wasm-bindgen/tests/wasm/duplicates_a.js new file mode 100644 index 000000000..e52f346bc --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/duplicates_a.js @@ -0,0 +1,2 @@ +exports.foo = () => {}; +exports.bar = 3; diff --git a/vendor/wasm-bindgen/tests/wasm/duplicates_b.js b/vendor/wasm-bindgen/tests/wasm/duplicates_b.js new file mode 100644 index 000000000..75263a245 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/duplicates_b.js @@ -0,0 +1,2 @@ +exports.foo = () => true; +exports.bar = 4; diff --git a/vendor/wasm-bindgen/tests/wasm/duplicates_c.js b/vendor/wasm-bindgen/tests/wasm/duplicates_c.js new file mode 100644 index 000000000..601a99a57 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/duplicates_c.js @@ -0,0 +1,2 @@ +exports.foo = () => false; +exports.bar = 5; diff --git a/vendor/wasm-bindgen/tests/wasm/enums.js b/vendor/wasm-bindgen/tests/wasm/enums.js new file mode 100644 index 000000000..640597dac --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/enums.js @@ -0,0 +1,40 @@ +const wasm = require('wasm-bindgen-test.js'); +const assert = require('assert'); + +exports.js_c_style_enum = () => { + assert.strictEqual(wasm.Color.Green, 0); + assert.strictEqual(wasm.Color.Yellow, 1); + assert.strictEqual(wasm.Color.Red, 2); + assert.strictEqual(wasm.Color[0], 'Green'); + assert.strictEqual(wasm.Color[1], 'Yellow'); + assert.strictEqual(wasm.Color[2], 'Red'); + assert.strictEqual(Object.keys(wasm.Color).length, 6); + + assert.strictEqual(wasm.enum_cycle(wasm.Color.Green), wasm.Color.Yellow); +}; + +exports.js_c_style_enum_with_custom_values = () => { + assert.strictEqual(wasm.ColorWithCustomValues.Green, 21); + assert.strictEqual(wasm.ColorWithCustomValues.Yellow, 34); + assert.strictEqual(wasm.ColorWithCustomValues.Red, 2); + assert.strictEqual(wasm.ColorWithCustomValues[21], 'Green'); + assert.strictEqual(wasm.ColorWithCustomValues[34], 'Yellow'); + assert.strictEqual(wasm.ColorWithCustomValues[2], 'Red'); + assert.strictEqual(Object.keys(wasm.ColorWithCustomValues).length, 6); + + assert.strictEqual(wasm.enum_with_custom_values_cycle(wasm.ColorWithCustomValues.Green), wasm.ColorWithCustomValues.Yellow); +}; + +exports.js_handle_optional_enums = x => wasm.handle_optional_enums(x); + +exports.js_expect_enum = (a, b) => { + assert.strictEqual(a, b); +}; + +exports.js_expect_enum_none = a => { + assert.strictEqual(a, undefined); +}; + +exports.js_renamed_enum = b => { + assert.strictEqual(wasm.JsRenamedEnum.B, b); +}; diff --git a/vendor/wasm-bindgen/tests/wasm/enums.rs b/vendor/wasm-bindgen/tests/wasm/enums.rs new file mode 100644 index 000000000..959a3e271 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/enums.rs @@ -0,0 +1,97 @@ +use self::inner::ColorWithCustomValues; +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[wasm_bindgen(module = "tests/wasm/enums.js")] +extern "C" { + fn js_c_style_enum(); + fn js_c_style_enum_with_custom_values(); + fn js_handle_optional_enums(x: Option<Color>) -> Option<Color>; + fn js_expect_enum(x: Color, y: Option<Color>); + fn js_expect_enum_none(x: Option<Color>); + fn js_renamed_enum(b: RenamedEnum); +} + +#[wasm_bindgen] +#[derive(PartialEq, Debug)] +pub enum Color { + Green, + Yellow, + Red, +} + +pub mod inner { + use wasm_bindgen::prelude::*; + + #[wasm_bindgen] + pub enum ColorWithCustomValues { + Green = 21, + Yellow = 34, + Red = 2, + } +} + +#[wasm_bindgen(js_name = JsRenamedEnum)] +#[derive(Copy, Clone)] +pub enum RenamedEnum { + A = 10, + B = 20, +} + +#[wasm_bindgen] +pub fn enum_cycle(color: Color) -> Color { + match color { + Color::Green => Color::Yellow, + Color::Yellow => Color::Red, + Color::Red => Color::Green, + } +} + +#[wasm_bindgen] +pub fn enum_with_custom_values_cycle(color: ColorWithCustomValues) -> ColorWithCustomValues { + match color { + ColorWithCustomValues::Green => ColorWithCustomValues::Yellow, + ColorWithCustomValues::Yellow => ColorWithCustomValues::Red, + ColorWithCustomValues::Red => ColorWithCustomValues::Green, + } +} + +#[wasm_bindgen_test] +fn c_style_enum() { + js_c_style_enum(); +} + +#[wasm_bindgen_test] +fn c_style_enum_with_custom_values() { + js_c_style_enum_with_custom_values(); +} + +#[wasm_bindgen] +pub fn handle_optional_enums(x: Option<Color>) -> Option<Color> { + x +} + +#[wasm_bindgen_test] +fn test_optional_enums() { + use self::Color::*; + + assert_eq!(js_handle_optional_enums(None), None); + assert_eq!(js_handle_optional_enums(Some(Green)), Some(Green)); + assert_eq!(js_handle_optional_enums(Some(Yellow)), Some(Yellow)); + assert_eq!(js_handle_optional_enums(Some(Red)), Some(Red)); +} + +#[wasm_bindgen_test] +fn test_optional_enum_values() { + use self::Color::*; + + js_expect_enum(Green, Some(Green)); + js_expect_enum(Yellow, Some(Yellow)); + js_expect_enum(Red, Some(Red)); + js_expect_enum_none(None); +} + +#[wasm_bindgen_test] +fn test_renamed_enum() { + js_renamed_enum(RenamedEnum::B); +} diff --git a/vendor/wasm-bindgen/tests/wasm/final.js b/vendor/wasm-bindgen/tests/wasm/final.js new file mode 100644 index 000000000..15b576d02 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/final.js @@ -0,0 +1,25 @@ +const assert = require('assert'); + +exports.MyType = class { + static foo(y) { + assert.equal(y, 'x'); + return y + 'y'; + } + + constructor(x) { + assert.equal(x, 2); + this._a = 1; + } + + bar(x) { + assert.equal(x, true); + return 3.2; + } + + get a() { + return this._a; + } + set a(v) { + this._a = v; + } +}; diff --git a/vendor/wasm-bindgen/tests/wasm/final.rs b/vendor/wasm-bindgen/tests/wasm/final.rs new file mode 100644 index 000000000..63aa661f5 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/final.rs @@ -0,0 +1,40 @@ +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[wasm_bindgen] +extern "C" { + type Math; + #[wasm_bindgen(static_method_of = Math, final)] + fn log(f: f32) -> f32; +} + +#[wasm_bindgen(module = "tests/wasm/final.js")] +extern "C" { + type MyType; + #[wasm_bindgen(constructor, final)] + fn new(x: u32) -> MyType; + #[wasm_bindgen(static_method_of = MyType, final)] + fn foo(a: &str) -> String; + #[wasm_bindgen(method, final)] + fn bar(this: &MyType, arg: bool) -> f32; + + #[wasm_bindgen(method, getter, final)] + fn a(this: &MyType) -> u32; + #[wasm_bindgen(method, setter, final)] + fn set_a(this: &MyType, a: u32); +} + +#[wasm_bindgen_test] +fn simple() { + assert_eq!(Math::log(1.0), 0.0); +} + +#[wasm_bindgen_test] +fn classes() { + assert_eq!(MyType::foo("x"), "xy"); + let x = MyType::new(2); + assert_eq!(x.bar(true), 3.2); + assert_eq!(x.a(), 1); + x.set_a(3); + assert_eq!(x.a(), 3); +} diff --git a/vendor/wasm-bindgen/tests/wasm/futures.js b/vendor/wasm-bindgen/tests/wasm/futures.js new file mode 100644 index 000000000..5f4564bac --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/futures.js @@ -0,0 +1,44 @@ +const assert = require('assert'); +const wasm = require('wasm-bindgen-test'); + +exports.call_exports = async function() { + await wasm.async_do_nothing(); + assert.strictEqual(1, await wasm.async_return_1()); + assert.strictEqual(2, await wasm.async_return_2()); + await wasm.async_nothing_again(); + assert.strictEqual(3, await wasm.async_return_3()); + assert.strictEqual(4, await wasm.async_return_4()); + assert.strictEqual(5, (await wasm.async_return_5()).val); + assert.strictEqual(6, (await wasm.async_return_6()).val); + await assert.rejects(wasm.async_throw_7(), /7/); + await assert.rejects(wasm.async_throw_custom(), /\[object Object\]/); + await assert.rejects(wasm.async_throw_message(), /async message/); + await assert.rejects(wasm.async_throw_jserror(), /async message/); + await assert.rejects(wasm.async_throw_custom_error(), /custom error/); + assert.strictEqual("Hi, Jim!", await wasm.async_take_reference("Jim")); + const foo = await new wasm.AsyncStruct(); + assert.strictEqual(42, await foo.method()); +}; + +exports.call_promise = async function() { + return "ok"; +} + +exports.call_promise_ok = async function() { + return "ok"; +} + +exports.call_promise_err = async function() { + throw "error"; +} + +exports.call_promise_unit = async function() { + console.log("asdfasdf"); +} + +exports.call_promise_ok_unit = async function() { +} + +exports.call_promise_err_unit = async function() { + throw "error"; +} diff --git a/vendor/wasm-bindgen/tests/wasm/futures.rs b/vendor/wasm-bindgen/tests/wasm/futures.rs new file mode 100644 index 000000000..ad2be0f71 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/futures.rs @@ -0,0 +1,166 @@ +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[rustfmt::skip] +#[wasm_bindgen(module = "tests/wasm/futures.js")] +extern "C" { + #[wasm_bindgen(catch)] + async fn call_exports() -> Result<JsValue, JsValue>; + + async fn call_promise() -> JsValue; + #[wasm_bindgen(catch)] + async fn call_promise_ok() -> Result<JsValue, JsValue>; + #[wasm_bindgen(catch)] + async fn call_promise_err() -> Result<JsValue, JsValue>; + + #[wasm_bindgen] + async fn call_promise_unit(); + #[wasm_bindgen(catch)] + async fn call_promise_ok_unit() -> Result<(), JsValue>; + #[wasm_bindgen(catch)] + async fn call_promise_err_unit() -> Result<(), JsValue>; +} + +#[wasm_bindgen_test] +async fn smoke() { + call_exports().await.unwrap(); +} + +#[wasm_bindgen] +pub async fn async_do_nothing() {} + +#[wasm_bindgen] +pub async fn async_return_1() -> JsValue { + 1.into() +} + +#[wasm_bindgen] +pub async fn async_return_2() -> u32 { + 2 +} + +#[wasm_bindgen] +pub async fn async_nothing_again() -> Result<(), JsValue> { + Ok(()) +} + +#[wasm_bindgen] +pub async fn async_return_3() -> Result<u32, JsValue> { + Ok(3) +} + +#[wasm_bindgen] +pub async fn async_return_4() -> Result<JsValue, JsValue> { + Ok(4.into()) +} + +#[wasm_bindgen] +pub struct AsyncCustomReturn { + pub val: u32, +} + +#[wasm_bindgen] +pub async fn async_return_5() -> AsyncCustomReturn { + AsyncCustomReturn { val: 5 } +} + +#[wasm_bindgen] +pub async fn async_return_6() -> Result<AsyncCustomReturn, JsValue> { + Ok(AsyncCustomReturn { val: 6 }) +} + +#[wasm_bindgen] +pub async fn async_throw_7() -> Result<AsyncCustomReturn, JsValue> { + Err(7.into()) +} + +#[wasm_bindgen] +pub async fn async_throw_custom() -> Result<AsyncCustomReturn, JsValue> { + Err(AsyncCustomReturn { val: 8 }.into()) +} + +#[wasm_bindgen] +pub async fn async_throw_message() -> Result<(), JsValue> { + Err(js_sys::Error::new("async message").into()) +} + +#[wasm_bindgen] +pub async fn async_throw_jserror() -> Result<AsyncCustomReturn, JsError> { + Err(JsError::new("async message")) +} + +pub struct AsyncCustomError { + pub val: JsValue, +} + +impl Into<JsValue> for AsyncCustomError { + fn into(self) -> JsValue { + self.val + } +} + +#[wasm_bindgen] +pub async fn async_throw_custom_error() -> Result<AsyncCustomReturn, AsyncCustomError> { + Err(AsyncCustomError { + val: JsValue::from("custom error"), + }) +} + +#[wasm_bindgen] +pub async fn async_take_reference(x: &str) -> String { + format!("Hi, {x}!") +} + +#[wasm_bindgen] +pub struct AsyncStruct; + +#[wasm_bindgen] +impl AsyncStruct { + #[wasm_bindgen(constructor)] + pub async fn new() -> AsyncStruct { + AsyncStruct + } + + pub async fn method(&self) -> u32 { + 42 + } +} + +#[wasm_bindgen_test] +async fn test_promise() { + assert_eq!(call_promise().await.as_string(), Some(String::from("ok"))) +} + +#[wasm_bindgen_test] +async fn test_promise_ok() { + assert_eq!( + call_promise_ok().await.map(|j| j.as_string()), + Ok(Some(String::from("ok"))) + ) +} + +#[wasm_bindgen_test] +async fn test_promise_err() { + assert_eq!( + call_promise_err().await.map_err(|j| j.as_string()), + Err(Some(String::from("error"))) + ) +} + +#[wasm_bindgen_test] +async fn test_promise_unit() { + call_promise_unit().await +} + +#[wasm_bindgen_test] +async fn test_promise_ok_unit() { + call_promise_ok_unit().await.unwrap() +} + +#[wasm_bindgen_test] +async fn test_promise_err_unit() { + assert_eq!( + call_promise_err_unit().await.map_err(|j| j.as_string()), + Err::<(), _>(Some(String::from("error"))) + ) +} diff --git a/vendor/wasm-bindgen/tests/wasm/getters_and_setters.js b/vendor/wasm-bindgen/tests/wasm/getters_and_setters.js new file mode 100644 index 000000000..48379e2e8 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/getters_and_setters.js @@ -0,0 +1,107 @@ +const wasm = require('wasm-bindgen-test.js'); +const assert = require('assert'); + +exports._1_js = (rules) => { + assert.equal(rules.field, 1); + rules.field *= 2; + return rules; +} + +exports._2_js = (rules) => { + let value = rules.no_js_name__no_getter_with_name__no_getter_without_name(); + assert.equal(value, 2); + rules.set_no_js_name__no_setter_with_name__no_setter_without_name(value * 2); + return rules; +} + +exports._3_js = (rules) => { + let value = rules.no_js_name__no_getter_with_name__getter_without_name; + assert.equal(value, 3); + rules.no_js_name__no_setter_with_name__setter_without_name = value * 2; + return rules; +} + +exports._4_js = (rules) => { + let value = rules.new_no_js_name__getter_with_name__getter_without_name; + assert.equal(value, 4); + rules.new_no_js_name__setter_with_name__setter_without_name = value * 2; + return rules; +} + +exports._5_js = (rules) => { + let value = rules.new_js_name__no_getter_with_name__no_getter_without_name(); + assert.equal(value, 5); + rules.new_js_name__no_setter_with_name__no_setter_without_name(value * 2); + return rules; +} + +exports._6_js = (rules) => { + let value = rules.new_js_name__no_getter_with_name__getter_without_name; + assert.equal(value, 6); + rules.new_js_name__no_setter_with_name__setter_without_name = value * 2; + return rules; +} + +exports._7_js = (rules) => { + let value = rules.new_js_name__getter_with_name__no_getter_without_name_for_field; + assert.equal(value, 7); + rules.new_js_name__setter_with_name__no_setter_without_name_for_field = value * 2; + return rules; +} + +exports._8_js = (rules) => { + let value = rules.new_js_name__no_getter_setter_with_name__getter_setter_without_name__same_getter_setter_name; + assert.equal(value, 8); + rules.new_js_name__no_getter_setter_with_name__getter_setter_without_name__same_getter_setter_name = value * 2; + return rules; +} + +exports._9_js = (rules) => { + let value = rules.new_js_name__no_getter_setter_with_name__getter_setter_without_name__same_getter_setter_name__same_getter_setter_origin_name; + assert.equal(value, 9); + rules.new_js_name__no_getter_setter_with_name__getter_setter_without_name__same_getter_setter_name__same_getter_setter_origin_name = value * 2; + return rules; +} + +exports._10_js = (rules) => { + let value = rules.new_js_name__getter_setter_with_name__no_getter_setter_without_name_for_field__same_getter_setter_name; + assert.equal(value, 10); + rules.new_js_name__getter_setter_with_name__no_getter_setter_without_name_for_field__same_getter_setter_name = value * 2; + return rules; +} + +exports._11_js = (rules) => { + let value = rules.new_js_name__getter_with_name__no_getter_without_name_for_field__same_getter_setter_name; + assert.equal(value, 11); + rules.new_js_name__setter_with_name__no_setter_without_name_for_field__same_getter_setter_name = value * 2; + return rules; +} + +exports._12_js = (rules) => { + let value = rules.new_js_name__getter_setter_with_name__no_getter_setter_without_name_for_field__same_getter_setter_name__same_getter_setter_origin_name; + assert.equal(value, 12); + rules.new_js_name__getter_setter_with_name__no_getter_setter_without_name_for_field__same_getter_setter_name__same_getter_setter_origin_name = value * 2; + return rules; +} + +exports._13_js = (rules) => { + let value = rules.new_js_name__getter_with_name__no_getter_without_name_for_field__same_getter_setter_name__same_getter_setter_origin_name; + assert.equal(value, 13); + rules.new_js_name__setter_with_name__no_setter_without_name_for_field__same_getter_setter_name__same_getter_setter_origin_name = value * 2; + return rules; +} + +exports.test_getter_compute = x => { + assert.equal(x.foo, 3) +}; + +exports.test_setter_compute = x => { + x.foo = 97; +}; + +exports.test_statics = x => { + assert.equal(x.field, 3); + assert.equal(wasm.Statics.field, 4); + x.field = 13; + wasm.Statics.field = 14; +} diff --git a/vendor/wasm-bindgen/tests/wasm/getters_and_setters.rs b/vendor/wasm-bindgen/tests/wasm/getters_and_setters.rs new file mode 100644 index 000000000..7425fc23e --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/getters_and_setters.rs @@ -0,0 +1,348 @@ +use std::cell::Cell; +use std::rc::Rc; +use std::sync::atomic::{AtomicU32, Ordering}; +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[wasm_bindgen(module = "tests/wasm/getters_and_setters.js")] +extern "C" { + fn _1_js(rules: Rules) -> Rules; + fn _2_js(rules: Rules) -> Rules; + fn _3_js(rules: Rules) -> Rules; + fn _4_js(rules: Rules) -> Rules; + fn _5_js(rules: Rules) -> Rules; + fn _6_js(rules: Rules) -> Rules; + fn _7_js(rules: Rules) -> Rules; + fn _8_js(rules: Rules) -> Rules; + fn _9_js(rules: Rules) -> Rules; + fn _10_js(rules: Rules) -> Rules; + fn _11_js(rules: Rules) -> Rules; + fn _12_js(rules: Rules) -> Rules; + fn _13_js(rules: Rules) -> Rules; + + fn test_getter_compute(x: GetterCompute); + fn test_setter_compute(x: SetterCompute); + fn test_statics(x: Statics); +} + +// Each getter/setter combination is derived +// from https://github.com/rustwasm/wasm-bindgen/pull/1440#issuecomment-487113564 +#[wasm_bindgen] +pub struct Rules { + pub field: i32, +} + +#[wasm_bindgen] +#[allow(non_snake_case)] +impl Rules { + #[wasm_bindgen] + pub fn no_js_name__no_getter_with_name__no_getter_without_name(&self) -> i32 { + self.field + } + #[wasm_bindgen] + pub fn set_no_js_name__no_setter_with_name__no_setter_without_name(&mut self, field: i32) { + self.field = field; + } + + #[wasm_bindgen(getter)] + pub fn no_js_name__no_getter_with_name__getter_without_name(&self) -> i32 { + self.field + } + #[wasm_bindgen(setter)] + pub fn set_no_js_name__no_setter_with_name__setter_without_name(&mut self, field: i32) { + self.field = field; + } + + #[wasm_bindgen(getter = new_no_js_name__getter_with_name__getter_without_name)] + pub fn no_js_name__getter_with_name__getter_without_name(&self) -> i32 { + self.field + } + #[wasm_bindgen(setter = new_no_js_name__setter_with_name__setter_without_name)] + pub fn set_no_js_name__setter_with_name__setter_without_name(&mut self, field: i32) { + self.field = field; + } + + #[wasm_bindgen(js_name = new_js_name__no_getter_with_name__no_getter_without_name)] + pub fn js_name__no_getter_with_name__no_getter_without_name(&self) -> i32 { + self.field + } + #[wasm_bindgen(js_name = new_js_name__no_setter_with_name__no_setter_without_name)] + pub fn set_js_name__no_setter_with_name__no_setter_without_name(&mut self, field: i32) { + self.field = field; + } + + #[wasm_bindgen(getter, js_name = new_js_name__no_getter_with_name__getter_without_name)] + pub fn js_name__no_getter_with_name__getter_without_name(&self) -> i32 { + self.field + } + #[wasm_bindgen(js_name = new_js_name__no_setter_with_name__setter_without_name, setter)] + pub fn set_js_name__no_setter_with_name__setter_without_name(&mut self, field: i32) { + self.field = field; + } + + #[wasm_bindgen( + getter = new_js_name__getter_with_name__no_getter_without_name_for_field, + js_name = new_js_name__getter_with_name__no_getter_without_name_for_method + )] + pub fn js_name__getter_with_name__no_getter_without_name(&self) -> i32 { + self.field + } + #[wasm_bindgen( + js_name = new_js_name__setter_with_name__no_setter_without_name_for_method, + setter = new_js_name__setter_with_name__no_setter_without_name_for_field + )] + pub fn set_js_name__setter_with_name__no_setter_without_name_for_field(&mut self, field: i32) { + self.field = field; + } + + #[wasm_bindgen(getter, js_name = new_js_name__no_getter_setter_with_name__getter_setter_without_name__same_getter_setter_name)] + pub fn js_name__no_getter_with_name__getter_without_name__same_getter_setter_name( + &self, + ) -> i32 { + self.field + } + #[wasm_bindgen(js_name = new_js_name__no_getter_setter_with_name__getter_setter_without_name__same_getter_setter_name, setter)] + pub fn set_js_name__no_setter_with_name__setter_without_name__same_getter_setter_name( + &mut self, + field: i32, + ) { + self.field = field; + } + + #[wasm_bindgen(getter, js_name = new_js_name__no_getter_setter_with_name__getter_setter_without_name__same_getter_setter_name__same_getter_setter_origin_name)] + pub fn js_name__no_getter_setter_with_name__getter_setter_without_name__same_getter_setter_name__same_getter_setter_origin_name( + &self, + ) -> i32 { + self.field + } + #[wasm_bindgen(js_name = new_js_name__no_getter_setter_with_name__getter_setter_without_name__same_getter_setter_name__same_getter_setter_origin_name, setter)] + pub fn set_js_name__no_getter_setter_with_name__getter_setter_without_name__same_getter_setter_name__same_getter_setter_origin_name( + &mut self, + field: i32, + ) { + self.field = field; + } + + #[wasm_bindgen( + getter = new_js_name__getter_setter_with_name__no_getter_setter_without_name_for_field__same_getter_setter_name, + js_name = new_js_name__getter_setter_with_name__no_getter_setter_without_name_for_method__same_getter_setter_name)] + pub fn js_name__getter_with_name__no_getter_without_name__same_getter_setter_name( + &self, + ) -> i32 { + self.field + } + #[wasm_bindgen( + js_name = new_js_name__getter_setter_with_name__no_getter_setter_without_name_for_method__same_getter_setter_name, + setter = new_js_name__getter_setter_with_name__no_getter_setter_without_name_for_field__same_getter_setter_name)] + pub fn set_js_name__setter_with_name__no_setter_without_name__same_getter_setter_name( + &mut self, + field: i32, + ) { + self.field = field; + } + + #[wasm_bindgen( + getter = new_js_name__getter_with_name__no_getter_without_name_for_field__same_getter_setter_name, + js_name = new_js_name__getter_setter_with_name__no_getter_setter_without_name_for_method__same_getter_setter_name__no_same_field_name)] + pub fn js_name__getter_with_name__no_getter_without_name__same_getter_setter_name__no_same_field_name( + &self, + ) -> i32 { + self.field + } + #[wasm_bindgen( + js_name = new_js_name__getter_setter_with_name__no_getter_setter_without_name_for_method__same_getter_setter_name__no_same_field_name, + setter = new_js_name__setter_with_name__no_setter_without_name_for_field__same_getter_setter_name)] + pub fn set_js_name__setter_with_name__no_setter_without_name__same_getter_setter_name__no_same_field_name( + &mut self, + field: i32, + ) { + self.field = field; + } + + #[wasm_bindgen( + getter = new_js_name__getter_setter_with_name__no_getter_setter_without_name_for_field__same_getter_setter_name__same_getter_setter_origin_name, + js_name = new_js_name__getter_setter_with_name__no_getter_setter_without_name_for_method__same_getter_setter_name__same_getter_setter_origin_name)] + pub fn js_name__getter_setter_with_name__no_getter_setter_without_name__same_getter_setter_name__same_getter_setter_origin_name( + &self, + ) -> i32 { + self.field + } + #[wasm_bindgen( + js_name = new_js_name__getter_setter_with_name__no_getter_setter_without_name_for_method__same_getter_setter_name__same_getter_setter_origin_name, + setter = new_js_name__getter_setter_with_name__no_getter_setter_without_name_for_field__same_getter_setter_name__same_getter_setter_origin_name)] + pub fn set_js_name__getter_setter_with_name__no_getter_setter_without_name__same_getter_setter_name__same_getter_setter_origin_name( + &mut self, + field: i32, + ) { + self.field = field; + } + + #[wasm_bindgen( + getter = new_js_name__getter_with_name__no_getter_without_name_for_field__same_getter_setter_name__same_getter_setter_origin_name, + js_name = new_js_name__getter_setter_with_name__no_getter_setter_without_name_for_method__same_getter_setter_name__same_getter_setter_origin_name__no_same_field_name)] + pub fn js_name__getter_setter_with_name__no_getter_setter_without_name__same_getter_setter_name__same_getter_setter_origin_name__no_same_field_name( + &self, + ) -> i32 { + self.field + } + #[wasm_bindgen( + js_name = new_js_name__getter_setter_with_name__no_getter_setter_without_name_for_method__same_getter_setter_name__same_getter_setter_origin_name__no_same_field_name, + setter = new_js_name__setter_with_name__no_setter_without_name_for_field__same_getter_setter_name__same_getter_setter_origin_name)] + pub fn set_js_name__getter_setter_with_name__no_getter_setter_without_name__same_getter_setter_name__same_getter_setter_origin_name__no_same_field_name( + &mut self, + field: i32, + ) { + self.field = field; + } +} + +#[wasm_bindgen_test] +fn _1_rust() { + let rules = _1_js(Rules { field: 1 }); + assert_eq!(rules.field, 2); +} + +#[wasm_bindgen_test] +fn _2_rust() { + let rules = _2_js(Rules { field: 2 }); + assert_eq!(rules.field, 4); +} + +#[wasm_bindgen_test] +fn _3_rust() { + let rules = _3_js(Rules { field: 3 }); + assert_eq!(rules.field, 6); +} + +#[wasm_bindgen_test] +fn _4_rust() { + let rules = _4_js(Rules { field: 4 }); + assert_eq!(rules.field, 8); +} + +#[wasm_bindgen_test] +fn _5_rust() { + let rules = _5_js(Rules { field: 5 }); + assert_eq!(rules.field, 10); +} + +#[wasm_bindgen_test] +fn _6_rust() { + let rules = _6_js(Rules { field: 6 }); + assert_eq!(rules.field, 12); +} + +#[wasm_bindgen_test] +fn _7_rust() { + let rules = _7_js(Rules { field: 7 }); + assert_eq!(rules.field, 14); +} + +#[wasm_bindgen_test] +fn _8_rust() { + let rules = _8_js(Rules { field: 8 }); + assert_eq!(rules.field, 16); +} + +#[wasm_bindgen_test] +fn _9_rust() { + let rules = _9_js(Rules { field: 9 }); + assert_eq!(rules.field, 18); +} + +#[wasm_bindgen_test] +fn _10_rust() { + let rules = _10_js(Rules { field: 10 }); + assert_eq!(rules.field, 20); +} + +#[wasm_bindgen_test] +fn _11_rust() { + let rules = _11_js(Rules { field: 11 }); + assert_eq!(rules.field, 22); +} + +#[wasm_bindgen_test] +fn _12_rust() { + let rules = _12_js(Rules { field: 12 }); + assert_eq!(rules.field, 24); +} + +#[wasm_bindgen_test] +fn _13_rust() { + let rules = _13_js(Rules { field: 13 }); + assert_eq!(rules.field, 26); +} + +#[wasm_bindgen] +struct GetterCompute; + +#[wasm_bindgen] +impl GetterCompute { + #[wasm_bindgen(getter)] + pub fn foo(&self) -> u32 { + 3 + } +} + +#[wasm_bindgen_test] +fn getter_compute() { + test_getter_compute(GetterCompute); +} + +#[wasm_bindgen] +struct SetterCompute(Rc<Cell<u32>>); + +#[wasm_bindgen] +impl SetterCompute { + #[wasm_bindgen(setter)] + pub fn set_foo(&self, x: u32) { + self.0.set(x + 3); + } +} + +#[wasm_bindgen_test] +fn setter_compute() { + let r = Rc::new(Cell::new(3)); + test_setter_compute(SetterCompute(r.clone())); + assert_eq!(r.get(), 100); +} + +static FIELD: AtomicU32 = AtomicU32::new(3); +static STATIC_FIELD: AtomicU32 = AtomicU32::new(4); + +#[wasm_bindgen] +struct Statics; + +#[wasm_bindgen] +impl Statics { + #[wasm_bindgen(getter = field)] + // Make sure that this still works if we make this mutable for no reason + pub fn getter(&mut self) -> u32 { + FIELD.load(Ordering::Relaxed) + } + + #[wasm_bindgen(setter = field)] + // Make sure that this still works if we make this consume the type for no reason + pub fn setter(self, x: u32) { + FIELD.store(x, Ordering::Relaxed) + } + + // Define a static field with the same name to make sure that works. + #[wasm_bindgen(getter = field)] + pub fn static_getter() -> u32 { + STATIC_FIELD.load(Ordering::Relaxed) + } + + #[wasm_bindgen(setter = field)] + pub fn static_setter(x: u32) { + STATIC_FIELD.store(x, Ordering::Relaxed) + } +} + +#[wasm_bindgen_test] +fn statics() { + test_statics(Statics); + assert_eq!(FIELD.load(Ordering::Relaxed), 13); + assert_eq!(STATIC_FIELD.load(Ordering::Relaxed), 14); +} diff --git a/vendor/wasm-bindgen/tests/wasm/import_class.js b/vendor/wasm-bindgen/tests/wasm/import_class.js new file mode 100644 index 000000000..848be7b14 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/import_class.js @@ -0,0 +1,170 @@ +const assert = require('assert'); +const wasm = require('wasm-bindgen-test'); + +exports.math_log = Math.log; + +exports.StaticFunction = class { + static bar() { return 2; } +}; + +class Construct { + static create() { + const ret = new Construct(); + ret.internal_string = 'this'; + return ret; + } + + get_internal_string() { + return this.internal_string; + } + + append_to_internal_string(s) { + this.internal_string += s; + } + + assert_internal_string(s) { + assert.strictEqual(this.internal_string, s); + } +} + +Construct.internal_string = ''; +exports.Construct = Construct; + +class NewConstructor { + constructor(field) { + this.field = field; + } + + get() { + return this.field + 1; + } +} + +exports.NewConstructors = NewConstructor; +exports.default = NewConstructor; + +let switch_called = false; +class SwitchMethods { + constructor() { + } + + static a() { + switch_called = true; + } + + b() { + switch_called = true; + } +} +exports.SwitchMethods = SwitchMethods; +exports.switch_methods_called = function() { + const tmp = switch_called; + switch_called = false; + return tmp; +}; +exports.switch_methods_a = function() { SwitchMethods.a = function() {}; }; +exports.switch_methods_b = function() { SwitchMethods.prototype.b = function() {}; }; + +exports.Properties = class { + constructor() { + this.num = 1; + } + + get a() { + return this.num; + } + + set a(val) { + this.num = val; + } +}; + +exports.RenameProperties = class { + constructor() { + this.num = 1; + } + + get a() { + return this.num; + } + + set a(val) { + this.num = val; + } +}; + +class Options { +} +exports.Options = Options; + +exports.take_none = function(val) { + assert.strictEqual(val, undefined); +}; + +exports.take_some = function(val) { + assert.strictEqual(val === undefined, false); +}; + +exports.return_null = function() { + return null; +}; + +exports.return_undefined = function() { + return undefined; +}; + +exports.return_some = function() { + return new Options(); +}; + +exports.run_rust_option_tests = function() { + wasm.rust_take_none(); + wasm.rust_take_none(null) + wasm.rust_take_none(undefined); + wasm.rust_take_some(new Options()); + assert.strictEqual(wasm.rust_return_none(), undefined); + assert.strictEqual(wasm.rust_return_none(), undefined); + assert.strictEqual(wasm.rust_return_some() === undefined, false); +}; + +exports.CatchConstructors = class { + constructor(x) { + if (x == 0) { + throw new Error('bad!'); + } + } +}; + +exports.StaticStructural = class { + static static_structural(x) { + return x + 3; + } +}; + +class InnerClass { + static inner_static_function(x) { + return x + 5; + } + + static create_inner_instance() { + const ret = new InnerClass(); + ret.internal_int = 3; + return ret; + } + + get_internal_int() { + return this.internal_int; + } + + append_to_internal_int(i) { + this.internal_int += i; + } + + assert_internal_int(i) { + assert.strictEqual(this.internal_int, i); + } +} + +exports.nestedNamespace = { + InnerClass: InnerClass +} diff --git a/vendor/wasm-bindgen/tests/wasm/import_class.rs b/vendor/wasm-bindgen/tests/wasm/import_class.rs new file mode 100644 index 000000000..7de986147 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/import_class.rs @@ -0,0 +1,263 @@ +//! dox + +#![deny(missing_docs)] // test that documenting public bindings is enough + +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[wasm_bindgen(module = "tests/wasm/import_class.js")] +extern "C" { + fn math_log(f: f64) -> f64; + + #[wasm_bindgen(js_namespace = StaticFunction)] + fn bar() -> u32; + + #[derive(Clone)] + type Construct; + #[wasm_bindgen(js_namespace = Construct)] + fn create() -> Construct; + #[wasm_bindgen(method)] + fn get_internal_string(this: &Construct) -> String; + #[wasm_bindgen(method)] + fn append_to_internal_string(this: &Construct, s: &str); + #[wasm_bindgen(method)] + fn assert_internal_string(this: &Construct, s: &str); + + type NewConstructors; + #[wasm_bindgen(constructor)] + fn new(arg: i32) -> NewConstructors; + #[wasm_bindgen(method)] + fn get(this: &NewConstructors) -> i32; + + #[wasm_bindgen(js_name = default)] + type RenamedTypes; + #[wasm_bindgen(constructor, js_class = default)] + fn new(arg: i32) -> RenamedTypes; + #[wasm_bindgen(method, js_class = default)] + fn get(this: &RenamedTypes) -> i32; + + fn switch_methods_a(); + fn switch_methods_b(); + type SwitchMethods; + #[wasm_bindgen(constructor)] + #[wasm_bindgen(final)] + fn new() -> SwitchMethods; + #[wasm_bindgen(js_namespace = SwitchMethods, final)] + fn a(); + fn switch_methods_called() -> bool; + #[wasm_bindgen(method, final)] + fn b(this: &SwitchMethods); + + type Properties; + #[wasm_bindgen(constructor)] + fn new() -> Properties; + #[wasm_bindgen(getter, method)] + fn a(this: &Properties) -> i32; + #[wasm_bindgen(setter, method)] + fn set_a(this: &Properties, a: i32); + + type RenameProperties; + #[wasm_bindgen(constructor)] + fn new() -> RenameProperties; + #[wasm_bindgen(getter = a, method)] + fn test(this: &RenameProperties) -> i32; + #[wasm_bindgen(getter, method, js_name = a)] + fn test2(this: &RenameProperties) -> i32; + #[wasm_bindgen(setter = a, method)] + fn another(this: &RenameProperties, a: i32); + #[wasm_bindgen(setter, method, js_name = a)] + fn another2(this: &RenameProperties, a: i32); + + /// dox + pub type AssertImportDenyDocsWorks; + /// dox + #[wasm_bindgen(constructor)] + pub fn new() -> AssertImportDenyDocsWorks; + /// dox + #[wasm_bindgen(getter = a, method)] + pub fn test(this: &AssertImportDenyDocsWorks) -> i32; + /// dox + pub fn foo(); + + pub type Options; + #[wasm_bindgen(constructor)] + fn new() -> Options; + fn take_none(val: Option<Options>); + fn take_some(val: Option<Options>); + fn return_null() -> Option<Options>; + fn return_undefined() -> Option<Options>; + fn return_some() -> Option<Options>; + fn run_rust_option_tests(); + + type CatchConstructors; + #[wasm_bindgen(constructor, catch)] + fn new(x: u32) -> Result<CatchConstructors, JsValue>; + + type StaticStructural; + #[wasm_bindgen(static_method_of = StaticStructural, structural)] + fn static_structural(a: u32) -> u32; + + #[derive(Clone)] + type InnerClass; + #[wasm_bindgen(js_namespace = ["nestedNamespace", "InnerClass"])] + fn inner_static_function(a: u32) -> u32; + #[wasm_bindgen(js_namespace = ["nestedNamespace", "InnerClass"])] + fn create_inner_instance() -> InnerClass; + #[wasm_bindgen(method)] + fn get_internal_int(this: &InnerClass) -> u32; + #[wasm_bindgen(method)] + fn append_to_internal_int(this: &InnerClass, i: u32); + #[wasm_bindgen(method)] + fn assert_internal_int(this: &InnerClass, i: u32); +} + +#[wasm_bindgen] +extern "C" { + #[wasm_bindgen(js_namespace = Math)] + fn random() -> f64; + #[wasm_bindgen(js_namespace = Math)] + fn log(a: f64) -> f64; +} + +#[wasm_bindgen_test] +fn simple() { + random(); + assert_eq!(log(1.0), math_log(1.0)); +} + +#[wasm_bindgen_test] +fn import_class() { + assert_eq!(bar(), 2); +} + +#[wasm_bindgen_test] +fn construct() { + let f = Construct::create(); + assert_eq!(f.get_internal_string(), "this"); + assert_eq!(f.clone().get_internal_string(), "this"); + f.append_to_internal_string(" foo"); + f.assert_internal_string("this foo"); +} + +#[wasm_bindgen_test] +fn new_constructors() { + let f = NewConstructors::new(1); + assert_eq!(f.get(), 2); +} + +#[wasm_bindgen_test] +fn rename_type() { + let f = RenamedTypes::new(1); + assert_eq!(f.get(), 2); +} + +#[wasm_bindgen_test] +#[cfg(ignored)] // TODO: fix this before landing +fn switch_methods() { + assert!(!switch_methods_called()); + SwitchMethods::a(); + assert!(switch_methods_called()); + + switch_methods_a(); + + assert!(!switch_methods_called()); + SwitchMethods::a(); + assert!(switch_methods_called()); + + assert!(!switch_methods_called()); + SwitchMethods::new().b(); + assert!(switch_methods_called()); + + switch_methods_b(); + + assert!(!switch_methods_called()); + SwitchMethods::new().b(); + assert!(!switch_methods_called()); +} + +#[wasm_bindgen_test] +fn properties() { + let a = Properties::new(); + assert_eq!(a.a(), 1); + a.set_a(2); + assert_eq!(a.a(), 2); +} + +#[wasm_bindgen_test] +fn rename_setter_getter() { + let x: fn() -> RenameProperties = RenameProperties::new; + let a = x(); + assert_eq!(a.test(), 1); + a.another(2); + assert_eq!(a.test(), 2); + a.another2(3); + assert_eq!(a.test2(), 3); +} + +/// dox +#[wasm_bindgen] +pub struct AssertDenyDocsWorks { + /// dox + pub a: u32, + _b: i64, +} + +/// dox +#[wasm_bindgen] +pub fn assert_deny_docs_works() {} + +#[wasm_bindgen_test] +fn options() { + take_none(None); + take_some(Some(Options::new())); + assert!(return_null().is_none()); + assert!(return_undefined().is_none()); + assert!(return_some().is_some()); + run_rust_option_tests(); +} + +/// doc +#[wasm_bindgen] +pub fn rust_take_none(a: Option<Options>) { + assert!(a.is_none()); +} + +/// doc +#[wasm_bindgen] +pub fn rust_take_some(a: Option<Options>) { + assert!(a.is_some()); +} + +/// doc +#[wasm_bindgen] +pub fn rust_return_none() -> Option<Options> { + None +} + +/// doc +#[wasm_bindgen] +pub fn rust_return_some() -> Option<Options> { + Some(Options::new()) +} + +#[wasm_bindgen_test] +fn catch_constructors() { + assert!(CatchConstructors::new(0).is_err()); + assert!(CatchConstructors::new(1).is_ok()); +} + +#[wasm_bindgen_test] +fn static_structural() { + assert_eq!(StaticStructural::static_structural(30), 33); +} + +#[wasm_bindgen_test] +fn nested_namespace() { + assert_eq!(InnerClass::inner_static_function(15), 20); + + let f = InnerClass::create_inner_instance(); + assert_eq!(f.get_internal_int(), 3); + assert_eq!(f.clone().get_internal_int(), 3); + f.append_to_internal_int(5); + f.assert_internal_int(8); +} diff --git a/vendor/wasm-bindgen/tests/wasm/imports.js b/vendor/wasm-bindgen/tests/wasm/imports.js new file mode 100644 index 000000000..70d8a3b08 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/imports.js @@ -0,0 +1,143 @@ +const assert = require('assert'); +const wasm = require('wasm-bindgen-test'); +const fs = require('fs'); + +let ARG = null; +let ANOTHER_ARG = null; +let SYM = Symbol('a'); + +exports.simple_foo = function(s) { + assert.strictEqual(ARG, null); + assert.strictEqual(s, "foo"); + ARG = s; +}; + +exports.simple_another = function(s) { + assert.strictEqual(ANOTHER_ARG, null); + assert.strictEqual(s, 21); + ANOTHER_ARG = s; + return 35; +}; + +exports.simple_take_and_return_bool = function(s) { + return s; +}; +exports.simple_return_object = function() { + return SYM; +}; +exports.test_simple = function() { + assert.strictEqual(ARG, null); + wasm.simple_take_str("foo"); + assert.strictEqual(ARG, "foo"); + + assert.strictEqual(ANOTHER_ARG, null); + assert.strictEqual(wasm.simple_another_thunk(21), 35); + assert.strictEqual(ANOTHER_ARG, 21); + + assert.strictEqual(wasm.simple_bool_thunk(true), true); + assert.strictEqual(wasm.simple_bool_thunk(false), false); + + assert.strictEqual(wasm.simple_get_the_object(), SYM); +}; + +exports.return_string = function() { + return 'bar'; +}; + +exports.take_and_ret_string = function(a) { + return a + 'b'; +}; + +exports.exceptions_throw = function() { + throw new Error('error!'); +}; +exports.exceptions_throw2 = function() { + throw new Error('error2'); +}; +exports.test_exception_propagates = function() { + assert.throws(wasm.exceptions_propagate, /error!/); +}; + +exports.assert_valid_error = function(obj) { + assert.strictEqual(obj instanceof Error, true); + assert.strictEqual(obj.message, 'error2'); +}; + +exports.IMPORT = 1.0; + +exports.return_three = function() { return 3; }; + +exports.underscore = function(x) {}; + +exports.pub = function() { return 2; }; + +exports.bar = { foo: 3 }; + +let CUSTOM_TYPE = null; + +exports.take_custom_type = function(f) { + CUSTOM_TYPE = f; + return f; +}; + +exports.custom_type_return_2 = function() { + return 2; +}; + +exports.touch_custom_type = function() { + assert.throws(() => CUSTOM_TYPE.touch(), + /Attempt to use a moved value|null pointer passed to rust/); +}; + +exports.interpret_2_as_custom_type = function() { + assert.throws(wasm.interpret_2_as_custom_type, /expected instance of CustomType/); +}; + +exports.baz$ = function() {}; +exports.$foo = 1.0; + +exports.assert_dead_import_not_generated = function() { + const filename = require.resolve("wasm-bindgen-test"); + const bindings = fs.readFileSync(filename); + assert.ok(!bindings.includes("unused_import")); +}; + +exports.import_inside_function_works = function() {}; +exports.import_inside_private_module = function() {}; +exports.should_call_undefined_functions = () => false; + +exports.STATIC_STRING = 'x'; + +class StaticMethodCheck { + static static_method_of_right_this() { + assert.ok(this === StaticMethodCheck); + } +} + +exports.StaticMethodCheck = StaticMethodCheck; + +exports.receive_undefined = val => { + assert.strictEqual(val, undefined); +}; + +const VAL = {}; + +exports.receive_some = val => { + assert.strictEqual(val, VAL); +}; + +exports.get_some_val = () => VAL; + +exports.Math = { + func_from_module_math: (a) => a * 2 +} + +exports.Number = { + func_from_module_number: () => 3.0 +} + +exports.same_name_from_import = (a) => a * 3; + +exports.same_js_namespace_from_module = { + func_from_module_1_same_js_namespace: (a) => a * 5 +}
\ No newline at end of file diff --git a/vendor/wasm-bindgen/tests/wasm/imports.rs b/vendor/wasm-bindgen/tests/wasm/imports.rs new file mode 100644 index 000000000..88dbf5ed6 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/imports.rs @@ -0,0 +1,323 @@ +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[wasm_bindgen(module = "tests/wasm/imports.js")] +extern "C" { + fn test_simple(); + + fn simple_foo(s: &str); + fn simple_another(a: u32) -> i32; + fn simple_take_and_return_bool(a: bool) -> bool; + fn simple_return_object() -> JsValue; + #[allow(dead_code)] + fn missing_symbol(s: &str); + fn return_string() -> String; + fn take_and_ret_string(s: String) -> String; + #[wasm_bindgen(js_name = take_and_ret_string)] + fn take_and_ret_string2(s: &str) -> String; + + fn exceptions_throw(); + #[wasm_bindgen(catch)] + fn exceptions_throw2() -> Result<(), JsValue>; + fn test_exception_propagates(); + + fn assert_valid_error(val: JsValue); + + static IMPORT: JsValue; + + #[wasm_bindgen(js_name = return_three)] + fn rust_name_for_return_three() -> u32; + + fn underscore(_: u8); + + #[wasm_bindgen(js_name = pub)] + fn js_function_named_rust_keyword() -> u32; + + type bar; + #[wasm_bindgen(js_namespace = bar, js_name = foo)] + static FOO: JsValue; + + fn take_custom_type(f: CustomType) -> CustomType; + fn touch_custom_type(); + fn custom_type_return_2() -> CustomType; + #[wasm_bindgen(js_name = interpret_2_as_custom_type)] + fn js_interpret_2_as_custom_type(); + + #[wasm_bindgen(js_name = "baz$")] + fn renamed_with_dollar_sign(); + #[wasm_bindgen(js_name = "$foo")] + static RENAMED: JsValue; + + fn unused_import(); + fn assert_dead_import_not_generated(); + fn should_call_undefined_functions() -> bool; + + type StaticMethodCheck; + #[wasm_bindgen(static_method_of = StaticMethodCheck)] + fn static_method_of_right_this(); + + static STATIC_STRING: String; + + #[derive(Clone)] + type PassOutOptionUndefined; + fn get_some_val() -> PassOutOptionUndefined; + #[wasm_bindgen(js_name = "receive_undefined")] + fn receive_undefined_ref(arg: Option<&PassOutOptionUndefined>); + #[wasm_bindgen(js_name = "receive_undefined")] + fn receive_undefined_owned(arg: Option<PassOutOptionUndefined>); + #[wasm_bindgen(js_name = "receive_some")] + fn receive_some_ref(arg: Option<&PassOutOptionUndefined>); + #[wasm_bindgen(js_name = "receive_some")] + fn receive_some_owned(arg: Option<PassOutOptionUndefined>); + + #[wasm_bindgen(js_namespace = Math)] + fn func_from_module_math(a: i32) -> i32; + + #[wasm_bindgen(js_namespace = Number)] + fn func_from_module_number() -> f64; + + #[wasm_bindgen(js_name = "same_name_from_import")] + fn same_name_from_import_1(s: i32) -> i32; + + #[wasm_bindgen(js_namespace = same_js_namespace_from_module)] + fn func_from_module_1_same_js_namespace(s: i32) -> i32; +} + +#[wasm_bindgen(module = "tests/wasm/imports_2.js")] +extern "C" { + #[wasm_bindgen(js_name = "same_name_from_import")] + fn same_name_from_import_2(s: i32) -> i32; + + #[wasm_bindgen(js_namespace = same_js_namespace_from_module)] + fn func_from_module_2_same_js_namespace(s: i32) -> i32; +} + +#[wasm_bindgen] +extern "C" { + fn parseInt(a: &str) -> u32; + + #[wasm_bindgen(js_namespace = Math, js_name = "sqrt")] + fn func_from_global_math(s: f64) -> f64; + + type Number; + #[wasm_bindgen(getter, static_method_of = Number, js_name = "NAN")] + fn static_getter_from_global_number() -> f64; +} + +#[wasm_bindgen_test] +fn simple() { + test_simple(); +} + +#[wasm_bindgen] +pub fn simple_take_str(s: &str) { + simple_foo(s); +} + +#[wasm_bindgen] +pub fn simple_another_thunk(a: u32) -> i32 { + simple_another(a) +} + +#[wasm_bindgen] +pub fn simple_bool_thunk(a: bool) -> bool { + simple_take_and_return_bool(a) +} + +#[wasm_bindgen] +pub fn simple_get_the_object() -> JsValue { + simple_return_object() +} + +#[wasm_bindgen_test] +fn string_ret() { + assert_eq!(return_string(), "bar"); +} + +#[wasm_bindgen_test] +fn strings() { + assert_eq!(take_and_ret_string(String::from("a")), "ab"); + assert_eq!(take_and_ret_string2("b"), "bb"); +} + +#[wasm_bindgen_test] +fn exceptions() { + test_exception_propagates(); + assert!(exceptions_throw2().is_err()); +} + +#[wasm_bindgen] +pub fn exceptions_propagate() { + exceptions_throw(); +} + +#[wasm_bindgen_test] +fn exn_caught() { + assert_valid_error(exceptions_throw2().unwrap_err()); +} + +#[wasm_bindgen_test] +fn free_imports() { + assert_eq!(parseInt("3"), 3); +} + +#[wasm_bindgen_test] +fn import_a_field() { + assert_eq!(IMPORT.as_f64(), Some(1.0)); +} + +#[wasm_bindgen_test] +fn rename() { + assert_eq!(rust_name_for_return_three(), 3); +} + +#[wasm_bindgen_test] +fn underscore_pattern() { + underscore(2); +} + +#[wasm_bindgen_test] +fn rust_keyword() { + assert_eq!(js_function_named_rust_keyword(), 2); +} + +#[wasm_bindgen_test] +fn rust_keyword2() { + assert_eq!(FOO.as_f64(), Some(3.0)); +} + +#[wasm_bindgen_test] +fn custom_type() { + take_custom_type(CustomType(())); + touch_custom_type(); + js_interpret_2_as_custom_type(); +} + +#[wasm_bindgen] +pub fn interpret_2_as_custom_type() { + custom_type_return_2(); +} + +#[wasm_bindgen] +pub struct CustomType(()); + +#[wasm_bindgen] +impl CustomType { + pub fn touch(&self) { + panic!() + } +} + +#[wasm_bindgen_test] +fn rename_with_string() { + renamed_with_dollar_sign(); +} + +#[wasm_bindgen_test] +fn rename_static_with_string() { + assert_eq!(RENAMED.as_f64(), Some(1.0)); +} + +#[wasm_bindgen_test] +fn dead_imports_not_generated() { + assert_dead_import_not_generated(); +} + +#[wasm_bindgen_test] +fn import_inside_function_works() { + #[wasm_bindgen(module = "tests/wasm/imports.js")] + extern "C" { + fn import_inside_function_works(); + } + import_inside_function_works(); +} + +#[wasm_bindgen_test] +fn private_module_imports_work() { + private::foo(); +} + +mod private { + use wasm_bindgen::prelude::*; + + pub fn foo() { + #[wasm_bindgen(module = "tests/wasm/imports.js")] + extern "C" { + fn import_inside_private_module(); + } + import_inside_private_module(); + } +} + +#[wasm_bindgen] +extern "C" { + fn something_not_defined_in_the_environment(); + + type TypeThatIsNotDefined; + #[wasm_bindgen(constructor)] + fn new() -> TypeThatIsNotDefined; + #[wasm_bindgen(method)] + fn method(this: &TypeThatIsNotDefined); + #[wasm_bindgen(method, getter)] + fn property(this: &TypeThatIsNotDefined) -> u32; + #[wasm_bindgen(method, setter)] + fn set_property(this: &TypeThatIsNotDefined, val: u32); +} + +#[wasm_bindgen_test] +fn undefined_function_is_ok() { + if !should_call_undefined_functions() { + return; + } + something_not_defined_in_the_environment(); + + let x = TypeThatIsNotDefined::new(); + x.method(); + x.set_property(x.property()); +} + +#[wasm_bindgen_test] +fn static_string_ok() { + assert_eq!(*STATIC_STRING, "x"); +} + +#[wasm_bindgen_test] +fn static_method_of_has_right_this() { + StaticMethodCheck::static_method_of_right_this(); +} + +#[wasm_bindgen_test] +fn pass_out_options_as_undefined() { + receive_undefined_ref(None); + receive_undefined_ref(None); + receive_undefined_owned(None); + receive_undefined_owned(None); + + let v = get_some_val(); + receive_some_ref(Some(&v)); + receive_some_ref(Some(&v)); + receive_some_owned(Some(v.clone())); + receive_some_owned(Some(v)); +} + +#[wasm_bindgen_test] +fn func_from_global_and_module_same_js_namespace() { + assert_eq!(func_from_global_math(4.0), 2.0); + assert_eq!(func_from_module_math(2), 4); +} +#[wasm_bindgen_test] +fn getter_from_global_and_module_same_name() { + assert!(Number::static_getter_from_global_number().is_nan()); + assert_eq!(func_from_module_number(), 3.0); +} +#[wasm_bindgen_test] +fn func_from_two_modules_same_js_name() { + assert_eq!(same_name_from_import_1(1), 3); + assert_eq!(same_name_from_import_2(1), 4); +} + +#[wasm_bindgen_test] +fn func_from_two_modules_same_js_namespace() { + assert_eq!(func_from_module_1_same_js_namespace(2), 10); + assert_eq!(func_from_module_2_same_js_namespace(2), 12); +} diff --git a/vendor/wasm-bindgen/tests/wasm/imports_2.js b/vendor/wasm-bindgen/tests/wasm/imports_2.js new file mode 100644 index 000000000..78f55be0f --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/imports_2.js @@ -0,0 +1,5 @@ +exports.same_name_from_import = (a) => a * 4; + +exports.same_js_namespace_from_module = { + func_from_module_2_same_js_namespace: (a) => a * 6 +}
\ No newline at end of file diff --git a/vendor/wasm-bindgen/tests/wasm/intrinsics.rs b/vendor/wasm-bindgen/tests/wasm/intrinsics.rs new file mode 100644 index 000000000..15985e812 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/intrinsics.rs @@ -0,0 +1,113 @@ +//! Tests that some of our more obscure intrinsics work properly. + +use std::convert::TryFrom; +use std::fmt::Debug; + +use js_sys::{Object, RangeError, Reflect}; +use wasm_bindgen::{JsCast, JsValue}; +use wasm_bindgen_test::wasm_bindgen_test; + +// Shorter `JsValue::from(i32)`. +fn int(x: i32) -> JsValue { + JsValue::from(x) +} + +#[wasm_bindgen_test] +fn bitwise() { + assert_eq!(int(0b1110) & int(0b0111), 0b0110); + assert_eq!(int(0b1000) | int(0b0010), 0b1010); + assert_eq!(int(0b1110) ^ int(0b0100), 0b1010); + assert_eq!(int(0x00ffffff).bit_not(), 0xff000000u32 as i32); + + assert_eq!(int(0b0001) << int(2), 0b0100); + assert_eq!(int(0b1000) >> int(2), 0b0010); + assert_eq!(int(-0b1000) >> int(2), -0b0010); + // Note that bit-wise, this is the same as the above `-0b1000`. + assert_eq!( + JsValue::from(0xfffffff8u32).unsigned_shr(&int(2)), + 0x3ffffffe + ); +} + +#[wasm_bindgen_test] +fn arithmetic() { + assert_eq!(-int(12), -12); + assert_eq!(int(1) + int(2), 3); + assert_eq!(int(1) - int(2), -1); + assert_eq!(int(10) / int(5), 2); + assert_eq!(int(42).checked_div(&int(6)), 7); + // Note that this doesn't throw for regular numbers, since they just give + // `NaN` for invalid results. + assert!(JsValue::bigint_from_str("0") + .checked_div(&JsValue::bigint_from_str("0")) + .dyn_into::<RangeError>() + .is_ok()); + assert_eq!(int(12) * int(34), 408); + assert_eq!(int(17) % int(10), 7); + assert_eq!(int(2).pow(&int(8)), 256) +} + +#[wasm_bindgen_test] +fn cmp() { + assert!(int(2).lt(&int(3))); + assert!(!int(2).lt(&int(2))); + + assert!(int(2).le(&int(3))); + assert!(int(2).le(&int(2))); + + assert!(int(3).ge(&int(2))); + assert!(int(3).ge(&int(3))); + + assert!(int(3).gt(&int(2))); + assert!(!int(3).gt(&int(3))); + + assert!(int(2) == int(2)); + assert!(int(2) != int(3)); + + assert!(int(2) != JsValue::from_str("2")); + assert!(int(2).loose_eq(&JsValue::from_str("2"))); +} + +#[wasm_bindgen_test] +fn types() { + assert!( + Reflect::get(&js_sys::global(), &JsValue::from_str("Number")) + .unwrap() + .is_function() + ); + assert!(JsValue::UNDEFINED.is_undefined()); + assert!(JsValue::NULL.is_null()); + assert!(Object::new().is_object()); + assert!(JsValue::symbol(None).is_symbol()); + assert!(JsValue::from_str("hi").is_string()); + assert!(JsValue::bigint_from_str("5").is_bigint()); + assert_eq!(int(5).js_typeof(), "number"); + assert_eq!(JsValue::bigint_from_str("5").js_typeof(), "bigint"); + assert_eq!(JsValue::NULL.js_typeof(), "object"); +} + +#[wasm_bindgen_test] +fn misc() { + assert!(JsValue::from_str("Number").js_in(&js_sys::global())); + assert!(!JsValue::from_str("frob").js_in(&js_sys::global())); + + assert_eq!(int(5).unchecked_into_f64(), 5.0); + assert_eq!(JsValue::from_str("5").unchecked_into_f64(), 5.0); + + assert_eq!(f64::try_from(int(5)), Ok(5.0)); + assert_eq!(f64::try_from(JsValue::from_str("5")), Ok(5.0)); + assert!(f64::try_from(JsValue::from_str("hi")).unwrap().is_nan()); + assert!(f64::try_from(JsValue::symbol(None)).is_err()); +} + +fn debug(x: impl Debug) -> String { + format!("{x:?}") +} + +#[wasm_bindgen_test] +fn debug_string() { + assert_eq!(debug(int(5)), "JsValue(5)"); + assert_eq!(debug(JsValue::TRUE), "JsValue(true)"); + assert_eq!(debug(JsValue::symbol(None)), "JsValue(Symbol)"); + assert_eq!(debug(JsValue::from_str("hi")), "JsValue(\"hi\")"); +} diff --git a/vendor/wasm-bindgen/tests/wasm/js_keywords.js b/vendor/wasm-bindgen/tests/wasm/js_keywords.js new file mode 100644 index 000000000..f7fb26dea --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/js_keywords.js @@ -0,0 +1,24 @@ +const wasm = require("wasm-bindgen-test.js"); +const assert = require("assert"); + +exports.js_keywords_compile = () => { + assert.strictEqual(wasm._throw(1), 1); + assert.strictEqual(wasm._class(1, 2), false); + assert.strictEqual(wasm.classy(3), 3); + let obj = new wasm.Class("class"); + assert.strictEqual(wasm.Class.void("string"), "string"); + assert.strictEqual(obj.catch, "class"); + assert.strictEqual(obj.instanceof("Class"), "class is instance of Class"); +}; + +exports.test_keyword_1_as_fn_name = (x) => { + return wasm._throw(x); +}; + +exports.test_keyword_2_as_fn_name = (x, y) => { + return wasm._class(x, y); +}; + +exports.test_keyword_as_fn_arg = (x) => { + return wasm.classy(x); +}; diff --git a/vendor/wasm-bindgen/tests/wasm/js_keywords.rs b/vendor/wasm-bindgen/tests/wasm/js_keywords.rs new file mode 100644 index 000000000..57feed7a7 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/js_keywords.rs @@ -0,0 +1,55 @@ +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[wasm_bindgen(module = "tests/wasm/js_keywords.js")] +extern "C" { + fn js_keywords_compile(); + fn test_keyword_1_as_fn_name(x: u8) -> u8; + fn test_keyword_2_as_fn_name(x: u8, y: u8) -> bool; + fn test_keyword_as_fn_arg(x: u8) -> u8; +} + +#[wasm_bindgen] +pub fn throw(class: u8) -> u8 { + class +} + +#[wasm_bindgen(js_name = class)] +pub fn fn_parsed_to_keyword(instanceof: u8, catch: u8) -> bool { + instanceof > catch +} + +#[wasm_bindgen(js_name = classy)] +pub fn arg_is_keyword(class: u8) -> u8 { + class +} + +#[wasm_bindgen] +struct Class { + name: String, +} +#[wasm_bindgen] +impl Class { + #[wasm_bindgen(constructor)] + pub fn new(void: String) -> Self { + Class { name: void } + } + pub fn instanceof(&self, class: String) -> String { + format!("{} is instance of {}", self.name.clone(), class) + } + #[wasm_bindgen(getter)] + pub fn catch(&self) -> String { + self.name.clone() + } + pub fn void(void: String) -> String { + void + } +} + +#[wasm_bindgen_test] +fn compile() { + js_keywords_compile(); + assert_eq!(test_keyword_1_as_fn_name(1), 1); + assert_eq!(test_keyword_2_as_fn_name(1, 2), false); + assert_eq!(test_keyword_as_fn_arg(1), 1); +} diff --git a/vendor/wasm-bindgen/tests/wasm/js_objects.js b/vendor/wasm-bindgen/tests/wasm/js_objects.js new file mode 100644 index 000000000..c131527b8 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/js_objects.js @@ -0,0 +1,112 @@ +const wasm = require('wasm-bindgen-test.js'); +const assert = require('assert'); + +let SIMPLE_ARG = null; + +exports.simple_foo = s => { + assert.strictEqual(SIMPLE_ARG, null); + SIMPLE_ARG = s; +}; + +exports.js_simple = () => { + assert.strictEqual(SIMPLE_ARG, null); + let sym = Symbol('test'); + wasm.simple_bar(sym); + assert.strictEqual(SIMPLE_ARG, sym); +}; + +let OWNED_ARG = null; + +exports.owned_foo = s => { + assert.strictEqual(OWNED_ARG, null); + OWNED_ARG = s; +}; + +exports.js_owned = () => { + assert.strictEqual(OWNED_ARG, null); + let sym = Symbol('test'); + wasm.owned_bar(sym); + assert.strictEqual(OWNED_ARG, sym); +}; + +let CLONE_ARG = Symbol('test'); + +exports.clone_foo1 = s => { + assert.strictEqual(s, CLONE_ARG); +}; +exports.clone_foo2 = s => { + assert.strictEqual(s, CLONE_ARG); +}; +exports.clone_foo3 = s => { + assert.strictEqual(s, CLONE_ARG); +}; +exports.clone_foo4 = s => { + assert.strictEqual(s, CLONE_ARG); +}; +exports.clone_foo5 = s => { + assert.strictEqual(s, CLONE_ARG); +}; + +exports.js_clone = () => { + wasm.clone_bar(CLONE_ARG); +}; + + +let PROMOTE_ARG = Symbol('test'); + +exports.promote_foo1 = s => { + assert.strictEqual(s, PROMOTE_ARG); +}; +exports.promote_foo2 = s => { + assert.strictEqual(s, PROMOTE_ARG); +}; +exports.promote_foo3 = s => { + assert.strictEqual(s, PROMOTE_ARG); +}; +exports.promote_foo4 = s => { + assert.strictEqual(s, PROMOTE_ARG); +}; + +exports.js_promote = () => { + wasm.promote_bar(PROMOTE_ARG); +}; + +exports.returning_vector_foo = () => { + return {'foo': 'bar'}; +}; + +exports.js_returning_vector = () => { + assert.strictEqual(wasm.returning_vector_bar().length, 10); +}; + +exports.js_another_vector_return = () => { + assert.deepStrictEqual(wasm.another_vector_return_get_array(), [1, 2, 3, 4, 5, 6]); +}; + +exports.returning_vector_string_foo = () => { + return "This is the mostest awesomest string that can possibly exist."; +}; + +exports.js_returning_vector_string = () => { + assert.strictEqual(wasm.returning_vector_string_bar().length, 10); +}; + +exports.js_another_vector_string_return = () => { + assert.deepStrictEqual(wasm.another_vector_string_return_get_array(), ["1", "2", "3", "4", "5", "6"]); +}; + +exports.verify_serde = function(a) { + assert.deepStrictEqual(a, { + a: 0, + b: 'foo', + c: null, + d: { a: 1 } + }); + + return { + a: 2, + b: 'bar', + c: { a: 3 }, + d: { a: 4 }, + } +}; diff --git a/vendor/wasm-bindgen/tests/wasm/js_objects.rs b/vendor/wasm-bindgen/tests/wasm/js_objects.rs new file mode 100644 index 000000000..445d5329a --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/js_objects.rs @@ -0,0 +1,184 @@ +use js_sys::JsString; +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[wasm_bindgen(module = "tests/wasm/js_objects.js")] +extern "C" { + fn simple_foo(s: &JsValue); + fn js_simple(); + + fn owned_foo(s: JsValue); + fn js_owned(); + + fn clone_foo1(s: JsValue); + fn clone_foo2(s: &JsValue); + fn clone_foo3(s: JsValue); + fn clone_foo4(s: &JsValue); + fn clone_foo5(s: JsValue); + fn js_clone(); + + fn promote_foo1(s: &JsValue); + fn promote_foo2(s: JsValue); + fn promote_foo3(s: &JsValue); + fn promote_foo4(s: JsValue); + fn js_promote(); + + fn returning_vector_foo() -> JsValue; + fn js_returning_vector(); + fn js_another_vector_return(); + + fn returning_vector_string_foo() -> JsString; + fn js_returning_vector_string(); + fn js_another_vector_string_return(); + + fn verify_serde(val: JsValue) -> JsValue; +} + +#[wasm_bindgen] +pub fn simple_bar(s: &JsValue) { + simple_foo(s); +} + +#[wasm_bindgen_test] +fn simple() { + js_simple(); +} + +#[wasm_bindgen] +pub fn owned_bar(s: JsValue) { + owned_foo(s); +} + +#[wasm_bindgen_test] +fn owned() { + js_owned(); +} + +#[wasm_bindgen] +pub fn clone_bar(s: JsValue) { + clone_foo1(s.clone()); + clone_foo2(&s); + clone_foo3(s.clone()); + clone_foo4(&s); + clone_foo5(s); +} + +#[wasm_bindgen_test] +fn clone() { + js_clone(); +} + +#[wasm_bindgen] +pub fn promote_bar(s: &JsValue) { + promote_foo1(s); + promote_foo2(s.clone()); + promote_foo3(s); + promote_foo4(s.clone()); +} + +#[wasm_bindgen_test] +fn promote() { + js_promote(); +} + +#[wasm_bindgen] +pub fn returning_vector_bar() -> Vec<JsValue> { + let mut res = Vec::new(); + for _ in 0..10 { + res.push(returning_vector_foo()) + } + res +} + +#[wasm_bindgen_test] +fn returning_vector() { + js_returning_vector(); +} + +#[wasm_bindgen] +pub fn another_vector_return_get_array() -> Vec<JsValue> { + vec![ + JsValue::from(1), + JsValue::from(2), + JsValue::from(3), + JsValue::from(4), + JsValue::from(5), + JsValue::from(6), + ] +} + +#[wasm_bindgen_test] +fn another_vector_return() { + js_another_vector_return(); +} + +#[wasm_bindgen] +pub fn returning_vector_string_bar() -> Vec<JsString> { + let mut res = Vec::new(); + for _ in 0..10 { + res.push(returning_vector_string_foo()) + } + res +} + +#[wasm_bindgen_test] +fn returning_vector_string() { + js_returning_vector_string(); +} + +#[wasm_bindgen] +pub fn another_vector_string_return_get_array() -> Vec<JsString> { + vec![ + "1".into(), + "2".into(), + "3".into(), + "4".into(), + "5".into(), + "6".into(), + ] +} + +#[wasm_bindgen_test] +fn another_vector_string_return() { + js_another_vector_string_return(); +} + +#[cfg(feature = "serde-serialize")] +#[wasm_bindgen_test] +fn serde() { + #[derive(Deserialize, Serialize)] + pub struct SerdeFoo { + a: u32, + b: String, + c: Option<SerdeBar>, + d: SerdeBar, + } + + #[derive(Deserialize, Serialize)] + pub struct SerdeBar { + a: u32, + } + + let js = JsValue::from_serde("foo").unwrap(); + assert_eq!(js.as_string(), Some("foo".to_string())); + + let ret = verify_serde( + JsValue::from_serde(&SerdeFoo { + a: 0, + b: "foo".to_string(), + c: None, + d: SerdeBar { a: 1 }, + }) + .unwrap(), + ); + + let foo = ret.into_serde::<SerdeFoo>().unwrap(); + assert_eq!(foo.a, 2); + assert_eq!(foo.b, "bar"); + assert!(foo.c.is_some()); + assert_eq!(foo.c.as_ref().unwrap().a, 3); + assert_eq!(foo.d.a, 4); + + assert_eq!(JsValue::from("bar").into_serde::<String>().unwrap(), "bar"); + assert_eq!(JsValue::undefined().into_serde::<i32>().ok(), None); +} diff --git a/vendor/wasm-bindgen/tests/wasm/jscast.js b/vendor/wasm-bindgen/tests/wasm/jscast.js new file mode 100644 index 000000000..3cecd9915 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/jscast.js @@ -0,0 +1,28 @@ +class JsCast1 { + constructor() { + this.val = 1; + } + myval() { return this.val; } +} + +class JsCast2 { +} + +class JsCast3 extends JsCast1 { + constructor() { + super(); + this.val = 3; + } +} + +class JsCast4 extends JsCast3 { + constructor() { + super(); + this.val = 4; + } +} + +exports.JsCast1 = JsCast1; +exports.JsCast2 = JsCast2; +exports.JsCast3 = JsCast3; +exports.JsCast4 = JsCast4; diff --git a/vendor/wasm-bindgen/tests/wasm/jscast.rs b/vendor/wasm-bindgen/tests/wasm/jscast.rs new file mode 100644 index 000000000..1279634d2 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/jscast.rs @@ -0,0 +1,88 @@ +use wasm_bindgen::prelude::*; +use wasm_bindgen::JsCast; +use wasm_bindgen_test::*; + +#[wasm_bindgen(module = "tests/wasm/jscast.js")] +extern "C" { + type JsCast1; + #[wasm_bindgen(constructor)] + fn new() -> JsCast1; + #[wasm_bindgen(method)] + fn myval(this: &JsCast1) -> u32; + + type JsCast2; + #[wasm_bindgen(constructor)] + fn new() -> JsCast2; + + #[wasm_bindgen(extends = JsCast1)] + type JsCast3; + #[wasm_bindgen(constructor)] + fn new() -> JsCast3; + + #[wasm_bindgen(extends = crate::jscast::JsCast1, extends = JsCast3)] + type JsCast4; + #[wasm_bindgen(constructor)] + fn new() -> JsCast4; +} + +#[wasm_bindgen_test] +fn instanceof_works() { + let a = JsCast1::new(); + let b = JsCast2::new(); + let c = JsCast3::new(); + + assert!(a.is_instance_of::<JsCast1>()); + assert!(!a.is_instance_of::<JsCast2>()); + assert!(!a.is_instance_of::<JsCast3>()); + + assert!(!b.is_instance_of::<JsCast1>()); + assert!(b.is_instance_of::<JsCast2>()); + assert!(!b.is_instance_of::<JsCast3>()); + + assert!(c.is_instance_of::<JsCast1>()); + assert!(!c.is_instance_of::<JsCast2>()); + assert!(c.is_instance_of::<JsCast3>()); +} + +#[wasm_bindgen_test] +fn casting() { + let a = JsCast1::new(); + let b = JsCast2::new(); + let c = JsCast3::new(); + + assert!(a.dyn_ref::<JsCast1>().is_some()); + assert!(a.dyn_ref::<JsCast2>().is_none()); + assert!(a.dyn_ref::<JsCast3>().is_none()); + + assert!(b.dyn_ref::<JsCast1>().is_none()); + assert!(b.dyn_ref::<JsCast2>().is_some()); + assert!(b.dyn_ref::<JsCast3>().is_none()); + + assert!(c.dyn_ref::<JsCast1>().is_some()); + assert!(c.dyn_ref::<JsCast2>().is_none()); + assert!(c.dyn_ref::<JsCast3>().is_some()); +} + +#[wasm_bindgen_test] +fn method_calling() { + let a = JsCast1::new(); + let b = JsCast3::new(); + + assert_eq!(a.myval(), 1); + assert_eq!(b.dyn_ref::<JsCast1>().unwrap().myval(), 3); + assert_eq!(b.unchecked_ref::<JsCast1>().myval(), 3); + let c: &JsCast1 = b.as_ref(); + assert_eq!(c.myval(), 3); +} + +#[wasm_bindgen_test] +fn multiple_layers_of_inheritance() { + let a = JsCast4::new(); + assert!(a.is_instance_of::<JsCast4>()); + assert!(a.is_instance_of::<JsCast3>()); + assert!(a.is_instance_of::<JsCast1>()); + + let _: &JsCast3 = a.as_ref(); + let b: &JsCast1 = a.as_ref(); + assert_eq!(b.myval(), 4); +} diff --git a/vendor/wasm-bindgen/tests/wasm/main.rs b/vendor/wasm-bindgen/tests/wasm/main.rs new file mode 100644 index 000000000..51e6dcafe --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/main.rs @@ -0,0 +1,56 @@ +#![cfg(target_arch = "wasm32")] + +extern crate js_sys; +extern crate wasm_bindgen; +extern crate wasm_bindgen_test; +extern crate wasm_bindgen_test_crate_a; +extern crate wasm_bindgen_test_crate_b; + +#[cfg(feature = "serde-serialize")] +#[macro_use] +extern crate serde_derive; + +use wasm_bindgen::prelude::*; + +pub mod api; +pub mod arg_names; +pub mod bigint; +pub mod char; +pub mod classes; +pub mod closures; +pub mod comments; +pub mod duplicate_deps; +pub mod duplicates; +pub mod enums; +#[path = "final.rs"] +pub mod final_; +pub mod futures; +pub mod getters_and_setters; +pub mod import_class; +pub mod imports; +pub mod intrinsics; +pub mod js_keywords; +pub mod js_objects; +pub mod jscast; +pub mod math; +pub mod no_shims; +pub mod node; +pub mod option; +pub mod optional_primitives; +pub mod result; +pub mod result_jserror; +pub mod rethrow; +pub mod simple; +pub mod slice; +pub mod structural; +pub mod truthy_falsy; +pub mod usize; +pub mod validate_prt; +pub mod variadic; +pub mod vendor_prefix; + +// should not be executed +#[wasm_bindgen(start)] +pub fn start() { + panic!(); +} diff --git a/vendor/wasm-bindgen/tests/wasm/math.js b/vendor/wasm-bindgen/tests/wasm/math.js new file mode 100644 index 000000000..e3b518305 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/math.js @@ -0,0 +1,37 @@ +const wasm = require('wasm-bindgen-test.js'); +const assert = require('assert'); + +exports.js_auto_bind_math = () => { + wasm.math(1.0, 2.0); +}; + +exports.roundtrip = x => x; + +exports.test_js_roundtrip = () => { + assert.strictEqual(wasm.rust_roundtrip_i8(0), 0); + assert.strictEqual(wasm.rust_roundtrip_i8(0x80), -128); + assert.strictEqual(wasm.rust_roundtrip_i8(0x7f), 127); + + assert.strictEqual(wasm.rust_roundtrip_i16(0), 0); + assert.strictEqual(wasm.rust_roundtrip_i16(0x8000), -32768); + assert.strictEqual(wasm.rust_roundtrip_i16(0x7fff), 32767); + + assert.strictEqual(wasm.rust_roundtrip_i32(0), 0); + assert.strictEqual(wasm.rust_roundtrip_i32(0x80000000), -2147483648); + assert.strictEqual(wasm.rust_roundtrip_i32(0x7fffffff), 2147483647); + + assert.strictEqual(wasm.rust_roundtrip_u8(0), 0); + assert.strictEqual(wasm.rust_roundtrip_u8(0x80), 128); + assert.strictEqual(wasm.rust_roundtrip_u8(0x7f), 127); + assert.strictEqual(wasm.rust_roundtrip_u8(0xff), 255); + + assert.strictEqual(wasm.rust_roundtrip_u16(0), 0); + assert.strictEqual(wasm.rust_roundtrip_u16(0x8000), 32768); + assert.strictEqual(wasm.rust_roundtrip_u16(0x7fff), 32767); + assert.strictEqual(wasm.rust_roundtrip_u16(0xffff), 65535); + + assert.strictEqual(wasm.rust_roundtrip_u32(0), 0); + assert.strictEqual(wasm.rust_roundtrip_u32(0x80000000), 2147483648); + assert.strictEqual(wasm.rust_roundtrip_u32(0x7fffffff), 2147483647); + assert.strictEqual(wasm.rust_roundtrip_u32(0xffffffff), 4294967295); +}; diff --git a/vendor/wasm-bindgen/tests/wasm/math.rs b/vendor/wasm-bindgen/tests/wasm/math.rs new file mode 100644 index 000000000..5462cc2d4 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/math.rs @@ -0,0 +1,142 @@ +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[wasm_bindgen(module = "tests/wasm/math.js")] +extern "C" { + fn js_auto_bind_math(); + + // There's an identity function called `roundtrip` in the module and we bind + // that one function with multiple different signatures here. Note that the + // return value is always `f64` to faithfully capture what was sent to JS + // (what we're interested in) because all JS numbers fit in `f64` anyway. + // This is testing what happens when we pass numbers to JS and what it sees. + #[wasm_bindgen(assert_no_shim, js_name = roundtrip)] + fn roundtrip_i8(a: i8) -> f64; + #[wasm_bindgen(assert_no_shim, js_name = roundtrip)] + fn roundtrip_i16(a: i16) -> f64; + #[wasm_bindgen(assert_no_shim, js_name = roundtrip)] + fn roundtrip_i32(a: i32) -> f64; + #[wasm_bindgen(assert_no_shim, js_name = roundtrip)] + fn roundtrip_u8(a: u8) -> f64; + #[wasm_bindgen(assert_no_shim, js_name = roundtrip)] + fn roundtrip_u16(a: u16) -> f64; + #[wasm_bindgen(js_name = roundtrip)] + fn roundtrip_u32(a: u32) -> f64; + + fn test_js_roundtrip(); +} + +#[wasm_bindgen] +pub fn math(a: f32, b: f64) -> f64 { + b.acos() + + b.asin() + + b.atan() + + b.atan2(b) + + b.cbrt() + + b.cosh() + + b.exp_m1() + + b.ln_1p() + + b.sinh() + + b.tan() + + b.tanh() + + b.hypot(b) + + b.cos() + + b.exp() + + b.exp2() + + b.mul_add(b, b) + + b.ln() + + b.log(b) + + b.log10() + + b.log2() + + b.powi(8) + + b.powf(b) + + b.round() + + b.sin() + + b.abs() + + b.signum() + + b.floor() + + b.ceil() + + b.trunc() + + b.sqrt() + + (b % (a as f64)) + + ((a.cos() + + a.exp() + + a.exp2() + + a.mul_add(a, a) + + a.ln() + + a.log(a) + + a.log10() + + a.log2() + + a.powi(8) + + a.powf(a) + + a.round() + + a.sin() + + a.abs() + + a.signum() + + a.floor() + + a.ceil() + + a.trunc() + + a.sqrt() + + (a % (b as f32))) as f64) + + (b + 2.0f64.powf(a as f64)) +} + +#[wasm_bindgen_test] +fn auto_bind_math() { + js_auto_bind_math(); +} + +macro_rules! t_roundtrip { + ($f:ident($e:expr)) => { + assert_eq!($f($e), $e as f64) + }; +} + +#[wasm_bindgen_test] +fn limits_correct() { + t_roundtrip!(roundtrip_i8(i8::min_value())); + t_roundtrip!(roundtrip_i8(0)); + t_roundtrip!(roundtrip_i8(i8::max_value())); + t_roundtrip!(roundtrip_i16(i16::min_value())); + t_roundtrip!(roundtrip_i16(0)); + t_roundtrip!(roundtrip_i16(i16::max_value())); + t_roundtrip!(roundtrip_i32(i32::min_value())); + t_roundtrip!(roundtrip_i32(0)); + t_roundtrip!(roundtrip_i32(i32::max_value())); + t_roundtrip!(roundtrip_u8(u8::min_value())); + t_roundtrip!(roundtrip_u8(0)); + t_roundtrip!(roundtrip_u8(u8::max_value())); + t_roundtrip!(roundtrip_u16(u16::min_value())); + t_roundtrip!(roundtrip_u16(0)); + t_roundtrip!(roundtrip_u16(u16::max_value())); + t_roundtrip!(roundtrip_u32(u32::min_value())); + t_roundtrip!(roundtrip_u32(0)); + t_roundtrip!(roundtrip_u32(u32::max_value())); + + test_js_roundtrip(); + + #[wasm_bindgen] + pub fn rust_roundtrip_i8(a: i8) -> i8 { + a + } + #[wasm_bindgen] + pub fn rust_roundtrip_i16(a: i16) -> i16 { + a + } + #[wasm_bindgen] + pub fn rust_roundtrip_i32(a: i32) -> i32 { + a + } + #[wasm_bindgen] + pub fn rust_roundtrip_u8(a: u8) -> u8 { + a + } + #[wasm_bindgen] + pub fn rust_roundtrip_u16(a: u16) -> u16 { + a + } + #[wasm_bindgen] + pub fn rust_roundtrip_u32(a: u32) -> u32 { + a + } +} diff --git a/vendor/wasm-bindgen/tests/wasm/no_shims.rs b/vendor/wasm-bindgen/tests/wasm/no_shims.rs new file mode 100644 index 000000000..2f9455ae2 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/no_shims.rs @@ -0,0 +1,152 @@ +//! A collection of tests to exercise imports where we don't need to generate a +//! JS shim to convert arguments/returns even when Web IDL bindings is not +//! implemented. + +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[wasm_bindgen(inline_js = " + function assert_eq(a, b) { + if (a !== b) { + throw new Error(`assert_eq failed: ${a} != ${b}`); + } + } + + module.exports.trivial = function () {}; + + module.exports.incoming_bool = function () { return true; }; + module.exports.incoming_u8 = function () { return 255; }; + module.exports.incoming_i8 = function () { return -127; }; + module.exports.incoming_u16 = function () { return 65535; }; + module.exports.incoming_i16 = function () { return 32767; }; + module.exports.incoming_u32 = function () { return 4294967295; }; + module.exports.incoming_i32 = function () { return 0; }; + module.exports.incoming_f32 = function () { return 1.5; }; + module.exports.incoming_f64 = function () { return 13.37; }; + + module.exports.outgoing_u8 = function (k) { assert_eq(k, 255); }; + module.exports.outgoing_i8 = function (i) { assert_eq(i, -127); }; + module.exports.outgoing_u16 = function (l) { assert_eq(l, 65535); }; + module.exports.outgoing_i16 = function (j) { assert_eq(j, 32767); }; + module.exports.outgoing_i32 = function (x) { assert_eq(x, 0); }; + module.exports.outgoing_f32 = function (y) { assert_eq(y, 1.5); }; + module.exports.outgoing_f64 = function (z) { assert_eq(z, 13.37); }; + + module.exports.many = function (x, y, z) { + assert_eq(x, 0); + assert_eq(y, 1.5); + assert_eq(z, 13.37); + return 42; + }; + + module.exports.works_when_externref_support_is_enabled = function (v) { + assert_eq(v, 'hello'); + return v; + }; + + module.exports.MyNamespace = {}; + module.exports.MyNamespace.incoming_namespaced = function () { return 3.14; }; + module.exports.MyNamespace.outgoing_namespaced = function (pi) { assert_eq(3.14, pi); }; +")] +extern "C" { + #[wasm_bindgen(assert_no_shim)] + fn trivial(); + + #[wasm_bindgen(assert_no_shim)] + fn incoming_bool() -> bool; + #[wasm_bindgen(assert_no_shim)] + fn incoming_u8() -> u8; + #[wasm_bindgen(assert_no_shim)] + fn incoming_i8() -> i8; + #[wasm_bindgen(assert_no_shim)] + fn incoming_u16() -> u16; + #[wasm_bindgen(assert_no_shim)] + fn incoming_i16() -> i16; + #[wasm_bindgen(assert_no_shim)] + fn incoming_u32() -> u32; + #[wasm_bindgen(assert_no_shim)] + fn incoming_i32() -> i32; + #[wasm_bindgen(assert_no_shim)] + fn incoming_f32() -> f32; + #[wasm_bindgen(assert_no_shim)] + fn incoming_f64() -> f64; + + #[wasm_bindgen(assert_no_shim)] + fn outgoing_u8(k: u8); + #[wasm_bindgen(assert_no_shim)] + fn outgoing_i8(i: i8); + #[wasm_bindgen(assert_no_shim)] + fn outgoing_u16(l: u16); + #[wasm_bindgen(assert_no_shim)] + fn outgoing_i16(j: i16); + #[wasm_bindgen(assert_no_shim)] + fn outgoing_i32(x: i32); + #[wasm_bindgen(assert_no_shim)] + fn outgoing_f32(y: f32); + #[wasm_bindgen(assert_no_shim)] + fn outgoing_f64(z: f64); + + #[wasm_bindgen(assert_no_shim)] + fn many(x: i32, y: f32, z: f64) -> i32; + + #[wasm_bindgen(assert_no_shim, js_namespace = MyNamespace)] + fn incoming_namespaced() -> f64; + #[wasm_bindgen(assert_no_shim, js_namespace = MyNamespace)] + fn outgoing_namespaced(x: f64); + + // Note that this should only skip the JS shim if we have externref support + // enabled. + // + // #[wasm_bindgen(assert_no_shim)] + fn works_when_externref_support_is_enabled(v: JsValue) -> JsValue; +} + +#[wasm_bindgen_test] +fn no_shims() { + trivial(); + + let k = incoming_u8(); + assert_eq!(k, 255); + outgoing_u8(k); + + let l = incoming_u16(); + assert_eq!(l, 65535); + outgoing_u16(l); + + let m = incoming_u32(); + assert_eq!(m, 4294967295); + + let i = incoming_i8(); + assert_eq!(i, -127); + outgoing_i8(i); + + let j = incoming_i16(); + assert_eq!(j, 32767); + outgoing_i16(j); + + let x = incoming_i32(); + assert_eq!(x, 0); + outgoing_i32(x); + + let y = incoming_f32(); + assert_eq!(y, 1.5); + outgoing_f32(y); + + let z = incoming_f64(); + assert_eq!(z, 13.37); + outgoing_f64(z); + + let w = many(x, y, z); + assert_eq!(w, 42); + + let pi = incoming_namespaced(); + assert_eq!(pi, 3.14); + outgoing_namespaced(pi); + + let b = incoming_bool(); + assert!(b); + + let v = JsValue::from("hello"); + let vv = works_when_externref_support_is_enabled(v.clone()); + assert_eq!(v, vv); +} diff --git a/vendor/wasm-bindgen/tests/wasm/node.js b/vendor/wasm-bindgen/tests/wasm/node.js new file mode 100644 index 000000000..41baa8b24 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/node.js @@ -0,0 +1,37 @@ +const assert = require('assert'); +const wasm = require('wasm-bindgen-test'); + +var called = false; + +exports.hit = function() { + called = true; +}; + +exports.FOO = 1.0; + +exports.test_works = function() { + assert.strictEqual(called, true); + + var r = wasm.Foo.new(); + assert.strictEqual(r.add(0), 0); + assert.strictEqual(r.add(1), 1); + assert.strictEqual(r.add(2), 3); + r.free(); + + var r2 = wasm.Foo.with_contents(10); + assert.strictEqual(r2.add(0), 10); + assert.strictEqual(r2.add(1), 11); + assert.strictEqual(r2.add(2), 13); + r2.free(); + + assert.strictEqual(wasm.Color.Green, 0); + assert.strictEqual(wasm.Color.Yellow, 1); + assert.strictEqual(wasm.Color.Red, 2); + assert.strictEqual(wasm.Color[0], 'Green'); + assert.strictEqual(wasm.Color[1], 'Yellow'); + assert.strictEqual(wasm.Color[2], 'Red'); + assert.strictEqual(Object.keys(wasm.Color).length, 6); + assert.strictEqual(wasm.cycle(wasm.Color.Green), wasm.Color.Yellow); + + wasm.node_math(1.0, 2.0); +}; diff --git a/vendor/wasm-bindgen/tests/wasm/node.rs b/vendor/wasm-bindgen/tests/wasm/node.rs new file mode 100644 index 000000000..742dbcfb5 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/node.rs @@ -0,0 +1,105 @@ +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[wasm_bindgen(module = "tests/wasm/node.js")] +extern "C" { + fn test_works(); + static FOO: JsValue; + fn hit(); +} + +#[wasm_bindgen_test] +fn works() { + hit(); + assert_eq!(FOO.as_f64(), Some(1.0)); + test_works(); +} + +#[wasm_bindgen] +pub struct Foo { + contents: u32, +} + +#[wasm_bindgen] +impl Foo { + pub fn new() -> Foo { + Foo::with_contents(0) + } + pub fn with_contents(a: u32) -> Foo { + Foo { contents: a } + } + pub fn add(&mut self, amt: u32) -> u32 { + self.contents += amt; + self.contents + } +} + +#[wasm_bindgen] +pub enum Color { + Green, + Yellow, + Red, +} +#[wasm_bindgen] +pub fn cycle(color: Color) -> Color { + match color { + Color::Green => Color::Yellow, + Color::Yellow => Color::Red, + Color::Red => Color::Green, + } +} + +#[wasm_bindgen] +pub fn node_math(a: f32, b: f64) -> f64 { + b.acos() + + b.asin() + + b.atan() + + b.atan2(b) + + b.cbrt() + + b.cosh() + + b.exp_m1() + + b.ln_1p() + + b.sinh() + + b.tan() + + b.tanh() + + b.hypot(b) + + b.cos() + + b.exp() + + b.exp2() + + b.mul_add(b, b) + + b.ln() + + b.log(b) + + b.log10() + + b.log2() + + b.powi(8) + + b.powf(b) + + b.round() + + b.sin() + + b.abs() + + b.signum() + + b.floor() + + b.ceil() + + b.trunc() + + b.sqrt() + + (b % (a as f64)) + + ((a.cos() + + a.exp() + + a.exp2() + + a.mul_add(a, a) + + a.ln() + + a.log(a) + + a.log10() + + a.log2() + + a.powi(8) + + a.powf(a) + + a.round() + + a.sin() + + a.abs() + + a.signum() + + a.floor() + + a.ceil() + + a.trunc() + + a.sqrt() + + (a % (b as f32))) as f64) + + (b + 2.0f64.powf(a as f64)) +} diff --git a/vendor/wasm-bindgen/tests/wasm/option.js b/vendor/wasm-bindgen/tests/wasm/option.js new file mode 100644 index 000000000..e9162feb1 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/option.js @@ -0,0 +1,28 @@ +const wasm = require('wasm-bindgen-test.js'); +const assert = require('assert'); + +class MyType { +} + +exports.MyType = MyType; + +exports.take_none_byval = x => { + assert.strictEqual(x, undefined); +}; +exports.take_some_byval = x => { + assert.ok(x !== null && x !== undefined); + assert.ok(x instanceof MyType); +}; +exports.return_undef_byval = () => undefined; +exports.return_null_byval = () => null; +exports.return_some_byval = () => new MyType(); + +exports.test_option_values = () => { + wasm.rust_take_none_byval(null); + wasm.rust_take_none_byval(undefined); + wasm.rust_take_some_byval(new MyType()); + assert.strictEqual(wasm.rust_return_none_byval(), undefined); + const x = wasm.rust_return_some_byval(); + assert.ok(x !== null && x !== undefined); + assert.ok(x instanceof MyType); +}; diff --git a/vendor/wasm-bindgen/tests/wasm/option.rs b/vendor/wasm-bindgen/tests/wasm/option.rs new file mode 100644 index 000000000..4b4cc4379 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/option.rs @@ -0,0 +1,61 @@ +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[wasm_bindgen(module = "tests/wasm/option.js")] +extern "C" { + pub type MyType; + #[wasm_bindgen(constructor)] + fn new() -> MyType; + + fn take_none_byval(t: Option<MyType>); + fn take_some_byval(t: Option<MyType>); + fn return_undef_byval() -> Option<MyType>; + fn return_null_byval() -> Option<MyType>; + fn return_some_byval() -> Option<MyType>; + fn test_option_values(); + + #[wasm_bindgen(js_name = take_none_byval)] + fn take_none_byref(t: Option<&MyType>); + #[wasm_bindgen(js_name = take_some_byval)] + fn take_some_byref(t: Option<&MyType>); +} + +#[wasm_bindgen_test] +fn import_by_value() { + take_none_byval(None); + take_some_byval(Some(MyType::new())); + assert!(return_null_byval().is_none()); + assert!(return_undef_byval().is_none()); + assert!(return_some_byval().is_some()); +} + +#[wasm_bindgen_test] +fn export_by_value() { + test_option_values(); +} + +#[wasm_bindgen] +pub fn rust_take_none_byval(t: Option<MyType>) { + assert!(t.is_none()); +} + +#[wasm_bindgen] +pub fn rust_take_some_byval(t: Option<MyType>) { + assert!(t.is_some()); +} + +#[wasm_bindgen] +pub fn rust_return_none_byval() -> Option<MyType> { + None +} + +#[wasm_bindgen] +pub fn rust_return_some_byval() -> Option<MyType> { + Some(MyType::new()) +} + +#[wasm_bindgen_test] +fn import_by_ref() { + take_none_byref(None); + take_some_byref(Some(&MyType::new())); +} diff --git a/vendor/wasm-bindgen/tests/wasm/optional_primitives.js b/vendor/wasm-bindgen/tests/wasm/optional_primitives.js new file mode 100644 index 000000000..89bf4df7e --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/optional_primitives.js @@ -0,0 +1,102 @@ +const wasm = require('wasm-bindgen-test.js'); +const assert = require('assert'); + +exports.optional_i32_js_identity = a => a; +exports.optional_u32_js_identity = a => a; +exports.optional_isize_js_identity = a => a; +exports.optional_usize_js_identity = a => a; +exports.optional_f32_js_identity = a => a; +exports.optional_f64_js_identity = a => a; +exports.optional_i8_js_identity = a => a; +exports.optional_u8_js_identity = a => a; +exports.optional_i16_js_identity = a => a; +exports.optional_u16_js_identity = a => a; +exports.optional_i64_js_identity = a => a; +exports.optional_u64_js_identity = a => a; +exports.optional_bool_js_identity = a => a; +exports.optional_char_js_identity = a => a; + +exports.js_works = () => { + assert.strictEqual(wasm.optional_i32_identity(wasm.optional_i32_none()), undefined); + assert.strictEqual(wasm.optional_i32_identity(wasm.optional_i32_zero()), 0); + assert.strictEqual(wasm.optional_i32_identity(wasm.optional_i32_one()), 1); + assert.strictEqual(wasm.optional_i32_identity(wasm.optional_i32_neg_one()), -1); + assert.strictEqual(wasm.optional_i32_identity(wasm.optional_i32_min()), -2147483648); + assert.strictEqual(wasm.optional_i32_identity(wasm.optional_i32_max()), 2147483647); + + assert.strictEqual(wasm.optional_u32_identity(wasm.optional_u32_none()), undefined); + assert.strictEqual(wasm.optional_u32_identity(wasm.optional_u32_zero()), 0); + assert.strictEqual(wasm.optional_u32_identity(wasm.optional_u32_one()), 1); + assert.strictEqual(wasm.optional_u32_identity(wasm.optional_u32_min()), 0); + assert.strictEqual(wasm.optional_u32_identity(wasm.optional_u32_max()), 4294967295); + + assert.strictEqual(wasm.optional_isize_identity(wasm.optional_isize_none()), undefined); + assert.strictEqual(wasm.optional_isize_identity(wasm.optional_isize_zero()), 0); + assert.strictEqual(wasm.optional_isize_identity(wasm.optional_isize_one()), 1); + assert.strictEqual(wasm.optional_isize_identity(wasm.optional_isize_neg_one()), -1); + assert.strictEqual(wasm.optional_isize_identity(wasm.optional_isize_min()), -2147483648); + assert.strictEqual(wasm.optional_isize_identity(wasm.optional_isize_max()), 2147483647); + + assert.strictEqual(wasm.optional_usize_identity(wasm.optional_usize_none()), undefined); + assert.strictEqual(wasm.optional_usize_identity(wasm.optional_usize_zero()), 0); + assert.strictEqual(wasm.optional_usize_identity(wasm.optional_usize_one()), 1); + assert.strictEqual(wasm.optional_usize_identity(wasm.optional_usize_min()), 0); + assert.strictEqual(wasm.optional_usize_identity(wasm.optional_usize_max()), 4294967295); + + assert.strictEqual(wasm.optional_f32_identity(wasm.optional_f32_none()), undefined); + assert.strictEqual(wasm.optional_f32_identity(wasm.optional_f32_zero()), 0); + assert.strictEqual(wasm.optional_f32_identity(wasm.optional_f32_one()), 1); + assert.strictEqual(wasm.optional_f32_identity(wasm.optional_f32_neg_one()), -1); + + assert.strictEqual(wasm.optional_f64_identity(wasm.optional_f64_none()), undefined); + assert.strictEqual(wasm.optional_f64_identity(wasm.optional_f64_zero()), 0); + assert.strictEqual(wasm.optional_f64_identity(wasm.optional_f64_one()), 1); + assert.strictEqual(wasm.optional_f64_identity(wasm.optional_f64_neg_one()), -1); + + assert.strictEqual(wasm.optional_i8_identity(wasm.optional_i8_none()), undefined); + assert.strictEqual(wasm.optional_i8_identity(wasm.optional_i8_zero()), 0); + assert.strictEqual(wasm.optional_i8_identity(wasm.optional_i8_one()), 1); + assert.strictEqual(wasm.optional_i8_identity(wasm.optional_i8_neg_one()), -1); + assert.strictEqual(wasm.optional_i8_identity(wasm.optional_i8_min()), -128); + assert.strictEqual(wasm.optional_i8_identity(wasm.optional_i8_max()), 127); + + assert.strictEqual(wasm.optional_u8_identity(wasm.optional_u8_none()), undefined); + assert.strictEqual(wasm.optional_u8_identity(wasm.optional_u8_zero()), 0); + assert.strictEqual(wasm.optional_u8_identity(wasm.optional_u8_one()), 1); + assert.strictEqual(wasm.optional_u8_identity(wasm.optional_u8_min()), 0); + assert.strictEqual(wasm.optional_u8_identity(wasm.optional_u8_max()), 255); + + assert.strictEqual(wasm.optional_i16_identity(wasm.optional_i16_none()), undefined); + assert.strictEqual(wasm.optional_i16_identity(wasm.optional_i16_zero()), 0); + assert.strictEqual(wasm.optional_i16_identity(wasm.optional_i16_one()), 1); + assert.strictEqual(wasm.optional_i16_identity(wasm.optional_i16_neg_one()), -1); + assert.strictEqual(wasm.optional_i16_identity(wasm.optional_i16_min()), -32768); + assert.strictEqual(wasm.optional_i16_identity(wasm.optional_i16_max()), 32767); + + assert.strictEqual(wasm.optional_u16_identity(wasm.optional_u16_none()), undefined); + assert.strictEqual(wasm.optional_u16_identity(wasm.optional_u16_zero()), 0); + assert.strictEqual(wasm.optional_u16_identity(wasm.optional_u16_one()), 1); + assert.strictEqual(wasm.optional_u16_identity(wasm.optional_u16_min()), 0); + assert.strictEqual(wasm.optional_u16_identity(wasm.optional_u16_max()), 65535); + + assert.strictEqual(wasm.optional_i64_identity(wasm.optional_i64_none()), undefined); + assert.strictEqual(wasm.optional_i64_identity(wasm.optional_i64_zero()), BigInt('0')); + assert.strictEqual(wasm.optional_i64_identity(wasm.optional_i64_one()), BigInt('1')); + assert.strictEqual(wasm.optional_i64_identity(wasm.optional_i64_neg_one()), BigInt('-1')); + assert.strictEqual(wasm.optional_i64_identity(wasm.optional_i64_min()), BigInt('-9223372036854775808')); + assert.strictEqual(wasm.optional_i64_identity(wasm.optional_i64_max()), BigInt('9223372036854775807')); + + assert.strictEqual(wasm.optional_u64_identity(wasm.optional_u64_none()), undefined); + assert.strictEqual(wasm.optional_u64_identity(wasm.optional_u64_zero()), BigInt('0')); + assert.strictEqual(wasm.optional_u64_identity(wasm.optional_u64_one()), BigInt('1')); + assert.strictEqual(wasm.optional_u64_identity(wasm.optional_u64_min()), BigInt('0')); + assert.strictEqual(wasm.optional_u64_identity(wasm.optional_u64_max()), BigInt('18446744073709551615')); + + assert.strictEqual(wasm.optional_bool_identity(wasm.optional_bool_none()), undefined); + assert.strictEqual(wasm.optional_bool_identity(wasm.optional_bool_false()), false); + assert.strictEqual(wasm.optional_bool_identity(wasm.optional_bool_true()), true); + + assert.strictEqual(wasm.optional_char_identity(wasm.optional_char_none()), undefined); + assert.strictEqual(wasm.optional_char_identity(wasm.optional_char_letter()), 'a'); + assert.strictEqual(wasm.optional_char_identity(wasm.optional_char_face()), '😀'); +}; diff --git a/vendor/wasm-bindgen/tests/wasm/optional_primitives.rs b/vendor/wasm-bindgen/tests/wasm/optional_primitives.rs new file mode 100644 index 000000000..b314ae5ce --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/optional_primitives.rs @@ -0,0 +1,442 @@ +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[wasm_bindgen(module = "tests/wasm/optional_primitives.js")] +extern "C" { + fn optional_i32_js_identity(a: Option<i32>) -> Option<i32>; + fn optional_u32_js_identity(a: Option<u32>) -> Option<u32>; + fn optional_isize_js_identity(a: Option<isize>) -> Option<isize>; + fn optional_usize_js_identity(a: Option<usize>) -> Option<usize>; + fn optional_f32_js_identity(a: Option<f32>) -> Option<f32>; + fn optional_f64_js_identity(a: Option<f64>) -> Option<f64>; + fn optional_i8_js_identity(a: Option<i8>) -> Option<i8>; + fn optional_u8_js_identity(a: Option<u8>) -> Option<u8>; + fn optional_i16_js_identity(a: Option<i16>) -> Option<i16>; + fn optional_u16_js_identity(a: Option<u16>) -> Option<u16>; + fn optional_i64_js_identity(a: Option<i64>) -> Option<i64>; + fn optional_u64_js_identity(a: Option<u64>) -> Option<u64>; + fn optional_bool_js_identity(a: Option<bool>) -> Option<bool>; + fn optional_char_js_identity(a: Option<char>) -> Option<char>; + + fn js_works(); +} + +#[wasm_bindgen] +pub fn optional_i32_none() -> Option<i32> { + None +} + +#[wasm_bindgen] +pub fn optional_i32_zero() -> Option<i32> { + Some(0) +} + +#[wasm_bindgen] +pub fn optional_i32_one() -> Option<i32> { + Some(1) +} + +#[wasm_bindgen] +pub fn optional_i32_neg_one() -> Option<i32> { + Some(-1) +} + +#[wasm_bindgen] +pub fn optional_i32_min() -> Option<i32> { + Some(i32::min_value()) +} + +#[wasm_bindgen] +pub fn optional_i32_max() -> Option<i32> { + Some(i32::max_value()) +} + +#[wasm_bindgen] +pub fn optional_i32_identity(a: Option<i32>) -> Option<i32> { + optional_i32_js_identity(a) +} + +#[wasm_bindgen] +pub fn optional_u32_none() -> Option<u32> { + None +} + +#[wasm_bindgen] +pub fn optional_u32_zero() -> Option<u32> { + Some(0) +} + +#[wasm_bindgen] +pub fn optional_u32_one() -> Option<u32> { + Some(1) +} + +#[wasm_bindgen] +pub fn optional_u32_min() -> Option<u32> { + Some(u32::min_value()) +} + +#[wasm_bindgen] +pub fn optional_u32_max() -> Option<u32> { + Some(u32::max_value()) +} + +#[wasm_bindgen] +pub fn optional_u32_identity(a: Option<u32>) -> Option<u32> { + optional_u32_js_identity(a) +} + +#[wasm_bindgen] +pub fn optional_isize_none() -> Option<isize> { + None +} + +#[wasm_bindgen] +pub fn optional_isize_zero() -> Option<isize> { + Some(0) +} + +#[wasm_bindgen] +pub fn optional_isize_one() -> Option<isize> { + Some(1) +} + +#[wasm_bindgen] +pub fn optional_isize_neg_one() -> Option<isize> { + Some(-1) +} + +#[wasm_bindgen] +pub fn optional_isize_min() -> Option<isize> { + Some(isize::min_value()) +} + +#[wasm_bindgen] +pub fn optional_isize_max() -> Option<isize> { + Some(isize::max_value()) +} + +#[wasm_bindgen] +pub fn optional_isize_identity(a: Option<isize>) -> Option<isize> { + optional_isize_js_identity(a) +} + +#[wasm_bindgen] +pub fn optional_usize_none() -> Option<usize> { + None +} + +#[wasm_bindgen] +pub fn optional_usize_zero() -> Option<usize> { + Some(0) +} + +#[wasm_bindgen] +pub fn optional_usize_one() -> Option<usize> { + Some(1) +} + +#[wasm_bindgen] +pub fn optional_usize_min() -> Option<usize> { + Some(usize::min_value()) +} + +#[wasm_bindgen] +pub fn optional_usize_max() -> Option<usize> { + Some(usize::max_value()) +} + +#[wasm_bindgen] +pub fn optional_usize_identity(a: Option<usize>) -> Option<usize> { + optional_usize_js_identity(a) +} + +#[wasm_bindgen] +pub fn optional_f32_none() -> Option<f32> { + None +} + +#[wasm_bindgen] +pub fn optional_f32_zero() -> Option<f32> { + Some(0f32) +} + +#[wasm_bindgen] +pub fn optional_f32_one() -> Option<f32> { + Some(1f32) +} + +#[wasm_bindgen] +pub fn optional_f32_neg_one() -> Option<f32> { + Some(-1f32) +} + +#[wasm_bindgen] +pub fn optional_f32_identity(a: Option<f32>) -> Option<f32> { + optional_f32_js_identity(a) +} + +#[wasm_bindgen] +pub fn optional_f64_none() -> Option<f64> { + None +} + +#[wasm_bindgen] +pub fn optional_f64_zero() -> Option<f64> { + Some(0f64) +} + +#[wasm_bindgen] +pub fn optional_f64_one() -> Option<f64> { + Some(1f64) +} + +#[wasm_bindgen] +pub fn optional_f64_neg_one() -> Option<f64> { + Some(-1f64) +} + +#[wasm_bindgen] +pub fn optional_f64_identity(a: Option<f64>) -> Option<f64> { + optional_f64_js_identity(a) +} + +#[wasm_bindgen] +pub fn optional_i8_none() -> Option<i8> { + None +} + +#[wasm_bindgen] +pub fn optional_i8_zero() -> Option<i8> { + Some(0) +} + +#[wasm_bindgen] +pub fn optional_i8_one() -> Option<i8> { + Some(1) +} + +#[wasm_bindgen] +pub fn optional_i8_neg_one() -> Option<i8> { + Some(-1) +} + +#[wasm_bindgen] +pub fn optional_i8_min() -> Option<i8> { + Some(i8::min_value()) +} + +#[wasm_bindgen] +pub fn optional_i8_max() -> Option<i8> { + Some(i8::max_value()) +} + +#[wasm_bindgen] +pub fn optional_i8_identity(a: Option<i8>) -> Option<i8> { + optional_i8_js_identity(a) +} + +#[wasm_bindgen] +pub fn optional_u8_none() -> Option<u8> { + None +} + +#[wasm_bindgen] +pub fn optional_u8_zero() -> Option<u8> { + Some(0) +} + +#[wasm_bindgen] +pub fn optional_u8_one() -> Option<u8> { + Some(1) +} + +#[wasm_bindgen] +pub fn optional_u8_min() -> Option<u8> { + Some(u8::min_value()) +} + +#[wasm_bindgen] +pub fn optional_u8_max() -> Option<u8> { + Some(u8::max_value()) +} + +#[wasm_bindgen] +pub fn optional_u8_identity(a: Option<u8>) -> Option<u8> { + optional_u8_js_identity(a) +} + +#[wasm_bindgen] +pub fn optional_i16_none() -> Option<i16> { + None +} + +#[wasm_bindgen] +pub fn optional_i16_zero() -> Option<i16> { + Some(0) +} + +#[wasm_bindgen] +pub fn optional_i16_one() -> Option<i16> { + Some(1) +} + +#[wasm_bindgen] +pub fn optional_i16_neg_one() -> Option<i16> { + Some(-1) +} + +#[wasm_bindgen] +pub fn optional_i16_min() -> Option<i16> { + Some(i16::min_value()) +} + +#[wasm_bindgen] +pub fn optional_i16_max() -> Option<i16> { + Some(i16::max_value()) +} + +#[wasm_bindgen] +pub fn optional_i16_identity(a: Option<i16>) -> Option<i16> { + optional_i16_js_identity(a) +} + +#[wasm_bindgen] +pub fn optional_u16_none() -> Option<u16> { + None +} + +#[wasm_bindgen] +pub fn optional_u16_zero() -> Option<u16> { + Some(0) +} + +#[wasm_bindgen] +pub fn optional_u16_one() -> Option<u16> { + Some(1) +} + +#[wasm_bindgen] +pub fn optional_u16_min() -> Option<u16> { + Some(u16::min_value()) +} + +#[wasm_bindgen] +pub fn optional_u16_max() -> Option<u16> { + Some(u16::max_value()) +} + +#[wasm_bindgen] +pub fn optional_u16_identity(a: Option<u16>) -> Option<u16> { + optional_u16_js_identity(a) +} + +#[wasm_bindgen] +pub fn optional_i64_none() -> Option<i64> { + None +} + +#[wasm_bindgen] +pub fn optional_i64_zero() -> Option<i64> { + Some(0) +} + +#[wasm_bindgen] +pub fn optional_i64_one() -> Option<i64> { + Some(1) +} + +#[wasm_bindgen] +pub fn optional_i64_neg_one() -> Option<i64> { + Some(-1) +} + +#[wasm_bindgen] +pub fn optional_i64_min() -> Option<i64> { + Some(i64::min_value()) +} + +#[wasm_bindgen] +pub fn optional_i64_max() -> Option<i64> { + Some(i64::max_value()) +} + +#[wasm_bindgen] +pub fn optional_i64_identity(a: Option<i64>) -> Option<i64> { + optional_i64_js_identity(a) +} + +#[wasm_bindgen] +pub fn optional_u64_none() -> Option<u64> { + None +} + +#[wasm_bindgen] +pub fn optional_u64_zero() -> Option<u64> { + Some(0) +} + +#[wasm_bindgen] +pub fn optional_u64_one() -> Option<u64> { + Some(1) +} + +#[wasm_bindgen] +pub fn optional_u64_min() -> Option<u64> { + Some(u64::min_value()) +} + +#[wasm_bindgen] +pub fn optional_u64_max() -> Option<u64> { + Some(u64::max_value()) +} + +#[wasm_bindgen] +pub fn optional_u64_identity(a: Option<u64>) -> Option<u64> { + optional_u64_js_identity(a) +} + +#[wasm_bindgen] +pub fn optional_bool_none() -> Option<bool> { + None +} + +#[wasm_bindgen] +pub fn optional_bool_false() -> Option<bool> { + Some(false) +} + +#[wasm_bindgen] +pub fn optional_bool_true() -> Option<bool> { + Some(true) +} + +#[wasm_bindgen] +pub fn optional_bool_identity(a: Option<bool>) -> Option<bool> { + optional_bool_js_identity(a) +} + +#[wasm_bindgen] +pub fn optional_char_none() -> Option<char> { + None +} + +#[wasm_bindgen] +pub fn optional_char_letter() -> Option<char> { + Some('a') +} + +#[wasm_bindgen] +pub fn optional_char_face() -> Option<char> { + Some('😀') +} + +#[wasm_bindgen] +pub fn optional_char_identity(a: Option<char>) -> Option<char> { + optional_char_js_identity(a) +} + +#[wasm_bindgen_test] +fn works() { + js_works(); +} diff --git a/vendor/wasm-bindgen/tests/wasm/result.js b/vendor/wasm-bindgen/tests/wasm/result.js new file mode 100644 index 000000000..2bf9f378f --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/result.js @@ -0,0 +1,126 @@ +const wasm = require('wasm-bindgen-test.js'); +const assert = require('assert'); + +exports.error_new = function(message) { + return new Error(message) +} + +exports.call_ok = function() { + assert.doesNotThrow(() => { + let five = wasm.return_my_ok(); + assert.strictEqual(five, 5); + }) +} + +exports.call_err = function() { + assert.throws(() => wasm.return_my_err(), { + message: "MyError::Variant" + }); +} + +function check_inflight(struct) { + assert.strictEqual(struct.is_inflight(), false); +} + +exports.all_struct_methods = function() { + let struct; + assert.throws(() => wasm.Struct.new_err(), { + message: "MyError::Variant" + }); + assert.doesNotThrow(() => { + struct = wasm.Struct.new(); + }); + check_inflight(struct); + assert.doesNotThrow(() => { + let five = struct.return_ok(); + assert.strictEqual(five, 5); + }); + check_inflight(struct); + assert.throws(() => struct.return_err(), { + message: "MyError::Variant" + }); + check_inflight(struct); +} + +exports.call_return_string = function() { + assert.doesNotThrow(() => { + let ok = wasm.return_string(); + assert.strictEqual(ok, "string here"); + }) +} + +exports.call_jsvalue_ok = function() { + assert.doesNotThrow(() => { + let five = wasm.return_jsvalue_ok(); + assert.strictEqual(five, 5); + }) +} + +exports.call_jsvalue_err = function() { + try { + wasm.return_jsvalue_err(); + assert.fail("should have thrown"); + } catch (e) { + assert.strictEqual(e, -1); + } +} + +exports.call_string_ok = function() { + assert.doesNotThrow(() => { + let ok = wasm.return_string_ok(); + assert.strictEqual(ok, "Ok"); + }) +} + +exports.call_string_err = function() { + // the behaviour of Result<String, _> is so finicky that it's not obvious + // how to to reproduce reliably but also pass the test suite. + assert.throws(() => e = wasm.return_string_err(), e => { + // one thing we can do (uncomment to test) + // is to throw an error in here. + // throw new Error("should not cause a SIGBUS in Node") + return e === "Er"; + }); +} + +exports.call_enum_ok = function() { + assert.doesNotThrow(() => { + let ok = wasm.return_enum_ok(); + assert.strictEqual(ok, 2); + }) +} + +exports.call_enum_err = function() { + assert.throws(() => { + wasm.return_enum_err(); + }, { + message: "MyError::Variant" + }) +} + +exports.call_unit = function() { + assert.doesNotThrow(() => { + wasm.return_unit_ok(); + }); + assert.throws(() => { + wasm.return_unit_err(); + }, { + message: "MyError::Variant" + }); +} + +exports.call_option = function() { + assert.doesNotThrow(() => { + let o = wasm.return_option_ok_some(); + assert.strictEqual(o, 10.0); + }); + assert.doesNotThrow(() => { + let o = wasm.return_option_ok_none(); + assert.strictEqual(o, undefined); + }); + assert.throws(() => { + wasm.return_option_err(); + }, { + message: "MyError::Variant" + }); +} diff --git a/vendor/wasm-bindgen/tests/wasm/result.rs b/vendor/wasm-bindgen/tests/wasm/result.rs new file mode 100644 index 000000000..c2c043ab8 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/result.rs @@ -0,0 +1,190 @@ +use std::fmt; +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[derive(Clone, Debug)] +pub enum MyError { + Variant, + InflightShouldBeFalse, +} +// shouldn't technically need this, surely +impl std::error::Error for MyError {} +impl fmt::Display for MyError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "MyError::{:?}", self) + } +} + +#[wasm_bindgen(module = "tests/wasm/result.js")] +extern "C" { + fn error_new(message: &str) -> JsValue; +} + +impl Into<JsValue> for MyError { + fn into(self) -> JsValue { + error_new(&format!("{}", self)) + } +} + +macro_rules! call_test { + ($test_fn:ident, $js_fn:ident) => { + #[wasm_bindgen_test] + fn $test_fn() { + #[wasm_bindgen(module = "tests/wasm/result.js")] + extern "C" { + fn $js_fn(); + } + $js_fn(); + } + }; +} + +#[wasm_bindgen] +pub fn return_my_err() -> Result<i32, MyError> { + let e = Err(MyError::Variant)?; + Ok(e) +} +call_test!(test_err, call_err); + +#[wasm_bindgen] +pub fn return_my_ok() -> Result<i32, MyError> { + Ok(5) +} +call_test!(test_ok, call_ok); + +#[wasm_bindgen] +pub struct Struct { + inflight: bool, +} + +call_test!(test_struct, all_struct_methods); + +struct ResetOnDrop<'a> { + flag: &'a mut bool, +} + +impl<'a> Drop for ResetOnDrop<'a> { + fn drop(&mut self) { + *self.flag = false; + } +} + +impl<'a> ResetOnDrop<'a> { + fn new(flag: &'a mut bool) -> Result<Self, MyError> { + if *flag { + return Err(MyError::InflightShouldBeFalse); + } + Ok(Self { flag }) + } +} + +#[wasm_bindgen] +impl Struct { + #[wasm_bindgen] + pub fn new() -> Result<Struct, MyError> { + Ok(Struct { inflight: false }) + } + + #[wasm_bindgen] + pub fn new_err() -> Result<Struct, MyError> { + Err(MyError::Variant.into()) + } + + #[wasm_bindgen] + pub fn return_ok(&mut self) -> Result<i32, MyError> { + let _guard = ResetOnDrop::new(&mut self.inflight)?; + Ok(5) + } + + #[wasm_bindgen] + pub fn return_err(&mut self) -> Result<i32, MyError> { + let guard = ResetOnDrop::new(&mut self.inflight)?; + let err = Err(MyError::Variant); + let nope = err?; + // we are checking both for the flag being reset (from js, via is_inflight) + // and for the running of drop code + drop(guard); + Ok(nope) + } + + #[wasm_bindgen] + pub fn is_inflight(&self) -> bool { + self.inflight + } +} + +// check some more Ok types +#[wasm_bindgen] +pub fn return_string() -> Result<String, MyError> { + Ok("string here".into()) +} +call_test!(test_return_string, call_return_string); + +// now we check that jsvalue works, as it did before + +#[wasm_bindgen] +pub fn return_jsvalue_ok() -> Result<i32, JsValue> { + Ok(5) +} +call_test!(test_jsvalue_ok, call_jsvalue_ok); + +#[wasm_bindgen] +pub fn return_jsvalue_err() -> Result<i32, JsValue> { + Err(JsValue::from(-1i32)) +} +call_test!(test_jsvalue_err, call_jsvalue_err); + +// test strings (they have a deferred free, in a finally block: tricky) +#[wasm_bindgen] +pub fn return_string_ok() -> Result<String, String> { + Ok("Ok".into()) +} +call_test!(test_string_ok, call_string_ok); +#[wasm_bindgen] +pub fn return_string_err() -> Result<String, String> { + Err("Er".into()) +} +call_test!(test_string_err, call_string_err); + +// test enums +#[wasm_bindgen] +pub enum MyEnum { + One = 1, + Two = 2, +} +#[wasm_bindgen] +pub fn return_enum_ok() -> Result<MyEnum, MyError> { + Ok(MyEnum::Two) +} +call_test!(test_enum_ok, call_enum_ok); +#[wasm_bindgen] +pub fn return_enum_err() -> Result<MyEnum, MyError> { + Err(MyError::Variant) +} +call_test!(test_enum_err, call_enum_err); + +// T = Unit +#[wasm_bindgen] +pub fn return_unit_ok() -> Result<(), MyError> { + Ok(()) +} +#[wasm_bindgen] +pub fn return_unit_err() -> Result<(), MyError> { + Err(MyError::Variant) +} +call_test!(test_unit, call_unit); + +// T = Option<f64> +#[wasm_bindgen] +pub fn return_option_ok_some() -> Result<Option<f64>, MyError> { + Ok(Some(10f64)) +} +#[wasm_bindgen] +pub fn return_option_ok_none() -> Result<Option<f64>, MyError> { + Ok(None) +} +#[wasm_bindgen] +pub fn return_option_err() -> Result<Option<f64>, MyError> { + Err(MyError::Variant) +} +call_test!(test_option, call_option); diff --git a/vendor/wasm-bindgen/tests/wasm/result_jserror.js b/vendor/wasm-bindgen/tests/wasm/result_jserror.js new file mode 100644 index 000000000..d27736d9c --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/result_jserror.js @@ -0,0 +1,54 @@ +const wasm = require('wasm-bindgen-test.js'); +const assert = require('assert'); + +exports.call_ok = function() { + assert.doesNotThrow(() => { + let five = wasm.return_ok(); + assert.strictEqual(five, 5); + }) +} + +exports.call_err = function() { + assert.throws(() => wasm.return_err(), { + message: "MyError::Variant" + }); +} + +exports.call_make_an_error = function() { + assert.doesNotThrow(() => { + let e = wasm.make_an_error() + assert.strictEqual(e.message, "un-thrown error"); + }); +} + +function check_inflight(struct) { + assert.strictEqual(struct.is_inflight(), false); +} + +exports.all_struct_methods = function() { + let struct; + assert.throws(() => wasm.MyStruct.new_err(), { + message: "MyError::Variant" + }); + assert.doesNotThrow(() => { + struct = wasm.MyStruct.new(); + }); + check_inflight(struct); + assert.doesNotThrow(() => { + let five = struct.return_ok(); + assert.strictEqual(five, 5); + }); + check_inflight(struct); + assert.throws(() => struct.return_err(), { + message: "MyError::Variant" + }); + check_inflight(struct); +} + +exports.call_return_string = function() { + assert.doesNotThrow(() => { + let ok = wasm.jserror_return_string(); + assert.strictEqual(ok, "string here"); + }) +} + diff --git a/vendor/wasm-bindgen/tests/wasm/result_jserror.rs b/vendor/wasm-bindgen/tests/wasm/result_jserror.rs new file mode 100644 index 000000000..f714ac2f1 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/result_jserror.rs @@ -0,0 +1,118 @@ +use wasm_bindgen::prelude::*; +use wasm_bindgen::JsError; +use wasm_bindgen_test::*; + +use std::fmt; + +#[derive(Clone, Debug)] +enum MyError { + Variant, + InflightShouldBeFalse, +} +// shouldn't technically need this, surely +impl std::error::Error for MyError {} +impl fmt::Display for MyError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "MyError::{:?}", self) + } +} + +macro_rules! call_test { + ($test_fn:ident, $js_fn:ident) => { + #[wasm_bindgen_test] + fn $test_fn() { + #[wasm_bindgen(module = "tests/wasm/result_jserror.js")] + extern "C" { + fn $js_fn(); + } + $js_fn(); + } + }; +} + +#[wasm_bindgen] +pub fn return_err() -> Result<i32, JsError> { + let e = Err(MyError::Variant)?; + Ok(e) +} +call_test!(test_err, call_err); + +#[wasm_bindgen] +pub fn return_ok() -> Result<i32, JsError> { + Ok(5) +} +call_test!(test_ok, call_ok); + +#[wasm_bindgen] +pub fn make_an_error() -> JsError { + JsError::new("un-thrown error").into() +} +call_test!(test_make_an_error, call_make_an_error); + +#[wasm_bindgen] +pub struct MyStruct { + inflight: bool, +} + +call_test!(test_struct, all_struct_methods); + +struct ResetOnDrop<'a> { + flag: &'a mut bool, +} + +impl<'a> Drop for ResetOnDrop<'a> { + fn drop(&mut self) { + *self.flag = false; + } +} + +impl<'a> ResetOnDrop<'a> { + fn new(flag: &'a mut bool) -> Result<Self, MyError> { + if *flag { + return Err(MyError::InflightShouldBeFalse); + } + Ok(Self { flag }) + } +} + +#[wasm_bindgen] +impl MyStruct { + #[wasm_bindgen] + pub fn new() -> Result<MyStruct, JsError> { + Ok(MyStruct { inflight: false }) + } + + #[wasm_bindgen] + pub fn new_err() -> Result<MyStruct, JsError> { + Err(MyError::Variant.into()) + } + + #[wasm_bindgen] + pub fn return_ok(&mut self) -> Result<i32, JsError> { + let _guard = ResetOnDrop::new(&mut self.inflight)?; + Ok(5) + } + + #[wasm_bindgen] + pub fn return_err(&mut self) -> Result<i32, JsError> { + let guard = ResetOnDrop::new(&mut self.inflight)?; + let err = Err(MyError::Variant); + let nope = err?; + // we are checking both for the flag being reset (from js, via is_inflight) + // and for the running of drop code + drop(guard); + Ok(nope) + } + + #[wasm_bindgen] + pub fn is_inflight(&self) -> bool { + self.inflight + } +} + +// check some more Ok types +#[wasm_bindgen] +pub fn jserror_return_string() -> Result<String, JsError> { + Ok("string here".into()) +} +call_test!(test_return_string, call_return_string); diff --git a/vendor/wasm-bindgen/tests/wasm/rethrow.js b/vendor/wasm-bindgen/tests/wasm/rethrow.js new file mode 100644 index 000000000..70e9c3381 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/rethrow.js @@ -0,0 +1,14 @@ +const wasm = require('wasm-bindgen-test.js'); +const assert = require('assert'); + +exports.call_throw_one = function() { + try { + wasm.throw_one(); + } catch (e) { + assert.strictEqual(e, 1); + } +}; + +exports.call_ok = function() { + wasm.nothrow(); +}; diff --git a/vendor/wasm-bindgen/tests/wasm/rethrow.rs b/vendor/wasm-bindgen/tests/wasm/rethrow.rs new file mode 100644 index 000000000..d2a0ffafd --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/rethrow.rs @@ -0,0 +1,28 @@ +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[wasm_bindgen(module = "tests/wasm/rethrow.js")] +extern "C" { + fn call_throw_one(); + fn call_ok(); +} + +#[wasm_bindgen_test] +fn err_works() { + call_throw_one(); +} + +#[wasm_bindgen] +pub fn throw_one() -> Result<u32, JsValue> { + Err(1.into()) +} + +#[wasm_bindgen_test] +fn ok_works() { + call_ok(); +} + +#[wasm_bindgen] +pub fn nothrow() -> Result<u32, JsValue> { + Ok(1) +} diff --git a/vendor/wasm-bindgen/tests/wasm/simple.js b/vendor/wasm-bindgen/tests/wasm/simple.js new file mode 100644 index 000000000..cf53525e6 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/simple.js @@ -0,0 +1,107 @@ +const assert = require('assert'); +const wasm = require('wasm-bindgen-test'); + +exports.test_add = function() { + assert.strictEqual(wasm.simple_add(1, 2), 3); + assert.strictEqual(wasm.simple_add(2, 3), 5); + assert.strictEqual(wasm.simple_add3(2), 5); + assert.strictEqual(wasm.simple_get2(true), 2); + assert.strictEqual(wasm.simple_return_and_take_bool(true, false), false); +}; + +exports.test_string_arguments = function() { + wasm.simple_assert_foo("foo"); + wasm.simple_assert_foo_and_bar("foo2", "bar"); +}; + +exports.test_return_a_string = function() { + assert.strictEqual(wasm.simple_clone("foo"), "foo"); + assert.strictEqual(wasm.simple_clone("another"), "another"); + assert.strictEqual(wasm.simple_concat("a", "b", 3), "a b 3"); + assert.strictEqual(wasm.simple_concat("c", "d", -2), "c d -2"); +}; + +exports.test_wrong_types = function() { + // this test only works when `--debug` is passed to `wasm-bindgen` (or the + // equivalent thereof) + if (require('process').env.WASM_BINDGEN_NO_DEBUG) + return; + assert.throws(() => wasm.simple_int('a'), /expected a number argument/); + assert.throws(() => wasm.simple_str(3), /expected a string argument/); +}; + +exports.test_other_exports_still_available = function() { + require('wasm-bindgen-test').__wasm.foo(3); +}; + +exports.test_jsvalue_typeof = function() { + assert.ok(wasm.is_object({})); + assert.ok(!wasm.is_object(42)); + assert.ok(wasm.is_function(function() {})); + assert.ok(!wasm.is_function(42)); + assert.ok(wasm.is_string("2b or !2b")); + assert.ok(!wasm.is_string(42)); +}; + +exports.optional_str_none = function(x) { + assert.strictEqual(x, undefined); +}; + +exports.optional_str_some = function(x) { + assert.strictEqual(x, 'x'); +}; + +exports.optional_slice_none = function(x) { + assert.strictEqual(x, undefined); +}; + +exports.optional_slice_some = function(x) { + assert.strictEqual(x.length, 3); + assert.strictEqual(x[0], 1); + assert.strictEqual(x[1], 2); + assert.strictEqual(x[2], 3); +} + +exports.optional_string_none = function(x) { + assert.strictEqual(x, undefined); +}; + +exports.optional_string_some = function(x) { + assert.strictEqual(x, 'abcd'); +}; + +exports.optional_string_some_empty = function(x) { + assert.strictEqual(x, ''); +}; + +exports.return_string_none = function() {}; +exports.return_string_some = function() { + return 'foo'; +}; + +exports.test_rust_optional = function() { + wasm.take_optional_str_none(); + wasm.take_optional_str_none(null); + wasm.take_optional_str_none(undefined); + wasm.take_optional_str_some('hello'); + assert.strictEqual(wasm.return_optional_str_none(), undefined); + assert.strictEqual(wasm.return_optional_str_some(), 'world'); +}; + +exports.RenamedInRust = class {}; +exports.new_renamed = () => new exports.RenamedInRust; + +exports.import_export_same_name = () => {}; + +exports.test_string_roundtrip = () => { + const test = s => { + assert.strictEqual(wasm.do_string_roundtrip(s), s); + }; + + test(''); + test('a'); + test('💖'); + + test('a longer string'); + test('a longer 💖 string'); +}; diff --git a/vendor/wasm-bindgen/tests/wasm/simple.rs b/vendor/wasm-bindgen/tests/wasm/simple.rs new file mode 100644 index 000000000..611b5320a --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/simple.rs @@ -0,0 +1,227 @@ +use wasm_bindgen::prelude::*; +use wasm_bindgen::{intern, unintern, JsCast}; +use wasm_bindgen_test::*; + +#[wasm_bindgen(module = "tests/wasm/simple.js")] +extern "C" { + fn test_add(); + fn test_string_arguments(); + fn test_return_a_string(); + fn test_wrong_types(); + fn test_other_exports_still_available(); + fn test_jsvalue_typeof(); + + fn optional_str_none(a: Option<&str>); + fn optional_str_some(a: Option<&str>); + fn optional_slice_none(a: Option<&[u8]>); + fn optional_slice_some(a: Option<&[u8]>); + fn optional_string_none(a: Option<String>); + fn optional_string_some(a: Option<String>); + fn optional_string_some_empty(a: Option<String>); + fn return_string_none() -> Option<String>; + fn return_string_some() -> Option<String>; + fn test_rust_optional(); + #[wasm_bindgen(js_name = import_export_same_name)] + fn js_import_export_same_name(); + + #[wasm_bindgen(js_name = RenamedInRust)] + type Renamed; + fn new_renamed() -> Renamed; + + fn test_string_roundtrip(); +} + +#[wasm_bindgen_test] +fn add() { + test_add(); +} + +#[wasm_bindgen] +pub fn simple_add(a: u32, b: u32) -> u32 { + a + b +} + +#[wasm_bindgen] +pub fn simple_add3(a: u32) -> u32 { + a + 3 +} + +#[wasm_bindgen] +pub fn simple_get2(_b: bool) -> u32 { + 2 +} + +#[wasm_bindgen] +pub fn simple_return_and_take_bool(a: bool, b: bool) -> bool { + a && b +} + +#[wasm_bindgen] +pub fn simple_raw_pointers_work(a: *mut u32, b: *const u8) -> *const u32 { + unsafe { + (*a) = (*b) as u32; + return a; + } +} + +#[wasm_bindgen_test] +fn string_arguments() { + test_string_arguments(); +} + +#[wasm_bindgen] +pub fn simple_assert_foo_and_bar(a: &str, b: &str) { + assert_eq!(a, "foo2"); + assert_eq!(b, "bar"); +} + +#[wasm_bindgen] +pub fn simple_assert_foo(a: &str) { + assert_eq!(a, "foo"); +} + +#[wasm_bindgen_test] +fn return_a_string() { + test_return_a_string(); +} + +#[wasm_bindgen] +pub fn simple_clone(a: &str) -> String { + a.to_string() +} + +#[wasm_bindgen] +pub fn simple_concat(a: &str, b: &str, c: i8) -> String { + format!("{} {} {}", a, b, c) +} + +#[wasm_bindgen_test] +fn wrong_types() { + test_wrong_types(); +} + +#[wasm_bindgen] +pub fn simple_int(_a: u32) {} + +#[wasm_bindgen] +pub fn simple_str(_a: &str) {} + +#[wasm_bindgen_test] +fn other_exports() { + test_other_exports_still_available(); +} + +#[no_mangle] +pub extern "C" fn foo(_a: u32) {} + +#[wasm_bindgen_test] +fn jsvalue_typeof() { + test_jsvalue_typeof(); +} + +#[wasm_bindgen] +pub fn is_object(val: &JsValue) -> bool { + val.is_object() +} + +#[wasm_bindgen] +pub fn is_function(val: &JsValue) -> bool { + val.is_function() +} + +#[wasm_bindgen] +pub fn is_string(val: &JsValue) -> bool { + val.is_string() +} + +#[wasm_bindgen] +extern "C" { + #[derive(Clone)] + type Array; + #[wasm_bindgen(constructor)] + fn new() -> Array; + #[wasm_bindgen(method, catch)] + fn standardized_method_this_js_runtime_doesnt_implement_yet( + this: &Array, + ) -> Result<(), JsValue>; +} + +#[wasm_bindgen_test] +fn binding_to_unimplemented_apis_doesnt_break_everything() { + let array = Array::new(); + let res = array.standardized_method_this_js_runtime_doesnt_implement_yet(); + assert!(res.is_err()); +} + +#[wasm_bindgen_test] +fn optional_slices() { + optional_str_none(None); + optional_str_some(Some("x")); + optional_str_some(Some(intern("x"))); + unintern("x"); + optional_str_some(Some("x")); + optional_slice_none(None); + optional_slice_some(Some(&[1, 2, 3])); + optional_string_none(None); + optional_string_some_empty(Some(String::new())); + optional_string_some(Some("abcd".to_string())); + + assert_eq!(return_string_none(), None); + assert_eq!(return_string_some(), Some("foo".to_string())); + test_rust_optional(); +} + +#[wasm_bindgen] +pub fn take_optional_str_none(x: Option<String>) { + assert!(x.is_none()) +} +#[wasm_bindgen] +pub fn take_optional_str_some(x: Option<String>) { + assert_eq!(x, Some(String::from("hello"))); +} + +#[wasm_bindgen] +pub fn return_optional_str_none() -> Option<String> { + None +} + +#[wasm_bindgen] +pub fn return_optional_str_some() -> Option<String> { + Some("world".to_string()) +} + +#[wasm_bindgen_test] +fn renaming_imports_and_instanceof() { + let null = JsValue::NULL; + assert!(!null.is_instance_of::<Renamed>()); + + let arr: JsValue = Array::new().into(); + assert!(!arr.is_instance_of::<Renamed>()); + + let renamed: JsValue = new_renamed().into(); + assert!(renamed.is_instance_of::<Renamed>()); +} + +#[wasm_bindgen] +pub fn import_export_same_name() { + js_import_export_same_name(); +} + +#[wasm_bindgen_test] +fn string_roundtrip() { + test_string_roundtrip(); +} + +#[wasm_bindgen] +pub fn do_string_roundtrip(s: String) -> String { + s +} + +#[wasm_bindgen_test] +fn externref_heap_live_count() { + let x = wasm_bindgen::externref_heap_live_count(); + let y = JsValue::null().clone(); + assert!(wasm_bindgen::externref_heap_live_count() > x); + drop(y); + assert_eq!(x, wasm_bindgen::externref_heap_live_count()); +} diff --git a/vendor/wasm-bindgen/tests/wasm/slice.js b/vendor/wasm-bindgen/tests/wasm/slice.js new file mode 100644 index 000000000..c23535e9b --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/slice.js @@ -0,0 +1,197 @@ +const wasm = require('wasm-bindgen-test.js'); +const assert = require('assert'); + +exports.js_export = () => { + const i8 = new Int8Array(2); + i8[0] = 1; + i8[1] = 2; + assert.deepStrictEqual(wasm.export_i8(i8), i8); + const u8 = new Uint8Array(2); + u8[0] = 1; + u8[1] = 2; + assert.deepStrictEqual(wasm.export_u8(u8), u8); + + const i16 = new Int16Array(2); + i16[0] = 1; + i16[1] = 2; + assert.deepStrictEqual(wasm.export_i16(i16), i16); + const u16 = new Uint16Array(2); + u16[0] = 1; + u16[1] = 2; + assert.deepStrictEqual(wasm.export_u16(u16), u16); + + const i32 = new Int32Array(2); + i32[0] = 1; + i32[1] = 2; + assert.deepStrictEqual(wasm.export_i32(i32), i32); + assert.deepStrictEqual(wasm.export_isize(i32), i32); + const u32 = new Uint32Array(2); + u32[0] = 1; + u32[1] = 2; + assert.deepStrictEqual(wasm.export_u32(u32), u32); + assert.deepStrictEqual(wasm.export_usize(u32), u32); + + const f32 = new Float32Array(2); + f32[0] = 1; + f32[1] = 2; + assert.deepStrictEqual(wasm.export_f32(f32), f32); + const f64 = new Float64Array(2); + f64[0] = 1; + f64[1] = 2; + assert.deepStrictEqual(wasm.export_f64(f64), f64); +}; + +const test_import = (a, b, c) => { + assert.strictEqual(a.length, 2); + assert.strictEqual(a[0], 1); + assert.strictEqual(a[1], 2); + assert.strictEqual(b.length, 2); + assert.strictEqual(b[0], 1); + assert.strictEqual(b[1], 2); + assert.strictEqual(c, undefined); + return a; +}; + +exports.import_js_i8 = test_import; +exports.import_js_u8 = test_import; +exports.import_js_i16 = test_import; +exports.import_js_u16 = test_import; +exports.import_js_i32 = test_import; +exports.import_js_isize = test_import; +exports.import_js_u32 = test_import; +exports.import_js_usize = test_import; +exports.import_js_f32 = test_import; +exports.import_js_f64 = test_import; + +exports.js_import = () => { + const i8 = new Int8Array(2); + i8[0] = 1; + i8[1] = 2; + assert.deepStrictEqual(wasm.import_rust_i8(i8), i8); + const u8 = new Uint8Array(2); + u8[0] = 1; + u8[1] = 2; + assert.deepStrictEqual(wasm.import_rust_u8(u8), u8); + + const i16 = new Int16Array(2); + i16[0] = 1; + i16[1] = 2; + assert.deepStrictEqual(wasm.import_rust_i16(i16), i16); + const u16 = new Uint16Array(2); + u16[0] = 1; + u16[1] = 2; + assert.deepStrictEqual(wasm.import_rust_u16(u16), u16); + + const i32 = new Int32Array(2); + i32[0] = 1; + i32[1] = 2; + assert.deepStrictEqual(wasm.import_rust_i32(i32), i32); + assert.deepStrictEqual(wasm.import_rust_isize(i32), i32); + const u32 = new Uint32Array(2); + u32[0] = 1; + u32[1] = 2; + assert.deepStrictEqual(wasm.import_rust_u32(u32), u32); + assert.deepStrictEqual(wasm.import_rust_usize(u32), u32); + + const f32 = new Float32Array(2); + f32[0] = 1; + f32[1] = 2; + assert.deepStrictEqual(wasm.import_rust_f32(f32), f32); + const f64 = new Float64Array(2); + f64[0] = 1; + f64[1] = 2; + assert.deepStrictEqual(wasm.import_rust_f64(f64), f64); +}; + +exports.js_pass_array = () => { + wasm.pass_array_rust_i8([1, 2]); + wasm.pass_array_rust_u8([1, 2]); + wasm.pass_array_rust_i16([1, 2]); + wasm.pass_array_rust_u16([1, 2]); + wasm.pass_array_rust_i32([1, 2]); + wasm.pass_array_rust_u32([1, 2]); + wasm.pass_array_rust_isize([1, 2]); + wasm.pass_array_rust_usize([1, 2]); + wasm.pass_array_rust_f32([1, 2]); + wasm.pass_array_rust_f64([1, 2]); +}; + +const import_mut_foo = (a, b, c) => { + assert.strictEqual(a.length, 3); + assert.strictEqual(a[0], 1); + assert.strictEqual(a[1], 2); + a[0] = 4; + a[1] = 5; + assert.strictEqual(b.length, 3); + assert.strictEqual(b[0], 4); + assert.strictEqual(b[1], 5); + assert.strictEqual(b[2], 6); + b[0] = 8; + b[1] = 7; + assert.strictEqual(c, undefined); +}; + +exports.import_mut_js_i8 = import_mut_foo; +exports.import_mut_js_u8 = import_mut_foo; +exports.import_mut_js_i16 = import_mut_foo; +exports.import_mut_js_u16 = import_mut_foo; +exports.import_mut_js_i32 = import_mut_foo; +exports.import_mut_js_u32 = import_mut_foo; +exports.import_mut_js_isize = import_mut_foo; +exports.import_mut_js_usize = import_mut_foo; +exports.import_mut_js_f32 = import_mut_foo; +exports.import_mut_js_f64 = import_mut_foo; + +const export_mut_run = (a, rust) => { + assert.strictEqual(a.length, 3); + a[0] = 1; + a[1] = 2; + a[2] = 3; + console.log(a); + rust(a); + console.log(a); + assert.strictEqual(a.length, 3); + assert.strictEqual(a[0], 4); + assert.strictEqual(a[1], 5); + assert.strictEqual(a[2], 3); +}; + +exports.js_export_mut = () => { + export_mut_run(new Int8Array(3), wasm.export_mut_i8); + export_mut_run(new Uint8Array(3), wasm.export_mut_u8); + export_mut_run(new Int16Array(3), wasm.export_mut_i16); + export_mut_run(new Uint16Array(3), wasm.export_mut_u16); + export_mut_run(new Int32Array(3), wasm.export_mut_i32); + export_mut_run(new Uint32Array(3), wasm.export_mut_u32); + export_mut_run(new Int32Array(3), wasm.export_mut_isize); + export_mut_run(new Uint32Array(3), wasm.export_mut_usize); + export_mut_run(new Float32Array(3), wasm.export_mut_f32); + export_mut_run(new Float64Array(3), wasm.export_mut_f64); +}; + +exports.js_return_vec = () => { + const app = wasm.return_vec_web_main(); + + for (let i = 0; i < 10; i++) { + app.tick(); + const bad = wasm.return_vec_broken_vec(); + console.log('Received from rust:', i, bad); + assert.strictEqual(bad[0], 1); + assert.strictEqual(bad[1], 2); + assert.strictEqual(bad[2], 3); + assert.strictEqual(bad[3], 4); + assert.strictEqual(bad[4], 5); + assert.strictEqual(bad[5], 6); + assert.strictEqual(bad[6], 7); + assert.strictEqual(bad[7], 8); + assert.strictEqual(bad[8], 9); + } +}; + +exports.js_clamped = (a, offset) => { + assert.ok(a instanceof Uint8ClampedArray); + assert.equal(a.length, 3); + assert.equal(a[0], offset + 0); + assert.equal(a[1], offset + 1); + assert.equal(a[2], offset + 2); +}; diff --git a/vendor/wasm-bindgen/tests/wasm/slice.rs b/vendor/wasm-bindgen/tests/wasm/slice.rs new file mode 100644 index 000000000..2f2457bc1 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/slice.rs @@ -0,0 +1,240 @@ +use wasm_bindgen::prelude::*; +use wasm_bindgen::Clamped; +use wasm_bindgen_test::*; + +#[wasm_bindgen(module = "tests/wasm/slice.js")] +extern "C" { + fn js_export(); + + fn js_import(); + + fn js_pass_array(); + + fn js_export_mut(); + + fn js_return_vec(); + + fn js_clamped(val: Clamped<&[u8]>, offset: u8); + #[wasm_bindgen(js_name = js_clamped)] + fn js_clamped2(val: Clamped<Vec<u8>>, offset: u8); + #[wasm_bindgen(js_name = js_clamped)] + fn js_clamped3(val: Clamped<&mut [u8]>, offset: u8); +} + +macro_rules! export_macro { + ($(($i:ident, $n:ident))*) => ($( + #[wasm_bindgen] + pub fn $n(a: &[$i]) -> Vec<$i> { + assert_eq!(a.len(), 2); + assert_eq!(a[0], 1 as $i); + assert_eq!(a[1], 2 as $i); + a.to_vec() + } + )*) +} + +export_macro! { + (i8, export_i8) + (u8, export_u8) + (i16, export_i16) + (u16, export_u16) + (i32, export_i32) + (u32, export_u32) + (isize, export_isize) + (usize, export_usize) + (f32, export_f32) + (f64, export_f64) +} + +#[wasm_bindgen_test] +fn export() { + js_export(); +} + +macro_rules! import_macro { + ($(($rust:ident, $js:ident, $i:ident))*) => ($( + #[wasm_bindgen(module = "tests/wasm/slice.js")] + extern "C" { + fn $js(a: &[$i], b: Option<&[$i]>, c: Option<&[$i]>) -> Vec<$i>; + } + + #[wasm_bindgen] + pub fn $rust(a: &[$i]) -> Vec<$i> { + assert_eq!(a.len(), 2); + assert_eq!(a[0], 1 as $i); + assert_eq!(a[1], 2 as $i); + $js(a, Some(a), None) + } + )*) +} + +import_macro! { + (import_rust_i8, import_js_i8, i8) + (import_rust_u8, import_js_u8, u8) + (import_rust_i16, import_js_i16, i16) + (import_rust_u16, import_js_u16, u16) + (import_rust_i32, import_js_i32, i32) + (import_rust_u32, import_js_u32, u32) + (import_rust_isize, import_js_isize, isize) + (import_rust_usize, import_js_usize, usize) + (import_rust_f32, import_js_f32, f32) + (import_rust_f64, import_js_f64, f64) +} + +#[wasm_bindgen_test] +fn import() { + js_import(); +} + +macro_rules! pass_array_marco { + ($(($rust:ident, $i:ident))*) => ($( + #[wasm_bindgen] + pub fn $rust(a: &[$i]) { + assert_eq!(a.len(), 2); + assert_eq!(a[0], 1 as $i); + assert_eq!(a[1], 2 as $i); + } + )*) +} + +pass_array_marco! { + (pass_array_rust_i8, i8) + (pass_array_rust_u8, u8) + (pass_array_rust_i16, i16) + (pass_array_rust_u16, u16) + (pass_array_rust_i32, i32) + (pass_array_rust_u32, u32) + (pass_array_rust_isize, isize) + (pass_array_rust_usize, usize) + (pass_array_rust_f32, f32) + (pass_array_rust_f64, f64) +} + +#[wasm_bindgen_test] +fn pass_array() { + js_pass_array(); +} + +macro_rules! import_mut_macro { + ($(($rust:ident, $js:ident, $i:ident))*) => ( + $( + #[wasm_bindgen(module = "tests/wasm/slice.js")] + extern "C" { + fn $js(a: &mut [$i], b: Option<&mut [$i]>, c: Option<&mut [$i]>); + } + + fn $rust() { + let mut buf1 = [ + 1 as $i, + 2 as $i, + 3 as $i, + ]; + let mut buf2 = [ + 4 as $i, + 5 as $i, + 6 as $i, + ]; + $js(&mut buf1, Some(&mut buf2), None); + assert_eq!(buf1[0], 4 as $i); + assert_eq!(buf1[1], 5 as $i); + assert_eq!(buf1[2], 3 as $i); + assert_eq!(buf2[0], 8 as $i); + assert_eq!(buf2[1], 7 as $i); + assert_eq!(buf2[2], 6 as $i); + } + )* + + #[wasm_bindgen_test] + fn import_mut() { + $($rust();)* + } + ) +} + +import_mut_macro! { + (import_mut_rust_i8, import_mut_js_i8, i8) + (import_mut_rust_u8, import_mut_js_u8, u8) + (import_mut_rust_i16, import_mut_js_i16, i16) + (import_mut_rust_u16, import_mut_js_u16, u16) + (import_mut_rust_i32, import_mut_js_i32, i32) + (import_mut_rust_u32, import_mut_js_u32, u32) + (import_mut_rust_f32, import_mut_js_f32, f32) + (import_mut_rust_f64, import_mut_js_f64, f64) +} + +macro_rules! export_mut_macro { + ($(($i:ident, $n:ident))*) => ($( + #[wasm_bindgen] + pub fn $n(a: &mut [$i]) { + assert_eq!(a.len(), 3); + assert_eq!(a[0], 1 as $i); + assert_eq!(a[1], 2 as $i); + assert_eq!(a[2], 3 as $i); + a[0] = 4 as $i; + a[1] = 5 as $i; + } + )*) +} + +export_mut_macro! { + (i8, export_mut_i8) + (u8, export_mut_u8) + (i16, export_mut_i16) + (u16, export_mut_u16) + (i32, export_mut_i32) + (u32, export_mut_u32) + (isize, export_mut_isize) + (usize, export_mut_usize) + (f32, export_mut_f32) + (f64, export_mut_f64) +} + +#[wasm_bindgen_test] +fn export_mut() { + js_export_mut(); +} + +#[wasm_bindgen] +pub fn return_vec_broken_vec() -> Vec<u32> { + vec![1, 2, 3, 4, 5, 6, 7, 8, 9] +} + +#[wasm_bindgen] +pub fn return_vec_web_main() -> ReturnVecApplication { + ReturnVecApplication::new() +} + +#[wasm_bindgen] +pub struct ReturnVecApplication { + thing: Vec<u32>, +} + +#[wasm_bindgen] +impl ReturnVecApplication { + pub fn new() -> ReturnVecApplication { + let mut thing = vec![]; + thing.push(0); + thing.push(0); + thing.push(0); + thing.push(0); + thing.push(0); + + ReturnVecApplication { thing } + } + + pub fn tick(&mut self) { + self.thing = self.thing.clone(); + } +} + +#[wasm_bindgen_test] +fn return_vec() { + js_return_vec(); +} + +#[wasm_bindgen_test] +fn take_clamped() { + js_clamped(Clamped(&[1, 2, 3]), 1); + js_clamped2(Clamped(vec![4, 5, 6]), 4); + js_clamped3(Clamped(&mut [7, 8, 9]), 7); +} diff --git a/vendor/wasm-bindgen/tests/wasm/structural.js b/vendor/wasm-bindgen/tests/wasm/structural.js new file mode 100644 index 000000000..0261c50e1 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/structural.js @@ -0,0 +1,13 @@ +const wasm = require('wasm-bindgen-test.js'); +const assert = require('assert'); + +exports.js_works = () => { + let called = false; + wasm.run({ + bar() { + called = true; + }, + baz: 1, + }); + assert.strictEqual(called, true); +}; diff --git a/vendor/wasm-bindgen/tests/wasm/structural.rs b/vendor/wasm-bindgen/tests/wasm/structural.rs new file mode 100644 index 000000000..5066156c6 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/structural.rs @@ -0,0 +1,32 @@ +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[wasm_bindgen(module = "tests/wasm/structural.js")] +extern "C" { + fn js_works(); +} + +#[wasm_bindgen] +extern "C" { + pub type StructuralFoo; + + #[wasm_bindgen(method, structural)] + fn bar(this: &StructuralFoo); + #[wasm_bindgen(method, getter, structural)] + fn baz(this: &StructuralFoo) -> u32; + #[wasm_bindgen(method, setter, structural)] + fn set_baz(this: &StructuralFoo, val: u32); +} + +#[wasm_bindgen] +pub fn run(a: &StructuralFoo) { + a.bar(); + assert_eq!(a.baz(), 1); + a.set_baz(2); + assert_eq!(a.baz(), 2); +} + +#[wasm_bindgen_test] +fn works() { + js_works(); +} diff --git a/vendor/wasm-bindgen/tests/wasm/truthy_falsy.rs b/vendor/wasm-bindgen/tests/wasm/truthy_falsy.rs new file mode 100644 index 000000000..d04abb053 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/truthy_falsy.rs @@ -0,0 +1,28 @@ +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[wasm_bindgen_test] +fn test_is_truthy() { + assert_eq!(JsValue::from(0).is_truthy(), false); + assert_eq!(JsValue::from("".to_string()).is_truthy(), false); + assert_eq!(JsValue::from(false).is_truthy(), false); + assert_eq!(JsValue::NULL.is_truthy(), false); + assert_eq!(JsValue::UNDEFINED.is_truthy(), false); + + assert_eq!(JsValue::from(10).is_truthy(), true); + assert_eq!(JsValue::from("null".to_string()).is_truthy(), true); + assert_eq!(JsValue::from(true).is_truthy(), true); +} + +#[wasm_bindgen_test] +fn test_is_falsy() { + assert_eq!(JsValue::from(0).is_falsy(), true); + assert_eq!(JsValue::from("".to_string()).is_falsy(), true); + assert_eq!(JsValue::from(false).is_falsy(), true); + assert_eq!(JsValue::NULL.is_falsy(), true); + assert_eq!(JsValue::UNDEFINED.is_falsy(), true); + + assert_eq!(JsValue::from(10).is_falsy(), false); + assert_eq!(JsValue::from("null".to_string()).is_falsy(), false); + assert_eq!(JsValue::from(true).is_falsy(), false); +} diff --git a/vendor/wasm-bindgen/tests/wasm/usize.js b/vendor/wasm-bindgen/tests/wasm/usize.js new file mode 100644 index 000000000..a1e0723e8 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/usize.js @@ -0,0 +1,39 @@ +const wasm = require('wasm-bindgen-test.js'); +const assert = require('assert'); + +exports.isize_js_identity = a => a; +exports.usize_js_identity = a => a; + +exports.js_works = async () => { + assert.strictEqual(wasm.usize_zero(), 0); + assert.strictEqual(wasm.usize_one(), 1); + assert.strictEqual(wasm.isize_neg_one(), -1); + assert.strictEqual(wasm.isize_i32_min(), -2147483648); + assert.strictEqual(wasm.isize_min(), -2147483648); + assert.strictEqual(wasm.usize_u32_max(), 4294967295); + assert.strictEqual(wasm.usize_max(), 4294967295); + + assert.strictEqual(wasm.isize_rust_identity(0), 0); + assert.strictEqual(wasm.isize_rust_identity(1), 1); + assert.strictEqual(wasm.isize_rust_identity(-1), -1); + assert.strictEqual(wasm.usize_rust_identity(0), 0); + assert.strictEqual(wasm.usize_rust_identity(1), 1); + + const usize_max = 4294967295; + const isize_min = -2147483648; + assert.strictEqual(wasm.isize_rust_identity(isize_min), isize_min); + assert.strictEqual(wasm.usize_rust_identity(usize_max), usize_max); + + assert.deepStrictEqual(wasm.usize_slice([]), new Uint32Array()); + assert.deepStrictEqual(wasm.isize_slice([]), new Int32Array()); + const arr1 = new Uint32Array([1, 2]); + assert.deepStrictEqual(wasm.usize_slice([1, 2]), arr1); + const arr2 = new Int32Array([1, 2]); + assert.deepStrictEqual(wasm.isize_slice([1, 2]), arr2); + + assert.deepStrictEqual(wasm.isize_slice([isize_min]), new Int32Array([isize_min])); + assert.deepStrictEqual(wasm.usize_slice([usize_max]), new Uint32Array([usize_max])); + + assert.deepStrictEqual(await wasm.async_usize_one(), 1); + assert.deepStrictEqual(await wasm.async_isize_neg_one(), -1); +}; diff --git a/vendor/wasm-bindgen/tests/wasm/usize.rs b/vendor/wasm-bindgen/tests/wasm/usize.rs new file mode 100644 index 000000000..80395d21e --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/usize.rs @@ -0,0 +1,79 @@ +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[wasm_bindgen(module = "tests/wasm/usize.js")] +extern "C" { + fn isize_js_identity(a: isize) -> isize; + fn usize_js_identity(a: usize) -> usize; + fn js_works(); +} + +#[wasm_bindgen] +pub fn usize_zero() -> usize { + 0 +} + +#[wasm_bindgen] +pub fn usize_one() -> usize { + 1 +} + +#[wasm_bindgen] +pub fn isize_neg_one() -> isize { + -1 +} + +#[wasm_bindgen] +pub fn isize_i32_min() -> isize { + i32::min_value() as isize +} + +#[wasm_bindgen] +pub fn usize_u32_max() -> usize { + u32::max_value() as usize +} + +#[wasm_bindgen] +pub fn isize_min() -> isize { + isize::min_value() +} + +#[wasm_bindgen] +pub fn usize_max() -> usize { + usize::max_value() +} + +#[wasm_bindgen] +pub fn isize_rust_identity(a: isize) -> isize { + isize_js_identity(a) +} + +#[wasm_bindgen] +pub fn usize_rust_identity(a: usize) -> usize { + usize_js_identity(a) +} + +#[wasm_bindgen] +pub fn isize_slice(a: &[isize]) -> Vec<isize> { + a.to_vec() +} + +#[wasm_bindgen] +pub fn usize_slice(a: &[usize]) -> Vec<usize> { + a.to_vec() +} + +#[wasm_bindgen] +pub async fn async_usize_one() -> usize { + 1 +} + +#[wasm_bindgen] +pub async fn async_isize_neg_one() -> isize { + -1 +} + +#[wasm_bindgen_test] +fn works() { + js_works(); +} diff --git a/vendor/wasm-bindgen/tests/wasm/validate_prt.js b/vendor/wasm-bindgen/tests/wasm/validate_prt.js new file mode 100644 index 000000000..070d71dfa --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/validate_prt.js @@ -0,0 +1,43 @@ +const wasm = require('wasm-bindgen-test.js'); +const assert = require('assert'); + +// NB: `wasm-pack` uses the presence of checks for moved values as a way to test +// whether it is correctly enabling `--debug` when configured to do so, so don't +// change this expected debug output without also updating `wasm-pack`'s tests. +const assertMovedPtrThrows = process.env.WASM_BINDGEN_NO_DEBUG == null + ? f => assert.throws(f, /Attempt to use a moved value/) + : f => assert.throws(f, /null pointer passed to rust/); + +const useMoved = () => { + const apple = new wasm.Fruit('apple'); + apple.name(); + wasm.eat(apple); + assertMovedPtrThrows(() => apple.name()); +}; + +const moveMoved = () => { + const pear = new wasm.Fruit('pear'); + pear.name(); + wasm.eat(pear); + assertMovedPtrThrows(() => wasm.eat(pear)); +}; + +const methodMoved = () => { + const quince = new wasm.Fruit('quince'); + quince.name(); + quince.rot(); + assertMovedPtrThrows(() => quince.rot()); +}; + +exports.js_works = () => { + useMoved(); + moveMoved(); + methodMoved(); + + const a = new wasm.Fruit('a'); + a.prop; + assertMovedPtrThrows(() => a.prop); + const b = new wasm.Fruit('a'); + b.prop = 3; + assertMovedPtrThrows(() => { b.prop = 4; }); +}; diff --git a/vendor/wasm-bindgen/tests/wasm/validate_prt.rs b/vendor/wasm-bindgen/tests/wasm/validate_prt.rs new file mode 100644 index 000000000..84cbf1d95 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/validate_prt.rs @@ -0,0 +1,44 @@ +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[wasm_bindgen(module = "tests/wasm/validate_prt.js")] +extern "C" { + fn js_works(); +} + +#[wasm_bindgen] +pub struct Fruit { + name: String, +} + +#[wasm_bindgen] +impl Fruit { + pub fn name(&self) -> String { + self.name.clone() + } + + #[wasm_bindgen(constructor)] + pub fn new(name: String) -> Self { + Fruit { name } + } + + pub fn rot(self) { + drop(self); + } + + #[wasm_bindgen(getter)] + pub fn prop(self) -> u32 { + 0 + } + + #[wasm_bindgen(setter)] + pub fn set_prop(self, _val: u32) {} +} + +#[wasm_bindgen] +pub fn eat(_: Fruit) {} + +#[wasm_bindgen_test] +fn works() { + js_works(); +} diff --git a/vendor/wasm-bindgen/tests/wasm/variadic.js b/vendor/wasm-bindgen/tests/wasm/variadic.js new file mode 100644 index 000000000..6094bc881 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/variadic.js @@ -0,0 +1,59 @@ +const assert = require('assert'); + +// a function for testing numbers +function variadic_sum(...args) { + let answer = 0; + for(var i=0; i<args.length; i++) { + answer += args[i]; + } + return answer; +} + +exports.variadic_sum_u8 = variadic_sum; +exports.variadic_sum_u16 = variadic_sum; +exports.variadic_sum_u32 = variadic_sum; +exports.variadic_sum_u64 = variadic_sum; +exports.variadic_sum_i8 = variadic_sum; +exports.variadic_sum_i16 = variadic_sum; +exports.variadic_sum_i32 = variadic_sum; +exports.variadic_sum_i64 = variadic_sum; +exports.variadic_sum_f32 = variadic_sum; +exports.variadic_sum_f64 = variadic_sum; +exports.variadic_sum_rest_vec = variadic_sum; + +// a function for testing nullable numbers +function variadic_sum_opt(...args) { + let answer = 0; + for(var i=0; i<args.length; i++) { + if(args[i] != null) { + answer += args[i]; + } + } + return answer; +} + +exports.variadic_sum_opt = variadic_sum_opt; + +// a function for testing strings +function variadic_concat(...args) { + let answer = ""; + for(var i=0; i<args.length; i++) { + answer = `${answer}${args[i]}`; + } + return answer; +} + +exports.variadic_concat_str = variadic_concat; +exports.variadic_concat_string = variadic_concat; + +// a test that takes any type of arguments (for testing JsValue). +function variadic_compare_pairs(...args) { + assert(args.length % 2 == 0, "args must be sequence of pairs"); + for(var i=0; i<args.length; i++) { + const first = args[i++]; + const second = args[i]; + assert.equal(first, second); + } +} + +exports.variadic_compare_pairs = variadic_compare_pairs; diff --git a/vendor/wasm-bindgen/tests/wasm/variadic.rs b/vendor/wasm-bindgen/tests/wasm/variadic.rs new file mode 100644 index 000000000..a55690449 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/variadic.rs @@ -0,0 +1,134 @@ +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[wasm_bindgen(module = "tests/wasm/variadic.js")] +extern "C" { + #[wasm_bindgen(variadic)] + fn variadic_sum_u8(first: u8, second: u8, rest: &[u8]) -> u8; + #[wasm_bindgen(variadic)] + fn variadic_sum_u16(first: u16, second: u16, rest: &[u16]) -> u16; + #[wasm_bindgen(variadic)] + fn variadic_sum_u32(first: u32, second: u32, rest: &[u32]) -> u32; + #[wasm_bindgen(variadic)] + fn variadic_sum_u64(first: u64, second: u64, rest: &[u64]) -> u64; + //#[wasm_bindgen(variadic)] + //fn variadic_sum_usize(first: usize, second: usize, rest: &[usize]) -> usize; + #[wasm_bindgen(variadic)] + fn variadic_sum_i8(first: i8, second: i8, rest: &[i8]) -> i8; + #[wasm_bindgen(variadic)] + fn variadic_sum_i16(first: i16, second: i16, rest: &[i16]) -> i16; + #[wasm_bindgen(variadic)] + fn variadic_sum_i32(first: i32, second: i32, rest: &[i32]) -> i32; + #[wasm_bindgen(variadic)] + fn variadic_sum_i64(first: i64, second: i64, rest: &[i64]) -> i64; + //#[wasm_bindgen(variadic)] + //fn variadic_sum_isize(first: isize, second: isize, rest: &[isize]) -> isize; + #[wasm_bindgen(variadic)] + fn variadic_sum_f32(first: f32, second: f32, rest: &[f32]) -> f32; + #[wasm_bindgen(variadic)] + fn variadic_sum_f64(first: f64, second: f64, rest: &[f64]) -> f64; + //#[wasm_bindgen(variadic)] + //fn variadic_sum_opt(first: Option<u32>, second: Option<u32>, rest: &[Option<u32>]) -> u32; + //#[wasm_bindgen(variadic)] + //fn variadic_concat_str(first: &str, second: &str, rest: &[&str]) -> String; + //#[wasm_bindgen(variadic)] + //fn variadic_concat_string(first: String, + // second: String, + // rest: Vec<String>) -> String; + #[wasm_bindgen(variadic)] + fn variadic_sum_rest_vec(first: u8, second: u8, rest: Vec<u8>) -> u8; + //#[wasm_bindgen(variadic)] + //fn variadic_compare_pairs(first: JsValue, second: JsValue, rest: &[JsValue]); + //TODO imported type +} + +// ints + +macro_rules! variadic_test_int { + ($fn_name:ident, $extern_name:ident) => { + #[wasm_bindgen_test] + fn $fn_name() { + assert_eq!($extern_name(1, 2, &[]), 3); + assert_eq!($extern_name(1, 2, &[3]), 6); + assert_eq!($extern_name(1, 2, &[3, 4]), 10); + } + }; +} + +// The <int>64 tests throw js `Cannot mix BigInt and other types, use explicit conversions` +variadic_test_int!(u8, variadic_sum_u8); +variadic_test_int!(u16, variadic_sum_u16); +variadic_test_int!(u32, variadic_sum_u32); +//variadic_test_int!(u64, variadic_sum_u64); +//variadic_test_int!(usize, variadic_sum_usize); +variadic_test_int!(i8, variadic_sum_i8); +variadic_test_int!(i16, variadic_sum_i16); +variadic_test_int!(i32, variadic_sum_i32); +//variadic_test_int!(i64, variadic_sum_i64); +//variadic_test_int!(isize, variadic_sum_isize); + +// floats + +macro_rules! variadic_test_float { + ($fn_name:ident, $extern_name:ident) => { + #[wasm_bindgen_test] + fn $fn_name() { + assert_eq!($extern_name(1., 2., &[]), 3.); + assert_eq!($extern_name(1., 2., &[3.]), 6.); + assert_eq!($extern_name(1., 2., &[3., 4.]), 10.); + } + }; +} + +variadic_test_float!(f32, variadic_sum_f32); +variadic_test_float!(f64, variadic_sum_f64); + +// strings + +// `the trait `wasm_bindgen::convert::IntoWasmAbi` is not implemented for `&[&str]` +/* +#[wasm_bindgen_test] +fn str() { + assert_eq!(variadic_concat_str("a ", "test", &[]), "a test"); + assert_eq!(variadic_concat_str("a", "nother ", &["test"]), "another test"); + assert_eq!(variadic_concat_str("yet ", "a", &["nother ", "test"]), "yet another test"); +} + +#[wasm_bindgen_test] +fn string() { + assert_eq!(variadic_concat_string("a ".into(), "test".into(), vec![]), "a test"); + assert_eq!(variadic_concat_string("a".into(), "nother ".into(), vec!["test".into()]), + "another test"); + assert_eq!(variadic_concat_string("yet ".into(), + "a".into(), + vec!["nother ".into(), "test".into()]), + "yet another test"); +} +*/ + +// options + +/* +#[wasm_bindgen_test] +fn opt() { + assert_eq!(variadic_sum_opt(Some(1), None, &[]), 1); + assert_eq!(variadic_sum_opt(Some(1), None, &[Some(2)]), 3); + assert_eq!(variadic_sum_opt(Some(1), None, &[None, Some(2)]), 3); +} +*/ + +// vec not slice + +#[wasm_bindgen_test] +fn rest_vec() { + assert_eq!(variadic_sum_rest_vec(1, 2, vec![]), 3); + assert_eq!(variadic_sum_rest_vec(1, 2, vec![3]), 6); + assert_eq!(variadic_sum_rest_vec(1, 2, vec![3, 4]), 10); +} + +// JsValue +//#[wasm_bindgen_test] +//fn jsvalue() { +// variadic_compare_pairs_jsvalue(true, true, vec![]); +// variadic_compare_pairs_jsvalue(false, false, vec![3, 3]); +//} diff --git a/vendor/wasm-bindgen/tests/wasm/vendor_prefix.js b/vendor/wasm-bindgen/tests/wasm/vendor_prefix.js new file mode 100644 index 000000000..a8cd4db15 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/vendor_prefix.js @@ -0,0 +1,11 @@ +exports.import_me = function() {}; + +global.webkitMySpecialApi = class { + foo() { return 123; } +}; +global.MySpecialApi2 = class { + foo() { return 124; } +}; +global.bMySpecialApi3 = class { + foo() { return 125; } +}; diff --git a/vendor/wasm-bindgen/tests/wasm/vendor_prefix.rs b/vendor/wasm-bindgen/tests/wasm/vendor_prefix.rs new file mode 100644 index 000000000..296271906 --- /dev/null +++ b/vendor/wasm-bindgen/tests/wasm/vendor_prefix.rs @@ -0,0 +1,48 @@ +use wasm_bindgen::prelude::*; +use wasm_bindgen_test::*; + +#[wasm_bindgen(module = "tests/wasm/vendor_prefix.js")] +extern "C" { + fn import_me(x: &str); +} + +#[wasm_bindgen] +extern "C" { + #[wasm_bindgen(vendor_prefix = webkit)] + type MySpecialApi; + #[wasm_bindgen(constructor)] + fn new() -> MySpecialApi; + #[wasm_bindgen(method)] + fn foo(this: &MySpecialApi) -> u32; + + #[wasm_bindgen(vendor_prefix = webkit)] + type MySpecialApi2; + #[wasm_bindgen(constructor)] + fn new() -> MySpecialApi2; + #[wasm_bindgen(method)] + fn foo(this: &MySpecialApi2) -> u32; + + #[wasm_bindgen(vendor_prefix = a, vendor_prefix = b)] + type MySpecialApi3; + #[wasm_bindgen(constructor)] + fn new() -> MySpecialApi3; + #[wasm_bindgen(method)] + fn foo(this: &MySpecialApi3) -> u32; + + // This API does not exist at all; + // test that Rust gets a chance to catch the error (#2437) + #[wasm_bindgen(vendor_prefix = a, vendor_prefix = b)] + type MyMissingApi; + #[wasm_bindgen(constructor, catch)] + fn new() -> Result<MyMissingApi, JsValue>; +} + +#[wasm_bindgen_test] +pub fn polyfill_works() { + import_me("foo"); + + assert_eq!(MySpecialApi::new().foo(), 123); + assert_eq!(MySpecialApi2::new().foo(), 124); + assert_eq!(MySpecialApi3::new().foo(), 125); + assert!(MyMissingApi::new().is_err()); +} |