ts-data-forge 5.0.1 → 5.1.1

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

@@ -10,15 +10,21 @@ describe('NonZeroSafeInt test', () => {
   describe(asNonZeroSafeInt, () => {
     test('accepts valid non-zero safe integers', () => {
       expect(() => asNonZeroSafeInt(1)).not.toThrow();
+
       expect(() => asNonZeroSafeInt(-1)).not.toThrow();
+
       expect(() => asNonZeroSafeInt(42)).not.toThrow();
+
       expect(() => asNonZeroSafeInt(-42)).not.toThrow();
+
       expect(() => asNonZeroSafeInt(Number.MAX_SAFE_INTEGER)).not.toThrow();
+
       expect(() => asNonZeroSafeInt(Number.MIN_SAFE_INTEGER)).not.toThrow();
     });
 
     test('rejects zero', () => {
       expect(() => asNonZeroSafeInt(0)).toThrow(TypeError);
+
       expect(() => asNonZeroSafeInt(-0)).toThrow(TypeError);
     });
 
@@ -26,28 +32,37 @@ describe('NonZeroSafeInt test', () => {
       expect(() => asNonZeroSafeInt(Number.MAX_SAFE_INTEGER + 1)).toThrow(
         TypeError,
       );
+
       expect(() => asNonZeroSafeInt(Number.MIN_SAFE_INTEGER - 1)).toThrow(
         TypeError,
       );
+
       expect(() => asNonZeroSafeInt(Number.MAX_VALUE)).toThrow(TypeError);
+
       expect(() => asNonZeroSafeInt(-Number.MAX_VALUE)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asNonZeroSafeInt(Number.NaN)).toThrow(TypeError);
+
       expect(() => asNonZeroSafeInt(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asNonZeroSafeInt(Number.NEGATIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asNonZeroSafeInt(1.2)).toThrow(TypeError);
+
       expect(() => asNonZeroSafeInt(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asNonZeroSafeInt(5)).toBe(5);
+
       expect(asNonZeroSafeInt(-10)).toBe(-10);
+
       expect(asNonZeroSafeInt(1)).toBe(1);
     });
 
@@ -70,39 +85,54 @@ describe('NonZeroSafeInt test', () => {
 
   describe(isNonZeroSafeInt, () => {
     test('correctly identifies non-zero safe integers', () => {
-      expect(isNonZeroSafeInt(1)).toBe(true);
-      expect(isNonZeroSafeInt(-1)).toBe(true);
-      expect(isNonZeroSafeInt(42)).toBe(true);
-      expect(isNonZeroSafeInt(-42)).toBe(true);
-      expect(isNonZeroSafeInt(Number.MAX_SAFE_INTEGER)).toBe(true);
-      expect(isNonZeroSafeInt(Number.MIN_SAFE_INTEGER)).toBe(true);
+      assert.isTrue(isNonZeroSafeInt(1));
+
+      assert.isTrue(isNonZeroSafeInt(-1));
+
+      assert.isTrue(isNonZeroSafeInt(42));
+
+      assert.isTrue(isNonZeroSafeInt(-42));
+
+      assert.isTrue(isNonZeroSafeInt(Number.MAX_SAFE_INTEGER));
+
+      assert.isTrue(isNonZeroSafeInt(Number.MIN_SAFE_INTEGER));
     });
 
     test('correctly identifies zero', () => {
-      expect(isNonZeroSafeInt(0)).toBe(false);
-      expect(isNonZeroSafeInt(-0)).toBe(false);
+      assert.isFalse(isNonZeroSafeInt(0));
+
+      assert.isFalse(isNonZeroSafeInt(-0));
     });
 
     test('correctly identifies values outside safe integer range', () => {
-      expect(isNonZeroSafeInt(Number.MAX_SAFE_INTEGER + 1)).toBe(false);
-      expect(isNonZeroSafeInt(Number.MIN_SAFE_INTEGER - 1)).toBe(false);
-      expect(isNonZeroSafeInt(Number.MAX_VALUE)).toBe(false);
-      expect(isNonZeroSafeInt(-Number.MAX_VALUE)).toBe(false);
+      assert.isFalse(isNonZeroSafeInt(Number.MAX_SAFE_INTEGER + 1));
+
+      assert.isFalse(isNonZeroSafeInt(Number.MIN_SAFE_INTEGER - 1));
+
+      assert.isFalse(isNonZeroSafeInt(Number.MAX_VALUE));
+
+      assert.isFalse(isNonZeroSafeInt(-Number.MAX_VALUE));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isNonZeroSafeInt(Number.NaN)).toBe(false);
-      expect(isNonZeroSafeInt(Number.POSITIVE_INFINITY)).toBe(false);
-      expect(isNonZeroSafeInt(Number.NEGATIVE_INFINITY)).toBe(false);
-      expect(isNonZeroSafeInt(1.2)).toBe(false);
-      expect(isNonZeroSafeInt(-3.4)).toBe(false);
+      assert.isFalse(isNonZeroSafeInt(Number.NaN));
+
+      assert.isFalse(isNonZeroSafeInt(Number.POSITIVE_INFINITY));
+
+      assert.isFalse(isNonZeroSafeInt(Number.NEGATIVE_INFINITY));
+
+      assert.isFalse(isNonZeroSafeInt(1.2));
+
+      assert.isFalse(isNonZeroSafeInt(-3.4));
     });
   });
 
   describe('NonZeroSafeInt.is', () => {
     test('same as isNonZeroSafeInt function', () => {
       expect(NonZeroSafeInt.is(5)).toBe(isNonZeroSafeInt(5));
+
       expect(NonZeroSafeInt.is(0)).toBe(isNonZeroSafeInt(0));
+
       expect(NonZeroSafeInt.is(-10)).toBe(isNonZeroSafeInt(-10));
     });
   });
@@ -110,41 +140,53 @@ describe('NonZeroSafeInt test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(NonZeroSafeInt.MIN_VALUE).toBe(Number.MIN_SAFE_INTEGER);
+
       expect(NonZeroSafeInt.MAX_VALUE).toBe(Number.MAX_SAFE_INTEGER);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asNonZeroSafeInt(5);
+
     const b = asNonZeroSafeInt(2);
+
     const c = asNonZeroSafeInt(-3);
 
     test('abs', () => {
       expect(NonZeroSafeInt.abs(a)).toBe(5);
+
       expect(NonZeroSafeInt.abs(c)).toBe(3);
+
       expect(NonZeroSafeInt.abs(asNonZeroSafeInt(-1))).toBe(1);
     });
 
     test('min and max', () => {
       expect(NonZeroSafeInt.min(a, b)).toBe(2);
+
       expect(NonZeroSafeInt.max(a, b)).toBe(5);
+
       expect(NonZeroSafeInt.min(a, c)).toBe(-3);
+
       expect(NonZeroSafeInt.max(a, c)).toBe(5);
     });
 
     test('add (with clamping to safe integer range)', () => {
       const largeValue = asNonZeroSafeInt(Number.MAX_SAFE_INTEGER - 1);
+
       const result = NonZeroSafeInt.add(largeValue, asNonZeroSafeInt(10));
 
       expect(result).toBe(Number.MAX_SAFE_INTEGER); // clamped to max
+
       expect(NonZeroSafeInt.add(a, b)).toBe(7);
     });
 
     test('sub (with clamping to safe integer range)', () => {
       const smallValue = asNonZeroSafeInt(Number.MIN_SAFE_INTEGER + 1);
+
       const result = NonZeroSafeInt.sub(smallValue, asNonZeroSafeInt(10));
 
       expect(result).toBe(Number.MIN_SAFE_INTEGER); // clamped to min
+
       expect(NonZeroSafeInt.sub(a, b)).toBe(3);
     });
 
@@ -152,9 +194,11 @@ describe('NonZeroSafeInt test', () => {
       const largeValue = asNonZeroSafeInt(
         Math.floor(Math.sqrt(Number.MAX_SAFE_INTEGER)),
       );
+
       const result = NonZeroSafeInt.mul(largeValue, largeValue);
 
       expect(result).toBeLessThanOrEqual(Number.MAX_SAFE_INTEGER);
+
       expect(
         NonZeroSafeInt.mul(asNonZeroSafeInt(10), asNonZeroSafeInt(5)),
       ).toBe(50);
@@ -162,9 +206,11 @@ describe('NonZeroSafeInt test', () => {
 
     test('div (floor division with clamping)', () => {
       expect(NonZeroSafeInt.div(a, b)).toBe(2);
+
       expect(NonZeroSafeInt.div(asNonZeroSafeInt(7), asNonZeroSafeInt(3))).toBe(
         2,
       );
+
       expect(
         NonZeroSafeInt.div(asNonZeroSafeInt(-7), asNonZeroSafeInt(3)),
       ).toBe(-3);
@@ -177,6 +223,7 @@ describe('NonZeroSafeInt test', () => {
       );
 
       expect(result).toBe(Number.MAX_SAFE_INTEGER); // clamped to max
+
       expect(NonZeroSafeInt.pow(asNonZeroSafeInt(2), asNonZeroSafeInt(3))).toBe(
         8,
       );
@@ -186,45 +233,60 @@ describe('NonZeroSafeInt test', () => {
   describe('random', () => {
     test('generates non-zero safe integers within specified range (positive range)', () => {
       const min = 1;
+
       const max = 20;
 
       for (const _ of range(10)) {
         const result = NonZeroSafeInt.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
-        expect(NonZeroSafeInt.is(result)).toBe(true);
-        expect(Number.isInteger(result)).toBe(true);
+
+        assert.isTrue(NonZeroSafeInt.is(result));
+
+        assert.isTrue(Number.isInteger(result));
+
         expect(result).not.toBe(0);
       }
     });
 
     test('generates non-zero safe integers within specified range (negative range)', () => {
       const min = -20;
+
       const max = -1;
 
       for (const _ of range(10)) {
         const result = NonZeroSafeInt.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
-        expect(NonZeroSafeInt.is(result)).toBe(true);
-        expect(Number.isInteger(result)).toBe(true);
+
+        assert.isTrue(NonZeroSafeInt.is(result));
+
+        assert.isTrue(Number.isInteger(result));
+
         expect(result).not.toBe(0);
       }
     });
 
     test('generates non-zero safe integers within range that spans zero', () => {
       const min = -5;
+
       const max = 5;
 
       for (const _ of range(10)) {
         const result = NonZeroSafeInt.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
-        expect(NonZeroSafeInt.is(result)).toBe(true);
-        expect(Number.isInteger(result)).toBe(true);
+
+        assert.isTrue(NonZeroSafeInt.is(result));
+
+        assert.isTrue(Number.isInteger(result));
+
         expect(result).not.toBe(0);
       }
     });

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

@@ -10,8 +10,11 @@ describe('NonZeroUint16 test', () => {
   describe(asNonZeroUint16, () => {
     test('accepts valid non-zero uint16 values', () => {
       expect(() => asNonZeroUint16(1)).not.toThrow();
+
       expect(() => asNonZeroUint16(1000)).not.toThrow();
+
       expect(() => asNonZeroUint16(65_535)).not.toThrow(); // 2^16 - 1
+
       expect(() => asNonZeroUint16(32_768)).not.toThrow(); // 2^15
     });
 
@@ -21,29 +24,37 @@ describe('NonZeroUint16 test', () => {
 
     test('rejects values outside uint16 range', () => {
       expect(() => asNonZeroUint16(65_536)).toThrow(TypeError); // 2^16
+
       expect(() => asNonZeroUint16(100_000)).toThrow(TypeError);
     });
 
     test('rejects negative integers', () => {
       expect(() => asNonZeroUint16(-1)).toThrow(TypeError);
+
       expect(() => asNonZeroUint16(-42)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asNonZeroUint16(Number.NaN)).toThrow(TypeError);
+
       expect(() => asNonZeroUint16(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asNonZeroUint16(Number.NEGATIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asNonZeroUint16(1.2)).toThrow(TypeError);
+
       expect(() => asNonZeroUint16(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asNonZeroUint16(5)).toBe(5);
+
       expect(asNonZeroUint16(1)).toBe(1);
+
       expect(asNonZeroUint16(65_535)).toBe(65_535);
     });
 
@@ -70,39 +81,50 @@ describe('NonZeroUint16 test', () => {
 
   describe(isNonZeroUint16, () => {
     test('correctly identifies non-zero uint16 values', () => {
-      expect(isNonZeroUint16(1)).toBe(true);
-      expect(isNonZeroUint16(1000)).toBe(true);
-      expect(isNonZeroUint16(65_535)).toBe(true);
-      expect(isNonZeroUint16(32_768)).toBe(true);
+      assert.isTrue(isNonZeroUint16(1));
+
+      assert.isTrue(isNonZeroUint16(1000));
+
+      assert.isTrue(isNonZeroUint16(65_535));
+
+      assert.isTrue(isNonZeroUint16(32_768));
     });
 
     test('correctly identifies zero', () => {
-      expect(isNonZeroUint16(0)).toBe(false);
+      assert.isFalse(isNonZeroUint16(0));
     });
 
     test('correctly identifies values outside uint16 range', () => {
-      expect(isNonZeroUint16(65_536)).toBe(false);
-      expect(isNonZeroUint16(100_000)).toBe(false);
+      assert.isFalse(isNonZeroUint16(65_536));
+
+      assert.isFalse(isNonZeroUint16(100_000));
     });
 
     test('correctly identifies negative integers', () => {
-      expect(isNonZeroUint16(-1)).toBe(false);
-      expect(isNonZeroUint16(-42)).toBe(false);
+      assert.isFalse(isNonZeroUint16(-1));
+
+      assert.isFalse(isNonZeroUint16(-42));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isNonZeroUint16(Number.NaN)).toBe(false);
-      expect(isNonZeroUint16(Number.POSITIVE_INFINITY)).toBe(false);
-      expect(isNonZeroUint16(Number.NEGATIVE_INFINITY)).toBe(false);
-      expect(isNonZeroUint16(1.2)).toBe(false);
-      expect(isNonZeroUint16(-3.4)).toBe(false);
+      assert.isFalse(isNonZeroUint16(Number.NaN));
+
+      assert.isFalse(isNonZeroUint16(Number.POSITIVE_INFINITY));
+
+      assert.isFalse(isNonZeroUint16(Number.NEGATIVE_INFINITY));
+
+      assert.isFalse(isNonZeroUint16(1.2));
+
+      assert.isFalse(isNonZeroUint16(-3.4));
     });
   });
 
   describe('NonZeroUint16.is', () => {
     test('same as isNonZeroUint16 function', () => {
       expect(NonZeroUint16.is(5)).toBe(isNonZeroUint16(5));
+
       expect(NonZeroUint16.is(0)).toBe(isNonZeroUint16(0));
+
       expect(NonZeroUint16.is(-1)).toBe(isNonZeroUint16(-1));
     });
   });
@@ -110,16 +132,19 @@ describe('NonZeroUint16 test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(NonZeroUint16.MIN_VALUE).toBe(1);
+
       expect(NonZeroUint16.MAX_VALUE).toBe(65_535);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asNonZeroUint16(100);
+
     const b = asNonZeroUint16(50);
 
     test('min and max', () => {
       expect(NonZeroUint16.min(a, b)).toBe(50);
+
       expect(NonZeroUint16.max(a, b)).toBe(100);
     });
 
@@ -130,11 +155,13 @@ describe('NonZeroUint16 test', () => {
       );
 
       expect(result).toBe(65_535); // clamped to max
+
       expect(NonZeroUint16.add(a, b)).toBe(150);
     });
 
     test('sub (never goes below 1)', () => {
       expect(NonZeroUint16.sub(a, b)).toBe(50);
+
       expect(NonZeroUint16.sub(b, a)).toBe(1); // clamped to 1
     });
 
@@ -145,6 +172,7 @@ describe('NonZeroUint16 test', () => {
       );
 
       expect(result).toBe(65_535); // clamped to max
+
       expect(NonZeroUint16.mul(asNonZeroUint16(10), asNonZeroUint16(5))).toBe(
         50,
       );
@@ -152,7 +180,9 @@ describe('NonZeroUint16 test', () => {
 
     test('div (floor division, never goes below 1)', () => {
       expect(NonZeroUint16.div(a, asNonZeroUint16(50))).toBe(2);
+
       expect(NonZeroUint16.div(asNonZeroUint16(7), asNonZeroUint16(3))).toBe(2);
+
       expect(NonZeroUint16.div(asNonZeroUint16(50), asNonZeroUint16(100))).toBe(
         1,
       ); // floor(50/100) = 0, clamped to 1
@@ -165,6 +195,7 @@ describe('NonZeroUint16 test', () => {
       );
 
       expect(result).toBe(65_535); // clamped to max
+
       expect(NonZeroUint16.pow(asNonZeroUint16(2), asNonZeroUint16(3))).toBe(8);
     });
   });
@@ -172,15 +203,20 @@ describe('NonZeroUint16 test', () => {
   describe('random', () => {
     test('generates non-zero uint16 values within specified range', () => {
       const min = 1;
+
       const max = 20;
 
       for (const _ of range(10)) {
         const result = NonZeroUint16.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
-        expect(NonZeroUint16.is(result)).toBe(true);
-        expect(Number.isInteger(result)).toBe(true);
+
+        assert.isTrue(NonZeroUint16.is(result));
+
+        assert.isTrue(Number.isInteger(result));
+
         expect(result).not.toBe(0);
       }
     });
@@ -190,6 +226,7 @@ describe('NonZeroUint16 test', () => {
         const result = NonZeroUint16.random(1, 30);
 
         expect(result).toBeGreaterThanOrEqual(1);
+
         expect(result).toBeLessThanOrEqual(65_535);
       }
     });

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

@@ -10,8 +10,11 @@ describe('NonZeroUint32 test', () => {
   describe(asNonZeroUint32, () => {
     test('accepts valid non-zero uint32 values', () => {
       expect(() => asNonZeroUint32(1)).not.toThrow();
+
       expect(() => asNonZeroUint32(1000)).not.toThrow();
+
       expect(() => asNonZeroUint32(4_294_967_295)).not.toThrow(); // 2^32 - 1
+
       expect(() => asNonZeroUint32(2_147_483_648)).not.toThrow(); // 2^31
     });
 
@@ -21,29 +24,37 @@ describe('NonZeroUint32 test', () => {
 
     test('rejects values outside uint32 range', () => {
       expect(() => asNonZeroUint32(4_294_967_296)).toThrow(TypeError); // 2^32
+
       expect(() => asNonZeroUint32(10_000_000_000)).toThrow(TypeError);
     });
 
     test('rejects negative integers', () => {
       expect(() => asNonZeroUint32(-1)).toThrow(TypeError);
+
       expect(() => asNonZeroUint32(-42)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asNonZeroUint32(Number.NaN)).toThrow(TypeError);
+
       expect(() => asNonZeroUint32(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asNonZeroUint32(Number.NEGATIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asNonZeroUint32(1.2)).toThrow(TypeError);
+
       expect(() => asNonZeroUint32(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asNonZeroUint32(5)).toBe(5);
+
       expect(asNonZeroUint32(1)).toBe(1);
+
       expect(asNonZeroUint32(4_294_967_295)).toBe(4_294_967_295);
     });
 
@@ -70,39 +81,50 @@ describe('NonZeroUint32 test', () => {
 
   describe(isNonZeroUint32, () => {
     test('correctly identifies non-zero uint32 values', () => {
-      expect(isNonZeroUint32(1)).toBe(true);
-      expect(isNonZeroUint32(1000)).toBe(true);
-      expect(isNonZeroUint32(4_294_967_295)).toBe(true);
-      expect(isNonZeroUint32(2_147_483_648)).toBe(true);
+      assert.isTrue(isNonZeroUint32(1));
+
+      assert.isTrue(isNonZeroUint32(1000));
+
+      assert.isTrue(isNonZeroUint32(4_294_967_295));
+
+      assert.isTrue(isNonZeroUint32(2_147_483_648));
     });
 
     test('correctly identifies zero', () => {
-      expect(isNonZeroUint32(0)).toBe(false);
+      assert.isFalse(isNonZeroUint32(0));
     });
 
     test('correctly identifies values outside uint32 range', () => {
-      expect(isNonZeroUint32(4_294_967_296)).toBe(false);
-      expect(isNonZeroUint32(10_000_000_000)).toBe(false);
+      assert.isFalse(isNonZeroUint32(4_294_967_296));
+
+      assert.isFalse(isNonZeroUint32(10_000_000_000));
     });
 
     test('correctly identifies negative integers', () => {
-      expect(isNonZeroUint32(-1)).toBe(false);
-      expect(isNonZeroUint32(-42)).toBe(false);
+      assert.isFalse(isNonZeroUint32(-1));
+
+      assert.isFalse(isNonZeroUint32(-42));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isNonZeroUint32(Number.NaN)).toBe(false);
-      expect(isNonZeroUint32(Number.POSITIVE_INFINITY)).toBe(false);
-      expect(isNonZeroUint32(Number.NEGATIVE_INFINITY)).toBe(false);
-      expect(isNonZeroUint32(1.2)).toBe(false);
-      expect(isNonZeroUint32(-3.4)).toBe(false);
+      assert.isFalse(isNonZeroUint32(Number.NaN));
+
+      assert.isFalse(isNonZeroUint32(Number.POSITIVE_INFINITY));
+
+      assert.isFalse(isNonZeroUint32(Number.NEGATIVE_INFINITY));
+
+      assert.isFalse(isNonZeroUint32(1.2));
+
+      assert.isFalse(isNonZeroUint32(-3.4));
     });
   });
 
   describe('NonZeroUint32.is', () => {
     test('same as isNonZeroUint32 function', () => {
       expect(NonZeroUint32.is(5)).toBe(isNonZeroUint32(5));
+
       expect(NonZeroUint32.is(0)).toBe(isNonZeroUint32(0));
+
       expect(NonZeroUint32.is(-1)).toBe(isNonZeroUint32(-1));
     });
   });
@@ -110,16 +132,19 @@ describe('NonZeroUint32 test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(NonZeroUint32.MIN_VALUE).toBe(1);
+
       expect(NonZeroUint32.MAX_VALUE).toBe(4_294_967_295);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asNonZeroUint32(1_000_000);
+
     const b = asNonZeroUint32(500_000);
 
     test('min and max', () => {
       expect(NonZeroUint32.min(a, b)).toBe(500_000);
+
       expect(NonZeroUint32.max(a, b)).toBe(1_000_000);
     });
 
@@ -130,11 +155,13 @@ describe('NonZeroUint32 test', () => {
       );
 
       expect(result).toBe(4_294_967_295); // clamped to max
+
       expect(NonZeroUint32.add(a, b)).toBe(1_500_000);
     });
 
     test('sub (never goes below 1)', () => {
       expect(NonZeroUint32.sub(a, b)).toBe(500_000);
+
       expect(NonZeroUint32.sub(b, a)).toBe(1); // clamped to 1
     });
 
@@ -145,6 +172,7 @@ describe('NonZeroUint32 test', () => {
       );
 
       expect(result).toBe(4_294_967_295); // clamped to max
+
       expect(NonZeroUint32.mul(asNonZeroUint32(1000), asNonZeroUint32(5))).toBe(
         5000,
       );
@@ -152,7 +180,9 @@ describe('NonZeroUint32 test', () => {
 
     test('div (floor division, never goes below 1)', () => {
       expect(NonZeroUint32.div(a, asNonZeroUint32(500_000))).toBe(2);
+
       expect(NonZeroUint32.div(asNonZeroUint32(7), asNonZeroUint32(3))).toBe(2);
+
       expect(
         NonZeroUint32.div(asNonZeroUint32(500_000), asNonZeroUint32(1_000_000)),
       ).toBe(1); // floor(500000/1000000) = 0, clamped to 1
@@ -165,6 +195,7 @@ describe('NonZeroUint32 test', () => {
       );
 
       expect(result).toBe(4_294_967_295); // clamped to max
+
       expect(NonZeroUint32.pow(asNonZeroUint32(2), asNonZeroUint32(3))).toBe(8);
     });
   });
@@ -172,15 +203,20 @@ describe('NonZeroUint32 test', () => {
   describe('random', () => {
     test('generates non-zero uint32 values within specified range', () => {
       const min = 1;
+
       const max = 20;
 
       for (const _ of range(10)) {
         const result = NonZeroUint32.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
-        expect(NonZeroUint32.is(result)).toBe(true);
-        expect(Number.isInteger(result)).toBe(true);
+
+        assert.isTrue(NonZeroUint32.is(result));
+
+        assert.isTrue(Number.isInteger(result));
+
         expect(result).not.toBe(0);
       }
     });
@@ -190,6 +226,7 @@ describe('NonZeroUint32 test', () => {
         const result = NonZeroUint32.random(1, 30);
 
         expect(result).toBeGreaterThanOrEqual(1);
+
         expect(result).toBeLessThanOrEqual(4_294_967_295);
       }
     });