fluencelabs/wasm-bindgen
1
0
Fork 0
mirror of https://github.com/fluencelabs/wasm-bindgen synced 2025-06-13 04:51:23 +00:00
Code Issues Projects Releases Wiki Activity

Move webidl tests to the webidl crate's test suite (#451)

Browse Source 
* webidl: Remove exact-output tests

These have not been as effective, nor as easy to write and maintain, as the
project()-based integration tests.

* tests: Move webidl tests into the webidl crate's test suite
This commit is contained in:
Nick Fitzgerald
2018-07-10 14:17:33 -07:00
committed by Alex Crichton
parent 42938792c7
commit 92dd8e859f
12 changed files with 6 additions and 855 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
tests/all/main.rs
View File

@ -24,4 +24,3 @@ mod structural;
mod typescript;
mod u64;
mod validate_prt;
mod webidl;

3
tests/all/webidl/mod.rs
View File

@ -1,3 +0,0 @@
use super::project;
mod simple;

372
tests/all/webidl/simple.rs
View File

@ -1,372 +0,0 @@
use super::project;
#[test]
fn method() {
project()
.file(
"foo.webidl",
r#"
[Constructor(double value)]
interface Foo {
[Pure]
boolean myCmp(Foo bar);
};
"#,
)
.file(
"foo.js",
r#"
export class Foo {
constructor(value) {
this.value = value;
}
myCmp(other) {
return this.value === other.value;
}
}
"#,
)
.file(
"src/lib.rs",
r#"
#![feature(proc_macro, wasm_custom_section, wasm_import_module)]
extern crate wasm_bindgen;
use wasm_bindgen::prelude::*;
pub mod foo;
use foo::Foo;
#[wasm_bindgen]
pub fn test() {
let pi = Foo::new(3.14159);
let e = Foo::new(2.71828);
// TODO: figure out why the following doesn't fail
// assert!(!pi.my_cmp(Foo::new(3.14159)));
let tmp = pi.my_cmp(Foo::new(3.14159));
assert!(tmp);
let tmp =!pi.my_cmp(Foo::new(2.71828));
assert!(tmp);
let tmp = !e.my_cmp(Foo::new(3.14159));
assert!(tmp);
let tmp = e.my_cmp(Foo::new(2.71828));
assert!(tmp);
}
"#,
)
.test();
}
#[test]
fn property() {
project()
.file(
"foo.webidl",
r#"
[Constructor(double value)]
interface Foo {
[Pure]
attribute double value;
};
"#,
)
.file(
"foo.js",
r#"
export class Foo {
constructor(value) {
this._value = value;
}
get value() {
return this._value;
}
set value(value) {
this._value = value;
}
}
"#,
)
.file(
"src/lib.rs",
r#"
#![feature(proc_macro, wasm_custom_section, wasm_import_module)]
extern crate wasm_bindgen;
use wasm_bindgen::prelude::*;
pub mod foo;
use foo::Foo;
#[wasm_bindgen]
pub fn test() {
let x = Foo::new(3.14159);
assert_eq!(x.value(), 3.14159);
assert_ne!(x.value(), 2.71828);
x.set_value(2.71828);
assert_ne!(x.value(), 3.14159);
assert_eq!(x.value(), 2.71828);
}
"#,
)
.test();
}
#[test]
fn named_constructor() {
project()
.file(
"foo.webidl",
r#"
[NamedConstructor=Bar(double value)]
interface Foo {
[Pure]
readonly attribute double value;
};
"#,
)
.file(
// Not a perfect test, but it gets the job done.
"foo.js",
r#"
export class Foo {
constructor() {
this._value = 0;
}
get value(){
return this._value;
}
}
export class Bar extends Foo {
constructor(_value) {
super();
this._value = _value;
}
}
"#,
)
.file(
"src/lib.rs",
r#"
#![feature(proc_macro, wasm_custom_section, wasm_import_module)]
extern crate wasm_bindgen;
use wasm_bindgen::prelude::*;
pub mod foo;
use foo::Foo;
#[wasm_bindgen]
pub fn test() {
let x = Foo::new(3.14159);
assert_eq!(x.value(), 3.14159);
assert_ne!(x.value(), 0.);
}
"#,
)
.test();
}
#[test]
fn static_method() {
project()
.file(
"foo.webidl",
r#"
interface Foo {
static double swap(double value);
};
"#,
)
.file(
"foo.js",
r#"
export class Foo {
static swap(value) {
const res = Foo.value;
Foo.value = value;
return res;
}
}
Foo.value = 0;
"#,
)
.file(
"src/lib.rs",
r#"
#![feature(proc_macro, wasm_custom_section, wasm_import_module)]
extern crate wasm_bindgen;
use wasm_bindgen::prelude::*;
pub mod foo;
use foo::Foo;
#[wasm_bindgen]
pub fn test() {
assert_eq!(Foo::swap(3.14159), 0.);
assert_eq!(Foo::swap(2.71828), 3.14159);
assert_ne!(Foo::swap(2.71828), 3.14159);
assert_eq!(Foo::swap(3.14159), 2.71828);
assert_ne!(Foo::swap(3.14159), 2.71828);
}
"#,
)
.test();
}
#[test]
fn static_property() {
project()
.file(
"foo.webidl",
r#"
interface Foo {
static attribute double value;
};
"#,
)
.file(
"foo.js",
r#"
export class Foo {
static get value(){
return Foo._value;
}
static set value(value) {
Foo._value = value;
}
}
Foo._value = 0;
"#,
)
.file(
"src/lib.rs",
r#"
#![feature(proc_macro, wasm_custom_section, wasm_import_module)]
extern crate wasm_bindgen;
use wasm_bindgen::prelude::*;
pub mod foo;
use foo::Foo;
#[wasm_bindgen]
pub fn test() {
assert_eq!(Foo::value(), 0.);
Foo::set_value(3.14159);
assert_eq!(Foo::value(), 3.14159);
assert_ne!(Foo::value(), 2.71828);
Foo::set_value(2.71828);
assert_eq!(Foo::value(), 2.71828);
assert_ne!(Foo::value(), 3.14159);
}
"#,
)
.test();
}
#[test]
fn one_method_using_an_undefined_import_doesnt_break_all_other_methods() {
project()
.file(
"foo.webidl",
r#"
[Constructor()]
interface Foo {
boolean ok_method();
boolean bad_method(UndefinedType undef);
};
"#,
)
.file(
"foo.js",
r#"
export class Foo {
constructor() {}
ok_method() {
return true;
}
}
"#,
)
.file(
"src/lib.rs",
r#"
#![feature(proc_macro, wasm_custom_section, wasm_import_module)]
extern crate wasm_bindgen;
use wasm_bindgen::prelude::*;
pub mod foo;
#[wasm_bindgen]
pub fn test() {
let f = foo::Foo::new();
assert!(f.ok_method());
}
"#,
)
.test();
}
#[test]
fn unforgeable_is_structural() {
project()
.file(
"foo.webidl",
r#"
[Constructor()]
interface Foo {
[Unforgeable] readonly attribute short uno;
readonly attribute short dos;
};
"#,
)
.file(
"foo.js",
r#"
export class Foo {
constructor() {
this.uno = 1;
}
get dos() {
return 2;
}
}
"#,
)
.file(
"src/lib.rs",
r#"
#![feature(proc_macro, wasm_custom_section, wasm_import_module)]
extern crate wasm_bindgen;
use wasm_bindgen::prelude::*;
pub mod foo;
#[wasm_bindgen]
pub fn test() {
let f = foo::Foo::new();
assert_eq!(f.uno(), 1);
assert_eq!(f.dos(), 2);
}
"#,
)
.test();
}