Skip to content

Commit f8c012e

Browse files
vgrichinavgrichina
authored
Merge pull request AssemblyScript#8 from nearprotocol/near-bindgen-test
Add diff to ./test.sh based on snapshots of output
2 parents 5d7a4e7 + 846515e commit f8c012e

File tree

4 files changed

+4576
-8
lines changed

4 files changed

+4576
-8
lines changed

‎tests/near-bindgen/main_near.ts.expected

Lines changed: 365 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,365 @@
1+
import "allocator/arena";
2+
// TODO: Why cannot import from index?
3+
// import { BSONEncoder, BSONDecoder } from "./bson";
4+
import { BSONEncoder } from "./bson/encoder";
5+
import { BSONDecoder } from "./bson/decoder";
6+
import { near } from "./near";
7+
8+
declare function log(str: string): void;
9+
10+
// Runtime functions
11+
declare function return_value(value_ptr: u32): void;
12+
declare function input_read_len(): u32;
13+
declare function input_read_into(ptr: usize): void;
14+
15+
export class FooBar {
16+
foo: i32 = 0;
17+
bar: i32 = 1;
18+
flag: bool;
19+
baz: string = "123";
20+
foobar: Uint8Array;
21+
}
22+
23+
export class ContainerClass {
24+
foobar: FooBar;
25+
}
26+
27+
export class AnotherContainerClass {
28+
foobar: FooBar;
29+
}
30+
31+
export function doNothing(): void {}
32+
33+
export function add(x: i32, y: i32): i32 {
34+
return x + y;
35+
}
36+
37+
export function getFoobar(container: ContainerClass): AnotherContainerClass {
38+
let result = new AnotherContainerClass();
39+
result.foobar = container.foobar;
40+
return result;
41+
}
42+
43+
export function __near_encode_FooBar(
44+
value: FooBar,
45+
encoder: BSONEncoder
46+
): void {
47+
encoder.setInteger("foo", value.foo);
48+
encoder.setInteger("bar", value.bar);
49+
encoder.setBoolean("flag", value.flag);
50+
if (value.baz != null) {
51+
encoder.setString("baz", value.baz);
52+
} else {
53+
encoder.setNull("baz");
54+
}
55+
if (value.foobar != null) {
56+
encoder.setUint8Array("foobar", value.foobar);
57+
} else {
58+
encoder.setNull("foobar");
59+
}
60+
}
61+
export class __near_BSONHandler_FooBar {
62+
buffer: Uint8Array;
63+
decoder: BSONDecoder<__near_BSONHandler_FooBar>;
64+
value: FooBar = new FooBar();
65+
setInteger(name: string, value: i32): void {
66+
if (name == "foo") {
67+
this.value.foo = value;
68+
return;
69+
}
70+
if (name == "bar") {
71+
this.value.bar = value;
72+
return;
73+
}
74+
}
75+
setString(name: string, value: String): void {
76+
if (name == "baz") {
77+
this.value.baz = value;
78+
return;
79+
}
80+
}
81+
setUint8Array(name: string, value: Uint8Array): void {
82+
if (name == "foobar") {
83+
this.value.foobar = value;
84+
return;
85+
}
86+
}
87+
setBoolean(name: string, value: bool): void {
88+
if (name == "flag") {
89+
this.value.flag = value;
90+
return;
91+
}
92+
}
93+
setNull(name: string): void {
94+
if (name == "foo") {
95+
this.value.foo = <i32>null;
96+
}
97+
if (name == "bar") {
98+
this.value.bar = <i32>null;
99+
}
100+
if (name == "flag") {
101+
this.value.flag = <bool>null;
102+
}
103+
if (name == "baz") {
104+
this.value.baz = <String>null;
105+
}
106+
if (name == "foobar") {
107+
this.value.foobar = <Uint8Array>null;
108+
}
109+
}
110+
111+
pushObject(name: string): bool {
112+
return false;
113+
}
114+
popObject(): void {}
115+
pushArray(name: string): bool {
116+
return false;
117+
}
118+
popArray(): void {}
119+
}
120+
121+
export function __near_decode_FooBar(buffer: Uint8Array, offset: i32): FooBar {
122+
let handler = new __near_BSONHandler_FooBar();
123+
handler.buffer = buffer;
124+
handler.decoder = new BSONDecoder<__near_BSONHandler_FooBar>(handler);
125+
handler.decoder.deserialize(buffer, offset);
126+
return handler.value;
127+
}
128+
129+
export function __near_encode_ContainerClass(
130+
value: ContainerClass,
131+
encoder: BSONEncoder
132+
): void {
133+
if (value.foobar != null) {
134+
__near_encode_FooBar(value.foobar, encoder);
135+
} else {
136+
encoder.setNull("foobar");
137+
}
138+
}
139+
export class __near_BSONHandler_ContainerClass {
140+
buffer: Uint8Array;
141+
decoder: BSONDecoder<__near_BSONHandler_ContainerClass>;
142+
value: ContainerClass = new ContainerClass();
143+
setInteger(name: string, value: i32): void {}
144+
setString(name: string, value: String): void {}
145+
setUint8Array(name: string, value: Uint8Array): void {}
146+
setBoolean(name: string, value: bool): void {}
147+
setNull(name: string): void {
148+
if (name == "foobar") {
149+
this.value.foobar = <FooBar>null;
150+
}
151+
}
152+
153+
pushObject(name: string): bool {
154+
if (name == "foobar") {
155+
this.value.foobar = __near_decode_FooBar(
156+
this.buffer,
157+
this.decoder.readIndex
158+
);
159+
return false;
160+
}
161+
162+
return false;
163+
}
164+
popObject(): void {}
165+
pushArray(name: string): bool {
166+
return false;
167+
}
168+
popArray(): void {}
169+
}
170+
171+
export function __near_decode_ContainerClass(
172+
buffer: Uint8Array,
173+
offset: i32
174+
): ContainerClass {
175+
let handler = new __near_BSONHandler_ContainerClass();
176+
handler.buffer = buffer;
177+
handler.decoder = new BSONDecoder<__near_BSONHandler_ContainerClass>(handler);
178+
handler.decoder.deserialize(buffer, offset);
179+
return handler.value;
180+
}
181+
182+
export function __near_encode_AnotherContainerClass(
183+
value: AnotherContainerClass,
184+
encoder: BSONEncoder
185+
): void {
186+
if (value.foobar != null) {
187+
__near_encode_FooBar(value.foobar, encoder);
188+
} else {
189+
encoder.setNull("foobar");
190+
}
191+
}
192+
export class __near_BSONHandler_AnotherContainerClass {
193+
buffer: Uint8Array;
194+
decoder: BSONDecoder<__near_BSONHandler_AnotherContainerClass>;
195+
value: AnotherContainerClass = new AnotherContainerClass();
196+
setInteger(name: string, value: i32): void {}
197+
setString(name: string, value: String): void {}
198+
setUint8Array(name: string, value: Uint8Array): void {}
199+
setBoolean(name: string, value: bool): void {}
200+
setNull(name: string): void {
201+
if (name == "foobar") {
202+
this.value.foobar = <FooBar>null;
203+
}
204+
}
205+
206+
pushObject(name: string): bool {
207+
if (name == "foobar") {
208+
this.value.foobar = __near_decode_FooBar(
209+
this.buffer,
210+
this.decoder.readIndex
211+
);
212+
return false;
213+
}
214+
215+
return false;
216+
}
217+
popObject(): void {}
218+
pushArray(name: string): bool {
219+
return false;
220+
}
221+
popArray(): void {}
222+
}
223+
224+
export function __near_decode_AnotherContainerClass(
225+
buffer: Uint8Array,
226+
offset: i32
227+
): AnotherContainerClass {
228+
let handler = new __near_BSONHandler_AnotherContainerClass();
229+
handler.buffer = buffer;
230+
handler.decoder = new BSONDecoder<__near_BSONHandler_AnotherContainerClass>(
231+
handler
232+
);
233+
handler.decoder.deserialize(buffer, offset);
234+
return handler.value;
235+
}
236+
237+
export class __near_ArgsParser_doNothing {
238+
buffer: Uint8Array;
239+
decoder: BSONDecoder<__near_ArgsParser_doNothing>;
240+
241+
setInteger(name: string, value: i32): void {}
242+
setString(name: string, value: String): void {}
243+
setUint8Array(name: string, value: Uint8Array): void {}
244+
setBoolean(name: string, value: bool): void {}
245+
setNull(name: string): void {}
246+
247+
pushObject(name: string): bool {
248+
return false;
249+
}
250+
popObject(): void {}
251+
pushArray(name: string): bool {
252+
return false;
253+
}
254+
popArray(): void {}
255+
}
256+
export function near_func_doNothing(): void {
257+
let bson = new Uint8Array(input_read_len());
258+
input_read_into(bson.buffer.data);
259+
let handler = new __near_ArgsParser_doNothing();
260+
handler.buffer = bson;
261+
handler.decoder = new BSONDecoder<__near_ArgsParser_doNothing>(handler);
262+
handler.decoder.deserialize(bson);
263+
doNothing();
264+
}
265+
export class __near_ArgsParser_add {
266+
buffer: Uint8Array;
267+
decoder: BSONDecoder<__near_ArgsParser_add>;
268+
269+
__near_param_x: i32;
270+
__near_param_y: i32;
271+
setInteger(name: string, value: i32): void {
272+
if (name == "x") {
273+
this.__near_param_x = value;
274+
return;
275+
}
276+
if (name == "y") {
277+
this.__near_param_y = value;
278+
return;
279+
}
280+
}
281+
setString(name: string, value: String): void {}
282+
setUint8Array(name: string, value: Uint8Array): void {}
283+
setBoolean(name: string, value: bool): void {}
284+
setNull(name: string): void {
285+
if (name == "x") {
286+
this.__near_param_x = <i32>null;
287+
}
288+
if (name == "y") {
289+
this.__near_param_y = <i32>null;
290+
}
291+
}
292+
293+
pushObject(name: string): bool {
294+
return false;
295+
}
296+
popObject(): void {}
297+
pushArray(name: string): bool {
298+
return false;
299+
}
300+
popArray(): void {}
301+
}
302+
export function near_func_add(): void {
303+
let bson = new Uint8Array(input_read_len());
304+
input_read_into(bson.buffer.data);
305+
let handler = new __near_ArgsParser_add();
306+
handler.buffer = bson;
307+
handler.decoder = new BSONDecoder<__near_ArgsParser_add>(handler);
308+
handler.decoder.deserialize(bson);
309+
let result = add(handler.__near_param_x, handler.__near_param_y);
310+
311+
let encoder = new BSONEncoder();
312+
encoder.setInteger("result", result);
313+
314+
return_value(near.bufferWithSize(encoder.serialize()).buffer.data);
315+
}
316+
export class __near_ArgsParser_getFoobar {
317+
buffer: Uint8Array;
318+
decoder: BSONDecoder<__near_ArgsParser_getFoobar>;
319+
320+
__near_param_container: ContainerClass;
321+
setInteger(name: string, value: i32): void {}
322+
setString(name: string, value: String): void {}
323+
setUint8Array(name: string, value: Uint8Array): void {}
324+
setBoolean(name: string, value: bool): void {}
325+
setNull(name: string): void {
326+
if (name == "container") {
327+
this.__near_param_container = <ContainerClass>null;
328+
}
329+
}
330+
331+
pushObject(name: string): bool {
332+
if (name == "container") {
333+
this.__near_param_container = __near_decode_ContainerClass(
334+
this.buffer,
335+
this.decoder.readIndex
336+
);
337+
return false;
338+
}
339+
340+
return false;
341+
}
342+
popObject(): void {}
343+
pushArray(name: string): bool {
344+
return false;
345+
}
346+
popArray(): void {}
347+
}
348+
export function near_func_getFoobar(): void {
349+
let bson = new Uint8Array(input_read_len());
350+
input_read_into(bson.buffer.data);
351+
let handler = new __near_ArgsParser_getFoobar();
352+
handler.buffer = bson;
353+
handler.decoder = new BSONDecoder<__near_ArgsParser_getFoobar>(handler);
354+
handler.decoder.deserialize(bson);
355+
let result = getFoobar(handler.__near_param_container);
356+
357+
let encoder = new BSONEncoder();
358+
if (result != null) {
359+
__near_encode_AnotherContainerClass(result, encoder);
360+
} else {
361+
encoder.setNull("result");
362+
}
363+
364+
return_value(near.bufferWithSize(encoder.serialize()).buffer.data);
365+
}

‎tests/near-bindgen/test.sh

Lines changed: 8 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,10 @@
11
#!/bin/sh
2+
set -e
3+
set -x
24
BASEDIR=../../
3-
$BASEDIR/bin/asc main.ts --outFile main.wat --nearFile main.near.ts
4-
cp main.near.ts combined.ts
5-
prettier --write combined.ts
6-
$BASEDIR/bin/asc combined.ts -o combined.wat
7-
$BASEDIR/bin/asc test.ts -o test.wasm
8-
5+
$BASEDIR/bin/asc main.ts --outFile main.wat --nearFile main_near.ts
6+
prettier --write main_near.ts
7+
$BASEDIR/bin/asc main_near.ts -o main_near.wat
8+
diff main_near.ts.expected main_near.ts
9+
$BASEDIR/bin/asc test.ts -o test.wasm --textFile test.wat
10+
diff test.wat.expected test.wat

‎tests/near-bindgen/test.ts

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11

2-
import * as main from "./combined";
2+
import * as main from "./main_near";
33

44
import { BSONEncoder } from "./bson/encoder";
55

@@ -55,4 +55,4 @@ function bin2hex(bin: Uint8Array, uppercase: boolean = false): string {
5555
}
5656

5757

58-
runTest();
58+
runTest();

0 commit comments

Comments
 (0)