Fix up tests after merging with latest AssemblyScript

Author: vgrichina

tests/near-bindgen/main.ts

@@ -32,7 +32,14 @@ export function getStringArrayLength(arr: string[]): i32 {
 }
 
 export function convertFoobars(foobars: Array<FooBar>): Array<ContainerClass> {
+    /* TODO: Fix compiler bug https://github.com/AssemblyScript/assemblyscript/issues/539
     return foobars.map<ContainerClass>((it: FooBar, i: i32, arr: Array<FooBar>): ContainerClass => {
         return { foobar: it};
     });
+    */
+    let result: ContainerClass[] = new Array(foobars.length);
+    for (let i = 0; i < foobars.length; i++) {
+        result[i] = { foobar: foobars[i] }
+    }
+    return result;
 }

tests/near-bindgen/model_near.ts.expected

@@ -403,16 +403,47 @@ export function __near_decode_ContainerClass(
   return handler.value;
 }
 
+export function __near_encode_Array_FooBar(
+  value: Array<wrapped_FooBar>,
+  encoder: JSONEncoder
+): void {
+  for (let i = 0; i < value.length; i++) {
+    if (value[i] != null) {
+      encoder.pushObject(null);
+      __near_encode_FooBar(<FooBar>value[i], encoder);
+      encoder.popObject();
+    } else {
+      encoder.setNull(null);
+    }
+  }
+}
+export function __near_encode_Array_Array_FooBar(
+  value: Array<Array<wrapped_FooBar>>,
+  encoder: JSONEncoder
+): void {
+  for (let i = 0; i < value.length; i++) {
+    if (value[i] != null) {
+      encoder.pushArray(null);
+      __near_encode_Array_FooBar(<Array<FooBar>>value[i], encoder);
+      encoder.popArray();
+    } else {
+      encoder.setNull(null);
+    }
+  }
+}
 export function __near_encode_AnotherContainerClass(
   value: wrapped_AnotherContainerClass,
   encoder: JSONEncoder
 ): void {
-  if (value.foobar != null) {
-    encoder.pushObject("foobar");
-    __near_encode_FooBar(<FooBar>value.foobar, encoder);
-    encoder.popObject();
+  if (value.foobars != null) {
+    encoder.pushArray("foobars");
+    __near_encode_Array_Array_FooBar(
+      <Array<Array<FooBar>>>value.foobars,
+      encoder
+    );
+    encoder.popArray();
   } else {
-    encoder.setNull("foobar");
+    encoder.setNull("foobars");
   }
 }
 export class __near_JSONHandler_AnotherContainerClass extends ThrowingJSONHandler {
@@ -421,8 +452,8 @@ export class __near_JSONHandler_AnotherContainerClass extends ThrowingJSONHandle
   handledRoot: boolean = false;
   value: wrapped_AnotherContainerClass = new wrapped_AnotherContainerClass();
   setNull(name: string): void {
-    if (name == "foobar") {
-      this.value.foobar = <wrapped_FooBar>null;
+    if (name == "foobars") {
+      this.value.foobars = <Array<Array<wrapped_FooBar>>>null;
       return;
     }
 
@@ -437,19 +468,92 @@ export class __near_JSONHandler_AnotherContainerClass extends ThrowingJSONHandle
     } else {
       assert(name != null);
     }
-    if (name == "foobar") {
-      this.value.foobar = <FooBar>(
-        __near_decode_FooBar(this.buffer, this.decoder.state)
+
+    return super.pushObject(name);
+  }
+
+  pushArray(name: string): bool {
+    if (name == "foobars") {
+      this.value.foobars = <Array<Array<FooBar>>>(
+        __near_decode_Array_Array_FooBar(this.buffer, this.decoder.state)
       );
       return false;
     }
 
-    return super.pushObject(name);
+    return super.pushArray(name);
   }
+}
 
+export class __near_JSONHandler_Array_Array_FooBar extends ThrowingJSONHandler {
+  buffer: Uint8Array;
+  decoder: JSONDecoder<__near_JSONHandler_Array_Array_FooBar>;
+  handledRoot: boolean = false;
+  value: Array<Array<wrapped_FooBar>> = new Array<Array<wrapped_FooBar>>();
+  pushObject(name: string): bool {
+    this.value.push(<Array<FooBar>>(
+      __near_decode_Array_FooBar(this.buffer, this.decoder.state)
+    ));
+    return false;
+  }
   pushArray(name: string): bool {
-    return super.pushArray(name);
+    assert(name == null);
+    if (!this.handledRoot) {
+      this.handledRoot = true;
+      return true;
+    }
+    this.value.push(<Array<FooBar>>(
+      __near_decode_Array_FooBar(this.buffer, this.decoder.state)
+    ));
+    return false;
+  }
+}
+
+export class __near_JSONHandler_Array_FooBar extends ThrowingJSONHandler {
+  buffer: Uint8Array;
+  decoder: JSONDecoder<__near_JSONHandler_Array_FooBar>;
+  handledRoot: boolean = false;
+  value: Array<wrapped_FooBar> = new Array<wrapped_FooBar>();
+  pushObject(name: string): bool {
+    this.value.push(<FooBar>(
+      __near_decode_FooBar(this.buffer, this.decoder.state)
+    ));
+    return false;
   }
+  pushArray(name: string): bool {
+    assert(name == null);
+    if (!this.handledRoot) {
+      this.handledRoot = true;
+      return true;
+    }
+    this.value.push(<FooBar>(
+      __near_decode_FooBar(this.buffer, this.decoder.state)
+    ));
+    return false;
+  }
+}
+
+export function __near_decode_Array_FooBar(
+  buffer: Uint8Array,
+  state: DecoderState
+): Array<wrapped_FooBar> {
+  let handler = new __near_JSONHandler_Array_FooBar();
+  handler.buffer = buffer;
+  handler.decoder = new JSONDecoder<__near_JSONHandler_Array_FooBar>(handler);
+  handler.decoder.deserialize(buffer, state);
+  return handler.value;
+}
+
+export function __near_decode_Array_Array_FooBar(
+  buffer: Uint8Array,
+  state: DecoderState
+): Array<Array<wrapped_FooBar>> {
+  let handler = new __near_JSONHandler_Array_Array_FooBar();
+  handler.buffer = buffer;
+  handler.decoder = new JSONDecoder<__near_JSONHandler_Array_Array_FooBar>(
+    handler
+  );
+  handler.decoder.deserialize(buffer, state);
+  return handler.value;
 }
 
 export function __near_decode_AnotherContainerClass(

tests/near-bindgen/test.js

@@ -84,9 +84,9 @@ async function loadModule(path) {
         [{ foobar: { foo: 0, bar: 1, u64Val: "64", i64Val: "-64", flag: false, baz: '123', arr: [["1", "2"], ["3"]], u32Arr: null, i32Arr: null }}]);
     assert.equal(await module.getStringArrayLength({ arr: ["1", "2", "3"] }), 3);
     assert.deepEqual(await module.rewrapFoobar({ container: { foobar: { foo: 123 } } }),
-        { foobars: [[{"foo":123,"bar":1,"flag":false,"baz":"123","arr":null}]] });
+        {"foobars":[[{"foo":123,"bar":1,"u64Val":"64","i64Val":"-64","flag":false,"baz":"123","arr":null,"u32Arr":null,"i32Arr":null}]]});
     assert.deepEqual(await module.unwrapFoobar({ container: { foobars: [[{ foo: 123 }]] } }),
-        {"foo":123,"bar":1,"flag":false,"baz":"123","arr":null} );
+        {"foo":123,"bar":1,"u64Val":"64","i64Val":"-64","flag":false,"baz":"123","arr":null,"u32Arr":null,"i32Arr":null});
 })().catch(e => {
     console.error('Error during test execution:', e);
     if (e.code == 'ERR_ASSERTION') {