RPM build fix (reverted CI changes which will need to be un-reverted or made conditional) and vendor Rust dependencies to make builds much faster in any CI system.

zeroidc/vendor/js-sys/tests/wasm/WebAssembly.rs

@@ -0,0 +1,215 @@
+use js_sys::*;
+use wasm_bindgen::{prelude::*, JsCast};
+use wasm_bindgen_futures::JsFuture;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen(module = "tests/wasm/WebAssembly.js")]
+extern "C" {
+    #[wasm_bindgen(js_name = getWasmArray)]
+    fn get_wasm_array() -> Uint8Array;
+
+    #[wasm_bindgen(js_name = getTableObject)]
+    fn get_table_object() -> Object;
+
+    #[wasm_bindgen(js_name = getInvalidTableObject)]
+    fn get_invalid_table_object() -> Object;
+
+    #[wasm_bindgen(js_name = getImports)]
+    fn get_imports() -> Object;
+}
+
+fn get_invalid_wasm() -> JsValue {
+    ArrayBuffer::new(42).into()
+}
+
+fn get_bad_type_wasm() -> JsValue {
+    2.into()
+}
+
+fn get_valid_wasm() -> JsValue {
+    get_wasm_array().into()
+}
+
+#[wasm_bindgen_test]
+fn validate() {
+    assert!(!WebAssembly::validate(&get_invalid_wasm()).unwrap());
+
+    assert!(WebAssembly::validate(&get_bad_type_wasm()).is_err());
+}
+
+#[wasm_bindgen_test]
+async fn compile_compile_error() {
+    let p = WebAssembly::compile(&get_invalid_wasm());
+    let e = JsFuture::from(p).await.unwrap_err();
+    assert!(e.is_instance_of::<WebAssembly::CompileError>());
+}
+
+#[wasm_bindgen_test]
+async fn compile_type_error() {
+    let p = WebAssembly::compile(&get_bad_type_wasm());
+    let e = JsFuture::from(p).await.unwrap_err();
+    assert!(e.is_instance_of::<TypeError>());
+}
+
+#[wasm_bindgen_test]
+async fn compile_valid() {
+    let p = WebAssembly::compile(&get_valid_wasm());
+    let module = JsFuture::from(p).await.unwrap();
+    assert!(module.is_instance_of::<WebAssembly::Module>());
+}
+
+#[wasm_bindgen_test]
+fn module_inheritance() {
+    let module = WebAssembly::Module::new(&get_valid_wasm()).unwrap();
+    assert!(module.is_instance_of::<WebAssembly::Module>());
+    assert!(module.is_instance_of::<Object>());
+
+    let _: &Object = module.as_ref();
+}
+
+#[wasm_bindgen_test]
+fn module_error() {
+    let error = WebAssembly::Module::new(&get_invalid_wasm()).err().unwrap();
+    assert!(error.is_instance_of::<WebAssembly::CompileError>());
+
+    let error = WebAssembly::Module::new(&get_bad_type_wasm())
+        .err()
+        .unwrap();
+    assert!(error.is_instance_of::<TypeError>());
+}
+
+#[wasm_bindgen_test]
+fn module_custom_sections() {
+    let module = WebAssembly::Module::new(&get_valid_wasm()).unwrap();
+    let cust_sec = WebAssembly::Module::custom_sections(&module, "abcd");
+    assert_eq!(cust_sec.length(), 0);
+}
+
+#[wasm_bindgen_test]
+fn module_exports() {
+    let module = WebAssembly::Module::new(&get_valid_wasm()).unwrap();
+    let exports = WebAssembly::Module::exports(&module);
+    assert_eq!(exports.length(), 1);
+}
+
+#[wasm_bindgen_test]
+fn module_imports() {
+    let module = WebAssembly::Module::new(&get_valid_wasm()).unwrap();
+    let imports = WebAssembly::Module::imports(&module);
+    assert_eq!(imports.length(), 1);
+}
+
+#[wasm_bindgen_test]
+fn table_inheritance() {
+    let table = WebAssembly::Table::new(&get_table_object().into()).unwrap();
+    assert!(table.is_instance_of::<WebAssembly::Table>());
+    assert!(table.is_instance_of::<Object>());
+
+    let _: &Object = table.as_ref();
+}
+
+#[wasm_bindgen_test]
+fn table_error() {
+    let error = WebAssembly::Table::new(&get_invalid_table_object())
+        .err()
+        .unwrap();
+    assert!(error.is_instance_of::<RangeError>());
+}
+
+#[wasm_bindgen_test]
+fn table() {
+    let table = WebAssembly::Table::new(&get_table_object().into()).unwrap();
+    assert_eq!(table.length(), 1);
+
+    assert!(table.get(0).is_ok());
+    assert!(table.get(999).is_err());
+
+    table.grow(1).unwrap();
+    assert_eq!(table.length(), 2);
+
+    let f = table.get(0).unwrap();
+    table.set(1, &f).unwrap();
+}
+
+#[wasm_bindgen_test]
+fn compile_error_inheritance() {
+    let error = WebAssembly::CompileError::new("");
+    assert!(error.is_instance_of::<WebAssembly::CompileError>());
+    assert!(error.is_instance_of::<Error>());
+
+    let _: &Error = error.as_ref();
+}
+
+#[wasm_bindgen_test]
+fn link_error_inheritance() {
+    let error = WebAssembly::LinkError::new("");
+    assert!(error.is_instance_of::<WebAssembly::LinkError>());
+    assert!(error.is_instance_of::<Error>());
+
+    let _: &Error = error.as_ref();
+}
+
+#[wasm_bindgen_test]
+fn runtime_error_inheritance() {
+    let error = WebAssembly::RuntimeError::new("");
+    assert!(error.is_instance_of::<WebAssembly::RuntimeError>());
+    assert!(error.is_instance_of::<Error>());
+
+    let _: &Error = error.as_ref();
+}
+
+#[wasm_bindgen_test]
+fn webassembly_instance() {
+    let module = WebAssembly::Module::new(&get_valid_wasm()).unwrap();
+    let imports = get_imports();
+    let instance = WebAssembly::Instance::new(&module, &imports).unwrap();
+
+    // Inheritance chain is correct.
+    assert!(instance.is_instance_of::<WebAssembly::Instance>());
+    assert!(instance.is_instance_of::<Object>());
+    let _: &Object = instance.as_ref();
+
+    // Has expected exports.
+    let exports = instance.exports();
+    assert!(Reflect::has(exports.as_ref(), &"exported_func".into()).unwrap());
+}
+
+#[wasm_bindgen_test]
+async fn instantiate_module() {
+    let module = WebAssembly::Module::new(&get_valid_wasm()).unwrap();
+    let imports = get_imports();
+    let p = WebAssembly::instantiate_module(&module, &imports);
+    let inst = JsFuture::from(p).await.unwrap();
+    assert!(inst.is_instance_of::<WebAssembly::Instance>());
+}
+
+#[wasm_bindgen_test]
+async fn instantiate_streaming() {
+    let response = Promise::resolve(&get_valid_wasm());
+    let imports = get_imports();
+    let p = WebAssembly::instantiate_streaming(&response, &imports);
+    let obj = JsFuture::from(p).await.unwrap();
+    assert!(Reflect::get(obj.as_ref(), &"instance".into())
+        .unwrap()
+        .is_instance_of::<WebAssembly::Instance>());
+}
+
+#[wasm_bindgen_test]
+fn memory_works() {
+    let obj = Object::new();
+    Reflect::set(obj.as_ref(), &"initial".into(), &1.into()).unwrap();
+    let mem = WebAssembly::Memory::new(&obj).unwrap();
+    assert!(mem.is_instance_of::<WebAssembly::Memory>());
+    assert!(mem.is_instance_of::<Object>());
+    assert!(mem.buffer().is_instance_of::<ArrayBuffer>());
+    assert_eq!(mem.grow(1), 1);
+    assert_eq!(mem.grow(2), 2);
+    assert_eq!(mem.grow(3), 4);
+    assert_eq!(
+        mem.buffer()
+            .dyn_into::<ArrayBuffer>()
+            .unwrap()
+            .byte_length(),
+        7 * 64 * 1024,
+    );
+}