Debian Codegraph @

.cargo/vendor/wasm-bindgen/tests/wasm/api.rs

raw
1 use js_sys::{Uint8Array, WebAssembly};
2 use wasm_bindgen::prelude::*;
3 use wasm_bindgen_test::*;
4
5 #[wasm_bindgen(module = "tests/wasm/api.js")]
6 extern "C" {
7 fn js_works();
8 fn js_eq_works();
9 fn assert_null(v: JsValue);
10 fn debug_values() -> JsValue;
11 fn assert_function_table(a: JsValue, b: usize);
12 }
13
14 #[wasm_bindgen_test]
15 fn works() {
16 js_works();
17 }
18
19 #[wasm_bindgen]
20 pub fn api_foo() -> JsValue {
21 JsValue::from("foo")
22 }
23
24 #[wasm_bindgen]
25 pub fn api_bar(s: &str) -> JsValue {
26 JsValue::from(s)
27 }
28
29 #[wasm_bindgen]
30 pub fn api_baz() -> JsValue {
31 JsValue::from(1.0)
32 }
33
34 #[wasm_bindgen]
35 pub fn api_baz2(a: &JsValue, b: &JsValue) {
36 assert_eq!(a.as_f64(), Some(2.0));
37 assert_eq!(b.as_f64(), None);
38 }
39
40 #[wasm_bindgen]
41 pub fn api_js_null() -> JsValue {
42 JsValue::null()
43 }
44
45 #[wasm_bindgen]
46 pub fn api_js_undefined() -> JsValue {
47 JsValue::undefined()
48 }
49
50 #[wasm_bindgen]
51 pub fn api_test_is_null_undefined(a: &JsValue, b: &JsValue, c: &JsValue) {
52 assert!(a.is_null());
53 assert!(!a.is_undefined());
54
55 assert!(!b.is_null());
56 assert!(b.is_undefined());
57
58 assert!(!c.is_null());
59 assert!(!c.is_undefined());
60 }
61
62 #[wasm_bindgen]
63 pub fn api_get_true() -> JsValue {
64 JsValue::from(true)
65 }
66
67 #[wasm_bindgen]
68 pub fn api_get_false() -> JsValue {
69 JsValue::from(false)
70 }
71
72 #[wasm_bindgen]
73 pub fn api_test_bool(a: &JsValue, b: &JsValue, c: &JsValue) {
74 assert_eq!(a.as_bool(), Some(true));
75 assert_eq!(format!("{:?}", a), "JsValue(true)");
76 assert_eq!(b.as_bool(), Some(false));
77 assert_eq!(c.as_bool(), None);
78 }
79
80 #[wasm_bindgen]
81 pub fn api_mk_symbol() -> JsValue {
82 let a = JsValue::symbol(None);
83 assert!(a.is_symbol());
84 assert_eq!(format!("{:?}", a), "JsValue(Symbol)");
85 a
86 }
87
88 #[wasm_bindgen]
89 pub fn api_mk_symbol2(s: &str) -> JsValue {
90 let a = JsValue::symbol(Some(s));
91 assert!(a.is_symbol());
92 a
93 }
94
95 #[wasm_bindgen]
96 pub fn api_assert_symbols(a: &JsValue, b: &JsValue) {
97 assert!(a.is_symbol());
98 assert!(!b.is_symbol());
99 }
100
101 #[wasm_bindgen]
102 pub fn api_acquire_string(a: &JsValue, b: &JsValue) {
103 assert_eq!(a.as_string().unwrap(), "foo");
104 assert_eq!(format!("{:?}", a), "JsValue(\"foo\")");
105 assert_eq!(b.as_string(), None);
106 }
107
108 #[wasm_bindgen]
109 pub fn api_acquire_string2(a: &JsValue) -> String {
110 a.as_string().unwrap_or("wrong".to_string())
111 }
112
113 #[wasm_bindgen_test]
114 fn eq_works() {
115 js_eq_works();
116 }
117
118 #[wasm_bindgen]
119 pub fn eq_test(a: &JsValue, b: &JsValue) -> bool {
120 a == b
121 }
122
123 #[wasm_bindgen]
124 #[allow(clippy::eq_op)]
125 pub fn eq_test1(a: &JsValue) -> bool {
126 a == a
127 }
128
129 #[wasm_bindgen(variadic)]
130 pub fn api_completely_variadic(args: &JsValue) -> JsValue {
131 args.into()
132 }
133
134 #[wasm_bindgen(variadic)]
135 pub fn api_variadic_with_prefixed_params(
136 _first: &JsValue,
137 _second: &JsValue,
138 args: &JsValue,
139 ) -> JsValue {
140 args.into()
141 }
142
143 #[wasm_bindgen_test]
144 fn null_keeps_working() {
145 assert_null(JsValue::null());
146 assert_null(JsValue::null());
147 }
148
149 #[wasm_bindgen_test]
150 fn memory_accessor_appears_to_work() {
151 let data = 3u32;
152 let ptr = &data as *const u32 as u32;
153
154 let my_mem = wasm_bindgen::memory();
155 let mem = my_mem.dyn_into::<WebAssembly::Memory>().unwrap();
156 let buf = mem.buffer();
157 let slice = Uint8Array::new(&buf);
158 let mut v = Vec::new();
159 slice
160 .subarray(ptr, ptr + 4)
161 .for_each(&mut |val, _, _| v.push(val));
162 assert_eq!(v, [3, 0, 0, 0]);
163 }
164
165 #[wasm_bindgen_test]
166 fn debug_output() {
167 let test_iter = debug_values()
168 .dyn_into::<js_sys::Array>()
169 .unwrap()
170 .values()
171 .into_iter();
172 let expecteds = vec![
173 "JsValue(null)",
174 "JsValue(undefined)",
175 "JsValue(0)",
176 "JsValue(1)",
177 "JsValue(true)",
178 "JsValue([1, 2, 3])",
179 "JsValue(\"string\")",
180 "JsValue(Object({\"test\":\"object\"}))",
181 "JsValue([1, [2, 3]])",
182 "JsValue(Function)",
183 "JsValue(Set)",
184 ];
185 for (test, expected) in test_iter.zip(expecteds) {
186 assert_eq!(format!("{:?}", test.unwrap()), expected);
187 }
188 }
189
190 #[wasm_bindgen_test]
191 fn function_table_is() {
192 assert_function_table(
193 wasm_bindgen::function_table(),
194 function_table_lookup as usize,
195 );
196 }
197
198 #[no_mangle]
199 pub extern "C" fn function_table_lookup() {}