fluencelabs/wasm-bindgen
1
0
Fork 0
mirror of https://github.com/fluencelabs/wasm-bindgen synced 2025-03-17 02:30:50 +00:00
Code Issues Projects Releases Wiki Activity

Port Math tests to wasm

Browse Source
This commit is contained in:
Alex Crichton 2018-07-20 14:21:29 -07:00
parent 230f923fdb
commit 627ddcb192
5 changed files with 246 additions and 976 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
crates/js-sys/src/lib.rs
View File

@ -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.

971
crates/js-sys/tests/all/Math.rs
View File

@ -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()
}

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 Math;
mod Number;
mod Object;
mod Proxy;

241
crates/js-sys/tests/wasm/Math.rs Normal file
View File

@ -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.);
}

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

@ -19,3 +19,4 @@ pub mod Intl;
pub mod JsString;
pub mod Map;
pub mod MapIterator;
pub mod Math;