vitest-pool-assemblyscript 0.11.0 → 0.12.0

package/assembly/compare.ts

@@ -1,4 +1,4 @@
-import { stringifyValue } from './utils';
+import { isNull, stringifyValue } from './utils';
 
 /**
  * Byte offset from an object pointer to the rtId field in the AS managed object header.
@@ -325,19 +325,15 @@ function arrayBufferEquals<T, U>(actual: T, expected: U): __vitest_assemblyscrip
  * (or same reference type) for provided values.
  */
 export function identical<T, U>(actual: T, expected: U): bool {
+  const actualIsNull = isNull(actual);
+  const expectedIsNull = isNull(expected);
+
   // both refs
   if (isReference<T>() && isReference<U>()) {
-    const actualIsNullable = isNullable<T>();
-    // Use changetype pointer check instead of `== null` to avoid invoking
-    // user-defined @operator("==") overloads, which reject null arguments
-    const actualIsNull = actualIsNullable && changetype<usize>(actual) == 0;
-    const expectedIsNullable = isNullable<U>();
-    const expectedIsNull = expectedIsNullable && changetype<usize>(expected) == 0;
-    
     // null refs
     if (actualIsNull && expectedIsNull) {
       return true;
-    } else if ( (actualIsNull && !expectedIsNull) || (!actualIsNull && expectedIsNull) ) {
+    } else if ( actualIsNull != expectedIsNull ) {
       return false;
     }
 
@@ -348,27 +344,26 @@ export function identical<T, U>(actual: T, expected: U): bool {
       // object refs
       return changetype<usize>(actual) == changetype<usize>(expected);
     }
-  } else if (isReference<T>() && !isReference<U>()) {
-    // Both null/zero: null reference matches bare null (usize(0))
-    if (changetype<usize>(actual) == 0 && expected == usize(0)) {
+  } else if (
+      (isReference<T>() && !isReference<U>())
+      || (!isReference<T>() && isReference<U>())
+    ) {
+    if (actualIsNull && expectedIsNull) {
       return true;
+    } else if ( actualIsNull != expectedIsNull ) {
+      return false;
     }
+
     // Non-null reference vs value type: fundamentally incomparable
     throw new Error(
       "Cannot compare " + nameof<T>() + " with " + nameof<U>()
       + equalsPathAtSuffix() + ": reference and value types are not comparable."
     );
-  } else if (!isReference<T>() && isReference<U>()) {
-    // Both null/zero: bare null (usize(0)) matches null reference
-    if (actual == usize(0) && changetype<usize>(expected) == 0) {
-      return true;
-    }
-    // Value type vs non-null reference: fundamentally incomparable
-    throw new Error(
-      "Cannot compare " + nameof<T>() + " with " + nameof<U>()
-      + equalsPathAtSuffix() + ": reference and value types are not comparable."
-    );
   } else { // both primitives
+    if ( actualIsNull != expectedIsNull ) {
+      return false;
+    }
+
     if ( (isBoolean<T>() && !isBoolean<U>()) || (!isBoolean<T>() && isBoolean<U>())
     ) {
       // when one is boolean and the other is not, they are not identical
@@ -484,27 +479,39 @@ export function equals<T, U>(actual: T, expected: U): __vitest_assemblyscript_Eq
     exactMatch = identical(actual, expected);
   }
 
-  if (!isReference<T>() || isString<T>() || isVector<T>()) {
-    // non-bool primitives or strings: return result of comparing
+  const actualIsNull = isNull(actual);
+  const expectedIsNull = isNull(expected);
+
+  if (
+    (!isReference<T>() && !isReference<U>())
+    || (isString<T>() && isString<U>())
+    || (isVector<T>() && isVector<U>())
+  ) {
+    // non-bool primitives or strings or vectors: return result of identity compare
     return exactMatch ? __vitest_assemblyscript_EqualityResult.Equal : __vitest_assemblyscript_EqualityResult.NotEqual;
   } else if (exactMatch) {
     // primitive / reference comparison passed already
     return __vitest_assemblyscript_EqualityResult.Equal;
-  }
-
-  if (isNullable<T>()) {
-    // Use changetype pointer checks instead of `== null` / `!= null` to avoid
-    // invoking user-defined @operator("==") overloads, which reject null arguments
-    const actualIsNull = changetype<usize>(actual) == 0;
-    const expectedIsNull = changetype<usize>(expected) == 0;
-
-    if (actualIsNull && expectedIsNull) {
-      return __vitest_assemblyscript_EqualityResult.Equal;
+  } else if (
+    (isReference<T>() && !isReference<U>())
+    || (!isReference<T>() && isReference<U>())
+  ) {
+    if (actualIsNull || expectedIsNull) {
+      return exactMatch ? __vitest_assemblyscript_EqualityResult.Equal : __vitest_assemblyscript_EqualityResult.NotEqual;
     }
 
-    if (actualIsNull != expectedIsNull) {
-      return __vitest_assemblyscript_EqualityResult.NotEqual;
-    }
+    // Non-null reference vs value type: fundamentally incomparable
+    throw new Error(
+      "Cannot compare " + nameof<T>() + " with " + nameof<U>()
+      + equalsPathAtSuffix() + ": reference and value types are not comparable."
+    );
+  }
+
+  if (actualIsNull && expectedIsNull) {
+    return __vitest_assemblyscript_EqualityResult.Equal;
+  }
+  if (actualIsNull != expectedIsNull) {
+    return __vitest_assemblyscript_EqualityResult.NotEqual;
   }
 
   // Cycle detection: if this reference pair is already being compared further up
@@ -784,4 +791,3 @@ export function compareInequality<T, U>(actual: T, compareTo: U, expectedOperati
 export function truthyOrFalsey<T>(actual: T, expected: bool): bool {
   return actual ? expected == true : expected == false;
 }
-

package/assembly/expect.ts

@@ -77,10 +77,15 @@ abstract class BaseExpectMatcher<T> {
    * involving a float and allows all numeric types because it can still produce accurate
    * results in precision-loss casting edge cases.
    *
+   * Null comparison: a null reference, the bare `null` literal, and `usize(0)` are all treated
+   * as null and compare as identical to one another. Zero-valued primitives (`0`, `false`, `0.0`) are
+   * **not** identical to null. Because the bare `null` literal is `usize(0)` in AssemblyScript, 
+   * `usize(0)` will not compare as identical to a `0` of another numeric type.
+   *
    * @throws When comparing float/integer types where the float's mantissa cannot losslessly
    * represent the integer type's range (e.g. `f32` vs `i32`, `f64` vs `i64`).
    * @throws When comparing fundamentally incompatible types: reference vs value type
-   * (e.g. `string` vs `i32`, unless one is null/zero), or `v128` vs non-vector type.
+   * (e.g. `string` vs `i32`, unless one side is null, or `v128` vs non-vector type).
    *
    * @example
    * expect(1 + 1).toBe(2);
@@ -278,12 +283,17 @@ abstract class BaseExpectMatcher<T> {
    *   are not included, as deep equality injection is scoped to user source files only
    *
    * SIMD vectors use WASM's native `==` comparison, which compares at the bit level, 
-   * ignoring lane type. 
+   * ignoring lane type.
+   *
+   * Null comparison: a null reference, the bare `null` literal, and `usize(0)` are all treated
+   * as null and compare equal to one another. Zero-valued primitives (`0`, `false`, `0.0`) are
+   * **not** equal to null. Because the bare `null` literal is `usize(0)` in AssemblyScript, 
+   * `usize(0)` will not compare as identical to a `0` of another numeric type.
    *
    * @throws When comparing float/integer types where the float's mantissa cannot losslessly
    * represent the integer type's range (e.g. `f32` vs `i32`, `f64` vs `i64`).
    * @throws When comparing fundamentally incompatible types: reference vs value type
-   * (e.g. `string` vs `i32`, unless one is null/zero), or `v128` vs non-vector type.
+   * (e.g. `string` vs `i32`, unless one side is null, or `v128` vs non-vector type).
    * @throws When comparing containers with incompatible element types (e.g. `Array<string>`
    * vs `Array<i32>`), or precision-loss numeric combinations (e.g. `Array<f32>` vs `Array<i32>`).
    *

package/assembly/utils.ts

@@ -1,7 +1,9 @@
 export function isNull<T>(value: T): bool {
   if (isReference<T>()) {
     if (isNullable<T>()) {
-      return value == null;
+      // Use changetype pointer checks instead of `== null` / `!= null` to avoid
+      // invoking user-defined @operator("==") overloads, which reject null arguments
+      return changetype<usize>(value) == 0;
     } else {
       return false;
     }
@@ -11,6 +13,7 @@ export function isNull<T>(value: T): bool {
     } else if (isVector<T>()) {
       return false;
     } else {
+      // handles bare nulls
       return nameof<T>(value) == 'usize' && value == 0;
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest-pool-assemblyscript",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "AssemblyScript testing with Vitest - Simple, fast, familiar, AS-native, with full coverage output",
   "author": "Matt Ritter <matthew.d.ritter@gmail.com>",
   "license": "MIT",