Merge pull request #685 from fitzgen/a-few-more-js-sys-things

A few more js sys things

crates/js-sys/tests/wasm/Array.rs

@@ -126,6 +126,19 @@ fn copy_within() {
     assert_eq!(to_rust(&characters)[5], JsValue::from(3));
 }
 
+#[wasm_bindgen_test]
+fn of() {
+    let a = JsValue::from("a");
+    let b = JsValue::from("b");
+    let c = JsValue::from("c");
+    let arr = Array::of3(&a, &b, &c);
+    let vec = to_rust(&arr);
+    assert_eq!(vec.len(), 3);
+    assert_eq!(vec[0], a);
+    assert_eq!(vec[1], b);
+    assert_eq!(vec[2], c);
+}
+
 #[wasm_bindgen_test]
 fn pop() {
     let characters = js_array![8, 5, 4, 3, 1, 2];

crates/js-sys/tests/wasm/Intl.rs

@@ -1,4 +1,4 @@
-use wasm_bindgen::JsValue;
+use wasm_bindgen::{JsCast, JsValue};
 use wasm_bindgen_test::*;
 use js_sys::*;
 
@@ -23,3 +23,16 @@ fn get_canonical_locales() {
         assert_eq!(l, "en-US");
     });
 }
+
+#[wasm_bindgen_test]
+fn collator() {
+    let locales = Array::of1(&JsValue::from("en-US"));
+    let opts = Object::new();
+
+    let c = Intl::Collator::new(&locales, &opts);
+    assert!(c.compare().is_instance_of::<Function>());
+    assert!(c.resolved_options().is_instance_of::<Object>());
+
+    let a = Intl::Collator::supported_locales_of(&locales, &opts);
+    assert!(a.is_instance_of::<Array>());
+}

crates/js-sys/tests/wasm/Object.rs

@@ -1,17 +1,18 @@
-use wasm_bindgen::prelude::*;
-use wasm_bindgen_test::*;
-use std::f64::NAN;
 use js_sys::*;
+use std::f64::NAN;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen_test::*;
 
 #[wasm_bindgen]
-extern {
+extern "C" {
     type Foo42;
     #[wasm_bindgen(method, setter, structural)]
     fn set_foo(this: &Foo42, val: JsValue);
 }
 
 #[wasm_bindgen(module = "tests/wasm/Object.js")]
-extern {
+extern "C" {
     fn map_with_symbol_key() -> Object;
     fn symbol_key() -> JsValue;
 
@@ -36,6 +37,42 @@ fn new() {
     assert!(JsValue::from(Object::new()).is_object());
 }
 
+#[wasm_bindgen_test]
+fn assign() {
+    let a = JsValue::from("a");
+    let b = JsValue::from("b");
+    let c = JsValue::from("c");
+
+    let target = Object::new();
+    Reflect::set(target.as_ref(), a.as_ref(), a.as_ref());
+
+    let src1 = Object::new();
+    Reflect::set(src1.as_ref(), &a, &c);
+
+    let src2 = Object::new();
+    Reflect::set(src2.as_ref(), &b, &b);
+
+    let src3 = Object::new();
+    Reflect::set(src3.as_ref(), &c, &c);
+
+    let res = Object::assign3(&target, &src1, &src2, &src3);
+
+    assert!(Object::is(target.as_ref(), res.as_ref()));
+    assert_eq!(Reflect::get(target.as_ref(), &a), c);
+    assert_eq!(Reflect::get(target.as_ref(), &b), b);
+    assert_eq!(Reflect::get(target.as_ref(), &c), c);
+}
+
+#[wasm_bindgen_test]
+fn create() {
+    let array_proto = eval("Array.prototype")
+        .unwrap()
+        .dyn_into::<Object>()
+        .unwrap();
+    let my_array = Object::create(&array_proto);
+    assert!(my_array.is_instance_of::<Array>());
+}
+
 #[wasm_bindgen_test]
 fn has_own_property() {
     assert!(foo_42().has_own_property(&"foo".into()));

crates/js-sys/tests/wasm/RangeError.rs

@@ -0,0 +1,14 @@
+use wasm_bindgen::JsValue;
+use wasm_bindgen_test::*;
+use wasm_bindgen::JsCast;
+use js_sys::*;
+
+#[wasm_bindgen_test]
+fn range_error() {
+    let error = RangeError::new("out of range yo");
+    assert!(error.is_instance_of::<RangeError>());
+    assert!(error.is_instance_of::<Error>());
+
+    let base: &Error = error.as_ref();
+    assert_eq!(JsValue::from(base.message()), "out of range yo");
+}

crates/js-sys/tests/wasm/ReferenceError.rs

@@ -0,0 +1,14 @@
+use wasm_bindgen::JsValue;
+use wasm_bindgen_test::*;
+use wasm_bindgen::JsCast;
+use js_sys::*;
+
+#[wasm_bindgen_test]
+fn reference_error() {
+    let error = ReferenceError::new("bad reference, fool");
+    assert!(error.is_instance_of::<ReferenceError>());
+    assert!(error.is_instance_of::<Error>());
+
+    let base: &Error = error.as_ref();
+    assert_eq!(JsValue::from(base.message()), "bad reference, fool");
+}

crates/js-sys/tests/wasm/RegExp.rs

@@ -56,6 +56,15 @@ fn input() {
     assert_eq!(RegExp::input(), "hi there!");
 }
 
+#[wasm_bindgen_test]
+fn last_index() {
+    let re = RegExp::new("hi", "g");
+    assert_eq!(re.last_index(), 0);
+
+    re.set_last_index(42);
+    assert_eq!(re.last_index(), 42);
+}
+
 #[wasm_bindgen_test]
 fn last_match() {
     let re = RegExp::new("hi", "g");

crates/js-sys/tests/wasm/Symbol.rs

@@ -1,6 +1,5 @@
 use wasm_bindgen::prelude::*;
 use wasm_bindgen_test::*;
-use wasm_bindgen::JsCast;
 use js_sys::*;
 
 #[wasm_bindgen(module = "tests/wasm/Symbol.js")]
@@ -100,6 +99,11 @@ fn to_string() {
     assert_eq!(gensym("desc".into()).to_string(), "Symbol(desc)");
 }
 
+#[wasm_bindgen_test]
+fn unscopables() {
+    assert_eq!(Symbol::unscopables().to_string(), "Symbol(Symbol.unscopables)");
+}
+
 #[wasm_bindgen_test]
 fn value_of() {
     let a = Symbol::for_("foo");

crates/js-sys/tests/wasm/SyntaxError.rs

@@ -0,0 +1,14 @@
+use wasm_bindgen::JsValue;
+use wasm_bindgen_test::*;
+use wasm_bindgen::JsCast;
+use js_sys::*;
+
+#[wasm_bindgen_test]
+fn syntax_error() {
+    let error = SyntaxError::new("msg");
+    assert!(error.is_instance_of::<SyntaxError>());
+    assert!(error.is_instance_of::<Error>());
+
+    let base: &Error = error.as_ref();
+    assert_eq!(JsValue::from(base.message()), "msg");
+}

crates/js-sys/tests/wasm/TypeError.rs

@@ -0,0 +1,14 @@
+use wasm_bindgen::JsValue;
+use wasm_bindgen_test::*;
+use wasm_bindgen::JsCast;
+use js_sys::*;
+
+#[wasm_bindgen_test]
+fn type_error() {
+    let error = TypeError::new("msg");
+    assert!(error.is_instance_of::<TypeError>());
+    assert!(error.is_instance_of::<Error>());
+
+    let base: &Error = error.as_ref();
+    assert_eq!(JsValue::from(base.message()), "msg");
+}

crates/js-sys/tests/wasm/UriError.rs

@@ -0,0 +1,14 @@
+use wasm_bindgen::JsValue;
+use wasm_bindgen_test::*;
+use wasm_bindgen::JsCast;
+use js_sys::*;
+
+#[wasm_bindgen_test]
+fn uri_error() {
+    let error = UriError::new("msg");
+    assert!(error.is_instance_of::<UriError>());
+    assert!(error.is_instance_of::<Error>());
+
+    let base: &Error = error.as_ref();
+    assert_eq!(JsValue::from(base.message()), "msg");
+}

crates/js-sys/tests/wasm/main.rs

@@ -26,12 +26,17 @@ pub mod Math;
 pub mod Number;
 pub mod Object;
 pub mod Proxy;
+pub mod RangeError;
+pub mod ReferenceError;
 pub mod Reflect;
 pub mod RegExp;
 pub mod Set;
 pub mod SetIterator;
 pub mod Symbol;
+pub mod SyntaxError;
+pub mod TypeError;
 pub mod TypedArray;
+pub mod UriError;
 pub mod WeakMap;
 pub mod WeakSet;
 pub mod WebAssembly;