as-test 0.0.2 → 0.0.3

package/README.md

@@ -1,10 +1,10 @@
 <h5 align="center">
-<pre>
- _____ _____     _____ _____ _____ _____ 
-|  _  |   __|___|_   _|   __|   __|_   _|
-|     |__   |___| | | |   __|__   | | |  
-|__|__|_____|     |_| |_____|_____| |_|  
-v0.0.2
+<pre>                              
+ _____  _____      _____  _____  _____  _____ 
+|  _  ||   __| ___|_   _||   __||   __||_   _|
+|     ||__   ||___| | |  |   __||__   |  | |  
+|__|__||_____|      |_|  |_____||_____|  |_|  
+v0.0.3
 </pre>
 </h5>
 
@@ -20,16 +20,101 @@ npm install as-test
 import {
   describe,
   expect,
+  test,
+  beforeAll,
+  afterAll,
+  beforeEach,
+  afterEach,
+  log,
   run
 } from "as-test";
 
-describe("Should create suite", () => {
-  expect("foo").toBe("foo");
-  expect(3.14).toBeGreaterThan(0.0);
-  expect("a").toBe("b");
+// Shared setup for all tests (executed once before all tests)
+beforeAll(() => {
+  log("Setting up test environment...");
 });
 
-run();
+// Shared teardown for all tests (executed once after all tests)
+afterAll(() => {
+  log("Tearing down test environment...");
+});
+
+describe("Math operations", () => {
+  // Setup before each test in this group (optional)
+  beforeEach(() => {
+    log("Initializing test...");
+  });
+
+  // Teardown after each test in this group (optional)
+  afterEach(() => {
+    log("Cleaning up after test...");
+  });
+
+  test("Addition", () => {
+    expect(1 + 2).toBe(3);
+  });
+
+  test("Comparison", () => {
+    expect(5).toBeGreaterThan(3);
+    expect(2).toBeLessThan(4);
+  });
+
+  test("Type checking", () => {
+    expect("hello").toBeString();
+    expect(true).toBeBoolean();
+    expect(10.5).toBeNumber();
+  });
+});
+
+describe("Array manipulation", () => {
+  let myArray;
+
+  beforeAll(() => {
+    myArray = [1, 2, 3];
+  });
+
+  test("Array length", () => {
+    expect(myArray).toHaveLength(3);
+  });
+
+  test("Array inclusion", () => {
+    expect(myArray).toContain(2);
+  });
+});
+
+run({
+  log: false
+});
+```
+
+```
+ _____  _____      _____  _____  _____  _____ 
+|  _  ||   __| ___|_   _||   __||   __||_   _|
+|     ||__   ||___| | |  |   __||__   |  | |  
+|__|__||_____|      |_|  |_____||_____|  |_|  
+
+-----------------------------------------
+
+ [PASS]  Math operations
+
+ [PASS]  Array manipulation
+
+ [PASS]  Addition
+
+ [PASS]  Comparison
+
+ [PASS]  Type checking
+
+ [PASS]  Array length
+
+ [PASS]  Array inclusion
+
+-----------------------------------------
+
+Test Suites: 0 failed, 2 total
+Tests:       0 failed, 8 total
+Snapshots:   0 total
+Time:        101.812μs
 ```
 
 If you use this project in your codebase, consider dropping a [⭐ HERE](https://github.com/JairusSW/as-test). I would really appreciate it!

package/assembly/index.ts

@@ -1,24 +1,43 @@
 import { rainbow } from "as-rainbow";
 import { TestGroup } from "./src/group";
 import { Expectation } from "./src/expectation";
-import { Verdict } from "./src/result";
-import { formatTime } from "./util";
+import { colorText, formatTime } from "./util";
+import { stringify } from "as-console/assembly";
+
+/**
+ * Enumeration representing the verdict of a test case.
+ */
+export enum Verdict {
+    Unreachable,
+    Ok,
+    Fail
+}
 
 // Globals
 let current_group: TestGroup | null = null;
 let groups: TestGroup[] = [];
 
+let before_all_callback: (() => void) | null = null;
+let after_all_callback: (() => void) | null = null;
+
+// @ts-ignore
+@global let before_each_callback: (() => void) | null = null;
+// @ts-ignore
+@global let after_each_callback: (() => void) | null = null;
+// @ts-ignore
+@global let __test_options!: RunOptions;
+
 /**
- * Creates a test group containing multiple test cases
+ * Creates a test group containing multiple test cases.
  * 
  * @param {string} description - The name of the test group
- * @param callback - The block containing the test cases for this group
+ * @param {() => void} callback - The block containing the test cases for this group
  * 
  * @example
- * 
  * ```ts
  * describe("my test suite", () => {
- *  // Tests go here
+ *   expect(1 + 3).toBe(4);
+ *   // More tests here
  * });
  * ```
  */
@@ -29,24 +48,172 @@ export function describe(description: string, callback: () => void): void {
     groups.push(group);
 }
 
+/**
+ * Creates a test group containing multiple test cases
+ * 
+ * @param {string} description - The name of the test group
+ * @param {() => void} callback - The block containing the test cases for this group
+ * 
+ * @example
+ * 
+ * ```ts
+ * test("1 + 3 = 4", () => {
+ *  expect(1 + 3).toBe(4);
+ * });
+ * ```
+ */
+export function test(description: string, callback: () => void): void {
+    const group = new TestGroup(description, callback);
+
+    current_group = group;
+    groups.push(group);
+}
+
+/**
+ * Creates a test group containing multiple test cases
+ * 
+ * @param {string} description - The name of the test group
+ * @param {() => void} callback - The block containing the test cases for this group
+ * 
+ * @example
+ * 
+ * ```ts
+ * it("should perform additions", () => {
+ *  expect(1 + 3).toBe(4);
+ * });
+ * ```
+ */
+export function it(description: string, callback: () => void): void {
+    const group = new TestGroup(description, callback);
+
+    current_group = group;
+    groups.push(group);
+}
+
+/**
+ * Creates an expectation object for making assertions within a test case.
+ * 
+ * Use this function to chain assertions about a specific value. 
+ * The returned expectation object provides various methods for testing 
+ * different properties and conditions of the value.
+ * 
+ * @param {T} value - The value to be asserted against.
+ * @returns {Expectation<T>} - The expectation object for chaining assertions.
+ * 
+ * @example
+ * ```ts
+ * test("number comparison", () => {
+ *   expect(1 + 2).toBe(3);
+ *   expect(5).toBeGreaterThan(3);
+ * });
+ * ```
+ */
 export function expect<T>(value: T): Expectation<T> {
     const result = new Expectation<T>(value);
-
     current_group!.addExpectation(result);
 
-    //if (!result.tested) {
-    //
-    //}
-
     return result;
 }
 
-export function run(): void {
-    console.log(rainbow.boldMk(rainbow.blue(
-        ` _____ _____     _____ _____ _____ _____ 
-|  _  |   __|___|_   _|   __|   __|_   _|
-|     |__   |___| | | |   __|__   | | |  
-|__|__|_____|     |_| |_____|_____| |_|  `)));
+/**
+ * Formats and prints content to the terminal
+ * Can be disabled like so:
+ * 
+ * ```js
+ * // ...
+ * 
+ * run({ log: false });
+ * ```
+ * 
+ * @param {T} data - The data to format and print
+ */
+export function log<T>(data: T): void {
+    if (!__test_options.log) return;
+    const formatted = stringify(data);
+    if (formatted) {
+        const lines = formatted.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+            const line = unchecked(lines[i]);
+            console.log("  " + rainbow.bgYellow(" LOG ") + " " + line);
+        }
+        console.log("");
+    }
+}
+
+/**
+ * Registers a callback function to be executed before each test group is run.
+ * 
+ * @param {() => void} callback - The function to be executed before each test group.
+ */
+export function beforeAll(callback: () => void): void {
+    before_all_callback = callback;
+}
+
+/**
+ * Registers a callback function to be executed after each test group is run.
+ * 
+ * @param {() => void} callback - The function to be executed after each test group.
+ */
+export function afterAll(callback: () => void): void {
+    after_all_callback = callback;
+}
+
+/**
+ * Registers a callback function to be executed before each test case is run.
+ * 
+ * @param {() => void} callback - The function to be executed before each test case.
+ */
+export function beforeEach(callback: () => void): void {
+    before_each_callback = callback;
+}
+
+/**
+ * Registers a callback function to be executed after each test case is run.
+ * 
+ * @param {() => void} callback - The function to be executed after each test case.
+ */
+export function afterEach(callback: () => void): void {
+    after_each_callback = callback;
+}
+
+/**
+ * Class defining options that can be passed to the `run` function.
+ * 
+ * Currently, it offers a single option:
+ * 
+ * - `log` (boolean, default: true): Controls whether enable the log() function
+ **/
+class RunOptions {
+    log: boolean = true
+}
+
+/**
+ * Runs all the test suites defined within the current test scope.
+ * 
+ * This function executes all the test cases you've defined in your test suites.
+ * It iterates through each suite, runs the tests within the suite, and tracks results.
+ * Finally, it prints a colorful summary of the test execution.
+ * 
+ * @param {RunOptions} [options] - Optional options for running tests.
+ * 
+ * @example
+ * ```javascript
+ * describe("Math operations", () => {
+ *   test("Addition", () => {
+ *     expect(1 + 2).toBe(3);
+ *   });
+ *   // ... other tests
+ * });
+ * 
+ * run(); // Executes all tests in the "Math operations" suite
+ * ```
+ */
+export function run(options: RunOptions = new RunOptions()): void {
+    __test_options = options;
+    console.log(rainbow.boldMk(rainbow.green(` _____  _____      _____  _____  _____  _____ `)));
+    console.log(rainbow.boldMk(rainbow.green(`|  _  ||   __| ___|_   _||   __||   __||_   _|`)));
+    console.log(rainbow.boldMk(rainbow.green(`|     ||__   ||___| | |  |   __||__   |  | |  `)));
+    console.log(rainbow.boldMk(rainbow.green(`|__|__||_____|      |_|  |_____||_____|  |_|  `)));
     console.log(rainbow.dimMk("\n-----------------------------------------\n"));
     const suites = groups.length;
     let failed = 0;
@@ -54,6 +221,7 @@ export function run(): void {
     let failed_tests = 0;
     const start = performance.now();
     for (let i = 0; i < groups.length; i++) {
+        if (before_all_callback) before_all_callback();
         const suite = unchecked(groups[i]);
         suite.run();
         for (let i = 0; i < suite.results.length; i++) {
@@ -70,7 +238,7 @@ export function run(): void {
         }
         if (suite.verdict == Verdict.Unreachable) {
             suite.verdict = Verdict.Ok;
-            console.log(rainbow.bgGreen(" PASS ") + " " + rainbow.dimMk(suite.description) + "\n");
+            console.log(rainbow.bgGreenBright(" PASS ") + " " + rainbow.dimMk(suite.description) + "\n");
         } else {
             failed++;
             console.log(rainbow.bgRed(" FAIL ") + " " + rainbow.dimMk(suite.description) + "\n");
@@ -78,6 +246,7 @@ export function run(): void {
 
         const report = suite.report();
         if (report) console.log(report);
+        if (after_all_callback) after_all_callback();
     }
     const ms = performance.now() - start;
     console.log(rainbow.dimMk("-----------------------------------------\n"));

package/assembly/src/expectation.ts

@@ -1,12 +1,14 @@
-import { Verdict } from "./result";
 import { rainbow } from "as-rainbow";
 import { diff, visualize } from "../util";
 import { Node } from "./node";
+import { Verdict } from "..";
 
 export class Expectation<T> extends Node {
     public verdict: Verdict = Verdict.Unreachable;
     public left: T;
-    public right!: T;
+    private _left: string | null = null;
+    public right: u64 = 0;
+    private _right: string | null = null;
     private _not: boolean = false;
     private op: string = "=";
     constructor(left: T) {
@@ -17,94 +19,290 @@ export class Expectation<T> extends Node {
         this._not = true;
         return this;
     }
-    toBeNull(): Expectation<T> {
+
+    /**
+    * Tests if a == null
+    * @returns - void
+    */
+    toBeNull(): void {
         this.verdict = (isNullable<T>() && changetype<usize>(this.left)) ? Verdict.Ok : Verdict.Fail;
 
         // @ts-ignore
-        this.right = null;
-        
+        store<T>(changetype<usize>(this), null, offsetof<Expectation<T>>("right"));
+
         this.op = "="
 
-        return this;
+        // @ts-ignore
+        if (after_each_callback) after_each_callback();
+        // @ts-ignore
+        if (before_each_callback) before_each_callback();
     }
+
     /**
      * Tests if a > b
      * @param number equals - The value to test
-     * @returns - Expectation
+     * @returns - void
      */
-    toBeGreaterThan(value: T): Expectation<T> {
+    toBeGreaterThan(value: T): void {
         if (!isInteger<T>() && !isFloat<T>()) throw new Error("toBeGreaterThan() can only be used on number types. Received " + nameof<T>() + " instead!");
-        
+
         this.verdict = this.left > value ? Verdict.Ok : Verdict.Fail;
-        this.right = value;
+        store<T>(changetype<usize>(this), value, offsetof<Expectation<T>>("right"));
 
         this.op = ">";
 
-        return this;
+        // @ts-ignore
+        if (after_each_callback) after_each_callback();
+        // @ts-ignore
+        if (before_each_callback) before_each_callback();
     }
+
     /**
      * Tests if a >= b
      * @param number equals - The value to test
-     * @returns - Expectation
+     * @returns - void
      */
-    toBeGreaterOrEqualTo(value: T): Expectation<T> {
+    toBeGreaterOrEqualTo(value: T): void {
         if (!isInteger<T>() && !isFloat<T>()) throw new Error("toBeGreaterOrEqualTo() can only be used on number types. Received " + nameof<T>() + " instead!");
-        
+
         this.verdict = this.left >= value ? Verdict.Ok : Verdict.Fail;
-        this.right = value;
+        store<T>(changetype<usize>(this), value, offsetof<Expectation<T>>("right"));
 
         this.op = ">=";
 
-        return this;
+        // @ts-ignore
+        if (after_each_callback) after_each_callback();
+        // @ts-ignore
+        if (before_each_callback) before_each_callback();
     }
+
     /**
      * Tests if a < b
      * @param number equals - The value to test
-     * @returns - Expectation
+     * @returns - void
      */
-    toBeLessThan(value: T): Expectation<T> {
+    toBeLessThan(value: T): void {
         if (!isInteger<T>() && !isFloat<T>()) throw new Error("toBeLessThan() can only be used on number types. Received " + nameof<T>() + " instead!");
-        
+
         this.verdict = this.left < value ? Verdict.Ok : Verdict.Fail;
-        this.right = value;
+        store<T>(changetype<usize>(this), value, offsetof<Expectation<T>>("right"));
 
         this.op = "<";
 
-        return this;
+        // @ts-ignore
+        if (after_each_callback) after_each_callback();
+        // @ts-ignore
+        if (before_each_callback) before_each_callback();
     }
+
     /**
      * Tests if a <= b
      * @param number equals - The value to test
-     * @returns - Expectation
+     * @returns - void
      */
-    toBeLessThanOrEqualTo(value: T): Expectation<T> {
+    toBeLessThanOrEqualTo(value: T): void {
         if (!isInteger<T>() && !isFloat<T>()) throw new Error("toBeLessThanOrEqualTo() can only be used on number types. Received " + nameof<T>() + " instead!");
-        
+
         this.verdict = this.left <= value ? Verdict.Ok : Verdict.Fail;
-        this.right = value;
+        store<T>(changetype<usize>(this), value, offsetof<Expectation<T>>("right"));
 
         this.op = "<=";
 
-        return this;
+        // @ts-ignore
+        if (after_each_callback) after_each_callback();
+        // @ts-ignore
+        if (before_each_callback) before_each_callback();
     }
+
+    /**
+     * Tests if a is string
+     * @returns - void
+     */
+    toBeString(): void {
+        this.verdict = isString<T>() ? Verdict.Ok : Verdict.Fail;
+
+        this._left = nameof<T>();
+        this._right = "string";
+
+        this.op = "type";
+
+        // @ts-ignore
+        if (after_each_callback) after_each_callback();
+        // @ts-ignore
+        if (before_each_callback) before_each_callback();
+    }
+
+    /**
+     * Tests if a is boolean
+     * @returns - void
+     */
+    toBeBoolean(): void {
+        this.verdict = isBoolean<T>() ? Verdict.Ok : Verdict.Fail;
+
+        this._left = nameof<T>();
+        this._right = "boolean";
+
+        this.op = "type";
+
+        // @ts-ignore
+        if (after_each_callback) after_each_callback();
+        // @ts-ignore
+        if (before_each_callback) before_each_callback();
+    }
+
+    /**
+     * Tests if a is array
+     * @returns - void
+     */
+    toBeArray(): void {
+        this.verdict = isArray<T>() ? Verdict.Ok : Verdict.Fail;
+
+        this._left = nameof<T>();
+        this._right = "Array<any>";
+
+        this.op = "type";
+
+        // @ts-ignore
+        if (after_each_callback) after_each_callback();
+        // @ts-ignore
+        if (before_each_callback) before_each_callback();
+    }
+
+    /**
+     * Tests if a is number
+     * @returns - void
+     */
+    toBeNumber(): void {
+        this.verdict = (isFloat<T>() || isInteger<T>()) ? Verdict.Ok : Verdict.Fail;
+
+        this._left = nameof<T>();
+        this._right = "number";
+
+        this.op = "type";
+
+        // @ts-ignore
+        if (after_each_callback) after_each_callback();
+        // @ts-ignore
+        if (before_each_callback) before_each_callback();
+    }
+
+    /**
+     * Tests if a is integer
+     * @returns - void
+     */
+    toBeInteger(): void {
+        this.verdict = isInteger<T>() ? Verdict.Ok : Verdict.Fail;
+
+        this._left = nameof<T>();
+        this._right = "float";
+
+        this.op = "type";
+
+        // @ts-ignore
+        if (after_each_callback) after_each_callback();
+        // @ts-ignore
+        if (before_each_callback) before_each_callback();
+    }
+
+    /**
+     * Tests if a is float
+     * @returns - void
+     */
+    toBeFloat(): void {
+        this.verdict = isFloat<T>() ? Verdict.Ok : Verdict.Fail;
+
+        this._left = nameof<T>();
+        this._right = "integer";
+
+        this.op = "type";
+
+        // @ts-ignore
+        if (after_each_callback) after_each_callback();
+        // @ts-ignore
+        if (before_each_callback) before_each_callback();
+    }
+
+    /**
+     * Tests if a is finite
+     * @returns - void
+     */
+    toBeFinite(): void {
+        // @ts-ignore
+        this.verdict = ((isFloat<T>() || isInteger<T>()) && isFinite(this.left)) ? Verdict.Ok : Verdict.Fail;
+
+        this._left = "Infinity";
+        this._right = "Finite";
+
+        this.op = "=";
+
+        // @ts-ignore
+        if (after_each_callback) after_each_callback();
+        // @ts-ignore
+        if (before_each_callback) before_each_callback();
+    }
+
+    /**
+     * Tests if an array has length x
+     * 
+     * @param {i32} value - The value to check
+     * @returns - void
+     */
+    toHaveLength(value: i32): void {
+        // @ts-ignore
+        this.verdict = (isArray<T>() && this.left.length == value) ? Verdict.Ok : Verdict.Fail;
+
+        // @ts-ignore
+        this._left = this.left.length.toString();
+        this._right = value.toString();
+
+        this.op = "length";
+
+        // @ts-ignore
+        if (after_each_callback) after_each_callback();
+        // @ts-ignore
+        if (before_each_callback) before_each_callback();
+    }
+
+    /**
+     * Tests if an array contains an element
+     * 
+     * @param { valueof<T> } value - The value to check
+     * @returns - void
+     */
+    // @ts-ignore
+    toContain(value: valueof<T>): void {
+        // @ts-ignore
+        this.verdict = (isArray<T>() && this.left.includes(value)) ? Verdict.Ok : Verdict.Fail;
+
+        // @ts-ignore
+        this._left = "includes value";
+        this._right = "does not include value";
+        this.op = "=";
+
+        // @ts-ignore
+        if (after_each_callback) after_each_callback();
+        // @ts-ignore
+        if (before_each_callback) before_each_callback();
+    }
+
     /**
      * Tests for equality
-     * @param any equals - The value to test
-     * @returns - Expectation
+     * @param {T} equals - The value to test
+     * @returns - void
      */
-    toBe(equals: T): Expectation<T> {
-        this.right = equals;
+    toBe(equals: T): void {
+        store<T>(changetype<usize>(this), equals, offsetof<Expectation<T>>("right"));
         if (isBoolean<T>()) {
-            this.verdict = this.left === this.right
+            this.verdict = this.left === equals
                 ? Verdict.Ok
                 : Verdict.Fail;
 
         } else if (isString<T>()) {
-            this.verdict = this.left === this.right
+            this.verdict = this.left === equals
                 ? Verdict.Ok
                 : Verdict.Fail;
         } else if (isInteger<T>() || isFloat<T>()) {
-            this.verdict = this.left === this.right
+            this.verdict = this.left === equals
                 ? Verdict.Ok
                 : Verdict.Fail;
         } else if (isArray<T>()) {
@@ -115,14 +313,17 @@ export class Expectation<T> extends Node {
 
         this.op = "=";
 
-        return this;
+        // @ts-ignore
+        if (after_each_callback) after_each_callback();
+        // @ts-ignore
+        if (before_each_callback) before_each_callback();
     }
 
     report(): string | null {
         if (!this._not && this.verdict === Verdict.Ok) return null;
 
-        const left = visualize(this.left);
-        const right = visualize(this.right);
+        const left = this._left || visualize(this.left);
+        const right = this._right || visualize(load<T>(changetype<usize>(this), offsetof<Expectation<T>>("right")));
 
         if (this._not) {
             if (this.verdict === Verdict.Fail) return null;

package/assembly/src/group.ts

@@ -1,6 +1,6 @@
+import { Verdict } from "..";
 import { Expectation } from "./expectation";
 import { Node } from "./node";
-import { Verdict } from "./result";
 export class TestGroup {
     public results: Node[] = [];
 

package/assembly/src/node.ts

@@ -1,4 +1,4 @@
-import { Verdict } from "./result";
+import { Verdict } from "..";
 
 export class Node {
     public verdict: Verdict = Verdict.Unreachable;

package/assembly/test.ts

@@ -1,13 +1,69 @@
-import { describe, expect, run } from ".";
+import {
+    describe,
+    expect,
+    test, // Alias for `it`
+    beforeAll,
+    afterAll,
+    beforeEach,
+    afterEach,
+    log,
+    run
+} from ".";
 
-describe("Should create suite successfully", () => {
-    expect("foo joe momma joe mommmmma").toBe("booq2132132312");
-    expect("abcdefg").not.toBe("abcdefg");
-    expect("hello").toBe("hello");
-    expect<Nullable | null>(null).toBeNull();
-    expect(5).toBeGreaterOrEqualTo(9)
+
+// Shared setup for all tests (executed once before all tests)
+beforeAll(() => {
+    log("Setting up test environment...");
+});
+
+// Shared teardown for all tests (executed once after all tests)
+afterAll(() => {
+    log("Tearing down test environment...");
 });
 
-class Nullable { }
+describe("Math operations", () => {
+    // Setup before each test in this group (optional)
+    beforeEach(() => {
+        log("Initializing test...");
+    });
+
+    // Teardown after each test in this group (optional)
+    afterEach(() => {
+        log("Cleaning up after test...");
+    });
+
+    test("Addition", () => {
+        expect(1 + 2).toBe(3);
+    });
+
+    test("Comparison", () => {
+        expect(5).toBeGreaterThan(3);
+        expect(2).toBeLessThan(4);
+    });
+
+    test("Type checking", () => {
+        expect("hello").toBeString();
+        expect(true).toBeBoolean();
+        expect(10.5).toBeNumber();
+    });
+});
+
+let myArray: i32[] = [];
+
+describe("Array manipulation", () => {
+    beforeAll(() => {
+        myArray = [1, 2, 3];
+    });
+
+    test("Array length", () => {
+        expect(myArray).toHaveLength(3);
+    });
+
+    test("Array inclusion", () => {
+        expect(myArray).toContain(2);
+    });
+});
 
-run();
+run({
+    log: false
+});

package/assembly/util.ts

@@ -107,4 +107,10 @@ export function formatTime(ms: number): string {
     }
 
     return `${us}us`;
+}
+
+// @ts-ignore
+@inline
+export function colorText(format: i32[], text: string): string {
+    return `\u001b[${format[0].toString()}m${text}\u001b[${format[1].toString()}m`
 }

package/jest.test.js

@@ -1,5 +1,5 @@
 describe("Should create suite successfully", () => {
     expect("foo joe momma joe mommmmma").toBe("booq2132132312");
     expect("abcdefg").not.toBe("abcdefg");
-    expect("hello").toBe("hello")
+    expect("hello").toBe("hello");
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "as-test",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Testing framework for AssemblyScript. Compatible with WASI or Bindings ",
   "types": "assembly/index.ts",
   "author": "Jairus Tanaka",
@@ -22,7 +22,7 @@
     "typescript": "^5.3.3",
     "visitor-as": "^0.11.4"
   },
-  "dependencies": { "as-convert-seconds": "^1.0.0", "as-rainbow": "^0.1.0", "as-string-sink": "^0.5.3", "as-variant": "^0.4.1", "json-as": "^0.9.6" },
+  "dependencies": { "as-console": "^6.0.2", "as-convert-seconds": "^1.0.0", "as-rainbow": "^0.1.0", "as-string-sink": "^0.5.3", "as-variant": "^0.4.1", "json-as": "^0.9.6" },
   "overrides": {
     "assemblyscript": "$assemblyscript"
   },

package/assembly/src/it.ts

@@ -1,90 +0,0 @@
-import { Variant } from "as-variant/assembly";
-import { Verdict } from "./result";
-import { rainbow } from "as-rainbow";
-import { visualize } from "../util";
-import { StringSink } from "as-string-sink/assembly";
-
-export class It {
-    public verdict: Verdict = Verdict.Unreachable;
-    public left: Variant;
-    public right!: Variant;
-    private _not: boolean = false;
-    constructor(left: Variant) {
-        this.left = left;
-    }
-    not(): It {
-        this._not = true;
-        return this;
-    }
-    /**
-     * Tests for strict equality
-     * @param any equals - The value to test
-     * @returns - Expectation
-     */
-    toBe<T>(equals: T): It {
-        this.right = Variant.from(equals);
-        if (this.left.id !== this.right.id) throw "cannot compare different types";
-
-        if (isBoolean<T>()) {
-            this.verdict = this.left.getUnchecked<T>() === this.right.getUnchecked<T>()
-                ? Verdict.Ok
-                : Verdict.Fail;
-
-        } else if (isString<T>()) {
-            this.verdict = this.left.getUnchecked<T>() === this.right.getUnchecked<T>()
-                ? Verdict.Ok
-                : Verdict.Fail;
-        } else if (isInteger<T>() || isFloat<T>()) {
-            this.verdict = this.left.getUnchecked<T>() === this.right.getUnchecked<T>()
-                ? Verdict.Ok
-                : Verdict.Fail;
-        } else if (isArray<T>()) {
-            // getArrayDepth<T>();
-        } else {
-            this.verdict = Verdict.Unreachable;
-        }
-
-        console.log(this.report<T>());
-
-        return this;
-    }
-
-    report<T>(): string {
-        if (!this.not && this.verdict === Verdict.Ok) {
-            return rainbow.green(" - Test completed successfully");
-        }
-
-        const left = visualize<T>(this.left.getUnchecked<T>());
-        const right = visualize<T>(this.right.getUnchecked<T>());
-
-        if (this._not) {
-            if (this.verdict === Verdict.Fail) return rainbow.green(" - Test completed successfully");
-            return rainbow.red(" - Test failed") + "\n" + rainbow.italicMk(`  ${rainbow.dimMk("(expected) ->")} ${rainbow.bgGreen(left.toString())}\n  ${rainbow.dimMk("(recieved) ->")} ${rainbow.bgRed(right.toString())}`);
-        }
-
-        let leftDiff = StringSink.withCapacity(left.length);
-        let rightDiff = StringSink.withCapacity(right.length);
-
-        let i = 0
-
-        for (; i < min(left.length, right.length); i++) {
-            const lChar = left.charAt(i);
-            const rChar = right.charAt(i);
-            if (lChar != rChar) {
-                leftDiff.write(rainbow.bgGreen(lChar));
-                rightDiff.write(rainbow.bgRed(rChar));
-            } else {
-                leftDiff.write(lChar);
-                rightDiff.write(rChar);
-            }
-        }
-
-        for (; i < left.length; i++) {
-            leftDiff.write(rainbow.bgGreen(left.charAt(i)));
-            rightDiff.write(rainbow.bgRed(" "));
-        }
-        for (; i < right.length; i++) rightDiff.write(rainbow.bgRed(right.charAt(i)));
-
-        return rainbow.red(" - Test failed") + "\n" + rainbow.italicMk(`  ${rainbow.dimMk("(expected) ->")} ${leftDiff.toString()}\n  ${rainbow.dimMk("(recieved) ->")} ${rightDiff.toString()}`);
-    }
-}

package/assembly/src/result.ts

@@ -1,23 +0,0 @@
-import { Variant } from "as-variant/assembly";
-
-export enum Verdict {
-    Unreachable,
-    Ok,
-    Fail,
-}
-
-export class TestResult {
-    public verdict: Verdict = Verdict.Unreachable;
-    public left: Variant;
-    public right!: Variant;
-    constructor(left: Variant) {
-        this.left = left;
-    }
-    toBe<T>(equals: T): TestResult {
-        return this;
-    }
-
-    report(): string {
-        
-    }
-}