add coverage... now to fix the bugs (as-pect#359)

* add coverage... now to fix the bugs

* functions can be null

* logging an unmanaged null reference branch

* unamanged array-likes

* strings are truthy

* transform code coverage first

* strings should be falsy, some blocks are unecessary

* prettier check-in

* toIncludeEqual nullable type check

* 96% test coverage... pairSeen doesn't work?

* 98.7% code coverage

* configuration init with coverage

* prettier

index.js

@@ -0,0 +1,9 @@
+const ignoreRegex = /^[\t ]*\/\/ @as-covers: ignore.*$/gm;
+const linecol = require("line-column");
+const fs = require("fs");
+const text = fs.readFileSync("./packages/assembly/assembly/internal/Expectation.ts", "utf8");
+const lc = linecol(text);
+let results = text.matchAll(ignoreRegex);
+for (const result of results) {
+  console.log(lc.fromIndex(result.index));
+}

package.json

@@ -34,21 +34,24 @@
     "@as-pect/snapshots": "file:./packages/snapshots",
     "@types/diff": "^5.0.0",
     "@types/glob": "^7.1.3",
-    "@types/jest": "^26.0.20",
-    "@types/node": "^14.14.25",
-    "@typescript-eslint/eslint-plugin": "^4.15.0",
-    "@typescript-eslint/parser": "^4.15.0",
-    "assemblyscript": "^0.18.7",
+    "@types/jest": "^26.0.23",
+    "@types/node": "^15.12.3",
+    "@typescript-eslint/eslint-plugin": "^4.27.0",
+    "@typescript-eslint/parser": "^4.27.0",
+    "assemblyscript": "^0.19.3",
     "coveralls": "^3.1.0",
-    "eslint": "^7.25.0",
-    "jest": "^26.6.3",
+    "eslint": "^7.28.0",
+    "jest": "^27.0.4",
     "lerna": "^4.0.0",
     "npm-run-all": "^4.1.5",
-    "prettier": "^2.2.1",
+    "prettier": "^2.3.1",
     "rimraf": "^3.0.2",
-    "strip-ansi": "^6.0.0",
-    "ts-jest": "^26.5.5",
-    "ts-node": "^9.1.1",
-    "typescript": "^4.1.3"
+    "strip-ansi": "^7.0.0",
+    "ts-jest": "^27.0.3",
+    "ts-node": "^10.0.0",
+    "typescript": "^4.3.4"
+  },
+  "dependencies": {
+    "line-column": "^1.0.2"
   }
 }

packages/assembly/as-pect.config.js

@@ -29,6 +29,8 @@ module.exports = {
     instance = instantiateSync(binary, createImports(myImports));
     return instance;
   },
+  /** Add code coverage. */
+  coverage: ["assembly/internal/**/*.ts"],
   /** Use the summary reporter. */
   // reporter: new SummaryTestReporter(),
 };

packages/assembly/assembly/__tests__/logs.spec.ts

@@ -1,5 +1,20 @@
+import { __ignoreLogs } from "../internal/log";
 import { Vec3 } from "./setup/Vec3";
 
+@unmanaged
+class UnmanagedTest {}
+
+@unmanaged
+class UnmanagedArrayLike {
+  get length(): i32 { return 0; }
+
+  @operator("[]")
+  __get(index: i32): i32 { return index; }
+
+  @operator("[]=")
+  __set(_index: i32, _value: i32): void {}
+}
+
 function IDFunc(i: i32): i32 {
   return i;
 }
@@ -226,4 +241,32 @@ describe("logs", () => {
    * This todo should show up in the test output.
    */
   todo("This should be a valid todo.");
+
+  test("ignoring logs (directly)", () => {
+    // we will fake ignoring a log so that code coverage is passed artificially
+    __ignoreLogs(true);
+    log("this should be ignored");
+    __ignoreLogs(false);
+  });
+
+  test("logging a null function", () => {
+    log<(() => void) | null>(null);
+  });
+
+  test("logging an unmanaged null reference", () => {
+    log(changetype<UnmanagedClass | null>(0));
+  });
+
+  test("logging a typed array", () => {
+    let a = new Uint8Array(0);
+    log(a);
+  });
+
+  test("logging an array of numbers", () => {
+    log<i32[]>([1, 2, 3]);
+  });
+
+  test("logging a nullable unmanaged arraylike", () => {
+    log(changetype<UnmanagedArrayLike>(1));
+  });
 });

packages/assembly/assembly/__tests__/toBeFalsy.spec.ts

@@ -170,4 +170,9 @@ describe("toBeFalsy", () => {
     },
     "Non-null references are not falsy.",
   );
+
+  /** Empty strings should be falsy. */
+  it("should be a falsy string", () => {
+    expect("").toBeFalsy();
+  });
 });

packages/assembly/assembly/__tests__/toBeTruthy.spec.ts

@@ -167,4 +167,10 @@ describe("toBeTruthy", () => {
     },
     "Non-null references are truthy.",
   );
+
+  /** Strings should be truthy unless their length is 0. */
+  it("should expect strings to be truthy", () => {
+    expect("this string").toBeTruthy();
+    expect("").not.toBeTruthy();
+  });
 });

packages/assembly/assembly/__tests__/toInclude.spec.ts

@@ -183,4 +183,9 @@ describe("toInclude reference arrays", () => {
     },
     "The item should be included in the set.",
   );
+
+  /** Nullable collections require a null check. */
+  it("should check nullable collections", () => {
+    expect<i32[] | null>([1]).toInclude(1);
+  });
 });

packages/assembly/assembly/__tests__/toIncludeEqual.spec.ts

@@ -143,6 +143,28 @@ describe("toIncludeEqual reference arrays", () => {
   throws("should include a function pointer", () => {
     expect(eventDispatcher.events).not.toIncludeEqual(listener);
   });
+
+  /** Arrays can be nullable. */
+  it("should work with nullable type arrays, and perform null checks", () => {
+    let a: i32[] | null = [1];
+    expect(a).toIncludeEqual(1, "nullable array should have a value");
+  });
+
+  it("should test actually included values in the set", () => {
+    let a = new Vec3(1, 2, 3);
+    let b = new Set<Vec3>();
+    b.add(a);
+    expect(b).toIncludeEqual(a, "Values inside sets should pass toIncludeEqual calls");
+  });
+
+  /** Sets should include values. */
+  it("should match values in sets", () => {
+    let a = new Vec3(1, 2, 3);
+    let b = new Vec3(1, 2, 3);
+    let c = new Set<Vec3>();
+    c.add(a);
+    expect(c).toIncludeEqual(b, "toIncludeEqual should perform strict equality checks on elements.");
+  });
 });
 
 let typedarray = new Uint8Array(10);

packages/assembly/assembly/__tests__/toStrictEqual.spec.ts

@@ -147,6 +147,15 @@ describe("toStrictEqual", () => {
     expect<Vec3 | null>(vec1).not.toStrictEqual(null);
   });
 
+  /**
+   * When types are nullable, references should be strictly equal.
+   */
+  it("should validate references are equal despite the nullable type", () => {
+    let a: Vec3 | null = vec1;
+    let b: Vec3 | null = vec3;
+    expect<Vec3 | null>(a).toStrictEqual(b);
+  });
+
   /**
    * This is the contrapositive of the previous test.
    */
@@ -382,6 +391,16 @@ describe("toStrictEqual", () => {
   throws("throws if pointers aren't equal", () => {
     expect(eventDispatcher.events[0]).not.toStrictEqual(listener);
   });
+
+  /** Arrays with exact reference pairs should match. */
+  it("should match arrays with exact reference pairs", () => {
+    let a = new Vec3(1, 2, 3);
+    let b = new Vec3(4, 5, 6);
+
+    let c = [a, b];
+    let d = [a, b];
+    expect(c).toStrictEqual(d, "previously compared pairs should be shortcutted.");
+  });
 });
 
 class A {
@@ -609,6 +628,14 @@ describe("nested structures", () => {
     );
   });
 
+  /** Sets of different sizes should not be equal. */
+  test("sets of different sizes", () => {
+    let a = new Set<i32>();
+    let b = new Set<i32>();
+    a.add(1);
+    expect(a).not.toStrictEqual(b);
+  });
+
   /**
    * Sets with numeric values should strictly equal each other.
    */
@@ -744,6 +771,14 @@ describe("nested structures", () => {
     expect(a).toStrictEqual(b, "maps should strictly equal each other");
   });
 
+  /** Maps of different sizes should be not equal. */
+  test("maps of different sizes", () => {
+    let a = new Map<i32, i32>();
+    let b = new Map<i32, i32>();
+    a.set(1, 2);
+    expect(a).not.toStrictEqual(b);
+  });
+
   /**
    * Maps with dissimilar values, when expected to match each other, should throw.
    */

packages/assembly/assembly/internal/Expectation.ts

@@ -70,6 +70,7 @@ export class Expectation<T> {
     Expected.clear();
   }
 
+  // @as-covers: ignore because this function is deprecated
   public toBlockEqual(expected: T, message: string = ""): void {
     WARNING(
       "toBlockEqual has been deprecated and results in a toStrictEqual call.",
@@ -146,10 +147,12 @@ export class Expectation<T> {
     let negated = this._not;
 
     if (!isFunction(this.actual))
+      // @as-covers: ignore because this is a compile time error
       ERROR(
-        "Expectation#toThrow assertion called on actual T where T is not a function reference",
+      "Expectation#toThrow assertion called on actual T where T is not a function reference",
       );
     if (idof<T>() != idof<() => void>())
+      // @as-covers: ignore because this is a compile time error
       ERROR(
         "Expectation#toThrow assertion called on actual T where T is not a function reference with signature () => void",
       );
@@ -170,6 +173,7 @@ export class Expectation<T> {
     Expected.report(expected, negated);
 
     if (!isDefined(actual > expected))
+      // @as-covers: ignore because this is a compile time error
       ERROR(
         "Invalid call to toBeGreaterThan. Generic type T must have an operator implemented for the greaterThan (>) operation.",
       );
@@ -212,6 +216,7 @@ export class Expectation<T> {
     Expected.report(expected, negated);
 
     if (!isDefined(actual >= expected))
+      // @as-covers: ignore because this is a compile time error
       ERROR(
         "Invalid call to toBeGreaterThanOrEqual. Generic type T must have an operator implemented for the greaterThanOrEqual (>=) operation.",
       );
@@ -253,6 +258,7 @@ export class Expectation<T> {
     Expected.report(expected, negated);
 
     if (!isDefined(actual < expected))
+      // @as-covers: ignore because this is a compile time error
       ERROR(
         "Invalid call to toBeLessThan. Generic type T must have an operator implemented for the lessThan (<) operation.",
       );
@@ -291,6 +297,7 @@ export class Expectation<T> {
     Expected.report(expected, negated);
 
     if (!isDefined(actual > expected))
+      // @as-covers: ignore because this is a compile time error
       ERROR(
         "Invalid call to toBeLessThanOrEqual. Generic type T must have an operator implemented for the lessThanOrEqual (<=) operation.",
       );
@@ -342,6 +349,7 @@ export class Expectation<T> {
       assert(negated ^ i32(changetype<usize>(actual) == 0), message);
       Actual.clear();
       Expected.clear();
+      // @as-covers: ignore because this is a compile time error
     } else {
       ERROR(
         "toBeNull assertion must be called with a reference type T or usize.",
@@ -359,6 +367,7 @@ export class Expectation<T> {
 
     // must be called on a float T
     if (!isFloat(actual))
+      // @as-covers: ignore because this is a compile time error
       ERROR("toBeCloseTo must be called with a Float value type T.");
     Actual.report(actual);
     Expected.report(expected, negated);
@@ -387,6 +396,7 @@ export class Expectation<T> {
 
     // must be called on a float T
     if (!isFloat(actual))
+      // @as-covers: ignore because this is a compile time error
       ERROR("toBeNaN must be called with a Float value type T.");
     Actual.report(actual);
 
@@ -405,6 +415,7 @@ export class Expectation<T> {
 
     // must be called on a float T
     if (!isFloat(actual))
+      // @as-covers: ignore because this is a compile time error
       ERROR("toBeNaN must be called with a Float value type T.");
     Actual.report(actual);
     Expected.reportFinite(negated);
@@ -424,6 +435,7 @@ export class Expectation<T> {
     } else {
       // @ts-ignore: This results in a compile time check for a length property with a better error message
       if (!isDefined(actual.length))
+        // @as-covers: ignore because this is a compile time error
         ERROR(
           "toHaveLength cannot be called on type T where T.length is not defined.",
         );
@@ -447,6 +459,7 @@ export class Expectation<T> {
   }
 
   // @ts-ignore: valueof<T> requires that T extends something with an @operator("[]")
+  // @as-covers: ignore because this is just an alias function
   public toContain(expected: valueof<T>, message: string = ""): void {
     this.toInclude(expected, message);
   }
@@ -457,6 +470,7 @@ export class Expectation<T> {
     Expected.clear();
   }
 
+  // @as-covers: ignore because this is an alias
   public toContainEqual<U>(expected: U, message: string = ""): void {
     this.toIncludeEqual(expected, message);
   }
@@ -474,8 +488,8 @@ export function expect<T>(actual: T): Expectation<T> {
 }
 
 // @ts-ignore: decorators *are* valid here
-@global
-export function expectFn(cb: () => void): Expectation<() => void> {
+// @as-covers: ignore because this is deprecated
+@global export function expectFn(cb: () => void): Expectation<() => void> {
   WARNING("expectFn() has been deprecated. Use expect() instead.");
   return new Expectation(cb);
 }