ts-data-forge 1.0.0

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

@@ -0,0 +1,232 @@
+import { expectType } from '../../expect-type.mjs';
+import {
+  asNonZeroSafeInt,
+  isNonZeroSafeInt,
+  NonZeroSafeInt,
+} from './non-zero-safe-int.mjs';
+
+describe('NonZeroSafeInt', () => {
+  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);
+    });
+
+    test('rejects values outside safe integer range', () => {
+      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);
+    });
+
+    test.each([
+      { name: 'Number.NaN', value: Number.NaN },
+      { name: 'Number.POSITIVE_INFINITY', value: Number.POSITIVE_INFINITY },
+      { name: 'Number.NEGATIVE_INFINITY', value: Number.NEGATIVE_INFINITY },
+      { name: '1.2', value: 1.2 },
+      { name: '-3.4', value: -3.4 },
+      { name: '0', value: 0 },
+    ] as const)(
+      `asNonZeroSafeInt($name) should throw a TypeError`,
+      ({ value }) => {
+        expect(() => asNonZeroSafeInt(value)).toThrow(
+          new TypeError(`Expected a non-zero safe integer, got: ${value}`),
+        );
+      },
+    );
+  });
+
+  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);
+    });
+
+    test('correctly identifies zero', () => {
+      expect(isNonZeroSafeInt(0)).toBe(false);
+      expect(isNonZeroSafeInt(-0)).toBe(false);
+    });
+
+    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);
+    });
+
+    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);
+    });
+  });
+
+  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));
+    });
+  });
+
+  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);
+    });
+
+    test('mul (with clamping to safe integer range)', () => {
+      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);
+    });
+
+    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);
+    });
+
+    test('pow (with clamping to safe integer range)', () => {
+      const result = NonZeroSafeInt.pow(
+        asNonZeroSafeInt(1000),
+        asNonZeroSafeInt(10),
+      );
+      expect(result).toBe(Number.MAX_SAFE_INTEGER); // clamped to max
+      expect(NonZeroSafeInt.pow(asNonZeroSafeInt(2), asNonZeroSafeInt(3))).toBe(
+        8,
+      );
+    });
+  });
+
+  describe('random', () => {
+    test('generates non-zero safe integers within specified range (positive range)', () => {
+      const min = 1;
+      const max = 20;
+
+      for (let i = 0; i < 10; i++) {
+        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);
+        expect(result).not.toBe(0);
+      }
+    });
+
+    test('generates non-zero safe integers within specified range (negative range)', () => {
+      const min = -20;
+      const max = -1;
+
+      for (let i = 0; i < 10; i++) {
+        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);
+        expect(result).not.toBe(0);
+      }
+    });
+
+    test('generates non-zero safe integers within range that spans zero', () => {
+      const min = -5;
+      const max = 5;
+
+      for (let i = 0; i < 10; i++) {
+        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);
+        expect(result).not.toBe(0);
+      }
+    });
+  });
+
+  describe('type assertions', () => {
+    test('type relationships', () => {
+      expectType<NonZeroSafeInt, number>('<=');
+
+      expectTypeOf(asNonZeroSafeInt(5)).toExtend<NonZeroSafeInt>();
+    });
+  });
+});

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

@@ -0,0 +1,189 @@
+import { expectType } from '../../expect-type.mjs';
+import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+
+type ElementType = NonZeroUint16;
+
+const typeNameInMessage = 'a non-zero integer in [1, 2^16)';
+
+const {
+  MIN_VALUE,
+  MAX_VALUE,
+  min: min_,
+  max: max_,
+  pow,
+  add,
+  sub,
+  mul,
+  div,
+  randomNonZero: random,
+  is,
+  castType,
+  clamp,
+} = TsVerifiedInternals.RefinedNumberUtils.operatorsForInteger<
+  ElementType,
+  1,
+  number
+>({
+  integerOrSafeInteger: 'SafeInteger',
+  nonZero: true,
+  MIN_VALUE: 1,
+  MAX_VALUE: 2 ** 16 - 1,
+  typeNameInMessage,
+} as const);
+
+/**
+ * Checks if a number is a NonZeroUint16 (16-bit non-zero unsigned integer in the range [1, 2^16)).
+ * @param value The value to check.
+ * @returns `true` if the value is a NonZeroUint16, `false` otherwise.
+ */
+export const isNonZeroUint16 = is;
+
+/**
+ * Casts a number to a NonZeroUint16 type.
+ * @param value The value to cast.
+ * @returns The value as a NonZeroUint16 type.
+ * @throws {TypeError} If the value is not a non-zero integer in [1, 2^16).
+ * @example
+ * ```typescript
+ * const x = asNonZeroUint16(1000); // NonZeroUint16
+ * const y = asNonZeroUint16(65535); // NonZeroUint16
+ * // asNonZeroUint16(0); // throws TypeError
+ * // asNonZeroUint16(-1); // throws TypeError
+ * // asNonZeroUint16(65536); // throws TypeError
+ * ```
+ */
+export const asNonZeroUint16 = castType;
+
+/**
+ * Namespace providing type-safe arithmetic operations for 16-bit non-zero unsigned integers.
+ *
+ * All operations automatically clamp results to the valid NonZeroUint16 range [1, 65535].
+ * This ensures that all arithmetic maintains the 16-bit non-zero unsigned integer constraint,
+ * with results below 1 clamped to MIN_VALUE and overflow results clamped to MAX_VALUE.
+ *
+ * @example
+ * ```typescript
+ * const a = asNonZeroUint16(60000);
+ * const b = asNonZeroUint16(10000);
+ *
+ * // Arithmetic operations with automatic clamping and non-zero constraint
+ * const sum = NonZeroUint16.add(a, b);       // NonZeroUint16 (65535 - clamped to MAX_VALUE)
+ * const diff = NonZeroUint16.sub(a, b);      // NonZeroUint16 (50000)
+ * const reverseDiff = NonZeroUint16.sub(b, a); // NonZeroUint16 (1 - clamped to MIN_VALUE)
+ * const product = NonZeroUint16.mul(a, b);   // NonZeroUint16 (65535 - clamped due to overflow)
+ *
+ * // Range operations (maintaining non-zero constraint)
+ * const clamped = NonZeroUint16.clamp(-100);     // NonZeroUint16 (1)
+ * const minimum = NonZeroUint16.min(a, b);       // NonZeroUint16 (10000)
+ * const maximum = NonZeroUint16.max(a, b);       // NonZeroUint16 (60000)
+ *
+ * // Utility operations
+ * const random = NonZeroUint16.random();         // NonZeroUint16 (random value in [1, 65535])
+ * const power = NonZeroUint16.pow(asNonZeroUint16(2), asNonZeroUint16(10)); // NonZeroUint16 (1024)
+ * ```
+ */
+export const NonZeroUint16 = {
+  /**
+   * Type guard to check if a value is a NonZeroUint16.
+   * @param value The value to check.
+   * @returns `true` if the value is a 16-bit non-zero unsigned integer, `false` otherwise.
+   */
+  is,
+
+  /**
+   * The minimum value for a 16-bit non-zero unsigned integer.
+   * @readonly
+   */
+  MIN_VALUE,
+
+  /**
+   * The maximum value for a 16-bit non-zero unsigned integer.
+   * @readonly
+   */
+  MAX_VALUE,
+
+  /**
+   * Returns the smaller of two NonZeroUint16 values.
+   * @param a The first NonZeroUint16.
+   * @param b The second NonZeroUint16.
+   * @returns The minimum value as a NonZeroUint16.
+   */
+  min: min_,
+
+  /**
+   * Returns the larger of two NonZeroUint16 values.
+   * @param a The first NonZeroUint16.
+   * @param b The second NonZeroUint16.
+   * @returns The maximum value as a NonZeroUint16.
+   */
+  max: max_,
+
+  /**
+   * Clamps a number to the NonZeroUint16 range.
+   * @param value The number to clamp.
+   * @returns The value clamped to [1, 65535] as a NonZeroUint16.
+   */
+  clamp,
+
+  /**
+   * Generates a random NonZeroUint16 value within the valid range.
+   * @returns A random NonZeroUint16 between 1 and 65535.
+   */
+  random,
+
+  /**
+   * Raises a NonZeroUint16 to the power of another NonZeroUint16.
+   * @param a The base NonZeroUint16.
+   * @param b The exponent NonZeroUint16.
+   * @returns `a ** b` clamped to [1, 65535] as a NonZeroUint16.
+   */
+  pow,
+
+  /**
+   * Adds two NonZeroUint16 values.
+   * @param a The first NonZeroUint16.
+   * @param b The second NonZeroUint16.
+   * @returns `a + b` clamped to [1, 65535] as a NonZeroUint16.
+   */
+  add,
+
+  /**
+   * Subtracts one NonZeroUint16 from another.
+   * @param a The minuend NonZeroUint16.
+   * @param b The subtrahend NonZeroUint16.
+   * @returns `a - b` clamped to [1, 65535] as a NonZeroUint16 (minimum 1).
+   */
+  sub,
+
+  /**
+   * Multiplies two NonZeroUint16 values.
+   * @param a The first NonZeroUint16.
+   * @param b The second NonZeroUint16.
+   * @returns `a * b` clamped to [1, 65535] as a NonZeroUint16.
+   */
+  mul,
+
+  /**
+   * Divides one NonZeroUint16 by another using floor division.
+   * @param a The dividend NonZeroUint16.
+   * @param b The divisor NonZeroUint16.
+   * @returns `⌊a / b⌋` clamped to [1, 65535] as a NonZeroUint16.
+   */
+  div,
+} as const;
+
+expectType<
+  keyof typeof NonZeroUint16,
+  keyof TsVerifiedInternals.RefinedNumberUtils.NumberClass<
+    ElementType,
+    'int' | 'positive' | 'range'
+  >
+>('=');
+
+expectType<
+  typeof NonZeroUint16,
+  TsVerifiedInternals.RefinedNumberUtils.NumberClass<
+    ElementType,
+    'int' | 'positive' | 'range'
+  >
+>('<=');

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

@@ -0,0 +1,199 @@
+import { expectType } from '../../expect-type.mjs';
+import {
+  asNonZeroUint16,
+  isNonZeroUint16,
+  NonZeroUint16,
+} from './non-zero-uint16.mjs';
+
+describe('NonZeroUint16', () => {
+  describe('asNonZeroUint16', () => {
+    test('accepts valid non-zero uint16 values', () => {
+      expect(() => asNonZeroUint16(1)).not.toThrow();
+      expect(() => asNonZeroUint16(1000)).not.toThrow();
+      expect(() => asNonZeroUint16(65535)).not.toThrow(); // 2^16 - 1
+      expect(() => asNonZeroUint16(32768)).not.toThrow(); // 2^15
+    });
+
+    test('rejects zero', () => {
+      expect(() => asNonZeroUint16(0)).toThrow(TypeError);
+    });
+
+    test('rejects values outside uint16 range', () => {
+      expect(() => asNonZeroUint16(65536)).toThrow(TypeError); // 2^16
+      expect(() => asNonZeroUint16(100000)).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(65535)).toBe(65535);
+    });
+
+    test.each([
+      { name: 'Number.NaN', value: Number.NaN },
+      { name: 'Number.POSITIVE_INFINITY', value: Number.POSITIVE_INFINITY },
+      { name: 'Number.NEGATIVE_INFINITY', value: Number.NEGATIVE_INFINITY },
+      { name: '1.2', value: 1.2 },
+      { name: '-3.4', value: -3.4 },
+      { name: '0', value: 0 },
+      { name: '-1', value: -1 },
+      { name: '65536', value: 65536 },
+    ] as const)(
+      `asNonZeroUint16($name) should throw a TypeError`,
+      ({ value }) => {
+        expect(() => asNonZeroUint16(value)).toThrow(
+          new TypeError(
+            `Expected a non-zero integer in [1, 2^16), got: ${value}`,
+          ),
+        );
+      },
+    );
+  });
+
+  describe('isNonZeroUint16', () => {
+    test('correctly identifies non-zero uint16 values', () => {
+      expect(isNonZeroUint16(1)).toBe(true);
+      expect(isNonZeroUint16(1000)).toBe(true);
+      expect(isNonZeroUint16(65535)).toBe(true);
+      expect(isNonZeroUint16(32768)).toBe(true);
+    });
+
+    test('correctly identifies zero', () => {
+      expect(isNonZeroUint16(0)).toBe(false);
+    });
+
+    test('correctly identifies values outside uint16 range', () => {
+      expect(isNonZeroUint16(65536)).toBe(false);
+      expect(isNonZeroUint16(100000)).toBe(false);
+    });
+
+    test('correctly identifies negative integers', () => {
+      expect(isNonZeroUint16(-1)).toBe(false);
+      expect(isNonZeroUint16(-42)).toBe(false);
+    });
+
+    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);
+    });
+  });
+
+  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));
+    });
+  });
+
+  describe('constants', () => {
+    test('MIN_VALUE and MAX_VALUE', () => {
+      expect(NonZeroUint16.MIN_VALUE).toBe(1);
+      expect(NonZeroUint16.MAX_VALUE).toBe(65535);
+    });
+  });
+
+  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);
+    });
+
+    test('add (with clamping to non-zero uint16 range)', () => {
+      const result = NonZeroUint16.add(
+        asNonZeroUint16(65000),
+        asNonZeroUint16(1000),
+      );
+      expect(result).toBe(65535); // 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
+    });
+
+    test('mul (with clamping to non-zero uint16 range)', () => {
+      const result = NonZeroUint16.mul(
+        asNonZeroUint16(1000),
+        asNonZeroUint16(100),
+      );
+      expect(result).toBe(65535); // clamped to max
+      expect(NonZeroUint16.mul(asNonZeroUint16(10), asNonZeroUint16(5))).toBe(
+        50,
+      );
+    });
+
+    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
+    });
+
+    test('pow (with clamping to non-zero uint16 range)', () => {
+      const result = NonZeroUint16.pow(
+        asNonZeroUint16(256),
+        asNonZeroUint16(3),
+      );
+      expect(result).toBe(65535); // clamped to max
+      expect(NonZeroUint16.pow(asNonZeroUint16(2), asNonZeroUint16(3))).toBe(8);
+    });
+  });
+
+  describe('random', () => {
+    test('generates non-zero uint16 values within specified range', () => {
+      const min = 1;
+      const max = 20;
+
+      for (let i = 0; i < 10; i++) {
+        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);
+        expect(result).not.toBe(0);
+      }
+    });
+
+    test('generates values within NonZeroUint16 range', () => {
+      for (let i = 0; i < 10; i++) {
+        const result = NonZeroUint16.random(1, 30);
+        expect(result).toBeGreaterThanOrEqual(1);
+        expect(result).toBeLessThanOrEqual(65535);
+      }
+    });
+  });
+
+  describe('type assertions', () => {
+    test('type relationships', () => {
+      expectType<NonZeroUint16, number>('<=');
+
+      expectTypeOf(asNonZeroUint16(100)).toExtend<NonZeroUint16>();
+    });
+  });
+});