From 627ddcb192e2d16c464c19f31c4d5b16c31323d2 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Fri, 20 Jul 2018 14:21:29 -0700 Subject: [PATCH] Port `Math` tests to `wasm` --- crates/js-sys/src/lib.rs | 8 +- crates/js-sys/tests/all/Math.rs | 971 ------------------------------- crates/js-sys/tests/all/main.rs | 1 - crates/js-sys/tests/wasm/Math.rs | 241 ++++++++ crates/js-sys/tests/wasm/main.rs | 1 + 5 files changed, 246 insertions(+), 976 deletions(-) delete mode 100644 crates/js-sys/tests/all/Math.rs create mode 100644 crates/js-sys/tests/wasm/Math.rs diff --git a/crates/js-sys/src/lib.rs b/crates/js-sys/src/lib.rs index 10abef37..1a28826f 100644 --- a/crates/js-sys/src/lib.rs +++ b/crates/js-sys/src/lib.rs @@ -1018,7 +1018,7 @@ extern "C" { /// /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil #[wasm_bindgen(static_method_of = Math)] - pub fn ceil(x: f64) -> i32; + pub fn ceil(x: f64) -> f64; /// The Math.clz32() function returns the number of leading zero bits in /// the 32-bit binary representation of a number. @@ -1061,7 +1061,7 @@ extern "C" { /// /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor #[wasm_bindgen(static_method_of = Math)] - pub fn floor(x: f64) -> i32; + pub fn floor(x: f64) -> f64; /// The Math.fround() function returns the nearest 32-bit single precision float representation /// of a Number. @@ -1121,7 +1121,7 @@ extern "C" { /// /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round #[wasm_bindgen(static_method_of = Math)] - pub fn round(x: f64) -> i32; + pub fn round(x: f64) -> f64; /// The Math.sign() function returns the sign of a number, indicating whether the number is /// positive, negative or zero. @@ -1168,7 +1168,7 @@ extern "C" { /// /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc #[wasm_bindgen(static_method_of = Math)] - pub fn trunc(x: f64) -> i32; + pub fn trunc(x: f64) -> f64; } // Number. diff --git a/crates/js-sys/tests/all/Math.rs b/crates/js-sys/tests/all/Math.rs deleted file mode 100644 index e4fdf9a4..00000000 --- a/crates/js-sys/tests/all/Math.rs +++ /dev/null @@ -1,971 +0,0 @@ -#![allow(non_snake_case)] - -use super::project; - -#[test] -fn abs() { - 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 abs(x: f64) -> f64 { - js_sys::Math::abs(x) - } - "#, - ) - .file( - "test.js", - r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.abs(-32), Math.abs(-32)); - assert.equal(wasm.abs(32), 32); - assert.equal(wasm.abs(-4.7), Math.abs(-4.7)); - } - "#, - ) - .test() -} - -#[test] -fn acos() { - 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 acos(x: f64) -> f64 { - js_sys::Math::acos(x) - } - "#, - ) - .file( - "test.js", - r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.acos(-1), Math.PI); - assert.equal(wasm.acos(0.5), 1.0471975511965979); - assert.ok(Number.isNaN(wasm.acos(2))); - } - "#, - ) - .test() -} - -#[test] -fn acosh() { - 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 acosh(x: f64) -> f64 { - js_sys::Math::acosh(x) - } - "#, - ) - .file( - "test.js", - r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.acosh(1), 0); - assert.equal(wasm.acosh(2), Math.acosh(2)); - assert.ok(Number.isNaN(wasm.acosh(0.5))); - } - "#, - ) - .test() -} - -#[test] -fn asin() { - 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 asin(x: f64) -> f64 { - js_sys::Math::asin(x) - } - "#, - ) - .file( - "test.js", - r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.asin(1), Math.asin(1)); - assert.equal(wasm.asin(0.5), Math.asin(0.5)); - assert.ok(Number.isNaN(wasm.asin(2))); - } - "#, - ) - .test() -} - -#[test] -fn asinh() { - 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 asinh(x: f64) -> f64 { - js_sys::Math::asinh(x) - } - "#, - ) - .file( - "test.js", - r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.asinh(1), Math.asinh(1)); - assert.equal(wasm.asinh(0.5), Math.asinh(0.5)); - } - "#, - ) - .test() -} - -#[test] -fn atan() { - 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 atan(x: f64) -> f64 { - js_sys::Math::atan(x) - } - "#, - ) - .file( - "test.js", - r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.atan(1), Math.atan(1)); - assert.equal(wasm.atan(0.5), Math.atan(0.5)); - } - "#, - ) - .test() -} - -#[test] -fn atan2() { - 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 atan2(y: f64, x: f64) -> f64 { - js_sys::Math::atan2(y, x) - } - "#, - ) - .file( - "test.js", - r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.atan2(1, 2), Math.atan2(1, 2)); - assert.equal(wasm.atan2(0.7, 3.8), Math.atan2(0.7, 3.8)); - } - "#, - ) - .test() -} - -#[test] -fn atanh() { - 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 atanh(x: f64) -> f64 { - js_sys::Math::atanh(x) - } - "#, - ) - .file( - "test.js", - r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.atanh(1), Math.atanh(1)); - assert.equal(wasm.atanh(0.5), Math.atanh(0.5)); - assert.ok(Number.isNaN(wasm.atanh(2))); - } - "#, - ) - .test() -} - -#[test] -fn cbrt() { - 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 cbrt(x: f64) -> f64 { - js_sys::Math::cbrt(x) - } - "#, - ) - .file( - "test.js", - r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.cbrt(27), 3); - assert.equal(wasm.cbrt(12.3), Math.cbrt(12.3)); - } - "#, - ) - .test() -} - -#[test] -fn ceil() { - 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 ceil(x: f64) -> i32 { - js_sys::Math::ceil(x) - } - "#, - ) - .file( - "test.js", - r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.ceil(1.1), 2); - assert.equal(wasm.ceil(-1.1), -1); - } - "#, - ) - .test() -} - -#[test] -fn clz32() { - 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 clz32(x: i32) -> u32 { - js_sys::Math::clz32(x) - } - "#, - ) - .file( - "test.js", - r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.clz32(1), 31); - assert.equal(wasm.clz32(1000), 22); - } - "#, - ) - .test() -} - -#[test] -fn cos() { - 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 cos(x: f64) -> f64 { - js_sys::Math::cos(x) - } - "#) - .file("test.js", r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.cos(0), 1); - assert.equal(wasm.cos(1.5), Math.cos(1.5)); - } - "#) - .test() -} - -#[test] -fn cosh() { - 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 cosh(x: f64) -> f64 { - js_sys::Math::cosh(x) - } - "#) - .file("test.js", r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.cosh(0), 1); - assert.equal(wasm.cosh(2), 3.7621956910836314); - } - "#) - .test() -} - -#[test] -fn exp() { - 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 exp(x: f64) -> f64 { - js_sys::Math::exp(x) - } - "#) - .file("test.js", r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.exp(0), 1); - assert.equal(wasm.exp(-1), 0.36787944117144233); - assert.equal(wasm.exp(2), 7.38905609893065); - } - "#) - .test() -} - -#[test] -fn expm1() { - 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 expm1(x: f64) -> f64 { - js_sys::Math::expm1(x) - } - "#) - .file("test.js", r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.expm1(0), 0); - assert.equal(wasm.expm1(1), 1.718281828459045); - assert.equal(wasm.expm1(-1), -0.6321205588285577); - assert.equal(wasm.expm1(2), 6.38905609893065); - } - "#) - .test() -} - -#[test] -fn floor() { - 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 floor(x: f64) -> i32 { - js_sys::Math::floor(x) - } - "#, - ) - .file( - "test.js", - r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.floor(5.95), 5); - assert.equal(wasm.floor(-5.05), -6); - } - "#, - ) - .test() -} - -#[test] -fn fround() { - 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 fround(x: f64) -> f32 { - js_sys::Math::fround(x) - } - "#) - .file("test.js", r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.fround(5.5), 5.5); - assert.equal(wasm.fround(5.05), 5.050000190734863); - assert.equal(wasm.fround(5), 5); - assert.equal(wasm.fround(-5.05), -5.050000190734863); - } - "#) - .test() -} - -#[test] -fn imul() { - 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 imul(x: i32, y:i32) -> i32 { - js_sys::Math::imul(x, y) - } - "#) - .file("test.js", r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.imul(3, 4), 12); - assert.equal(wasm.imul(-5, 12), -60); - assert.equal(wasm.imul(0xffffffff, 5), Math.imul(0xffffffff, 5)); - } - "#) - .test() -} - -#[test] -fn log() { - 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 log(x: f64) -> f64 { - js_sys::Math::log(x) - } - "#) - .file("test.js", r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.log(8) / wasm.log(2), 3); - assert.equal(wasm.log(625) / wasm.log(5), 4); - } - "#) - .test() -} - -#[test] -fn log10() { - 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 log10(x: f64) -> f64 { - js_sys::Math::log10(x) - } - "#) - .file("test.js", r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.log10(100000), 5); - assert.equal(wasm.log10(1), 0); - assert.equal(wasm.log10(2), 0.3010299956639812); - } - "#) - .test() -} - -#[test] -fn log1p() { - 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 log1p(x: f64) -> f64 { - js_sys::Math::log1p(x) - } - "#) - .file("test.js", r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.log1p(1), 0.6931471805599453); - assert.equal(wasm.log1p(0), 0); - assert.equal(wasm.log1p(-1), -Infinity); - assert.ok(isNaN(wasm.log1p(-2))); - } - "#) - .test() -} - -#[test] -fn log2() { - 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 log2(x: f64) -> f64 { - js_sys::Math::log2(x) - } - "#) - .file("test.js", r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.log2(3), 1.584962500721156); - assert.equal(wasm.log2(2), 1); - assert.equal(wasm.log2(1), 0); - assert.equal(wasm.log2(0), -Infinity); - } - "#) - .test() -} - -#[test] -fn pow() { - 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 pow(base: f64, exponent: f64) -> f64 { - js_sys::Math::pow(base, exponent) - } - "#) - .file("test.js", r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.pow(7, 2), 49); - assert.equal(wasm.pow(3.8, 0.5), Math.pow(3.8, 0.5)); - assert.ok(Number.isNaN(wasm.pow(-2, 0.5))); - } - "#) - .test() -} - -#[test] -fn random() { - 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 random() -> f64 { - js_sys::Math::random() - } - "#) - .file("test.js", r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.ok(wasm.random() < 1); - assert.ok(wasm.random() >= 0); - } - "#) - .test() -} - -#[test] -fn round() { - 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 round(x: f64) -> i32 { - js_sys::Math::round(x) - } - "#) - .file("test.js", r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.round(20.49), 20); - assert.equal(wasm.round(20.5), 21); - assert.equal(wasm.round(42), 42); - assert.equal(wasm.round(-20.5), -20); - assert.equal(wasm.round(-20.51), -21); - } - "#) - .test() -} - -#[test] -fn sign() { - 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 sign(x: f64) -> f64 { - js_sys::Math::sign(x) - } - "#) - .file("test.js", r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.sign(3), 1); - assert.equal(wasm.sign(-3), -1); - assert.equal(wasm.sign(2.3), 1); - assert.equal(wasm.sign(0), 0); - assert.ok(Number.isNaN(wasm.sign(NaN))); - } - "#) - .test() -} - -#[test] -fn sin() { - 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 sin(x: f64) -> f64 { - js_sys::Math::sin(x) - } - "#) - .file("test.js", r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.sin(0), 0); - assert.equal(wasm.sin(1), Math.sin(1)); - assert.equal(wasm.sin(Math.PI / 2), 1); - } - "#) - .test() -} - -#[test] -fn sinh() { - 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 sinh(x: f64) -> f64 { - js_sys::Math::sinh(x) - } - "#) - .file("test.js", r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.sinh(0), 0); - assert.equal(wasm.sinh(1), Math.sinh(1)); - assert.equal(wasm.sinh(2.3), Math.sinh(2.3)); - } - "#) - .test() -} - -#[test] -fn sqrt() { - 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 sqrt(x: f64) -> f64 { - js_sys::Math::sqrt(x) - } - "#) - .file("test.js", r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.sqrt(9), 3); - assert.equal(wasm.sqrt(2), Math.sqrt(2)); - assert.equal(wasm.sqrt(42.42), Math.sqrt(42.42)); - assert.equal(wasm.sqrt(1), 1); - assert.ok(Number.isNaN(wasm.sqrt(-1))); - } - "#) - .test() -} - -#[test] -fn tan() { - 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 tan(x: f64) -> f64 { - js_sys::Math::tan(x) - } - "#) - .file("test.js", r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.tan(0), 0); - assert.equal(wasm.tan(1), Math.tan(1)); - assert.equal(wasm.tan(0.5), Math.tan(0.5)); - } - "#) - .test() -} - -#[test] -fn tanh() { - 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 tanh(x: f64) -> f64 { - js_sys::Math::tanh(x) - } - "#) - .file("test.js", r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.tanh(0), 0); - assert.equal(wasm.tanh(1), Math.tanh(1)); - assert.equal(wasm.tanh(0.5), Math.tanh(0.5)); - } - "#) - .test() -} - -#[test] -fn trunc() { - 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 trunc(x: f64) -> i32 { - js_sys::Math::trunc(x) - } - "#) - .file("test.js", r#" - import * as assert from "assert"; - import * as wasm from "./out"; - - export function test() { - assert.equal(wasm.trunc(13.37), 13); - assert.equal(wasm.trunc(42.84), 42); - assert.equal(wasm.trunc(0.123), 0); - assert.equal(wasm.trunc(-0.123), 0); - } - "#) - .test() -} diff --git a/crates/js-sys/tests/all/main.rs b/crates/js-sys/tests/all/main.rs index 19adfa1d..15bf4d86 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 Math; mod Number; mod Object; mod Proxy; diff --git a/crates/js-sys/tests/wasm/Math.rs b/crates/js-sys/tests/wasm/Math.rs new file mode 100644 index 00000000..eb83b79c --- /dev/null +++ b/crates/js-sys/tests/wasm/Math.rs @@ -0,0 +1,241 @@ +use std::f64::consts::PI; +use std::f64::{NEG_INFINITY, NAN}; + +use wasm_bindgen_test::*; +use js_sys::*; + +macro_rules! assert_eq { + ($a:expr, $b:expr) => ({ + let (a, b) = (&$a, &$b); + if f64::is_infinite(*a) && f64::is_infinite(*b) { + assert!(a == b); + } else { + assert!((*a - *b).abs() < 1.0e-6, + "not approximately equal {:?} ?= {:?}", a, b); + } + }) +} + +#[wasm_bindgen_test] +fn abs() { + assert_eq!(Math::abs(-32.), 32.); + assert_eq!(Math::abs(-32.), 32.); + assert_eq!(Math::abs(-4.7), 4.7); +} + +#[wasm_bindgen_test] +fn acos() { + assert_eq!(Math::acos(-1.), PI); + assert_eq!(Math::acos(0.5), 1.0471975511965979); + assert!(Math::acos(2.).is_nan()); +} + +#[wasm_bindgen_test] +fn acosh() { + assert_eq!(Math::acosh(1.), 0.); + assert_eq!(Math::acosh(2.), 2.0f64.acosh()); + assert!(Math::acosh(0.5).is_nan()); +} + +#[wasm_bindgen_test] +fn asin() { + assert_eq!(Math::asin(1.), 1.0f64.asin()); + assert_eq!(Math::asin(0.5), 0.5f64.asin()); + assert!(Math::asin(2.).is_nan()); +} + +#[wasm_bindgen_test] +fn asinh() { + assert_eq!(Math::asinh(1.0), 1f64.asinh()); + assert_eq!(Math::asinh(0.5), 0.5f64.asinh()); +} + +#[wasm_bindgen_test] +fn atan() { + assert_eq!(Math::atan(1.0), 1f64.atan()); + assert_eq!(Math::atan(0.5), 0.5f64.atan()); +} + +#[wasm_bindgen_test] +fn atan2() { + assert_eq!(Math::atan2(1.0, 2.0), 1f64.atan2(2.)); + assert_eq!(Math::atan2(0.7, 3.8), 0.7f64.atan2(3.8f64)); +} + +#[wasm_bindgen_test] +fn atanh() { + assert_eq!(Math::atanh(1.), 1f64.atanh()); + assert_eq!(Math::atanh(0.5), 0.5f64.atanh()); + assert!(Math::atanh(2.).is_nan()); +} + +#[wasm_bindgen_test] +fn cbrt() { + assert_eq!(Math::cbrt(27.), 3.); + assert_eq!(Math::cbrt(12.3), 12.3f64.cbrt()); +} + +#[wasm_bindgen_test] +fn ceil() { + assert_eq!(Math::ceil(1.1), 2.); + assert_eq!(Math::ceil(-1.1), -1.); +} + +#[wasm_bindgen_test] +fn clz32() { + assert!(Math::clz32(1) == 31); + assert!(Math::clz32(1000) == 22); +} + +#[wasm_bindgen_test] +fn cos() { + assert_eq!(Math::cos(0.0), 1.); + assert_eq!(Math::cos(1.5), 1.5f64.cos()); +} + +#[wasm_bindgen_test] +fn cosh() { + assert_eq!(Math::cosh(0.), 1.); + assert_eq!(Math::cosh(2.), 3.7621956910836314); +} + +#[wasm_bindgen_test] +fn exp() { + assert_eq!(Math::exp(0.), 1.); + assert_eq!(Math::exp(-1.), 0.36787944117144233); + assert_eq!(Math::exp(2.), 7.38905609893065); +} + +#[wasm_bindgen_test] +fn expm1() { + assert_eq!(Math::expm1(0.), 0.); + assert_eq!(Math::expm1(1.), 1.718281828459045); + assert_eq!(Math::expm1(-1.), -0.6321205588285577); + assert_eq!(Math::expm1(2.), 6.38905609893065); +} + +#[wasm_bindgen_test] +fn floor() { + assert_eq!(Math::floor(5.95), 5.); + assert_eq!(Math::floor(-5.05), -6.); +} + +#[wasm_bindgen_test] +fn fround() { + assert!(Math::fround(5.5) == 5.5); + assert!(Math::fround(5.05) == 5.050000190734863); + assert!(Math::fround(5.) == 5.); + assert!(Math::fround(-5.05) == -5.050000190734863); +} + +#[wasm_bindgen_test] +fn imul() { + assert!(Math::imul(3, 4) == 12); + assert!(Math::imul(-5, 12) == -60); + assert!(Math::imul(0xffffffffu32 as i32, 5) == 0xffffffffu32.wrapping_mul(5) as i32); +} + +#[wasm_bindgen_test] +fn log() { + assert_eq!(Math::log(8.) / Math::log(2.), 3.); + assert_eq!(Math::log(625.) / Math::log(5.), 4.); +} + +#[wasm_bindgen_test] +fn log10() { + assert_eq!(Math::log10(100000.), 5.); + assert_eq!(Math::log10(1.), 0.); + assert_eq!(Math::log10(2.), 0.3010299956639812); +} + +#[wasm_bindgen_test] +fn log1p() { + assert_eq!(Math::log1p(1.), 0.6931471805599453); + assert_eq!(Math::log1p(0.), 0.); + assert_eq!(Math::log1p(-1.), NEG_INFINITY); + assert!(Math::log1p(-2.).is_nan()); +} + +#[wasm_bindgen_test] +fn log2() { + assert_eq!(Math::log2(3.), 1.584962500721156); + assert_eq!(Math::log2(2.), 1.); + assert_eq!(Math::log2(1.), 0.); + assert_eq!(Math::log2(0.), NEG_INFINITY); +} + +#[wasm_bindgen_test] +fn pow() { + assert_eq!(Math::pow(7., 2.), 49.); + assert_eq!(Math::pow(3.8, 0.5), 3.8f64.powf(0.5f64)); + assert!(Math::pow(-2., 0.5).is_nan()); +} + +#[wasm_bindgen_test] +fn random() { + assert!(Math::random() < 1.); + assert!(Math::random() >= 0.); +} + +#[wasm_bindgen_test] +fn round() { + assert_eq!(Math::round(20.49), 20.); + assert_eq!(Math::round(20.5), 21.); + assert_eq!(Math::round(42.), 42.); + assert_eq!(Math::round(-20.5), -20.); + assert_eq!(Math::round(-20.51), -21.); +} + +#[wasm_bindgen_test] +fn sign() { + assert_eq!(Math::sign(3.), 1.); + assert_eq!(Math::sign(-3.), -1.); + assert_eq!(Math::sign(2.3), 1.); + assert_eq!(Math::sign(0.), 0.); + assert!(Math::sign(NAN).is_nan()); +} + +#[wasm_bindgen_test] +fn sin() { + assert_eq!(Math::sin(0.), 0.); + assert_eq!(Math::sin(1.), 1f64.sin()); + assert_eq!(Math::sin(PI / 2.), 1.); +} + +#[wasm_bindgen_test] +fn sinh() { + assert_eq!(Math::sinh(0.), 0.); + assert_eq!(Math::sinh(1.), 1f64.sinh()); + assert_eq!(Math::sinh(2.3), 2.3f64.sinh()); +} + +#[wasm_bindgen_test] +fn sqrt() { + assert_eq!(Math::sqrt(9.), 3.); + assert_eq!(Math::sqrt(2.), 2f64.sqrt()); + assert_eq!(Math::sqrt(42.42), 42.42f64.sqrt()); + assert_eq!(Math::sqrt(1.), 1.); + assert!(Math::sqrt(-1.).is_nan()); +} + +#[wasm_bindgen_test] +fn tan() { + assert_eq!(Math::tan(0.), 0.); + assert_eq!(Math::tan(1.), 1f64.tan()); + assert_eq!(Math::tan(0.5), 0.5f64.tan()); +} + +#[wasm_bindgen_test] +fn tanh() { + assert_eq!(Math::tanh(0.), 0.); + assert_eq!(Math::tanh(1.), 1f64.tanh()); + assert_eq!(Math::tanh(0.5), 0.5f64.tanh()); +} + +#[wasm_bindgen_test] +fn trunc() { + assert_eq!(Math::trunc(13.37), 13.); + assert_eq!(Math::trunc(42.84), 42.); + assert_eq!(Math::trunc(0.123), 0.); + assert_eq!(Math::trunc(-0.123), 0.); +} diff --git a/crates/js-sys/tests/wasm/main.rs b/crates/js-sys/tests/wasm/main.rs index 58662568..613d34a0 100644 --- a/crates/js-sys/tests/wasm/main.rs +++ b/crates/js-sys/tests/wasm/main.rs @@ -19,3 +19,4 @@ pub mod Intl; pub mod JsString; pub mod Map; pub mod MapIterator; +pub mod Math;