1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
use wasm_bindgen::prelude::*;
use wasm_bindgen::JsError;
use wasm_bindgen_test::*;
use std::fmt;
#[derive(Clone, Debug)]
enum MyError {
Variant,
InflightShouldBeFalse,
}
// shouldn't technically need this, surely
impl std::error::Error for MyError {}
impl fmt::Display for MyError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "MyError::{:?}", self)
}
}
macro_rules! call_test {
($test_fn:ident, $js_fn:ident) => {
#[wasm_bindgen_test]
fn $test_fn() {
#[wasm_bindgen(module = "tests/wasm/result_jserror.js")]
extern "C" {
fn $js_fn();
}
$js_fn();
}
};
}
#[wasm_bindgen]
pub fn return_err() -> Result<i32, JsError> {
let e = Err(MyError::Variant)?;
Ok(e)
}
call_test!(test_err, call_err);
#[wasm_bindgen]
pub fn return_ok() -> Result<i32, JsError> {
Ok(5)
}
call_test!(test_ok, call_ok);
#[wasm_bindgen]
pub fn make_an_error() -> JsError {
JsError::new("un-thrown error")
}
call_test!(test_make_an_error, call_make_an_error);
#[wasm_bindgen]
pub struct MyStruct {
inflight: bool,
}
call_test!(test_struct, all_struct_methods);
struct ResetOnDrop<'a> {
flag: &'a mut bool,
}
impl<'a> Drop for ResetOnDrop<'a> {
fn drop(&mut self) {
*self.flag = false;
}
}
impl<'a> ResetOnDrop<'a> {
fn new(flag: &'a mut bool) -> Result<Self, MyError> {
if *flag {
return Err(MyError::InflightShouldBeFalse);
}
Ok(Self { flag })
}
}
#[wasm_bindgen]
impl MyStruct {
#[wasm_bindgen]
pub fn new() -> Result<MyStruct, JsError> {
Ok(MyStruct { inflight: false })
}
#[wasm_bindgen]
pub fn new_err() -> Result<MyStruct, JsError> {
Err(MyError::Variant.into())
}
#[wasm_bindgen]
pub fn return_ok(&mut self) -> Result<i32, JsError> {
let _guard = ResetOnDrop::new(&mut self.inflight)?;
Ok(5)
}
#[wasm_bindgen]
pub fn return_err(&mut self) -> Result<i32, JsError> {
let guard = ResetOnDrop::new(&mut self.inflight)?;
let err = Err(MyError::Variant);
let nope = err?;
// we are checking both for the flag being reset (from js, via is_inflight)
// and for the running of drop code
drop(guard);
Ok(nope)
}
#[wasm_bindgen]
pub fn is_inflight(&self) -> bool {
self.inflight
}
}
// check some more Ok types
#[wasm_bindgen]
pub fn jserror_return_string() -> Result<String, JsError> {
Ok("string here".into())
}
call_test!(test_return_string, call_return_string);
|
