fluencelabs/wasm-bindgen
1
0
Fork 0
mirror of https://github.com/fluencelabs/wasm-bindgen synced 2025-03-16 18:20:51 +00:00
Code Issues Projects Releases Wiki Activity

Port Number tests to wasm

Browse Source
This commit is contained in:
Alex Crichton 2018-07-20 14:35:44 -07:00
parent 627ddcb192
commit fb6041cf3b
4 changed files with 89 additions and 380 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

379
crates/js-sys/tests/all/Number.rs
View File

@ -1,379 +0,0 @@
#![allow(non_snake_case)]
use super::project;
#[test]
fn is_finite() {
project()
.file("src/lib.rs", r#"
#![feature(use_extern_macros)]
extern crate wasm_bindgen;
extern crate js_sys;
use wasm_bindgen::prelude::*;
#[wasm_bindgen]
pub fn is_finite(value: &JsValue) -> bool {
js_sys::Number::is_finite(value)
}
"#)
.file("test.js", r#"
import * as assert from "assert";
import * as wasm from "./out";
export function test() {
assert.equal(wasm.is_finite(42), true);
assert.equal(wasm.is_finite(42.1), true);
assert.equal(wasm.is_finite('42'), false);
assert.equal(wasm.is_finite(NaN), false);
assert.equal(wasm.is_finite(Infinity), false);
}
"#)
.test()
}
#[test]
fn is_integer() {
project()
.file("src/lib.rs", r#"
#![feature(use_extern_macros)]
extern crate wasm_bindgen;
extern crate js_sys;
use wasm_bindgen::prelude::*;
#[wasm_bindgen]
pub fn is_integer(value: &JsValue) -> bool {
js_sys::Number::is_integer(value)
}
"#)
.file("test.js", r#"
import * as assert from "assert";
import * as wasm from "./out";
export function test() {
assert.ok(wasm.is_integer(123));
assert.ok(!wasm.is_integer(123.45));
}
"#)
.test()
}
#[test]
fn is_safe_integer() {
project()
.file("src/lib.rs", r#"
#![feature(use_extern_macros)]
extern crate wasm_bindgen;
extern crate js_sys;
use wasm_bindgen::prelude::*;
#[wasm_bindgen]
pub fn is_safe_integer(value: &JsValue) -> bool {
js_sys::Number::is_safe_integer(value)
}
"#)
.file("test.js", r#"
import * as assert from "assert";
import * as wasm from "./out";
export function test() {
assert.equal(wasm.is_safe_integer(42), true);
assert.equal(wasm.is_safe_integer(Math.pow(2, 53) - 1), true);
assert.equal(wasm.is_safe_integer(Math.pow(2, 53)), false);
assert.equal(wasm.is_safe_integer('42'), false);
assert.equal(wasm.is_safe_integer(42.1), false);
assert.equal(wasm.is_safe_integer(NaN), false);
assert.equal(wasm.is_safe_integer(Infinity), false);
}
"#)
.test()
}
#[test]
fn new() {
project()
.file("src/lib.rs", r#"
#![feature(use_extern_macros)]
extern crate wasm_bindgen;
extern crate js_sys;
use wasm_bindgen::prelude::*;
use js_sys::Number;
#[wasm_bindgen]
pub fn new_number() -> Number {
Number::new(JsValue::from(42))
}
"#)
.file("test.js", r#"
import * as assert from "assert";
import * as wasm from "./out";
export function test() {
assert.equal(typeof wasm.new_number(), "object");
assert.equal(wasm.new_number(), 42);
}
"#)
.test()
}
#[test]
fn parse_int_float() {
project()
.file(
"src/lib.rs", r#"
#![feature(use_extern_macros)]
extern crate wasm_bindgen;
extern crate js_sys;
use wasm_bindgen::prelude::*;
use js_sys::Number;
#[wasm_bindgen]
pub fn parse_int(text: &str, radix: u8) -> Number {
Number::parse_int(text, radix)
}
#[wasm_bindgen]
pub fn parse_float(text: &str) -> Number {
Number::parse_float(text)
}
"#,
)
.file(
"test.js", r#"
import * as assert from "assert";
import * as wasm from "./out";
export function test() {
assert.equal(wasm.parse_int("42", 10), 42);
assert.equal(wasm.parse_int("42", 16), 66); // 0x42 == 66
assert.ok(Number.isNaN(wasm.parse_int("invalid int", 10)), "should be NaN");
assert.equal(wasm.parse_float("123456.789"), 123456.789);
assert.ok(Number.isNaN(wasm.parse_float("invalid float")), "should be NaN");
}
"#,
)
.test()
}
#[test]
fn to_locale_string() {
project()
.file("src/lib.rs", r#"
#![feature(use_extern_macros)]
extern crate wasm_bindgen;
extern crate js_sys;
use wasm_bindgen::prelude::*;
#[wasm_bindgen]
pub fn to_locale_string(this: &js_sys::Number, locale: &str) -> js_sys::JsString {
this.to_locale_string(locale)
}
"#)
.file("test.js", r#"
import * as assert from "assert";
import * as wasm from "./out";
export function test() {
let number = 1234.45;
assert.equal(wasm.to_locale_string(number, "en-US"), "1,234.45");
// TODO: these tests seems to be system dependent, disable for now
// assert.equal(wasm.to_locale_string(number, "de-DE"), "1,234.45");
// assert.equal(wasm.to_locale_string(number, "zh-Hans-CN-u-nu-hanidec"), "1,234.45");
}
"#)
.test()
}
#[test]
fn to_precision() {
project()
.file(
"src/lib.rs",
r#"
#![feature(use_extern_macros)]
extern crate wasm_bindgen;
extern crate js_sys;
use wasm_bindgen::prelude::*;
#[wasm_bindgen]
pub fn to_precision(this: &js_sys::Number, precision: u8) -> js_sys::JsString {
let result = this.to_precision(precision);
let result = match result {
Ok(num) => num,
Err(_err) => "RangeError".into()
};
result
}
"#,
)
.file(
"test.js",
r#"
import * as assert from "assert";
import * as wasm from "./out";
export function test() {
assert.equal(wasm.to_precision(0.1, 3), "0.100");
assert.equal(wasm.to_precision(10, 101), "RangeError");
}
"#,
)
.test()
}
#[test]
fn to_string() {
project()
.file(
"src/lib.rs",
r#"
#![feature(use_extern_macros)]
extern crate wasm_bindgen;
extern crate js_sys;
use wasm_bindgen::prelude::*;
#[wasm_bindgen]
pub fn to_string(this: &js_sys::Number, radix: u8) -> js_sys::JsString {
let result = this.to_string(radix);
let result = match result {
Ok(num) => num,
Err(_err) => "RangeError".into()
};
result
}
"#,
)
.file(
"test.js",
r#"
import * as assert from "assert";
import * as wasm from "./out";
export function test() {
let number = 42;
assert.equal(wasm.to_string(number, 10), "42");
assert.equal(wasm.to_string(233, 16), "e9");
assert.equal(wasm.to_string(number, 100), "RangeError");
}
"#,
)
.test()
}
#[test]
fn value_of() {
project()
.file(
"src/lib.rs",
r#"
#![feature(use_extern_macros)]
extern crate wasm_bindgen;
extern crate js_sys;
use wasm_bindgen::prelude::*;
#[wasm_bindgen]
pub fn js_value_of(this: &js_sys::Number) -> f64 {
this.value_of()
}
"#,
)
.file(
"test.js",
r#"
import * as assert from "assert";
import * as wasm from "./out";
export function test() {
let number = 42;
assert.equal(wasm.js_value_of(number), 42);
assert.equal(typeof wasm.js_value_of(number), "number");
}
"#,
)
.test()
}
#[test]
fn to_fixed() {
project()
.file(
"src/lib.rs",
r#"
#![feature(use_extern_macros)]
extern crate wasm_bindgen;
extern crate js_sys;
use wasm_bindgen::prelude::*;
#[wasm_bindgen]
pub fn to_fixed(this: &js_sys::Number, digits: u8) -> js_sys::JsString {
let result = this.to_fixed(digits);
let result = match result {
Ok(num) => num,
Err(_err) => "RangeError".into()
};
result
}
"#,
)
.file(
"test.js",
r#"
import * as assert from "assert";
import * as wasm from "./out";
export function test() {
assert.equal(wasm.to_fixed(123.456, 2), "123.46");
assert.equal(wasm.to_fixed(10, 101), "RangeError");
}
"#,
)
.test()
}
#[test]
fn to_exponential() {
project()
.file(
"src/lib.rs",
r#"
#![feature(use_extern_macros)]
extern crate wasm_bindgen;
extern crate js_sys;
use wasm_bindgen::prelude::*;
#[wasm_bindgen]
pub fn to_exponential(this: &js_sys::Number, fraction_digits: u8) -> js_sys::JsString {
let result = this.to_exponential(fraction_digits);
let result = match result {
Ok(num) => num,
Err(_err) => "RangeError".into()
};
result
}
"#,
)
.file(
"test.js",
r#"
import * as assert from "assert";
import * as wasm from "./out";
export function test() {
assert.equal(wasm.to_exponential(123456, 2), "1.23e+5");
assert.equal(wasm.to_exponential(10, 101), "RangeError");
}
"#,
)
.test()
}

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

@ -11,7 +11,6 @@ fn project() -> project_builder::Project {
// Keep these tests in alphabetical order, just like the imports in `src/js.rs`.
mod ArrayIterator;
mod Number;
mod Object;
mod Proxy;
mod Reflect;

88
crates/js-sys/tests/wasm/Number.rs Normal file
View File

@ -0,0 +1,88 @@
use std::f64::{INFINITY, NAN};
use wasm_bindgen::JsValue;
use wasm_bindgen_test::*;
use js_sys::*;
#[wasm_bindgen_test]
fn is_finite() {
assert!(Number::is_finite(&42.into()));
assert!(Number::is_finite(&42.1.into()));
assert!(!Number::is_finite(&"42".into()));
assert!(!Number::is_finite(&NAN.into()));
assert!(!Number::is_finite(&INFINITY.into()));
}
#[wasm_bindgen_test]
fn is_integer() {
assert!(Number::is_integer(&42.into()));
assert!(!Number::is_integer(&42.1.into()));
}
#[wasm_bindgen_test]
fn is_safe_integer() {
assert_eq!(Number::is_safe_integer(&42.into()), true);
assert_eq!(Number::is_safe_integer(&(Math::pow(2., 53.) - 1.).into()), true);
assert_eq!(Number::is_safe_integer(&Math::pow(2., 53.).into()), false);
assert_eq!(Number::is_safe_integer(&"42".into()), false);
assert_eq!(Number::is_safe_integer(&42.1.into()), false);
assert_eq!(Number::is_safe_integer(&NAN.into()), false);
assert_eq!(Number::is_safe_integer(&INFINITY.into()), false);
}
#[wasm_bindgen_test]
fn new() {
let n = Number::new(JsValue::from(42));
let v = JsValue::from(n);
assert!(v.is_object());
assert_eq!(Number::from(v).value_of(), 42.);
}
#[wasm_bindgen_test]
fn parse_int_float() {
assert_eq!(Number::parse_int("42", 10).value_of(), 42.);
assert_eq!(Number::parse_int("42", 16).value_of(), 66.); // 0x42 == 66
assert!(Number::parse_int("invalid int", 10).value_of().is_nan());
assert_eq!(Number::parse_float("123456.789").value_of(), 123456.789);
assert!(Number::parse_float("invalid float").value_of().is_nan());
}
#[wasm_bindgen_test]
fn to_locale_string() {
let number = Number::new(1234.45.into());
assert_eq!(number.to_locale_string("en-US"), "1,234.45");
// TODO: these tests seems to be system dependent, disable for now
// assert_eq!(wasm.to_locale_string(number, "de-DE"), "1,234.45");
// assert_eq!(wasm.to_locale_string(number, "zh-Hans-CN-u-nu-hanidec"), "1,234.45");
}
#[wasm_bindgen_test]
fn to_precision() {
assert_eq!(Number::new(0.1.into()).to_precision(3).unwrap(), "0.100");
assert!(Number::new(10.into()).to_precision(101).is_err());
}
#[wasm_bindgen_test]
fn to_string() {
assert_eq!(Number::new(42.into()).to_string(10).unwrap(), "42");
assert_eq!(Number::new(233.into()).to_string(16).unwrap(), "e9");
assert!(Number::new(100.into()).to_string(100).is_err());
}
#[wasm_bindgen_test]
fn value_of() {
assert_eq!(Number::new(42.into()).value_of(), 42.);
}
#[wasm_bindgen_test]
fn to_fixed() {
assert_eq!(Number::new(123.456.into()).to_fixed(2).unwrap(), "123.46");
assert!(Number::new(10.into()).to_fixed(101).is_err());
}
#[wasm_bindgen_test]
fn to_exponential() {
assert_eq!(Number::new(123456.into()).to_exponential(2).unwrap(), "1.23e+5");
assert!(Number::new(10.into()).to_exponential(101).is_err());
}

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

@ -20,3 +20,4 @@ pub mod JsString;
pub mod Map;
pub mod MapIterator;
pub mod Math;
pub mod Number;