as-test 1.1.0 → 1.1.2

package/assembly/src/expectation.ts

@@ -62,6 +62,7 @@ export class Expectation<T> extends Tests {
     instr: string,
     left: string,
     right: string,
+    message: string = "",
   ): void {
     if (this._skip) {
       this.verdict = "skip";
@@ -77,7 +78,8 @@ export class Expectation<T> extends Tests {
     this.instr = instr;
     this.left = left;
     this.right = right;
-    this.message = isFail ? this._message : "";
+    const resolvedMessage = message.length ? message : this._message;
+    this.message = isFail ? resolvedMessage : "";
     if (isFail) {
       sendAssertionFailure(this._snapshotKey, instr, left, right, this.message);
       // @ts-ignore
@@ -103,7 +105,7 @@ export class Expectation<T> extends Tests {
   /**
    * Tests if a == null
    */
-  toBeNull(): void {
+  toBeNull(message: string = ""): void {
     const passed =
       (isNullable<T>() && changetype<usize>(this._left) == 0) ||
       (isInteger<T>() && nameof<T>() == "usize" && this._left == 0);
@@ -117,13 +119,14 @@ export class Expectation<T> extends Tests {
       visualize<T>(
         load<T>(changetype<usize>(this), offsetof<Expectation<T>>("_right")),
       ),
+      message,
     );
   }
 
   /**
    * Tests if a > b
    */
-  toBeGreaterThan(value: T): void {
+  toBeGreaterThan(value: T, message: string = ""): void {
     if (!isInteger<T>() && !isFloat<T>())
       ERROR("toBeGreaterThan() can only be used on number types!");
 
@@ -139,13 +142,14 @@ export class Expectation<T> extends Tests {
       visualize<T>(
         load<T>(changetype<usize>(this), offsetof<Expectation<T>>("_right")),
       ),
+      message,
     );
   }
 
   /**
    * Tests if a >= b
    */
-  toBeGreaterOrEqualTo(value: T): void {
+  toBeGreaterOrEqualTo(value: T, message: string = ""): void {
     if (!isInteger<T>() && !isFloat<T>())
       ERROR("toBeGreaterOrEqualTo() can only be used on number types!");
 
@@ -161,13 +165,14 @@ export class Expectation<T> extends Tests {
       visualize<T>(
         load<T>(changetype<usize>(this), offsetof<Expectation<T>>("_right")),
       ),
+      message,
     );
   }
 
   /**
    * Tests if a < b
    */
-  toBeLessThan(value: T): void {
+  toBeLessThan(value: T, message: string = ""): void {
     if (!isInteger<T>() && !isFloat<T>())
       ERROR("toBeLessThan() can only be used on number types!");
 
@@ -183,13 +188,14 @@ export class Expectation<T> extends Tests {
       visualize<T>(
         load<T>(changetype<usize>(this), offsetof<Expectation<T>>("_right")),
       ),
+      message,
     );
   }
 
   /**
    * Tests if a <= b
    */
-  toBeLessThanOrEqualTo(value: T): void {
+  toBeLessThanOrEqualTo(value: T, message: string = ""): void {
     if (!isInteger<T>() && !isFloat<T>())
       ERROR("toBeLessThanOrEqualTo() can only be used on number types!");
 
@@ -205,93 +211,127 @@ export class Expectation<T> extends Tests {
       visualize<T>(
         load<T>(changetype<usize>(this), offsetof<Expectation<T>>("_right")),
       ),
+      message,
     );
   }
 
   /**
    * Tests if a is string
    */
-  toBeString(): void {
-    this._resolve(isString<T>(), "toBeString", q(nameof<T>()), q("string"));
+  toBeString(message: string = ""): void {
+    this._resolve(
+      isString<T>(),
+      "toBeString",
+      q(nameof<T>()),
+      q("string"),
+      message,
+    );
   }
 
   /**
    * Tests if a is boolean
    */
-  toBeBoolean(): void {
-    this._resolve(isBoolean<T>(), "toBeBoolean", q(nameof<T>()), q("boolean"));
+  toBeBoolean(message: string = ""): void {
+    this._resolve(
+      isBoolean<T>(),
+      "toBeBoolean",
+      q(nameof<T>()),
+      q("boolean"),
+      message,
+    );
   }
 
   /**
    * Tests if a is array
    */
-  toBeArray(): void {
-    this._resolve(isArray<T>(), "toBeArray", q(nameof<T>()), q("Array<any>"));
+  toBeArray(message: string = ""): void {
+    this._resolve(
+      isArray<T>(),
+      "toBeArray",
+      q(nameof<T>()),
+      q("Array<any>"),
+      message,
+    );
   }
 
   /**
    * Tests if a is number
    */
-  toBeNumber(): void {
+  toBeNumber(message: string = ""): void {
     this._resolve(
       isFloat<T>() || isInteger<T>(),
       "toBeNumber",
       q(nameof<T>()),
       q("number"),
+      message,
     );
   }
 
   /**
    * Tests if a is integer
    */
-  toBeInteger(): void {
-    this._resolve(isInteger<T>(), "toBeInteger", q(nameof<T>()), q("integer"));
+  toBeInteger(message: string = ""): void {
+    this._resolve(
+      isInteger<T>(),
+      "toBeInteger",
+      q(nameof<T>()),
+      q("integer"),
+      message,
+    );
   }
 
   /**
    * Tests if a is float
    */
-  toBeFloat(): void {
-    this._resolve(isFloat<T>(), "toBeFloat", q(nameof<T>()), q("float"));
+  toBeFloat(message: string = ""): void {
+    this._resolve(
+      isFloat<T>(),
+      "toBeFloat",
+      q(nameof<T>()),
+      q("float"),
+      message,
+    );
   }
 
   /**
    * Tests if a is finite
    */
-  toBeFinite(): void {
+  toBeFinite(message: string = ""): void {
     // @ts-ignore
     const passed = (isFloat<T>() || isInteger<T>()) && isFinite(this._left);
-    this._resolve(passed, "toBeFinite", q("Infinity"), q("Finite"));
+    this._resolve(passed, "toBeFinite", q("Infinity"), q("Finite"), message);
   }
 
   /**
    * Tests if a value is truthy
    */
-  toBeTruthy(): void {
+  toBeTruthy(message: string = ""): void {
     this._resolve(
       isTruthy<T>(this._left),
       "toBeTruthy",
       q("falsy"),
       q("truthy"),
+      message,
     );
   }
 
   /**
    * Tests if a value is falsy
    */
-  toBeFalsy(): void {
+  toBeFalsy(message: string = ""): void {
     this._resolve(
       !isTruthy<T>(this._left),
       "toBeFalsy",
       q("truthy"),
       q("falsy"),
+      message,
     );
   }
 
   /**
    * Tests if a floating-point number is close to expected
    */
-  toBeCloseTo(expected: T, precision: i32 = 2): void {
+  toBeCloseTo(expected: T, precision: i32 = 2, message: string = ""): void {
     if (!isFloat<T>() && !isInteger<T>())
       ERROR("toBeCloseTo() can only be used on number types!");
     const factor = Math.pow(10, precision as f64);
@@ -302,67 +342,80 @@ export class Expectation<T> extends Tests {
       "toBeCloseTo",
       visualize<T>(this._left),
       visualize<T>(expected),
+      message,
     );
   }
 
   /**
    * Tests if a string contains substring
    */
-  toMatch(value: string): void {
+  toMatch(value: string, message: string = ""): void {
     if (!isString<T>()) ERROR("toMatch() can only be used on string types!");
     // @ts-ignore
     const passed = this._left.indexOf(value) >= 0;
     // @ts-ignore
-    this._resolve(passed, "toMatch", q(this._left as string), q(value));
+    this._resolve(
+      passed,
+      "toMatch",
+      q(this._left as string),
+      q(value),
+      message,
+    );
   }
 
   /**
    * Tests if a string starts with the provided prefix.
    */
-  toStartWith(value: string): void {
+  toStartWith(value: string, message: string = ""): void {
     if (!isString<T>())
       ERROR("toStartWith() can only be used on string types!");
     // @ts-ignore
     const left = this._left as string;
     const passed = left.indexOf(value) == 0;
-    this._resolve(passed, "toStartWith", q(left), q(value));
+    this._resolve(passed, "toStartWith", q(left), q(value), message);
   }
 
   /**
    * Tests if a string ends with the provided suffix.
    */
-  toEndWith(value: string): void {
+  toEndWith(value: string, message: string = ""): void {
     if (!isString<T>()) ERROR("toEndWith() can only be used on string types!");
     // @ts-ignore
     const left = this._left as string;
     const idx = left.lastIndexOf(value);
     const passed = idx >= 0 && idx + value.length == left.length;
-    this._resolve(passed, "toEndWith", q(left), q(value));
+    this._resolve(passed, "toEndWith", q(left), q(value), message);
   }
 
   /**
    * Tests if an array has length x
    */
-  toHaveLength(value: i32): void {
+  toHaveLength(value: i32, message: string = ""): void {
     // @ts-ignore
     const leftLen = this._left.length as i32;
     // @ts-ignore
     const passed = isArray<T>() && leftLen == value;
-    this._resolve(passed, "toHaveLength", leftLen.toString(), value.toString());
+    this._resolve(
+      passed,
+      "toHaveLength",
+      leftLen.toString(),
+      value.toString(),
+      message,
+    );
   }
 
   /**
    * Tests if an array or string contains a value
    */
   // @ts-ignore
-  toContain(value: valueof<T>): void {
+  toContain(value: valueof<T>, message: string = ""): void {
     if (isString<T>()) {
       // @ts-ignore
       const left = this._left as string;
       // @ts-ignore
       const needle = value as string;
       const passed = left.indexOf(needle) >= 0;
-      this._resolve(passed, "toContain", q(left), q(needle));
+      this._resolve(passed, "toContain", q(left), q(needle), message);
       return;
     }
 
@@ -374,6 +427,7 @@ export class Expectation<T> extends Tests {
         "toContain",
         stringifyValue<T>(this._left),
         stringifyValue<valueof<T>>(value),
+        message,
       );
       return;
     }
@@ -385,28 +439,28 @@ export class Expectation<T> extends Tests {
    * Alias for toContain().
    */
   // @ts-ignore
-  toContains(value: valueof<T>): void {
-    this.toContain(value);
+  toContains(value: valueof<T>, message: string = ""): void {
+    this.toContain(value, message);
   }
 
   /**
    * Tests if serialized value matches stored snapshot.
    */
-  toMatchSnapshot(name: string = ""): void {
+  toMatchSnapshot(name: string = "", message: string = ""): void {
     let key = name.length
       ? namedSnapshotKey(this._snapshotKey, name)
       : nextUnnamedSnapshotKey(this._snapshotKey);
 
     const actual = stringifyValue<T>(this._left);
     const res = snapshotAssert(key, actual);
-    this._resolve(res.ok, "toMatchSnapshot", actual, res.expected);
+    this._resolve(res.ok, "toMatchSnapshot", actual, res.expected, message);
   }
 
   /**
    * Delegates throw assertions to try-as when available.
    * If try-as is unavailable, this matcher is disabled and warns once.
    */
-  toThrow(): void {
+  toThrow(message: string = ""): void {
     // @ts-ignore
     if (!isDefined(AS_TEST_TRY_AS)) {
       if (!warnedToThrowDisabled) {
@@ -415,7 +469,7 @@ export class Expectation<T> extends Tests {
         );
         warnedToThrowDisabled = true;
       }
-      this._resolve(true, "toThrow", q("disabled"), q("disabled"));
+      this._resolve(true, "toThrow", q("disabled"), q("disabled"), message);
       return;
     }
 
@@ -425,13 +479,13 @@ export class Expectation<T> extends Tests {
       // @ts-ignore
       __ExceptionState.Failures--;
     }
-    this._resolve(passed, "toThrow", q("throws"), q("throws"));
+    this._resolve(passed, "toThrow", q("throws"), q("throws"), message);
   }
 
   /**
    * Tests for equality
    */
-  toBe(equals: T): void {
+  toBe(equals: T, message: string = ""): void {
     const passed = this._left === equals;
 
     this._resolve(
@@ -439,32 +493,35 @@ export class Expectation<T> extends Tests {
       "toBe",
       stringifyValue<T>(this._left),
       stringifyValue<T>(equals),
+      message,
     );
   }
 
   /**
    * Tests for deep equality
    */
-  toEqual(equals: T): void {
+  toEqual(equals: T, message: string = ""): void {
     const passed = valueEquals<T>(this._left, equals, false);
     this._resolve(
       passed,
       "toEqual",
       stringifyValue<T>(this._left),
       stringifyValue<T>(equals),
+      message,
     );
   }
 
   /**
    * Tests for strict deep equality
    */
-  toStrictEqual(equals: T): void {
+  toStrictEqual(equals: T, message: string = ""): void {
     const passed = valueEquals<T>(this._left, equals, true);
     this._resolve(
       passed,
       "toStrictEqual",
       stringifyValue<T>(this._left),
       stringifyValue<T>(equals),
+      message,
     );
   }
 }

package/assembly/src/fuzz.ts

@@ -79,14 +79,24 @@ export class FuzzSeed {
 
   i8(options: IntegerOptions<i8> | null = null): i8 {
     if (options == null) {
-      return this.nextI8InRange(i8.MIN_VALUE, i8.MAX_VALUE, EMPTY_I8_EXCLUDE, false);
+      return this.nextI8InRange(
+        i8.MIN_VALUE,
+        i8.MAX_VALUE,
+        EMPTY_I8_EXCLUDE,
+        false,
+      );
     }
     return this.nextI8InRange(options.min, options.max, options.exclude, true);
   }
 
   u8(options: IntegerOptions<u8> | null = null): u8 {
     if (options == null) {
-      return this.nextU8InRange(u8.MIN_VALUE, u8.MAX_VALUE, EMPTY_U8_EXCLUDE, false);
+      return this.nextU8InRange(
+        u8.MIN_VALUE,
+        u8.MAX_VALUE,
+        EMPTY_U8_EXCLUDE,
+        false,
+      );
     }
     return this.nextU8InRange(options.min, options.max, options.exclude, true);
   }
@@ -186,7 +196,9 @@ export class FuzzSeed {
       if (!exclude.length) {
         for (let i = 0; i < length; i++) {
           unchecked(
-            (out[i] = <u8>unchecked(include[this.nextRange(0, include.length - 1)])),
+            (out[i] = <u8>(
+              unchecked(include[this.nextRange(0, include.length - 1)])
+            )),
           );
         }
         return out;
@@ -299,7 +311,9 @@ export class FuzzSeed {
       return <i32>this.nextU32();
     }
     if (!exclude.length) {
-      return max <= min ? min : min + <i32>(this.nextU32() % <u32>(max - min + 1));
+      return max <= min
+        ? min
+        : min + <i32>(this.nextU32() % <u32>(max - min + 1));
     }
     for (let attempts = 0; attempts < 1024; attempts++) {
       const value =
@@ -324,12 +338,16 @@ export class FuzzSeed {
     const right = <i32>max;
     if (!exclude.length) {
       return <i8>(
-        right <= left ? left : left + <i32>(this.nextU32() % <u32>(right - left + 1))
+        (right <= left
+          ? left
+          : left + <i32>(this.nextU32() % <u32>(right - left + 1)))
       );
     }
     for (let attempts = 0; attempts < 1024; attempts++) {
       const value = <i8>(
-        right <= left ? left : left + <i32>(this.nextU32() % <u32>(right - left + 1))
+        (right <= left
+          ? left
+          : left + <i32>(this.nextU32() % <u32>(right - left + 1)))
       );
       if (!containsValue<i8>(exclude, value)) return value;
     }
@@ -350,11 +368,13 @@ export class FuzzSeed {
     const left = <u32>min;
     const right = <u32>max;
     if (!exclude.length) {
-      return <u8>(right <= left ? left : left + (this.nextU32() % (right - left + 1)));
+      return <u8>(
+        (right <= left ? left : left + (this.nextU32() % (right - left + 1)))
+      );
     }
     for (let attempts = 0; attempts < 1024; attempts++) {
       const value = <u8>(
-        right <= left ? left : left + (this.nextU32() % (right - left + 1))
+        (right <= left ? left : left + (this.nextU32() % (right - left + 1)))
       );
       if (!containsValue<u8>(exclude, value)) return value;
     }
@@ -376,12 +396,16 @@ export class FuzzSeed {
     const right = <i32>max;
     if (!exclude.length) {
       return <i16>(
-        right <= left ? left : left + <i32>(this.nextU32() % <u32>(right - left + 1))
+        (right <= left
+          ? left
+          : left + <i32>(this.nextU32() % <u32>(right - left + 1)))
       );
     }
     for (let attempts = 0; attempts < 1024; attempts++) {
       const value = <i16>(
-        right <= left ? left : left + <i32>(this.nextU32() % <u32>(right - left + 1))
+        (right <= left
+          ? left
+          : left + <i32>(this.nextU32() % <u32>(right - left + 1)))
       );
       if (!containsValue<i16>(exclude, value)) return value;
     }
@@ -402,11 +426,13 @@ export class FuzzSeed {
     const left = <u32>min;
     const right = <u32>max;
     if (!exclude.length) {
-      return <u16>(right <= left ? left : left + (this.nextU32() % (right - left + 1)));
+      return <u16>(
+        (right <= left ? left : left + (this.nextU32() % (right - left + 1)))
+      );
     }
     for (let attempts = 0; attempts < 1024; attempts++) {
       const value = <u16>(
-        right <= left ? left : left + (this.nextU32() % (right - left + 1))
+        (right <= left ? left : left + (this.nextU32() % (right - left + 1)))
       );
       if (!containsValue<u16>(exclude, value)) return value;
     }
@@ -448,9 +474,7 @@ export class FuzzSeed {
     const left = this.toOrderedU64(min);
     const right = this.toOrderedU64(max);
     if (!exclude.length) {
-      return this.fromOrderedU64(
-        left + this.nextU64Offset(left, right),
-      );
+      return this.fromOrderedU64(left + this.nextU64Offset(left, right));
     }
     for (let attempts = 0; attempts < 1024; attempts++) {
       const value = this.fromOrderedU64(left + this.nextU64Offset(left, right));
@@ -529,7 +553,7 @@ export class FuzzSeed {
   }
 
   private toOrderedU64(value: i64): u64 {
-    return <u64>value ^ I64_SIGN_MASK;
+    return (<u64>value) ^ I64_SIGN_MASK;
   }
 
   private fromOrderedU64(value: u64): i64 {
@@ -543,13 +567,11 @@ const DIGIT_ALPHABET: i32[] = rangeChars(48, 57);
 const HEX_ALPHABET: i32[] = DIGIT_ALPHABET.concat(rangeChars(97, 102));
 const ALNUM_ALPHABET: i32[] = ALPHA_ALPHABET.concat(DIGIT_ALPHABET);
 const BASE64_ALPHABET: i32[] = ALPHA_ALPHABET.concat(DIGIT_ALPHABET).concat([
-  43,
-  47,
-  61,
+  43, 47, 61,
 ]);
-const IDENTIFIER_ALPHABET: i32[] = [95].concat(ALPHA_ALPHABET).concat(
-  DIGIT_ALPHABET,
-);
+const IDENTIFIER_ALPHABET: i32[] = [95]
+  .concat(ALPHA_ALPHABET)
+  .concat(DIGIT_ALPHABET);
 const WHITESPACE_ALPHABET: i32[] = [9, 10, 13, 32];
 
 export abstract class FuzzerBase {
@@ -1113,7 +1135,6 @@ function removeFirst(values: i32[], needle: i32): void {
   if (index >= 0) values.splice(index, 1);
 }
 
-
 function validateLengthRange(label: string, min: i32, max: i32): void {
   if (min < 0 || max < 0) panic();
   if (max < min) panic();

package/assembly/util/format.ts

@@ -0,0 +1,113 @@
+export function formatValue<T>(value: T, deep: boolean = false): string {
+  if (isNullable<T>() && changetype<usize>(value) == <usize>0) {
+    return "null";
+  }
+
+  if (isString<T>()) {
+    const text = value as string;
+    return deep ? "'" + text + "'" : text;
+  }
+
+  if (isBoolean<T>() || isInteger<T>() || isFloat<T>()) {
+    // @ts-expect-error: primitive formatting
+    return value.toString();
+  }
+
+  if (isArray<T>()) {
+    // @ts-expect-error: array-like handling
+    const values = value as valueof<T>[];
+    if (!values.length) return "[]";
+    let out = "[";
+    for (let i = 0; i < values.length; i++) {
+      if (i) out += ", ";
+      out += formatValue<valueof<T>>(unchecked(values[i]), true);
+    }
+    out += "]";
+    return out;
+  }
+
+  if (value instanceof Map) {
+    // @ts-expect-error: generic runtime access
+    const keys = value.keys();
+    if (!keys.length) return "Map(0) {}";
+    // @ts-expect-error: generic runtime access
+    const values = value.values();
+    let out = "Map(" + keys.length.toString() + ") { ";
+    for (let i = 0; i < keys.length; i++) {
+      if (i) out += ", ";
+      out += formatValue(
+        changetype<valueof<typeof keys>>(unchecked(keys[i])),
+        true,
+      );
+      out += " => ";
+      out += formatValue(
+        changetype<valueof<typeof values>>(unchecked(values[i])),
+        true,
+      );
+    }
+    out += " }";
+    return out;
+  }
+
+  if (value instanceof Set) {
+    // @ts-expect-error: generic runtime access
+    const values = value.values();
+    if (!values.length) return "Set(0) {}";
+    let out = "Set(" + values.length.toString() + ") { ";
+    for (let i = 0; i < values.length; i++) {
+      if (i) out += ", ";
+      out += formatValue(
+        changetype<valueof<typeof values>>(unchecked(values[i])),
+        true,
+      );
+    }
+    out += " }";
+    return out;
+  }
+
+  if (isManaged<T>()) {
+    // @ts-expect-error: custom serializer when provided
+    if (isDefined(value.__as_test_json)) {
+      // @ts-expect-error: dynamic method dispatch
+      return value.__as_test_json();
+    }
+  }
+
+  return nameof<T>();
+}
+
+
+@inline
+export function colorText(format: i32[], text: string): string {
+  return `\u001b[${format[0].toString()}m${text}\u001b[${format[1].toString()}m`;
+}
+
+
+@inline
+export function red(text: string): string {
+  return colorText([31, 39], text);
+}
+
+
+@inline
+export function green(text: string): string {
+  return colorText([32, 39], text);
+}
+
+
+@inline
+export function bgRed(text: string): string {
+  return colorText([41, 49], text);
+}
+
+
+@inline
+export function bgGreen(text: string): string {
+  return colorText([42, 49], text);
+}
+
+
+@inline
+export function bold(text: string): string {
+  return colorText([1, 22], text);
+}