| 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() {} |