1 use std::f64::{INFINITY, NAN};
2
3 use js_sys::*;
4 use wasm_bindgen::prelude::*;
5 use wasm_bindgen::JsCast;
6 use wasm_bindgen_test::*;
7
8 #[wasm_bindgen(module = "tests/wasm/Number.js")]
9 extern "C" {
const_epsilon() -> f6410 fn const_epsilon() -> f64;
const_max_safe_integer() -> f6411 fn const_max_safe_integer() -> f64;
const_max_value() -> f6412 fn const_max_value() -> f64;
const_min_safe_integer() -> f6413 fn const_min_safe_integer() -> f64;
const_min_value() -> f6414 fn const_min_value() -> f64;
const_negative_infinity() -> f6415 fn const_negative_infinity() -> f64;
const_positive_infinity() -> f6416 fn const_positive_infinity() -> f64;
17 }
18
19 #[wasm_bindgen_test]
is_finite()20 fn is_finite() {
21 assert!(Number::is_finite(&42.into()));
22 assert!(Number::is_finite(&42.1.into()));
23 assert!(!Number::is_finite(&"42".into()));
24 assert!(!Number::is_finite(&NAN.into()));
25 assert!(!Number::is_finite(&INFINITY.into()));
26 }
27
28 #[wasm_bindgen_test]
is_integer()29 fn is_integer() {
30 assert!(Number::is_integer(&42.into()));
31 assert!(!Number::is_integer(&42.1.into()));
32 }
33
34 #[wasm_bindgen_test]
is_nan()35 fn is_nan() {
36 assert!(Number::is_nan(&NAN.into()));
37
38 assert!(!Number::is_nan(&JsValue::TRUE));
39 assert!(!Number::is_nan(&JsValue::NULL));
40 assert!(!Number::is_nan(&37.into()));
41 assert!(!Number::is_nan(&"37".into()));
42 assert!(!Number::is_nan(&"37.37".into()));
43 assert!(!Number::is_nan(&"".into()));
44 assert!(!Number::is_nan(&" ".into()));
45
46 // These would all return true with the global isNaN()
47 assert!(!Number::is_nan(&"NaN".into()));
48 assert!(!Number::is_nan(&JsValue::UNDEFINED));
49 assert!(!Number::is_nan(&"blabla".into()));
50 }
51
52 #[wasm_bindgen_test]
is_safe_integer()53 fn is_safe_integer() {
54 assert_eq!(Number::is_safe_integer(&42.into()), true);
55 assert_eq!(
56 Number::is_safe_integer(&(Math::pow(2., 53.) - 1.).into()),
57 true
58 );
59 assert_eq!(Number::is_safe_integer(&Math::pow(2., 53.).into()), false);
60 assert_eq!(Number::is_safe_integer(&"42".into()), false);
61 assert_eq!(Number::is_safe_integer(&42.1.into()), false);
62 assert_eq!(Number::is_safe_integer(&NAN.into()), false);
63 assert_eq!(Number::is_safe_integer(&INFINITY.into()), false);
64 }
65
66 #[allow(deprecated)]
67 #[wasm_bindgen_test]
new()68 fn new() {
69 let n = Number::new(&JsValue::from(42));
70 let v = JsValue::from(n);
71 assert!(v.is_object());
72 assert_eq!(Number::from(v).value_of(), 42.);
73 }
74
75 #[wasm_bindgen_test]
parse_int_float()76 fn parse_int_float() {
77 assert_eq!(Number::parse_int("42", 10), 42.);
78 assert_eq!(Number::parse_int("42", 16), 66.); // 0x42 == 66
79 assert!(Number::parse_int("invalid int", 10).is_nan());
80
81 assert_eq!(Number::parse_float("123456.789"), 123456.789);
82 assert!(Number::parse_float("invalid float").is_nan());
83 }
84
85 #[wasm_bindgen_test]
to_locale_string()86 fn to_locale_string() {
87 let number = Number::from(1234.45);
88 assert_eq!(number.to_locale_string("en-US"), "1,234.45");
89 // TODO: these tests seems to be system dependent, disable for now
90 // assert_eq!(wasm.to_locale_string(number, "de-DE"), "1,234.45");
91 // assert_eq!(wasm.to_locale_string(number, "zh-Hans-CN-u-nu-hanidec"), "1,234.45");
92 }
93
94 #[wasm_bindgen_test]
to_precision()95 fn to_precision() {
96 assert_eq!(Number::from(0.1).to_precision(3).unwrap(), "0.100");
97 assert!(Number::from(10).to_precision(101).is_err());
98 }
99
100 #[wasm_bindgen_test]
to_string()101 fn to_string() {
102 assert_eq!(Number::from(42).to_string(10).unwrap(), "42");
103 assert_eq!(Number::from(233).to_string(16).unwrap(), "e9");
104 assert!(Number::from(100).to_string(100).is_err());
105 }
106
107 #[wasm_bindgen_test]
value_of()108 fn value_of() {
109 assert_eq!(Number::from(42).value_of(), 42.);
110 }
111
112 #[wasm_bindgen_test]
to_fixed()113 fn to_fixed() {
114 assert_eq!(Number::from(123.456).to_fixed(2).unwrap(), "123.46");
115 assert!(Number::from(10).to_fixed(101).is_err());
116 }
117
118 #[wasm_bindgen_test]
to_exponential()119 fn to_exponential() {
120 assert_eq!(Number::from(123456).to_exponential(2).unwrap(), "1.23e+5");
121 assert!(Number::from(10).to_exponential(101).is_err());
122 }
123
124 #[allow(deprecated)]
125 #[wasm_bindgen_test]
number_inheritance()126 fn number_inheritance() {
127 let n = Number::new(&JsValue::from(42));
128 assert!(n.is_instance_of::<Number>());
129 assert!(n.is_instance_of::<Object>());
130 let _: &Object = n.as_ref();
131 }
132
133 #[wasm_bindgen_test]
consts()134 fn consts() {
135 assert_eq!(const_epsilon(), Number::EPSILON, "EPSILON");
136 assert_eq!(
137 const_max_safe_integer(),
138 Number::MAX_SAFE_INTEGER,
139 "MAX_SAFE_INTEGER"
140 );
141 assert_eq!(const_max_value(), Number::MAX_VALUE, "MAX_VALUE");
142 assert_eq!(
143 const_min_safe_integer(),
144 Number::MIN_SAFE_INTEGER,
145 "MIN_SAFE_INTEGER"
146 );
147 assert_eq!(const_min_value(), Number::MIN_VALUE, "MIN_VALUE");
148 assert_eq!(
149 const_negative_infinity(),
150 Number::NEGATIVE_INFINITY,
151 "NEGATIVE_INFINITY"
152 );
153 assert_eq!(
154 const_positive_infinity(),
155 Number::POSITIVE_INFINITY,
156 "POSITIVE_INFINITY"
157 );
158 }
159