Debian Codegraph @

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

raw
1 use std::fmt;
2 use wasm_bindgen::prelude::*;
3 use wasm_bindgen_test::*;
4
5 #[derive(Clone, Debug)]
6 pub enum MyError {
7 Variant,
8 InflightShouldBeFalse,
9 }
10 // shouldn't technically need this, surely
11 impl std::error::Error for MyError {}
12 impl fmt::Display for MyError {
13 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14 write!(f, "MyError::{:?}", self)
15 }
16 }
17
18 #[wasm_bindgen(module = "tests/wasm/result.js")]
19 extern "C" {
20 fn error_new(message: &str) -> JsValue;
21 }
22
23 impl From<MyError> for JsValue {
24 fn from(e: MyError) -> Self {
25 error_new(&format!("{}", e))
26 }
27 }
28
29 macro_rules! call_test {
30 ($test_fn:ident, $js_fn:ident) => {
31 #[wasm_bindgen_test]
32 fn $test_fn() {
33 #[wasm_bindgen(module = "tests/wasm/result.js")]
34 extern "C" {
35 fn $js_fn();
36 }
37 $js_fn();
38 }
39 };
40 }
41
42 #[wasm_bindgen]
43 pub fn return_my_err() -> Result<i32, MyError> {
44 let e = Err(MyError::Variant)?;
45 Ok(e)
46 }
47 call_test!(test_err, call_err);
48
49 #[wasm_bindgen]
50 pub fn return_my_ok() -> Result<i32, MyError> {
51 Ok(5)
52 }
53 call_test!(test_ok, call_ok);
54
55 #[wasm_bindgen]
56 pub struct Struct {
57 inflight: bool,
58 }
59
60 call_test!(test_struct, all_struct_methods);
61
62 struct ResetOnDrop<'a> {
63 flag: &'a mut bool,
64 }
65
66 impl<'a> Drop for ResetOnDrop<'a> {
67 fn drop(&mut self) {
68 *self.flag = false;
69 }
70 }
71
72 impl<'a> ResetOnDrop<'a> {
73 fn new(flag: &'a mut bool) -> Result<Self, MyError> {
74 if *flag {
75 return Err(MyError::InflightShouldBeFalse);
76 }
77 Ok(Self { flag })
78 }
79 }
80
81 #[wasm_bindgen]
82 impl Struct {
83 #[wasm_bindgen]
84 pub fn new() -> Result<Struct, MyError> {
85 Ok(Struct { inflight: false })
86 }
87
88 #[wasm_bindgen]
89 pub fn new_err() -> Result<Struct, MyError> {
90 Err(MyError::Variant)
91 }
92
93 #[wasm_bindgen]
94 pub fn return_ok(&mut self) -> Result<i32, MyError> {
95 let _guard = ResetOnDrop::new(&mut self.inflight)?;
96 Ok(5)
97 }
98
99 #[wasm_bindgen]
100 pub fn return_err(&mut self) -> Result<i32, MyError> {
101 let guard = ResetOnDrop::new(&mut self.inflight)?;
102 let err = Err(MyError::Variant);
103 let nope = err?;
104 // we are checking both for the flag being reset (from js, via is_inflight)
105 // and for the running of drop code
106 drop(guard);
107 Ok(nope)
108 }
109
110 #[wasm_bindgen]
111 pub fn is_inflight(&self) -> bool {
112 self.inflight
113 }
114 }
115
116 // check some more Ok types
117 #[wasm_bindgen]
118 pub fn return_string() -> Result<String, MyError> {
119 Ok("string here".into())
120 }
121 call_test!(test_return_string, call_return_string);
122
123 // now we check that jsvalue works, as it did before
124
125 #[wasm_bindgen]
126 pub fn return_jsvalue_ok() -> Result<i32, JsValue> {
127 Ok(5)
128 }
129 call_test!(test_jsvalue_ok, call_jsvalue_ok);
130
131 #[wasm_bindgen]
132 pub fn return_jsvalue_err() -> Result<i32, JsValue> {
133 Err(JsValue::from(-1i32))
134 }
135 call_test!(test_jsvalue_err, call_jsvalue_err);
136
137 // test strings (they have a deferred free, in a finally block: tricky)
138 #[wasm_bindgen]
139 pub fn return_string_ok() -> Result<String, String> {
140 Ok("Ok".into())
141 }
142 call_test!(test_string_ok, call_string_ok);
143 #[wasm_bindgen]
144 pub fn return_string_err() -> Result<String, String> {
145 Err("Er".into())
146 }
147 call_test!(test_string_err, call_string_err);
148
149 // test enums
150 #[wasm_bindgen]
151 pub enum MyEnum {
152 One = 1,
153 Two = 2,
154 }
155 #[wasm_bindgen]
156 pub fn return_enum_ok() -> Result<MyEnum, MyError> {
157 Ok(MyEnum::Two)
158 }
159 call_test!(test_enum_ok, call_enum_ok);
160 #[wasm_bindgen]
161 pub fn return_enum_err() -> Result<MyEnum, MyError> {
162 Err(MyError::Variant)
163 }
164 call_test!(test_enum_err, call_enum_err);
165
166 // T = Unit
167 #[wasm_bindgen]
168 pub fn return_unit_ok() -> Result<(), MyError> {
169 Ok(())
170 }
171 #[wasm_bindgen]
172 pub fn return_unit_err() -> Result<(), MyError> {
173 Err(MyError::Variant)
174 }
175 call_test!(test_unit, call_unit);
176
177 // T = Option<f64>
178 #[wasm_bindgen]
179 pub fn return_option_ok_some() -> Result<Option<f64>, MyError> {
180 Ok(Some(10f64))
181 }
182 #[wasm_bindgen]
183 pub fn return_option_ok_none() -> Result<Option<f64>, MyError> {
184 Ok(None)
185 }
186 #[wasm_bindgen]
187 pub fn return_option_err() -> Result<Option<f64>, MyError> {
188 Err(MyError::Variant)
189 }
190 call_test!(test_option, call_option);