ts-data-forge 5.0.1 → 5.1.1

package/src/number/branded-types/non-negative-int32.test.mts

@@ -11,37 +11,49 @@ describe('NonNegativeInt32 test', () => {
   describe(asNonNegativeInt32, () => {
     test('accepts valid non-negative int32 values', () => {
       expect(() => asNonNegativeInt32(0)).not.toThrow();
+
       expect(() => asNonNegativeInt32(1)).not.toThrow();
+
       expect(() => asNonNegativeInt32(1000)).not.toThrow();
+
       expect(() => asNonNegativeInt32(2_147_483_647)).not.toThrow(); // 2^31 - 1
     });
 
     test('rejects negative integers', () => {
       expect(() => asNonNegativeInt32(-1)).toThrow(TypeError);
+
       expect(() => asNonNegativeInt32(-42)).toThrow(TypeError);
+
       expect(() => asNonNegativeInt32(-2_147_483_648)).toThrow(TypeError);
     });
 
     test('rejects values outside int32 range', () => {
       expect(() => asNonNegativeInt32(2_147_483_648)).toThrow(TypeError); // 2^31
+
       expect(() => asNonNegativeInt32(4_294_967_296)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asNonNegativeInt32(Number.NaN)).toThrow(TypeError);
+
       expect(() => asNonNegativeInt32(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asNonNegativeInt32(Number.NEGATIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asNonNegativeInt32(1.2)).toThrow(TypeError);
+
       expect(() => asNonNegativeInt32(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asNonNegativeInt32(0)).toBe(0);
+
       expect(asNonNegativeInt32(5)).toBe(5);
+
       expect(asNonNegativeInt32(2_147_483_647)).toBe(2_147_483_647);
     });
 
@@ -67,36 +79,48 @@ describe('NonNegativeInt32 test', () => {
 
   describe(isNonNegativeInt32, () => {
     test('correctly identifies non-negative int32 values', () => {
-      expect(isNonNegativeInt32(0)).toBe(true);
-      expect(isNonNegativeInt32(1)).toBe(true);
-      expect(isNonNegativeInt32(1000)).toBe(true);
-      expect(isNonNegativeInt32(2_147_483_647)).toBe(true);
+      assert.isTrue(isNonNegativeInt32(0));
+
+      assert.isTrue(isNonNegativeInt32(1));
+
+      assert.isTrue(isNonNegativeInt32(1000));
+
+      assert.isTrue(isNonNegativeInt32(2_147_483_647));
     });
 
     test('correctly identifies negative integers', () => {
-      expect(isNonNegativeInt32(-1)).toBe(false);
-      expect(isNonNegativeInt32(-42)).toBe(false);
-      expect(isNonNegativeInt32(-2_147_483_648)).toBe(false);
+      assert.isFalse(isNonNegativeInt32(-1));
+
+      assert.isFalse(isNonNegativeInt32(-42));
+
+      assert.isFalse(isNonNegativeInt32(-2_147_483_648));
     });
 
     test('correctly identifies values outside int32 range', () => {
-      expect(isNonNegativeInt32(2_147_483_648)).toBe(false);
-      expect(isNonNegativeInt32(4_294_967_296)).toBe(false);
+      assert.isFalse(isNonNegativeInt32(2_147_483_648));
+
+      assert.isFalse(isNonNegativeInt32(4_294_967_296));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isNonNegativeInt32(Number.NaN)).toBe(false);
-      expect(isNonNegativeInt32(Number.POSITIVE_INFINITY)).toBe(false);
-      expect(isNonNegativeInt32(Number.NEGATIVE_INFINITY)).toBe(false);
-      expect(isNonNegativeInt32(1.2)).toBe(false);
-      expect(isNonNegativeInt32(-3.4)).toBe(false);
+      assert.isFalse(isNonNegativeInt32(Number.NaN));
+
+      assert.isFalse(isNonNegativeInt32(Number.POSITIVE_INFINITY));
+
+      assert.isFalse(isNonNegativeInt32(Number.NEGATIVE_INFINITY));
+
+      assert.isFalse(isNonNegativeInt32(1.2));
+
+      assert.isFalse(isNonNegativeInt32(-3.4));
     });
   });
 
   describe('NonNegativeInt32.is', () => {
     test('same as isNonNegativeInt32 function', () => {
       expect(NonNegativeInt32.is(5)).toBe(isNonNegativeInt32(5));
+
       expect(NonNegativeInt32.is(0)).toBe(isNonNegativeInt32(0));
+
       expect(NonNegativeInt32.is(-1)).toBe(isNonNegativeInt32(-1));
     });
   });
@@ -104,19 +128,25 @@ describe('NonNegativeInt32 test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(NonNegativeInt32.MIN_VALUE).toBe(0);
+
       expect(NonNegativeInt32.MAX_VALUE).toBe(2_147_483_647);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asNonNegativeInt32(1_000_000);
+
     const b = asNonNegativeInt32(500_000);
+
     const c = asNonNegativeInt32(0);
 
     test('min and max', () => {
       expect(NonNegativeInt32.min(a, b)).toBe(500_000);
+
       expect(NonNegativeInt32.max(a, b)).toBe(1_000_000);
+
       expect(NonNegativeInt32.min(a, c)).toBe(0);
+
       expect(NonNegativeInt32.max(a, c)).toBe(1_000_000);
     });
 
@@ -127,12 +157,15 @@ describe('NonNegativeInt32 test', () => {
       );
 
       expect(result).toBe(2_147_483_647); // clamped to max
+
       expect(NonNegativeInt32.add(a, b)).toBe(1_500_000);
     });
 
     test('sub (never goes below 0)', () => {
       expect(NonNegativeInt32.sub(a, b)).toBe(500_000);
+
       expect(NonNegativeInt32.sub(b, a)).toBe(0); // clamped to 0
+
       expect(NonNegativeInt32.sub(c, a)).toBe(0); // clamped to 0
     });
 
@@ -143,6 +176,7 @@ describe('NonNegativeInt32 test', () => {
       );
 
       expect(result).toBe(2_147_483_647); // clamped to max
+
       expect(
         NonNegativeInt32.mul(asNonNegativeInt32(1000), asNonNegativeInt32(5)),
       ).toBe(5000);
@@ -150,9 +184,11 @@ describe('NonNegativeInt32 test', () => {
 
     test('div (floor division, never goes below 0)', () => {
       expect(NonNegativeInt32.div(a, asPositiveInt32(500_000))).toBe(2);
+
       expect(
         NonNegativeInt32.div(asNonNegativeInt32(7), asPositiveInt32(3)),
       ).toBe(2);
+
       expect(
         NonNegativeInt32.div(
           asNonNegativeInt32(500_000),
@@ -168,6 +204,7 @@ describe('NonNegativeInt32 test', () => {
       );
 
       expect(result).toBe(2_147_483_647); // clamped to max
+
       expect(
         NonNegativeInt32.pow(asNonNegativeInt32(2), asNonNegativeInt32(3)),
       ).toBe(8);
@@ -177,15 +214,20 @@ describe('NonNegativeInt32 test', () => {
   describe('random', () => {
     test('generates non-negative int32 values within specified range', () => {
       const min = 0;
+
       const max = 20;
 
       for (const _ of range(10)) {
         const result = NonNegativeInt32.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
-        expect(NonNegativeInt32.is(result)).toBe(true);
-        expect(Number.isInteger(result)).toBe(true);
+
+        assert.isTrue(NonNegativeInt32.is(result));
+
+        assert.isTrue(Number.isInteger(result));
+
         expect(result).toBeGreaterThanOrEqual(0);
       }
     });
@@ -195,6 +237,7 @@ describe('NonNegativeInt32 test', () => {
         const result = NonNegativeInt32.random(0, 30);
 
         expect(result).toBeGreaterThanOrEqual(0);
+
         expect(result).toBeLessThanOrEqual(2_147_483_647);
       }
     });

package/src/number/branded-types/non-zero-finite-number.test.mts

@@ -10,25 +10,35 @@ describe('NonZeroFiniteNumber test', () => {
   describe(asNonZeroFiniteNumber, () => {
     test('accepts valid non-zero finite numbers', () => {
       expect(() => asNonZeroFiniteNumber(1)).not.toThrow();
+
       expect(() => asNonZeroFiniteNumber(-1)).not.toThrow();
+
       expect(() => asNonZeroFiniteNumber(3.14)).not.toThrow();
+
       expect(() => asNonZeroFiniteNumber(-2.5)).not.toThrow();
+
       expect(() => asNonZeroFiniteNumber(0.001)).not.toThrow();
+
       expect(() => asNonZeroFiniteNumber(-0.001)).not.toThrow();
+
       expect(() => asNonZeroFiniteNumber(Number.MAX_VALUE)).not.toThrow();
+
       expect(() => asNonZeroFiniteNumber(-Number.MAX_VALUE)).not.toThrow();
     });
 
     test('rejects zero', () => {
       expect(() => asNonZeroFiniteNumber(0)).toThrow(TypeError);
+
       expect(() => asNonZeroFiniteNumber(-0)).toThrow(TypeError);
     });
 
     test('rejects non-finite numbers', () => {
       expect(() => asNonZeroFiniteNumber(Number.NaN)).toThrow(TypeError);
+
       expect(() => asNonZeroFiniteNumber(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asNonZeroFiniteNumber(Number.NEGATIVE_INFINITY)).toThrow(
         TypeError,
       );
@@ -36,7 +46,9 @@ describe('NonZeroFiniteNumber test', () => {
 
     test('returns the same value for valid inputs', () => {
       expect(asNonZeroFiniteNumber(5.5)).toBe(5.5);
+
       expect(asNonZeroFiniteNumber(-10)).toBe(-10);
+
       expect(asNonZeroFiniteNumber(1)).toBe(1);
     });
 
@@ -57,78 +69,104 @@ describe('NonZeroFiniteNumber test', () => {
 
   describe(isNonZeroFiniteNumber, () => {
     test('correctly identifies non-zero finite numbers', () => {
-      expect(isNonZeroFiniteNumber(1)).toBe(true);
-      expect(isNonZeroFiniteNumber(-1)).toBe(true);
-      expect(isNonZeroFiniteNumber(3.14)).toBe(true);
-      expect(isNonZeroFiniteNumber(-2.5)).toBe(true);
-      expect(isNonZeroFiniteNumber(0.001)).toBe(true);
-      expect(isNonZeroFiniteNumber(-0.001)).toBe(true);
+      assert.isTrue(isNonZeroFiniteNumber(1));
+
+      assert.isTrue(isNonZeroFiniteNumber(-1));
+
+      assert.isTrue(isNonZeroFiniteNumber(3.14));
+
+      assert.isTrue(isNonZeroFiniteNumber(-2.5));
+
+      assert.isTrue(isNonZeroFiniteNumber(0.001));
+
+      assert.isTrue(isNonZeroFiniteNumber(-0.001));
     });
 
     test('correctly identifies zero', () => {
-      expect(isNonZeroFiniteNumber(0)).toBe(false);
-      expect(isNonZeroFiniteNumber(-0)).toBe(false);
+      assert.isFalse(isNonZeroFiniteNumber(0));
+
+      assert.isFalse(isNonZeroFiniteNumber(-0));
     });
 
     test('correctly identifies non-finite numbers', () => {
-      expect(isNonZeroFiniteNumber(Number.NaN)).toBe(false);
-      expect(isNonZeroFiniteNumber(Number.POSITIVE_INFINITY)).toBe(false);
-      expect(isNonZeroFiniteNumber(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(isNonZeroFiniteNumber(Number.NaN));
+
+      assert.isFalse(isNonZeroFiniteNumber(Number.POSITIVE_INFINITY));
+
+      assert.isFalse(isNonZeroFiniteNumber(Number.NEGATIVE_INFINITY));
     });
   });
 
   describe('NonZeroFiniteNumber.is', () => {
     test('same as isNonZeroFiniteNumber function', () => {
       expect(NonZeroFiniteNumber.is(5)).toBe(isNonZeroFiniteNumber(5));
+
       expect(NonZeroFiniteNumber.is(0)).toBe(isNonZeroFiniteNumber(0));
+
       expect(NonZeroFiniteNumber.is(-1)).toBe(isNonZeroFiniteNumber(-1));
     });
   });
 
   describe('mathematical operations', () => {
     const a = asNonZeroFiniteNumber(5.5);
+
     const b = asNonZeroFiniteNumber(2.5);
+
     const c = asNonZeroFiniteNumber(-3.5);
 
     test('abs', () => {
       expect(NonZeroFiniteNumber.abs(a)).toBe(5.5);
+
       expect(NonZeroFiniteNumber.abs(c)).toBe(3.5);
+
       expect(NonZeroFiniteNumber.abs(asNonZeroFiniteNumber(-1))).toBe(1);
     });
 
     test('min and max', () => {
       expect(NonZeroFiniteNumber.min(a, b)).toBe(2.5);
+
       expect(NonZeroFiniteNumber.max(a, b)).toBe(5.5);
+
       expect(NonZeroFiniteNumber.min(a, c)).toBe(-3.5);
+
       expect(NonZeroFiniteNumber.max(a, c)).toBe(5.5);
     });
 
     test('floor, ceil, round', () => {
       expect(NonZeroFiniteNumber.floor(a)).toBe(5);
+
       expect(NonZeroFiniteNumber.ceil(a)).toBe(6);
+
       expect(NonZeroFiniteNumber.round(a)).toBe(6);
+
       expect(NonZeroFiniteNumber.floor(c)).toBe(-4);
+
       expect(NonZeroFiniteNumber.ceil(c)).toBe(-3);
+
       expect(NonZeroFiniteNumber.round(c)).toBe(-3);
     });
 
     test('add', () => {
       expect(NonZeroFiniteNumber.add(a, b)).toBe(8);
+
       expect(NonZeroFiniteNumber.add(a, c)).toBe(2);
     });
 
     test('sub', () => {
       expect(NonZeroFiniteNumber.sub(a, b)).toBe(3);
+
       expect(NonZeroFiniteNumber.sub(a, c)).toBe(9);
     });
 
     test('mul', () => {
       expect(NonZeroFiniteNumber.mul(a, b)).toBe(13.75);
+
       expect(NonZeroFiniteNumber.mul(a, c)).toBe(-19.25);
     });
 
     test('div', () => {
       expect(NonZeroFiniteNumber.div(a, b)).toBe(2.2);
+
       expect(NonZeroFiniteNumber.div(a, asNonZeroFiniteNumber(2))).toBe(2.75);
     });
 
@@ -139,6 +177,7 @@ describe('NonZeroFiniteNumber test', () => {
           asNonZeroFiniteNumber(3),
         ),
       ).toBe(8);
+
       expect(
         NonZeroFiniteNumber.pow(
           asNonZeroFiniteNumber(3),
@@ -151,42 +190,54 @@ describe('NonZeroFiniteNumber test', () => {
   describe('random', () => {
     test('generates non-zero numbers within specified range (positive range)', () => {
       const min = asNonZeroFiniteNumber(1.5);
+
       const max = asNonZeroFiniteNumber(10.3);
 
       for (const _ of range(10)) {
         const result = NonZeroFiniteNumber.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
-        expect(NonZeroFiniteNumber.is(result)).toBe(true);
+
+        assert.isTrue(NonZeroFiniteNumber.is(result));
+
         expect(result).not.toBe(0);
       }
     });
 
     test('generates non-zero numbers within specified range (negative range)', () => {
       const min = asNonZeroFiniteNumber(-10.3);
+
       const max = asNonZeroFiniteNumber(-1.5);
 
       for (const _ of range(10)) {
         const result = NonZeroFiniteNumber.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
-        expect(NonZeroFiniteNumber.is(result)).toBe(true);
+
+        assert.isTrue(NonZeroFiniteNumber.is(result));
+
         expect(result).not.toBe(0);
       }
     });
 
     test('generates non-zero numbers within range that spans zero', () => {
       const min = asNonZeroFiniteNumber(-5.5);
+
       const max = asNonZeroFiniteNumber(5.5);
 
       for (const _ of range(10)) {
         const result = NonZeroFiniteNumber.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
-        expect(NonZeroFiniteNumber.is(result)).toBe(true);
+
+        assert.isTrue(NonZeroFiniteNumber.is(result));
+
         expect(result).not.toBe(0);
       }
     });

package/src/number/branded-types/non-zero-int.test.mts

@@ -6,29 +6,41 @@ describe('NonZeroInt test', () => {
   describe(asNonZeroInt, () => {
     test('accepts valid non-zero integers', () => {
       expect(() => asNonZeroInt(1)).not.toThrow();
+
       expect(() => asNonZeroInt(-1)).not.toThrow();
+
       expect(() => asNonZeroInt(42)).not.toThrow();
+
       expect(() => asNonZeroInt(-42)).not.toThrow();
+
       expect(() => asNonZeroInt(Number.MAX_SAFE_INTEGER)).not.toThrow();
+
       expect(() => asNonZeroInt(Number.MIN_SAFE_INTEGER)).not.toThrow();
     });
 
     test('rejects zero', () => {
       expect(() => asNonZeroInt(0)).toThrow(TypeError);
+
       expect(() => asNonZeroInt(-0)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asNonZeroInt(Number.NaN)).toThrow(TypeError);
+
       expect(() => asNonZeroInt(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asNonZeroInt(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asNonZeroInt(1.2)).toThrow(TypeError);
+
       expect(() => asNonZeroInt(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asNonZeroInt(5)).toBe(5);
+
       expect(asNonZeroInt(-10)).toBe(-10);
+
       expect(asNonZeroInt(1)).toBe(1);
     });
 
@@ -48,78 +60,104 @@ describe('NonZeroInt test', () => {
 
   describe(isNonZeroInt, () => {
     test('correctly identifies non-zero integers', () => {
-      expect(isNonZeroInt(1)).toBe(true);
-      expect(isNonZeroInt(-1)).toBe(true);
-      expect(isNonZeroInt(42)).toBe(true);
-      expect(isNonZeroInt(-42)).toBe(true);
-      expect(isNonZeroInt(Number.MAX_SAFE_INTEGER)).toBe(true);
-      expect(isNonZeroInt(Number.MIN_SAFE_INTEGER)).toBe(true);
+      assert.isTrue(isNonZeroInt(1));
+
+      assert.isTrue(isNonZeroInt(-1));
+
+      assert.isTrue(isNonZeroInt(42));
+
+      assert.isTrue(isNonZeroInt(-42));
+
+      assert.isTrue(isNonZeroInt(Number.MAX_SAFE_INTEGER));
+
+      assert.isTrue(isNonZeroInt(Number.MIN_SAFE_INTEGER));
     });
 
     test('correctly identifies zero', () => {
-      expect(isNonZeroInt(0)).toBe(false);
-      expect(isNonZeroInt(-0)).toBe(false);
+      assert.isFalse(isNonZeroInt(0));
+
+      assert.isFalse(isNonZeroInt(-0));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isNonZeroInt(Number.NaN)).toBe(false);
-      expect(isNonZeroInt(Number.POSITIVE_INFINITY)).toBe(false);
-      expect(isNonZeroInt(Number.NEGATIVE_INFINITY)).toBe(false);
-      expect(isNonZeroInt(1.2)).toBe(false);
-      expect(isNonZeroInt(-3.4)).toBe(false);
+      assert.isFalse(isNonZeroInt(Number.NaN));
+
+      assert.isFalse(isNonZeroInt(Number.POSITIVE_INFINITY));
+
+      assert.isFalse(isNonZeroInt(Number.NEGATIVE_INFINITY));
+
+      assert.isFalse(isNonZeroInt(1.2));
+
+      assert.isFalse(isNonZeroInt(-3.4));
     });
   });
 
   describe('NonZeroInt.is', () => {
     test('same as isNonZeroInt function', () => {
       expect(NonZeroInt.is(5)).toBe(isNonZeroInt(5));
+
       expect(NonZeroInt.is(0)).toBe(isNonZeroInt(0));
+
       expect(NonZeroInt.is(-10)).toBe(isNonZeroInt(-10));
     });
   });
 
   describe('mathematical operations', () => {
     const a = asNonZeroInt(5);
+
     const b = asNonZeroInt(2);
+
     const c = asNonZeroInt(-3);
 
     test('abs', () => {
       expect(NonZeroInt.abs(a)).toBe(5);
+
       expect(NonZeroInt.abs(c)).toBe(3);
+
       expect(NonZeroInt.abs(asNonZeroInt(-1))).toBe(1);
     });
 
     test('min and max', () => {
       expect(NonZeroInt.min(a, b)).toBe(2);
+
       expect(NonZeroInt.max(a, b)).toBe(5);
+
       expect(NonZeroInt.min(a, c)).toBe(-3);
+
       expect(NonZeroInt.max(a, c)).toBe(5);
     });
 
     test('add', () => {
       expect(NonZeroInt.add(a, b)).toBe(7);
+
       expect(NonZeroInt.add(a, c)).toBe(2);
     });
 
     test('sub', () => {
       expect(NonZeroInt.sub(a, b)).toBe(3);
+
       expect(NonZeroInt.sub(a, c)).toBe(8);
     });
 
     test('mul', () => {
       expect(NonZeroInt.mul(a, b)).toBe(10);
+
       expect(NonZeroInt.mul(a, c)).toBe(-15);
     });
 
     test('div (floor division)', () => {
       expect(NonZeroInt.div(a, b)).toBe(2);
+
       expect(NonZeroInt.div(asNonZeroInt(7), asNonZeroInt(3))).toBe(2);
+
       expect(NonZeroInt.div(asNonZeroInt(-7), asNonZeroInt(3))).toBe(-3);
     });
 
     test('pow', () => {
       expect(NonZeroInt.pow(asNonZeroInt(2), asNonZeroInt(3))).toBe(8);
+
       expect(NonZeroInt.pow(asNonZeroInt(3), asNonZeroInt(2))).toBe(9);
+
       expect(NonZeroInt.pow(asNonZeroInt(-2), asNonZeroInt(3))).toBe(-8);
     });
   });
@@ -127,45 +165,60 @@ describe('NonZeroInt test', () => {
   describe('random', () => {
     test('generates non-zero integers within specified range (positive range)', () => {
       const min = 1;
+
       const max = 10;
 
       for (const _ of range(10)) {
         const result = NonZeroInt.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
-        expect(NonZeroInt.is(result)).toBe(true);
-        expect(Number.isInteger(result)).toBe(true);
+
+        assert.isTrue(NonZeroInt.is(result));
+
+        assert.isTrue(Number.isInteger(result));
+
         expect(result).not.toBe(0);
       }
     });
 
     test('generates non-zero integers within specified range (negative range)', () => {
       const min = -10;
+
       const max = -1;
 
       for (const _ of range(10)) {
         const result = NonZeroInt.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
-        expect(NonZeroInt.is(result)).toBe(true);
-        expect(Number.isInteger(result)).toBe(true);
+
+        assert.isTrue(NonZeroInt.is(result));
+
+        assert.isTrue(Number.isInteger(result));
+
         expect(result).not.toBe(0);
       }
     });
 
     test('generates non-zero integers within range that spans zero', () => {
       const min = -5;
+
       const max = 5;
 
       for (const _ of range(10)) {
         const result = NonZeroInt.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
-        expect(NonZeroInt.is(result)).toBe(true);
-        expect(Number.isInteger(result)).toBe(true);
+
+        assert.isTrue(NonZeroInt.is(result));
+
+        assert.isTrue(Number.isInteger(result));
+
         expect(result).not.toBe(0);
       }
     });