1 use js_sys::*;
2 use wasm_bindgen::{prelude::*, JsCast};
3 use wasm_bindgen_futures::JsFuture;
4 use wasm_bindgen_test::*;
5
6 #[wasm_bindgen(module = "tests/wasm/WebAssembly.js")]
7 extern "C" {
8 #[wasm_bindgen(js_name = getWasmArray)]
get_wasm_array() -> Uint8Array9 fn get_wasm_array() -> Uint8Array;
10
11 #[wasm_bindgen(js_name = getTableObject)]
get_table_object() -> Object12 fn get_table_object() -> Object;
13
14 #[wasm_bindgen(js_name = getInvalidTableObject)]
get_invalid_table_object() -> Object15 fn get_invalid_table_object() -> Object;
16
17 #[wasm_bindgen(js_name = getImports)]
get_imports() -> Object18 fn get_imports() -> Object;
19 }
20
get_invalid_wasm() -> JsValue21 fn get_invalid_wasm() -> JsValue {
22 ArrayBuffer::new(42).into()
23 }
24
get_bad_type_wasm() -> JsValue25 fn get_bad_type_wasm() -> JsValue {
26 2.into()
27 }
28
get_valid_wasm() -> JsValue29 fn get_valid_wasm() -> JsValue {
30 get_wasm_array().into()
31 }
32
33 #[wasm_bindgen_test]
validate()34 fn validate() {
35 assert!(!WebAssembly::validate(&get_invalid_wasm()).unwrap());
36
37 assert!(WebAssembly::validate(&get_bad_type_wasm()).is_err());
38 }
39
40 #[wasm_bindgen_test]
compile_compile_error()41 async fn compile_compile_error() {
42 let p = WebAssembly::compile(&get_invalid_wasm());
43 let e = JsFuture::from(p).await.unwrap_err();
44 assert!(e.is_instance_of::<WebAssembly::CompileError>());
45 }
46
47 #[wasm_bindgen_test]
compile_type_error()48 async fn compile_type_error() {
49 let p = WebAssembly::compile(&get_bad_type_wasm());
50 let e = JsFuture::from(p).await.unwrap_err();
51 assert!(e.is_instance_of::<TypeError>());
52 }
53
54 #[wasm_bindgen_test]
compile_valid()55 async fn compile_valid() {
56 let p = WebAssembly::compile(&get_valid_wasm());
57 let module = JsFuture::from(p).await.unwrap();
58 assert!(module.is_instance_of::<WebAssembly::Module>());
59 }
60
61 #[wasm_bindgen_test]
module_inheritance()62 fn module_inheritance() {
63 let module = WebAssembly::Module::new(&get_valid_wasm()).unwrap();
64 assert!(module.is_instance_of::<WebAssembly::Module>());
65 assert!(module.is_instance_of::<Object>());
66
67 let _: &Object = module.as_ref();
68 }
69
70 #[wasm_bindgen_test]
module_error()71 fn module_error() {
72 let error = WebAssembly::Module::new(&get_invalid_wasm()).err().unwrap();
73 assert!(error.is_instance_of::<WebAssembly::CompileError>());
74
75 let error = WebAssembly::Module::new(&get_bad_type_wasm())
76 .err()
77 .unwrap();
78 assert!(error.is_instance_of::<TypeError>());
79 }
80
81 #[wasm_bindgen_test]
module_custom_sections()82 fn module_custom_sections() {
83 let module = WebAssembly::Module::new(&get_valid_wasm()).unwrap();
84 let cust_sec = WebAssembly::Module::custom_sections(&module, "abcd");
85 assert_eq!(cust_sec.length(), 0);
86 }
87
88 #[wasm_bindgen_test]
module_exports()89 fn module_exports() {
90 let module = WebAssembly::Module::new(&get_valid_wasm()).unwrap();
91 let exports = WebAssembly::Module::exports(&module);
92 assert_eq!(exports.length(), 1);
93 }
94
95 #[wasm_bindgen_test]
module_imports()96 fn module_imports() {
97 let module = WebAssembly::Module::new(&get_valid_wasm()).unwrap();
98 let imports = WebAssembly::Module::imports(&module);
99 assert_eq!(imports.length(), 1);
100 }
101
102 #[wasm_bindgen_test]
table_inheritance()103 fn table_inheritance() {
104 let table = WebAssembly::Table::new(&get_table_object().into()).unwrap();
105 assert!(table.is_instance_of::<WebAssembly::Table>());
106 assert!(table.is_instance_of::<Object>());
107
108 let _: &Object = table.as_ref();
109 }
110
111 #[wasm_bindgen_test]
table_error()112 fn table_error() {
113 let error = WebAssembly::Table::new(&get_invalid_table_object())
114 .err()
115 .unwrap();
116 assert!(error.is_instance_of::<RangeError>());
117 }
118
119 #[wasm_bindgen_test]
table()120 fn table() {
121 let table = WebAssembly::Table::new(&get_table_object().into()).unwrap();
122 assert_eq!(table.length(), 1);
123
124 assert!(table.get(0).is_ok());
125 assert!(table.get(999).is_err());
126
127 table.grow(1).unwrap();
128 assert_eq!(table.length(), 2);
129
130 let f = table.get(0).unwrap();
131 table.set(1, &f).unwrap();
132 }
133
134 #[wasm_bindgen_test]
compile_error_inheritance()135 fn compile_error_inheritance() {
136 let error = WebAssembly::CompileError::new("");
137 assert!(error.is_instance_of::<WebAssembly::CompileError>());
138 assert!(error.is_instance_of::<Error>());
139
140 let _: &Error = error.as_ref();
141 }
142
143 #[wasm_bindgen_test]
link_error_inheritance()144 fn link_error_inheritance() {
145 let error = WebAssembly::LinkError::new("");
146 assert!(error.is_instance_of::<WebAssembly::LinkError>());
147 assert!(error.is_instance_of::<Error>());
148
149 let _: &Error = error.as_ref();
150 }
151
152 #[wasm_bindgen_test]
runtime_error_inheritance()153 fn runtime_error_inheritance() {
154 let error = WebAssembly::RuntimeError::new("");
155 assert!(error.is_instance_of::<WebAssembly::RuntimeError>());
156 assert!(error.is_instance_of::<Error>());
157
158 let _: &Error = error.as_ref();
159 }
160
161 #[wasm_bindgen_test]
webassembly_instance()162 fn webassembly_instance() {
163 let module = WebAssembly::Module::new(&get_valid_wasm()).unwrap();
164 let imports = get_imports();
165 let instance = WebAssembly::Instance::new(&module, &imports).unwrap();
166
167 // Inheritance chain is correct.
168 assert!(instance.is_instance_of::<WebAssembly::Instance>());
169 assert!(instance.is_instance_of::<Object>());
170 let _: &Object = instance.as_ref();
171
172 // Has expected exports.
173 let exports = instance.exports();
174 assert!(Reflect::has(exports.as_ref(), &"exported_func".into()).unwrap());
175 }
176
177 #[wasm_bindgen_test]
instantiate_module()178 async fn instantiate_module() {
179 let module = WebAssembly::Module::new(&get_valid_wasm()).unwrap();
180 let imports = get_imports();
181 let p = WebAssembly::instantiate_module(&module, &imports);
182 let inst = JsFuture::from(p).await.unwrap();
183 assert!(inst.is_instance_of::<WebAssembly::Instance>());
184 }
185
186 #[wasm_bindgen_test]
instantiate_streaming()187 async fn instantiate_streaming() {
188 let response = Promise::resolve(&get_valid_wasm());
189 let imports = get_imports();
190 let p = WebAssembly::instantiate_streaming(&response, &imports);
191 let obj = JsFuture::from(p).await.unwrap();
192 assert!(Reflect::get(obj.as_ref(), &"instance".into())
193 .unwrap()
194 .is_instance_of::<WebAssembly::Instance>());
195 }
196
197 #[wasm_bindgen_test]
memory_works()198 fn memory_works() {
199 let obj = Object::new();
200 Reflect::set(obj.as_ref(), &"initial".into(), &1.into()).unwrap();
201 let mem = WebAssembly::Memory::new(&obj).unwrap();
202 assert!(mem.is_instance_of::<WebAssembly::Memory>());
203 assert!(mem.is_instance_of::<Object>());
204 assert!(mem.buffer().is_instance_of::<ArrayBuffer>());
205 assert_eq!(mem.grow(1), 1);
206 assert_eq!(mem.grow(2), 2);
207 assert_eq!(mem.grow(3), 4);
208 assert_eq!(
209 mem.buffer()
210 .dyn_into::<ArrayBuffer>()
211 .unwrap()
212 .byte_length(),
213 7 * 64 * 1024,
214 );
215 }
216