ts-data-forge 5.0.1 → 5.1.1

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

@@ -10,20 +10,27 @@ describe('PositiveSafeInt test', () => {
   describe(asPositiveSafeInt, () => {
     test('accepts valid positive safe integers', () => {
       expect(() => asPositiveSafeInt(1)).not.toThrow();
+
       expect(() => asPositiveSafeInt(2)).not.toThrow();
+
       expect(() => asPositiveSafeInt(42)).not.toThrow();
+
       expect(() => asPositiveSafeInt(100)).not.toThrow();
+
       expect(() => asPositiveSafeInt(Number.MAX_SAFE_INTEGER)).not.toThrow();
     });
 
     test('rejects zero', () => {
       expect(() => asPositiveSafeInt(0)).toThrow(TypeError);
+
       expect(() => asPositiveSafeInt(-0)).toThrow(TypeError);
     });
 
     test('rejects negative integers', () => {
       expect(() => asPositiveSafeInt(-1)).toThrow(TypeError);
+
       expect(() => asPositiveSafeInt(-42)).toThrow(TypeError);
+
       expect(() => asPositiveSafeInt(Number.MIN_SAFE_INTEGER)).toThrow(
         TypeError,
       );
@@ -33,24 +40,31 @@ describe('PositiveSafeInt test', () => {
       expect(() => asPositiveSafeInt(Number.MAX_SAFE_INTEGER + 1)).toThrow(
         TypeError,
       );
+
       expect(() => asPositiveSafeInt(Number.MAX_VALUE)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asPositiveSafeInt(Number.NaN)).toThrow(TypeError);
+
       expect(() => asPositiveSafeInt(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asPositiveSafeInt(Number.NEGATIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asPositiveSafeInt(1.2)).toThrow(TypeError);
+
       expect(() => asPositiveSafeInt(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asPositiveSafeInt(5)).toBe(5);
+
       expect(asPositiveSafeInt(1)).toBe(1);
+
       expect(asPositiveSafeInt(10)).toBe(10);
     });
 
@@ -74,42 +88,56 @@ describe('PositiveSafeInt test', () => {
 
   describe(isPositiveSafeInt, () => {
     test('correctly identifies positive safe integers', () => {
-      expect(isPositiveSafeInt(1)).toBe(true);
-      expect(isPositiveSafeInt(2)).toBe(true);
-      expect(isPositiveSafeInt(42)).toBe(true);
-      expect(isPositiveSafeInt(100)).toBe(true);
-      expect(isPositiveSafeInt(Number.MAX_SAFE_INTEGER)).toBe(true);
+      assert.isTrue(isPositiveSafeInt(1));
+
+      assert.isTrue(isPositiveSafeInt(2));
+
+      assert.isTrue(isPositiveSafeInt(42));
+
+      assert.isTrue(isPositiveSafeInt(100));
+
+      assert.isTrue(isPositiveSafeInt(Number.MAX_SAFE_INTEGER));
     });
 
     test('correctly identifies zero', () => {
-      expect(isPositiveSafeInt(0)).toBe(false);
-      expect(isPositiveSafeInt(-0)).toBe(false);
+      assert.isFalse(isPositiveSafeInt(0));
+
+      assert.isFalse(isPositiveSafeInt(-0));
     });
 
     test('correctly identifies negative integers', () => {
-      expect(isPositiveSafeInt(-1)).toBe(false);
-      expect(isPositiveSafeInt(-42)).toBe(false);
-      expect(isPositiveSafeInt(Number.MIN_SAFE_INTEGER)).toBe(false);
+      assert.isFalse(isPositiveSafeInt(-1));
+
+      assert.isFalse(isPositiveSafeInt(-42));
+
+      assert.isFalse(isPositiveSafeInt(Number.MIN_SAFE_INTEGER));
     });
 
     test('correctly identifies values outside safe integer range', () => {
-      expect(isPositiveSafeInt(Number.MAX_SAFE_INTEGER + 1)).toBe(false);
-      expect(isPositiveSafeInt(Number.MAX_VALUE)).toBe(false);
+      assert.isFalse(isPositiveSafeInt(Number.MAX_SAFE_INTEGER + 1));
+
+      assert.isFalse(isPositiveSafeInt(Number.MAX_VALUE));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isPositiveSafeInt(Number.NaN)).toBe(false);
-      expect(isPositiveSafeInt(Number.POSITIVE_INFINITY)).toBe(false);
-      expect(isPositiveSafeInt(Number.NEGATIVE_INFINITY)).toBe(false);
-      expect(isPositiveSafeInt(1.2)).toBe(false);
-      expect(isPositiveSafeInt(-3.4)).toBe(false);
+      assert.isFalse(isPositiveSafeInt(Number.NaN));
+
+      assert.isFalse(isPositiveSafeInt(Number.POSITIVE_INFINITY));
+
+      assert.isFalse(isPositiveSafeInt(Number.NEGATIVE_INFINITY));
+
+      assert.isFalse(isPositiveSafeInt(1.2));
+
+      assert.isFalse(isPositiveSafeInt(-3.4));
     });
   });
 
   describe('PositiveSafeInt.is', () => {
     test('same as isPositiveSafeInt function', () => {
       expect(PositiveSafeInt.is(5)).toBe(isPositiveSafeInt(5));
+
       expect(PositiveSafeInt.is(0)).toBe(isPositiveSafeInt(0));
+
       expect(PositiveSafeInt.is(-10)).toBe(isPositiveSafeInt(-10));
     });
   });
@@ -117,33 +145,43 @@ describe('PositiveSafeInt test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(PositiveSafeInt.MIN_VALUE).toBe(1);
+
       expect(PositiveSafeInt.MAX_VALUE).toBe(Number.MAX_SAFE_INTEGER);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asPositiveSafeInt(5);
+
     const b = asPositiveSafeInt(2);
+
     const c = asPositiveSafeInt(1);
 
     test('min and max', () => {
       expect(PositiveSafeInt.min(a, b)).toBe(2);
+
       expect(PositiveSafeInt.max(a, b)).toBe(5);
+
       expect(PositiveSafeInt.min(a, c)).toBe(1);
+
       expect(PositiveSafeInt.max(a, c)).toBe(5);
     });
 
     test('add (clamped to positive safe int range)', () => {
       const largeValue = asPositiveSafeInt(Number.MAX_SAFE_INTEGER - 1);
+
       const result = PositiveSafeInt.add(largeValue, asPositiveSafeInt(10));
 
       expect(result).toBe(Number.MAX_SAFE_INTEGER); // clamped to max
+
       expect(PositiveSafeInt.add(a, b)).toBe(7);
     });
 
     test('sub (never goes below 1)', () => {
       expect(PositiveSafeInt.sub(a, b)).toBe(3);
+
       expect(PositiveSafeInt.sub(b, a)).toBe(1); // clamped to 1
+
       expect(PositiveSafeInt.sub(c, a)).toBe(1); // clamped to 1
     });
 
@@ -151,9 +189,11 @@ describe('PositiveSafeInt test', () => {
       const largeValue = asPositiveSafeInt(
         Math.floor(Math.sqrt(Number.MAX_SAFE_INTEGER)),
       );
+
       const result = PositiveSafeInt.mul(largeValue, largeValue);
 
       expect(result).toBeLessThanOrEqual(Number.MAX_SAFE_INTEGER);
+
       expect(
         PositiveSafeInt.mul(asPositiveSafeInt(10), asPositiveSafeInt(5)),
       ).toBe(50);
@@ -161,9 +201,11 @@ describe('PositiveSafeInt test', () => {
 
     test('div (floor division, never goes below 1)', () => {
       expect(PositiveSafeInt.div(a, b)).toBe(2);
+
       expect(
         PositiveSafeInt.div(asPositiveSafeInt(7), asPositiveSafeInt(3)),
       ).toBe(2);
+
       expect(PositiveSafeInt.div(b, a)).toBe(1); // floor(2/5) = 0, but clamped to 1
     });
 
@@ -174,6 +216,7 @@ describe('PositiveSafeInt test', () => {
       );
 
       expect(result).toBe(Number.MAX_SAFE_INTEGER); // clamped to max
+
       expect(
         PositiveSafeInt.pow(asPositiveSafeInt(2), asPositiveSafeInt(3)),
       ).toBe(8);
@@ -183,15 +226,20 @@ describe('PositiveSafeInt test', () => {
   describe('random', () => {
     test('generates positive safe integers within specified range', () => {
       const min = 1;
+
       const max = 20;
 
       for (const _ of range(10)) {
         const result = PositiveSafeInt.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
-        expect(PositiveSafeInt.is(result)).toBe(true);
-        expect(Number.isInteger(result)).toBe(true);
+
+        assert.isTrue(PositiveSafeInt.is(result));
+
+        assert.isTrue(Number.isInteger(result));
+
         expect(result).toBeGreaterThan(0);
       }
     });
@@ -201,6 +249,7 @@ describe('PositiveSafeInt test', () => {
         const result = PositiveSafeInt.random(1, 30);
 
         expect(result).toBeGreaterThanOrEqual(1);
+
         expect(result).toBeLessThanOrEqual(Number.MAX_SAFE_INTEGER);
       }
     });

package/src/number/branded-types/positive-uint16.test.mts

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

package/src/number/branded-types/positive-uint32.test.mts

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