From fb6041cf3b652c6058240a251edc7d35ab8f50d7 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Fri, 20 Jul 2018 14:35:44 -0700 Subject: [PATCH] Port `Number` tests to `wasm` --- crates/js-sys/tests/all/Number.rs | 379 ----------------------------- crates/js-sys/tests/all/main.rs | 1 - crates/js-sys/tests/wasm/Number.rs | 88 +++++++ crates/js-sys/tests/wasm/main.rs | 1 + 4 files changed, 89 insertions(+), 380 deletions(-) delete mode 100644 crates/js-sys/tests/all/Number.rs create mode 100644 crates/js-sys/tests/wasm/Number.rs diff --git a/crates/js-sys/tests/all/Number.rs b/crates/js-sys/tests/all/Number.rs deleted file mode 100644 index 06327e55..00000000 --- a/crates/js-sys/tests/all/Number.rs +++ /dev/null @@ -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() -} diff --git a/crates/js-sys/tests/all/main.rs b/crates/js-sys/tests/all/main.rs index 15bf4d86..a6c78ed2 100644 --- a/crates/js-sys/tests/all/main.rs +++ b/crates/js-sys/tests/all/main.rs @@ -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; diff --git a/crates/js-sys/tests/wasm/Number.rs b/crates/js-sys/tests/wasm/Number.rs new file mode 100644 index 00000000..fdd64609 --- /dev/null +++ b/crates/js-sys/tests/wasm/Number.rs @@ -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()); +} diff --git a/crates/js-sys/tests/wasm/main.rs b/crates/js-sys/tests/wasm/main.rs index 613d34a0..0f1a0c46 100644 --- a/crates/js-sys/tests/wasm/main.rs +++ b/crates/js-sys/tests/wasm/main.rs @@ -20,3 +20,4 @@ pub mod JsString; pub mod Map; pub mod MapIterator; pub mod Math; +pub mod Number;