Debian Codegraph @

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

raw
1 use js_sys::JsString;
2 use wasm_bindgen::prelude::*;
3 use wasm_bindgen_test::*;
4
5 #[wasm_bindgen(module = "tests/wasm/js_objects.js")]
6 extern "C" {
7 fn simple_foo(s: &JsValue);
8 fn js_simple();
9
10 fn owned_foo(s: JsValue);
11 fn js_owned();
12
13 fn clone_foo1(s: JsValue);
14 fn clone_foo2(s: &JsValue);
15 fn clone_foo3(s: JsValue);
16 fn clone_foo4(s: &JsValue);
17 fn clone_foo5(s: JsValue);
18 fn js_clone();
19
20 fn promote_foo1(s: &JsValue);
21 fn promote_foo2(s: JsValue);
22 fn promote_foo3(s: &JsValue);
23 fn promote_foo4(s: JsValue);
24 fn js_promote();
25
26 fn returning_vector_foo() -> JsValue;
27 fn js_returning_vector();
28 fn js_another_vector_return();
29
30 fn returning_vector_string_foo() -> JsString;
31 fn js_returning_vector_string();
32 fn js_another_vector_string_return();
33
34 fn verify_serde(val: JsValue) -> JsValue;
35 }
36
37 #[wasm_bindgen]
38 pub fn simple_bar(s: &JsValue) {
39 simple_foo(s);
40 }
41
42 #[wasm_bindgen_test]
43 fn simple() {
44 js_simple();
45 }
46
47 #[wasm_bindgen]
48 pub fn owned_bar(s: JsValue) {
49 owned_foo(s);
50 }
51
52 #[wasm_bindgen_test]
53 fn owned() {
54 js_owned();
55 }
56
57 #[wasm_bindgen]
58 pub fn clone_bar(s: JsValue) {
59 clone_foo1(s.clone());
60 clone_foo2(&s);
61 clone_foo3(s.clone());
62 clone_foo4(&s);
63 clone_foo5(s);
64 }
65
66 #[wasm_bindgen_test]
67 fn clone() {
68 js_clone();
69 }
70
71 #[wasm_bindgen]
72 pub fn promote_bar(s: &JsValue) {
73 promote_foo1(s);
74 promote_foo2(s.clone());
75 promote_foo3(s);
76 promote_foo4(s.clone());
77 }
78
79 #[wasm_bindgen_test]
80 fn promote() {
81 js_promote();
82 }
83
84 #[wasm_bindgen]
85 pub fn returning_vector_bar() -> Vec<JsValue> {
86 let mut res = Vec::new();
87 for _ in 0..10 {
88 res.push(returning_vector_foo())
89 }
90 res
91 }
92
93 #[wasm_bindgen_test]
94 fn returning_vector() {
95 js_returning_vector();
96 }
97
98 #[wasm_bindgen]
99 pub fn another_vector_return_get_array() -> Vec<JsValue> {
100 vec![
101 JsValue::from(1),
102 JsValue::from(2),
103 JsValue::from(3),
104 JsValue::from(4),
105 JsValue::from(5),
106 JsValue::from(6),
107 ]
108 }
109
110 #[wasm_bindgen_test]
111 fn another_vector_return() {
112 js_another_vector_return();
113 }
114
115 #[wasm_bindgen]
116 pub fn returning_vector_string_bar() -> Vec<JsString> {
117 let mut res = Vec::new();
118 for _ in 0..10 {
119 res.push(returning_vector_string_foo())
120 }
121 res
122 }
123
124 #[wasm_bindgen_test]
125 fn returning_vector_string() {
126 js_returning_vector_string();
127 }
128
129 #[wasm_bindgen]
130 pub fn another_vector_string_return_get_array() -> Vec<JsString> {
131 vec![
132 "1".into(),
133 "2".into(),
134 "3".into(),
135 "4".into(),
136 "5".into(),
137 "6".into(),
138 ]
139 }
140
141 #[wasm_bindgen_test]
142 fn another_vector_string_return() {
143 js_another_vector_string_return();
144 }
145
146 #[cfg(feature = "serde-serialize")]
147 #[wasm_bindgen_test]
148 #[allow(deprecated)]
149 fn serde() {
150 #[derive(Deserialize, Serialize)]
151 pub struct SerdeFoo {
152 a: u32,
153 b: String,
154 c: Option<SerdeBar>,
155 d: SerdeBar,
156 }
157
158 #[derive(Deserialize, Serialize)]
159 pub struct SerdeBar {
160 a: u32,
161 }
162
163 let js = JsValue::from_serde("foo").unwrap();
164 assert_eq!(js.as_string(), Some("foo".to_string()));
165
166 let ret = verify_serde(
167 JsValue::from_serde(&SerdeFoo {
168 a: 0,
169 b: "foo".to_string(),
170 c: None,
171 d: SerdeBar { a: 1 },
172 })
173 .unwrap(),
174 );
175
176 let result = ret.into_serde::<SerdeFoo>().unwrap();
177 assert_eq!(result.a, 2);
178 assert_eq!(result.b, "bar");
179 assert!(result.c.is_some());
180 assert_eq!(result.c.as_ref().unwrap().a, 3);
181 assert_eq!(result.d.a, 4);
182
183 assert_eq!(JsValue::from("bar").into_serde::<String>().unwrap(), "bar");
184 assert_eq!(JsValue::undefined().into_serde::<i32>().ok(), None);
185 }