feat(ut): add unittest framework assembly code to repo

as-test.config.js

@@ -1,6 +1,11 @@
 /** @type {import("assemblyscript-unittest-framework/config.d.ts").Config} */
 export default {
-  include: ["tests/assemblyscript", "assemblyscript/src/**.ts"],
+  include: [
+    "tests/assemblyscript",
+    "tests/warpo_extension",
+    "assemblyscript/src/**/*.ts",
+    "warpo_extension/std/warpo/**/*.ts",
+  ],
   entryFiles: ["assemblyscript/src/glue/wasm/index.ts", "assemblyscript/src/index-wasm.ts"],
   collectCoverage: false,
   temp: "build_coverage",

tests/warpo_extension/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../tsconfig-warpo.json",
+  "include": ["./**/*.ts"]
+}

tests/warpo_extension/warpo/test/comparison.test.ts

@@ -0,0 +1,210 @@
+import { describe, expect, test } from "../../../../warpo_extension/std/warpo/test";
+
+describe("base type equal", () => {
+  test("i32", () => {
+    let a: i32 = 1;
+    expect(a).equal(1);
+  });
+  test("i64", () => {
+    let b: i64 = i64.MAX_VALUE;
+    expect(b).equal(i64.MAX_VALUE);
+    expect(b).notEqual(i64.MIN_VALUE);
+  });
+  test("f32", () => {
+    let c: f32 = 2.5;
+    expect(c).closeTo(2.5, 1e-5);
+  });
+  test("f64", () => {
+    let d: f64 = 0.1 + 0.2;
+    expect(d).closeTo(0.3, 1e-5);
+  });
+});
+
+describe("single level container type equal", () => {
+  test("string", () => {
+    let a: string = "test";
+    expect(a).equal("test");
+  });
+  test("3 bytes ArrayBuffer", () => {
+    let a: Array<i8> = [1, 3, 5];
+    let b = new ArrayBuffer(3);
+    store<i8>(changetype<i32>(b), 1);
+    store<i8>(changetype<i32>(b) + 1, 3);
+    store<i8>(changetype<i32>(b) + 2, 5);
+    expect(changetype<ArrayBuffer>(a.dataStart)).equal(b);
+  });
+  test("8 bytes ArrayBuffer", () => {
+    let a: Array<i32> = [1, 3];
+    let b = new ArrayBuffer(8);
+    store<i32>(changetype<i32>(b), 1);
+    store<i32>(changetype<i32>(b) + 4, 3);
+    expect(changetype<ArrayBuffer>(a.dataStart)).equal(b);
+  });
+  test("array", () => {
+    let b: Array<i32> = [1, 2, 3, 4];
+    expect(b).equal([1, 2, 3, 4]);
+    expect(b).notEqual([1, 2, 4, 3]);
+    expect(b).notEqual([1, 2, 3]);
+    expect(b).notEqual([1, 2, 3, 4, 5]);
+  });
+  test("TypedArray", () => {
+    let c: Int32Array = new Int32Array(2);
+    c[0] = 1;
+    c[1] = 2;
+    let c1: Int32Array = new Int32Array(2);
+    c1[0] = 1;
+    c1[1] = 2;
+    expect(c).equal(c1);
+  });
+  test("StaticArray", () => {
+    let d: StaticArray<f32> = new StaticArray(2);
+    d[0] = 1.2;
+    d[1] = 2.4;
+    expect(d).equal(StaticArray.fromArray<f32>([1.2, 2.4]));
+  });
+
+  describe("Map", () => {
+    test("normal", () => {
+      let e: Map<i32, f32> = new Map();
+      e.set(1, 1.5);
+      e.set(2, 2.5);
+      let e1: Map<i32, f32> = new Map();
+      e1.set(1, 1.5);
+      e1.set(2, 2.5);
+      expect(e).equal(e1);
+    });
+    test("disorder", () => {
+      let e: Map<i32, f32> = new Map();
+      e.set(1, 1.5);
+      e.set(2, 2.5);
+      let e1: Map<i32, f32> = new Map();
+      e1.set(2, 2.5);
+      e1.set(1, 1.5);
+      expect(e).equal(e1);
+    });
+    test("value not equal", () => {
+      let e: Map<i32, f32> = new Map();
+      e.set(1, 1.5);
+      e.set(2, 2.5);
+      let e1: Map<i32, f32> = new Map();
+      e1.set(1, 1.6);
+      e1.set(2, 2.6);
+      expect(e).notEqual(e1);
+    });
+    test("key not equal", () => {
+      let e: Map<i32, f32> = new Map();
+      e.set(1, 1.5);
+      e.set(2, 2.5);
+      let e1: Map<i32, f32> = new Map();
+      e1.set(1, 1.5);
+      e1.set(3, 2.5);
+      expect(e).notEqual(e1);
+    });
+    test("more context", () => {
+      let e: Map<i32, f32> = new Map();
+      e.set(1, 1.5);
+      e.set(2, 2.5);
+      let e1: Map<i32, f32> = new Map();
+      e1.set(1, 1.5);
+      e1.set(2, 2.5);
+      e1.set(3, 3.5);
+      expect(e).notEqual(e1);
+    });
+    test("less context", () => {
+      let e: Map<i32, f32> = new Map();
+      e.set(1, 1.5);
+      e.set(2, 2.5);
+      let e1: Map<i32, f32> = new Map();
+      e1.set(1, 1.5);
+      expect(e).notEqual(e1);
+    });
+  });
+
+  describe("Set", () => {
+    test("normal", () => {
+      let a = new Set<i32>();
+      a.add(10);
+      let b = new Set<i32>();
+      b.add(10);
+      expect(a).equal(b);
+    });
+    test("not equal", () => {
+      let a = new Set<i32>();
+      a.add(10);
+      let b = new Set<i32>();
+      b.add(8);
+      expect(a).notEqual(b);
+    });
+    test("more context", () => {
+      let a = new Set<i32>();
+      a.add(10);
+      let b = new Set<i32>();
+      b.add(10);
+      b.add(11);
+      expect(a).notEqual(b);
+    });
+    test("less context", () => {
+      let a = new Set<i32>();
+      a.add(11);
+      a.add(10);
+      let b = new Set<i32>();
+      b.add(10);
+      expect(a).notEqual(b);
+    });
+    test("disorder", () => {
+      let a = new Set<i32>();
+      a.add(11);
+      a.add(10);
+      let b = new Set<i32>();
+      b.add(10);
+      b.add(11);
+      expect(a).equal(b);
+    });
+  });
+
+  describe("nullable", () => {
+    test("normal", () => {
+      let a: i32[] | null = [1, 2];
+      let b: i32[] = [1, 2];
+      expect(a).equal(b);
+      expect<i32[] | null>(a).notEqual(null);
+    });
+    test("nullable equal null", () => {
+      let a: i32[] | null = null;
+      let b: i32[] = [1, 2];
+      expect<i32[] | null>(a).notEqual(b);
+      expect<i32[] | null>(a).equal(null);
+    });
+    test("nullable equal normal", () => {});
+  });
+});
+
+describe("multi-level container type equal", () => {
+  test("multi-level nested container equality", () => {
+    let arr = new Array<Map<i32, Set<f64>>>();
+    for (let i = 0; i < 5; i++) {
+      let map = new Map<i32, Set<f64>>();
+      arr.push(map);
+      for (let j = 0; j < 5; j++) {
+        let set = new Set<f64>();
+        map.set(j, set);
+        for (let k = 0; k < 10; k++) {
+          set.add(f64(k) * 1.25);
+        }
+      }
+    }
+    let arr2 = new Array<Map<i32, Set<f64>>>();
+    for (let i = 0; i < 5; i++) {
+      let map = new Map<i32, Set<f64>>();
+      arr2.push(map);
+      for (let j = 4; j >= 0; j--) {
+        let set = new Set<f64>();
+        map.set(j, set);
+        for (let k = 9; k >= 0; k--) {
+          set.add(f64(k) * 1.25);
+        }
+      }
+    }
+    expect(arr).equal(arr2);
+  });
+});

tests/warpo_extension/warpo/test/expect.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, test } from "../../../../warpo_extension/std/warpo/test";
+
+class Base {}
+class Ext_0 extends Base {}
+class Ext_0_0 extends Ext_0 {}
+class Ext_0_0_0 extends Ext_0 {}
+class Ext_1 extends Base {}
+class Ext_1_1 extends Ext_1 {}
+
+describe("expect", () => {
+  test("< = >", () => {
+    expect(1).greaterThan(0);
+    expect(1).greaterThanOrEqual(0);
+    expect(1).greaterThanOrEqual(1);
+    expect(1).lessThan(2);
+    expect(1).lessThanOrEqual(2);
+    expect(1).lessThanOrEqual(1);
+  });
+  test("null", () => {
+    expect<string | null>(null).isNull();
+    expect<string | null>("test").notNull();
+  });
+  test("not", () => {
+    expect(1).not.equal(2);
+  });
+  test("isa", () => {
+    let ext: Base = new Ext_0_0();
+    expect(ext).isa<Base>();
+    expect(ext).isa<Ext_0>();
+    expect(ext).isa<Ext_0_0>();
+    expect(ext).not.isa<Ext_0_0_0>();
+    expect(ext).not.isa<Ext_1>();
+    expect(ext).not.isa<Ext_1_1>();
+  });
+  test("isExactly", () => {
+    let ext: Base = new Ext_0_0();
+    expect(ext).isExactly<Ext_0_0>();
+    expect(ext).not.isExactly<Base>();
+    expect(ext).not.isExactly<Ext_0>();
+    expect(ext).not.isExactly<Ext_0_0_0>();
+  });
+  test("nullable isExactly", () => {
+    let extNull: Base | null = null;
+    let extNonNull: Base | null = new Base();
+    expect(extNull).not.isExactly<Base>();
+    expect(extNonNull).isExactly<Base>();
+  });
+});

tests/warpo_extension/warpo/test/format.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, test } from "../../../../warpo_extension/std/warpo/test";
+import { toJson } from "../../../../warpo_extension/std/warpo/test/formatPrint";
+
+class A {}
+
+describe("print", () => {
+  test("array", () => {
+    expect(toJson([1, 2, 3])).equal("[1, 2, 3]");
+  });
+  test("ArrayBuffer", () => {
+    let a: Array<i32> = [1, 3];
+    expect(toJson(changetype<ArrayBuffer>(a.dataStart))).equal("[1, 0, 0, 0, 3, 0, 0, 0]");
+  });
+  test("set", () => {
+    const set = new Set<i32>();
+    set.add(1).add(2).add(4);
+    expect(toJson(set)).equal("[1, 2, 4]");
+  });
+  test("map", () => {
+    const map = new Map<i32, string>();
+    map.set(1, "aa").set(2, "bb").set(4, "cc");
+    expect(toJson(map)).equal('{ 1 : "aa", 2 : "bb", 4 : "cc" }');
+  });
+
+  test("nullable", () => {
+    const a: i32[] | null = null;
+    expect(toJson(a)).equal("null");
+  });
+
+  test("bool", () => {
+    expect(toJson(false)).equal("false");
+    expect(toJson(true)).equal("true");
+  });
+
+  test("string", () => {
+    expect(toJson("test")).equal('"test"');
+  });
+  test("unicode string", () => {
+    expect(toJson("测试")).equal('"测试"');
+  });
+  test("normal control code", () => {
+    expect(toJson("\0")).equal('"\\0"');
+    expect(toJson("\b")).equal('"\\b"');
+    expect(toJson("\t")).equal('"\\t"');
+    expect(toJson("\n")).equal('"\\n"');
+    expect(toJson("\v")).equal('"\\v"');
+    expect(toJson("\f")).equal('"\\f"');
+    expect(toJson("\r")).equal('"\\r"');
+    expect(toJson('-"-')).equal('"-\\"-"');
+    expect(toJson("\\")).equal('"\\\\"');
+  });
+  test("unknown control code", () => {
+    expect(toJson("\u0001")).equal('"\\u0001"');
+  });
+
+  test("user defined class", () => {
+    expect(toJson(new A())).equal("[Object A]");
+  });
+});