mirror of
https://github.com/rustwasm/wasm-bindgen.git
synced 2024-11-25 19:43:00 +03:00
d9e1dae298
Building on the previous commit to invoke not invoke `npm install` this takes the commit a step further (to hopefully fix some races) to use Webpack's native bundled wasm support. It turns out the circular dependencies between the wasm module and the module using it wasn't quite working out so a number of imports had to be tweaked, but otherwise it's a nice transition where we don't have to base64 encode anything in tests any more!
348 lines
8.7 KiB
Rust
348 lines
8.7 KiB
Rust
extern crate test_support;
|
|
|
|
#[test]
|
|
fn simple() {
|
|
test_support::project()
|
|
.file("src/lib.rs", r#"
|
|
#![feature(proc_macro)]
|
|
|
|
extern crate wasm_bindgen;
|
|
|
|
use wasm_bindgen::prelude::*;
|
|
|
|
#[wasm_bindgen]
|
|
#[no_mangle]
|
|
pub extern fn get_random() -> f64 {
|
|
Math::random()
|
|
}
|
|
|
|
#[wasm_bindgen]
|
|
#[no_mangle]
|
|
pub extern fn do_log(a: f64) -> f64 {
|
|
Math::log(a)
|
|
}
|
|
|
|
#[wasm_bindgen]
|
|
extern {
|
|
type Math;
|
|
#[wasm_bindgen(static = Math)]
|
|
fn random() -> f64;
|
|
#[wasm_bindgen(static = Math)]
|
|
fn log(a: f64) -> f64;
|
|
}
|
|
"#)
|
|
.file("test.ts", r#"
|
|
import * as wasm from "./out";
|
|
import * as assert from "assert";
|
|
|
|
export function test() {
|
|
wasm.get_random();
|
|
assert.strictEqual(wasm.do_log(1.0), Math.log(1.0));
|
|
}
|
|
"#)
|
|
.test();
|
|
}
|
|
|
|
#[test]
|
|
fn import_class() {
|
|
test_support::project()
|
|
.file("src/lib.rs", r#"
|
|
#![feature(proc_macro)]
|
|
|
|
extern crate wasm_bindgen;
|
|
|
|
use wasm_bindgen::prelude::*;
|
|
|
|
#[wasm_bindgen(module = "./another")]
|
|
extern {
|
|
type Foo;
|
|
#[wasm_bindgen(static = Foo)]
|
|
fn bar();
|
|
}
|
|
|
|
#[wasm_bindgen]
|
|
#[no_mangle]
|
|
pub extern fn bar() {
|
|
Foo::bar();
|
|
}
|
|
"#)
|
|
.file("test.ts", r#"
|
|
import { bar } from "./out";
|
|
import { called } from "./another";
|
|
import * as assert from "assert";
|
|
|
|
export function test() {
|
|
bar();
|
|
assert.strictEqual(called, true);
|
|
}
|
|
"#)
|
|
.file("another.ts", r#"
|
|
export let called = false;
|
|
|
|
export class Foo {
|
|
static bar() {
|
|
called = true;
|
|
}
|
|
}
|
|
"#)
|
|
.test();
|
|
}
|
|
|
|
#[test]
|
|
fn construct() {
|
|
test_support::project()
|
|
.file("src/lib.rs", r#"
|
|
#![feature(proc_macro)]
|
|
|
|
extern crate wasm_bindgen;
|
|
|
|
use wasm_bindgen::prelude::*;
|
|
|
|
#[wasm_bindgen(module = "./another")]
|
|
extern {
|
|
type Foo;
|
|
#[wasm_bindgen(static = Foo)]
|
|
fn create() -> Foo;
|
|
#[wasm_bindgen(method)]
|
|
fn get_internal_string(this: &Foo) -> String;
|
|
#[wasm_bindgen(method)]
|
|
fn append_to_internal_string(this: &Foo, s: &str);
|
|
#[wasm_bindgen(method)]
|
|
fn assert_internal_string(this: &Foo, s: &str);
|
|
}
|
|
|
|
#[wasm_bindgen]
|
|
#[no_mangle]
|
|
pub extern fn run() {
|
|
let f = Foo::create();
|
|
assert_eq!(f.get_internal_string(), "this");
|
|
f.append_to_internal_string(" foo");
|
|
f.assert_internal_string("this foo");
|
|
}
|
|
"#)
|
|
.file("test.ts", r#"
|
|
import { run } from "./out";
|
|
import { called } from "./another";
|
|
import * as assert from "assert";
|
|
|
|
export function test() {
|
|
run();
|
|
assert.strictEqual(called, true);
|
|
}
|
|
"#)
|
|
.file("another.ts", r#"
|
|
import * as assert from "assert";
|
|
|
|
export let called = false;
|
|
|
|
export class Foo {
|
|
private internal_string: string = '';
|
|
|
|
static create() {
|
|
const ret = new Foo();
|
|
ret.internal_string = 'this';
|
|
return ret;
|
|
}
|
|
|
|
get_internal_string() {
|
|
return this.internal_string;
|
|
}
|
|
|
|
append_to_internal_string(s: string) {
|
|
this.internal_string += s;
|
|
}
|
|
|
|
assert_internal_string(s: string) {
|
|
assert.strictEqual(this.internal_string, s);
|
|
called = true;
|
|
}
|
|
}
|
|
"#)
|
|
.test();
|
|
}
|
|
|
|
#[test]
|
|
fn new_constructors() {
|
|
test_support::project()
|
|
.file("src/lib.rs", r#"
|
|
#![feature(proc_macro)]
|
|
|
|
extern crate wasm_bindgen;
|
|
|
|
use wasm_bindgen::prelude::*;
|
|
|
|
#[wasm_bindgen(module = "./another")]
|
|
extern {
|
|
type Foo;
|
|
#[wasm_bindgen(constructor)]
|
|
fn new(arg: i32) -> Foo;
|
|
#[wasm_bindgen(method)]
|
|
fn get(this: &Foo) -> i32;
|
|
}
|
|
|
|
#[wasm_bindgen]
|
|
#[no_mangle]
|
|
pub extern fn run() {
|
|
let f = Foo::new(1);
|
|
assert_eq!(f.get(), 2);
|
|
}
|
|
"#)
|
|
.file("test.ts", r#"
|
|
import { run } from "./out";
|
|
|
|
export function test() {
|
|
run();
|
|
}
|
|
"#)
|
|
.file("another.ts", r#"
|
|
export class Foo {
|
|
constructor(private field: number) {
|
|
}
|
|
|
|
get() {
|
|
return this.field + 1;
|
|
}
|
|
}
|
|
"#)
|
|
.test();
|
|
}
|
|
|
|
#[test]
|
|
fn switch_methods() {
|
|
test_support::project()
|
|
.file("src/lib.rs", r#"
|
|
#![feature(proc_macro)]
|
|
|
|
extern crate wasm_bindgen;
|
|
|
|
use wasm_bindgen::prelude::*;
|
|
|
|
#[wasm_bindgen(module = "./another")]
|
|
extern {
|
|
type Foo;
|
|
|
|
#[wasm_bindgen(constructor)]
|
|
fn new() -> Foo;
|
|
|
|
#[wasm_bindgen(static = Foo)]
|
|
fn a();
|
|
|
|
#[wasm_bindgen(method)]
|
|
fn b(this: &Foo);
|
|
}
|
|
|
|
#[wasm_bindgen]
|
|
#[no_mangle]
|
|
pub extern fn a() {
|
|
Foo::a();
|
|
}
|
|
|
|
#[wasm_bindgen]
|
|
#[no_mangle]
|
|
pub extern fn b() {
|
|
Foo::new().b();
|
|
}
|
|
"#)
|
|
.file("test.ts", r#"
|
|
import { a, b } from "./out";
|
|
import { Foo, called } from "./another";
|
|
import * as assert from "assert";
|
|
|
|
export function test() {
|
|
assert.strictEqual(called.a, false);
|
|
a();
|
|
assert.strictEqual(called.a, true);
|
|
called.a = false;
|
|
Foo.a = function() {};
|
|
assert.strictEqual(called.a, false);
|
|
a();
|
|
assert.strictEqual(called.a, true);
|
|
|
|
called.a = false;
|
|
assert.strictEqual(called.a, false);
|
|
b();
|
|
assert.strictEqual(called.a, true);
|
|
called.a = false;
|
|
Foo.prototype.b = function() {};
|
|
assert.strictEqual(called.a, false);
|
|
b();
|
|
assert.strictEqual(called.a, true);
|
|
}
|
|
"#)
|
|
.file("another.ts", r#"
|
|
export let called = { a: false };
|
|
|
|
export class Foo {
|
|
constructor() {
|
|
}
|
|
|
|
static a() {
|
|
called.a = true;
|
|
}
|
|
|
|
b() {
|
|
called.a = true;
|
|
}
|
|
}
|
|
"#)
|
|
.test();
|
|
}
|
|
|
|
#[test]
|
|
fn properties() {
|
|
test_support::project()
|
|
.file("src/lib.rs", r#"
|
|
#![feature(proc_macro)]
|
|
|
|
extern crate wasm_bindgen;
|
|
|
|
use wasm_bindgen::prelude::*;
|
|
|
|
#[wasm_bindgen(module = "./another")]
|
|
extern {
|
|
type Foo;
|
|
|
|
#[wasm_bindgen(constructor)]
|
|
fn new() -> Foo;
|
|
|
|
#[wasm_bindgen(getter, method)]
|
|
fn a(this: &Foo) -> i32;
|
|
|
|
#[wasm_bindgen(setter, method)]
|
|
fn set_a(this: &Foo, a: i32);
|
|
}
|
|
|
|
#[wasm_bindgen]
|
|
#[no_mangle]
|
|
pub extern fn run() {
|
|
let a = Foo::new();
|
|
assert_eq!(a.a(), 1);
|
|
a.set_a(2);
|
|
assert_eq!(a.a(), 2);
|
|
}
|
|
"#)
|
|
.file("test.ts", r#"
|
|
import { run } from "./out";
|
|
|
|
export function test() {
|
|
run();
|
|
}
|
|
"#)
|
|
.file("another.ts", r#"
|
|
export class Foo {
|
|
constructor(private num: number) {
|
|
this.num = 1;
|
|
}
|
|
|
|
get a() {
|
|
return this.num;
|
|
}
|
|
|
|
set a(val) {
|
|
this.num = val;
|
|
}
|
|
}
|
|
"#)
|
|
.test();
|
|
}
|