Debian Codegraph @

.cargo/vendor/wasm-bindgen/tests/wasm/slice.js

raw
1 const wasm = require('wasm-bindgen-test.js');
2 const assert = require('assert');
3
4 exports.js_export = () => {
5 const i8 = new Int8Array(2);
6 i8[0] = 1;
7 i8[1] = 2;
8 assert.deepStrictEqual(wasm.export_i8(i8), i8);
9 assert.deepStrictEqual(wasm.export_optional_i8(i8), i8);
10 const u8 = new Uint8Array(2);
11 u8[0] = 1;
12 u8[1] = 2;
13 assert.deepStrictEqual(wasm.export_u8(u8), u8);
14 assert.deepStrictEqual(wasm.export_optional_u8(u8), u8);
15
16 const i16 = new Int16Array(2);
17 i16[0] = 1;
18 i16[1] = 2;
19 assert.deepStrictEqual(wasm.export_i16(i16), i16);
20 assert.deepStrictEqual(wasm.export_optional_i16(i16), i16);
21 const u16 = new Uint16Array(2);
22 u16[0] = 1;
23 u16[1] = 2;
24 assert.deepStrictEqual(wasm.export_u16(u16), u16);
25 assert.deepStrictEqual(wasm.export_optional_u16(u16), u16);
26
27 const i32 = new Int32Array(2);
28 i32[0] = 1;
29 i32[1] = 2;
30 assert.deepStrictEqual(wasm.export_i32(i32), i32);
31 assert.deepStrictEqual(wasm.export_optional_i32(i32), i32);
32 assert.deepStrictEqual(wasm.export_isize(i32), i32);
33 assert.deepStrictEqual(wasm.export_optional_isize(i32), i32);
34 const u32 = new Uint32Array(2);
35 u32[0] = 1;
36 u32[1] = 2;
37 assert.deepStrictEqual(wasm.export_u32(u32), u32);
38 assert.deepStrictEqual(wasm.export_optional_u32(u32), u32);
39 assert.deepStrictEqual(wasm.export_usize(u32), u32);
40 assert.deepStrictEqual(wasm.export_optional_usize(u32), u32);
41
42 const f32 = new Float32Array(2);
43 f32[0] = 1;
44 f32[1] = 2;
45 assert.deepStrictEqual(wasm.export_f32(f32), f32);
46 assert.deepStrictEqual(wasm.export_optional_f32(f32), f32);
47 const f64 = new Float64Array(2);
48 f64[0] = 1;
49 f64[1] = 2;
50 assert.deepStrictEqual(wasm.export_f64(f64), f64);
51 assert.deepStrictEqual(wasm.export_optional_f64(f64), f64);
52
53 assert.strictEqual(wasm.export_optional_i8(undefined), undefined);
54 assert.strictEqual(wasm.export_optional_u8(undefined), undefined);
55 assert.strictEqual(wasm.export_optional_i16(undefined), undefined);
56 assert.strictEqual(wasm.export_optional_u16(undefined), undefined);
57 assert.strictEqual(wasm.export_optional_i32(undefined), undefined);
58 assert.strictEqual(wasm.export_optional_isize(undefined), undefined);
59 assert.strictEqual(wasm.export_optional_u32(undefined), undefined);
60 assert.strictEqual(wasm.export_optional_usize(undefined), undefined);
61 assert.strictEqual(wasm.export_optional_f32(undefined), undefined);
62 assert.strictEqual(wasm.export_optional_f64(undefined), undefined);
63 };
64
65 const test_import = (a, b, c) => {
66 assert.strictEqual(a.length, 2);
67 assert.strictEqual(a[0], 1);
68 assert.strictEqual(a[1], 2);
69 assert.strictEqual(b.length, 2);
70 assert.strictEqual(b[0], 1);
71 assert.strictEqual(b[1], 2);
72 assert.strictEqual(c, undefined);
73 return a;
74 };
75
76 exports.import_js_i8 = test_import;
77 exports.import_js_u8 = test_import;
78 exports.import_js_i16 = test_import;
79 exports.import_js_u16 = test_import;
80 exports.import_js_i32 = test_import;
81 exports.import_js_isize = test_import;
82 exports.import_js_u32 = test_import;
83 exports.import_js_usize = test_import;
84 exports.import_js_f32 = test_import;
85 exports.import_js_f64 = test_import;
86
87 exports.js_import = () => {
88 const i8 = new Int8Array(2);
89 i8[0] = 1;
90 i8[1] = 2;
91 assert.deepStrictEqual(wasm.import_rust_i8(i8), i8);
92 const u8 = new Uint8Array(2);
93 u8[0] = 1;
94 u8[1] = 2;
95 assert.deepStrictEqual(wasm.import_rust_u8(u8), u8);
96
97 const i16 = new Int16Array(2);
98 i16[0] = 1;
99 i16[1] = 2;
100 assert.deepStrictEqual(wasm.import_rust_i16(i16), i16);
101 const u16 = new Uint16Array(2);
102 u16[0] = 1;
103 u16[1] = 2;
104 assert.deepStrictEqual(wasm.import_rust_u16(u16), u16);
105
106 const i32 = new Int32Array(2);
107 i32[0] = 1;
108 i32[1] = 2;
109 assert.deepStrictEqual(wasm.import_rust_i32(i32), i32);
110 assert.deepStrictEqual(wasm.import_rust_isize(i32), i32);
111 const u32 = new Uint32Array(2);
112 u32[0] = 1;
113 u32[1] = 2;
114 assert.deepStrictEqual(wasm.import_rust_u32(u32), u32);
115 assert.deepStrictEqual(wasm.import_rust_usize(u32), u32);
116
117 const f32 = new Float32Array(2);
118 f32[0] = 1;
119 f32[1] = 2;
120 assert.deepStrictEqual(wasm.import_rust_f32(f32), f32);
121 const f64 = new Float64Array(2);
122 f64[0] = 1;
123 f64[1] = 2;
124 assert.deepStrictEqual(wasm.import_rust_f64(f64), f64);
125 };
126
127 exports.js_pass_array = () => {
128 wasm.pass_array_rust_i8([1, 2]);
129 wasm.pass_array_rust_u8([1, 2]);
130 wasm.pass_array_rust_i16([1, 2]);
131 wasm.pass_array_rust_u16([1, 2]);
132 wasm.pass_array_rust_i32([1, 2]);
133 wasm.pass_array_rust_u32([1, 2]);
134 wasm.pass_array_rust_isize([1, 2]);
135 wasm.pass_array_rust_usize([1, 2]);
136 wasm.pass_array_rust_f32([1, 2]);
137 wasm.pass_array_rust_f64([1, 2]);
138 };
139
140 const import_mut_foo = (a, b, c) => {
141 assert.strictEqual(a.length, 3);
142 assert.strictEqual(a[0], 1);
143 assert.strictEqual(a[1], 2);
144 a[0] = 4;
145 a[1] = 5;
146 assert.strictEqual(b.length, 3);
147 assert.strictEqual(b[0], 4);
148 assert.strictEqual(b[1], 5);
149 assert.strictEqual(b[2], 6);
150 b[0] = 8;
151 b[1] = 7;
152 assert.strictEqual(c, undefined);
153 };
154
155 exports.import_mut_js_i8 = import_mut_foo;
156 exports.import_mut_js_u8 = import_mut_foo;
157 exports.import_mut_js_i16 = import_mut_foo;
158 exports.import_mut_js_u16 = import_mut_foo;
159 exports.import_mut_js_i32 = import_mut_foo;
160 exports.import_mut_js_u32 = import_mut_foo;
161 exports.import_mut_js_isize = import_mut_foo;
162 exports.import_mut_js_usize = import_mut_foo;
163 exports.import_mut_js_f32 = import_mut_foo;
164 exports.import_mut_js_f64 = import_mut_foo;
165
166 const export_mut_run = (a, rust) => {
167 assert.strictEqual(a.length, 3);
168 a[0] = 1;
169 a[1] = 2;
170 a[2] = 3;
171 console.log(a);
172 rust(a);
173 console.log(a);
174 assert.strictEqual(a.length, 3);
175 assert.strictEqual(a[0], 4);
176 assert.strictEqual(a[1], 5);
177 assert.strictEqual(a[2], 3);
178 };
179
180 exports.js_export_mut = () => {
181 export_mut_run(new Int8Array(3), wasm.export_mut_i8);
182 export_mut_run(new Uint8Array(3), wasm.export_mut_u8);
183 export_mut_run(new Int16Array(3), wasm.export_mut_i16);
184 export_mut_run(new Uint16Array(3), wasm.export_mut_u16);
185 export_mut_run(new Int32Array(3), wasm.export_mut_i32);
186 export_mut_run(new Uint32Array(3), wasm.export_mut_u32);
187 export_mut_run(new Int32Array(3), wasm.export_mut_isize);
188 export_mut_run(new Uint32Array(3), wasm.export_mut_usize);
189 export_mut_run(new Float32Array(3), wasm.export_mut_f32);
190 export_mut_run(new Float64Array(3), wasm.export_mut_f64);
191 };
192
193 exports.js_return_vec = () => {
194 const app = wasm.return_vec_web_main();
195
196 for (let i = 0; i < 10; i++) {
197 app.tick();
198 const bad = wasm.return_vec_broken_vec();
199 console.log('Received from rust:', i, bad);
200 assert.strictEqual(bad[0], 1);
201 assert.strictEqual(bad[1], 2);
202 assert.strictEqual(bad[2], 3);
203 assert.strictEqual(bad[3], 4);
204 assert.strictEqual(bad[4], 5);
205 assert.strictEqual(bad[5], 6);
206 assert.strictEqual(bad[6], 7);
207 assert.strictEqual(bad[7], 8);
208 assert.strictEqual(bad[8], 9);
209 }
210 };
211
212 exports.js_clamped = (a, offset) => {
213 assert.ok(a instanceof Uint8ClampedArray);
214 assert.equal(a.length, 3);
215 assert.equal(a[0], offset + 0);
216 assert.equal(a[1], offset + 1);
217 assert.equal(a[2], offset + 2);
218 };