1 use wasm_bindgen::prelude::*;
2 use wasm_bindgen::Clamped;
3 use wasm_bindgen_test::*;
4
5 #[wasm_bindgen(module = "tests/wasm/slice.js")]
6 extern "C" {
js_export()7 fn js_export();
8
js_import()9 fn js_import();
10
js_pass_array()11 fn js_pass_array();
12
js_export_mut()13 fn js_export_mut();
14
js_return_vec()15 fn js_return_vec();
16
js_clamped(val: Clamped<&[u8]>, offset: u8)17 fn js_clamped(val: Clamped<&[u8]>, offset: u8);
18 #[wasm_bindgen(js_name = js_clamped)]
js_clamped2(val: Clamped<Vec<u8>>, offset: u8)19 fn js_clamped2(val: Clamped<Vec<u8>>, offset: u8);
20 #[wasm_bindgen(js_name = js_clamped)]
js_clamped3(val: Clamped<&mut [u8]>, offset: u8)21 fn js_clamped3(val: Clamped<&mut [u8]>, offset: u8);
22 }
23
24 macro_rules! export_macro {
25 ($(($i:ident, $n:ident))*) => ($(
26 #[wasm_bindgen]
27 pub fn $n(a: &[$i]) -> Vec<$i> {
28 assert_eq!(a.len(), 2);
29 assert_eq!(a[0], 1 as $i);
30 assert_eq!(a[1], 2 as $i);
31 a.to_vec()
32 }
33 )*)
34 }
35
36 export_macro! {
37 (i8, export_i8)
38 (u8, export_u8)
39 (i16, export_i16)
40 (u16, export_u16)
41 (i32, export_i32)
42 (u32, export_u32)
43 (isize, export_isize)
44 (usize, export_usize)
45 (f32, export_f32)
46 (f64, export_f64)
47 }
48
49 #[wasm_bindgen_test]
export()50 fn export() {
51 js_export();
52 }
53
54 macro_rules! import_macro {
55 ($(($rust:ident, $js:ident, $i:ident))*) => ($(
56 #[wasm_bindgen(module = "tests/wasm/slice.js")]
57 extern "C" {
58 fn $js(a: &[$i], b: Option<&[$i]>, c: Option<&[$i]>) -> Vec<$i>;
59 }
60
61 #[wasm_bindgen]
62 pub fn $rust(a: &[$i]) -> Vec<$i> {
63 assert_eq!(a.len(), 2);
64 assert_eq!(a[0], 1 as $i);
65 assert_eq!(a[1], 2 as $i);
66 $js(a, Some(a), None)
67 }
68 )*)
69 }
70
71 import_macro! {
72 (import_rust_i8, import_js_i8, i8)
73 (import_rust_u8, import_js_u8, u8)
74 (import_rust_i16, import_js_i16, i16)
75 (import_rust_u16, import_js_u16, u16)
76 (import_rust_i32, import_js_i32, i32)
77 (import_rust_u32, import_js_u32, u32)
78 (import_rust_isize, import_js_isize, isize)
79 (import_rust_usize, import_js_usize, usize)
80 (import_rust_f32, import_js_f32, f32)
81 (import_rust_f64, import_js_f64, f64)
82 }
83
84 #[wasm_bindgen_test]
import()85 fn import() {
86 js_import();
87 }
88
89 macro_rules! pass_array_marco {
90 ($(($rust:ident, $i:ident))*) => ($(
91 #[wasm_bindgen]
92 pub fn $rust(a: &[$i]) {
93 assert_eq!(a.len(), 2);
94 assert_eq!(a[0], 1 as $i);
95 assert_eq!(a[1], 2 as $i);
96 }
97 )*)
98 }
99
100 pass_array_marco! {
101 (pass_array_rust_i8, i8)
102 (pass_array_rust_u8, u8)
103 (pass_array_rust_i16, i16)
104 (pass_array_rust_u16, u16)
105 (pass_array_rust_i32, i32)
106 (pass_array_rust_u32, u32)
107 (pass_array_rust_isize, isize)
108 (pass_array_rust_usize, usize)
109 (pass_array_rust_f32, f32)
110 (pass_array_rust_f64, f64)
111 }
112
113 #[wasm_bindgen_test]
pass_array()114 fn pass_array() {
115 js_pass_array();
116 }
117
118 macro_rules! import_mut_macro {
119 ($(($rust:ident, $js:ident, $i:ident))*) => (
120 $(
121 #[wasm_bindgen(module = "tests/wasm/slice.js")]
122 extern "C" {
123 fn $js(a: &mut [$i], b: Option<&mut [$i]>, c: Option<&mut [$i]>);
124 }
125
126 fn $rust() {
127 let mut buf1 = [
128 1 as $i,
129 2 as $i,
130 3 as $i,
131 ];
132 let mut buf2 = [
133 4 as $i,
134 5 as $i,
135 6 as $i,
136 ];
137 $js(&mut buf1, Some(&mut buf2), None);
138 assert_eq!(buf1[0], 4 as $i);
139 assert_eq!(buf1[1], 5 as $i);
140 assert_eq!(buf1[2], 3 as $i);
141 assert_eq!(buf2[0], 8 as $i);
142 assert_eq!(buf2[1], 7 as $i);
143 assert_eq!(buf2[2], 6 as $i);
144 }
145 )*
146
147 #[wasm_bindgen_test]
148 fn import_mut() {
149 $($rust();)*
150 }
151 )
152 }
153
154 import_mut_macro! {
155 (import_mut_rust_i8, import_mut_js_i8, i8)
156 (import_mut_rust_u8, import_mut_js_u8, u8)
157 (import_mut_rust_i16, import_mut_js_i16, i16)
158 (import_mut_rust_u16, import_mut_js_u16, u16)
159 (import_mut_rust_i32, import_mut_js_i32, i32)
160 (import_mut_rust_u32, import_mut_js_u32, u32)
161 (import_mut_rust_f32, import_mut_js_f32, f32)
162 (import_mut_rust_f64, import_mut_js_f64, f64)
163 }
164
165 macro_rules! export_mut_macro {
166 ($(($i:ident, $n:ident))*) => ($(
167 #[wasm_bindgen]
168 pub fn $n(a: &mut [$i]) {
169 assert_eq!(a.len(), 3);
170 assert_eq!(a[0], 1 as $i);
171 assert_eq!(a[1], 2 as $i);
172 assert_eq!(a[2], 3 as $i);
173 a[0] = 4 as $i;
174 a[1] = 5 as $i;
175 }
176 )*)
177 }
178
179 export_mut_macro! {
180 (i8, export_mut_i8)
181 (u8, export_mut_u8)
182 (i16, export_mut_i16)
183 (u16, export_mut_u16)
184 (i32, export_mut_i32)
185 (u32, export_mut_u32)
186 (isize, export_mut_isize)
187 (usize, export_mut_usize)
188 (f32, export_mut_f32)
189 (f64, export_mut_f64)
190 }
191
192 #[wasm_bindgen_test]
export_mut()193 fn export_mut() {
194 js_export_mut();
195 }
196
197 #[wasm_bindgen]
return_vec_broken_vec() -> Vec<u32>198 pub fn return_vec_broken_vec() -> Vec<u32> {
199 vec![1, 2, 3, 4, 5, 6, 7, 8, 9]
200 }
201
202 #[wasm_bindgen]
return_vec_web_main() -> ReturnVecApplication203 pub fn return_vec_web_main() -> ReturnVecApplication {
204 ReturnVecApplication::new()
205 }
206
207 #[wasm_bindgen]
208 pub struct ReturnVecApplication {
209 thing: Vec<u32>,
210 }
211
212 #[wasm_bindgen]
213 impl ReturnVecApplication {
new() -> ReturnVecApplication214 pub fn new() -> ReturnVecApplication {
215 let mut thing = vec![];
216 thing.push(0);
217 thing.push(0);
218 thing.push(0);
219 thing.push(0);
220 thing.push(0);
221
222 ReturnVecApplication { thing }
223 }
224
tick(&mut self)225 pub fn tick(&mut self) {
226 self.thing = self.thing.clone();
227 }
228 }
229
230 #[wasm_bindgen_test]
return_vec()231 fn return_vec() {
232 js_return_vec();
233 }
234
235 #[wasm_bindgen_test]
take_clamped()236 fn take_clamped() {
237 js_clamped(Clamped(&[1, 2, 3]), 1);
238 js_clamped2(Clamped(vec![4, 5, 6]), 4);
239 js_clamped3(Clamped(&mut [7, 8, 9]), 7);
240 }
241