ts-data-forge 1.0.0

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

@@ -0,0 +1,170 @@
+import { expectType } from '../../expect-type.mjs';
+import { asNonZeroUint32 } from './non-zero-uint32.mjs';
+import { asUint32, isUint32, Uint32 } from './uint32.mjs';
+
+describe('Uint32', () => {
+  describe('asUint32', () => {
+    test('accepts valid uint32 values', () => {
+      expect(() => asUint32(0)).not.toThrow();
+      expect(() => asUint32(1)).not.toThrow();
+      expect(() => asUint32(4294967295)).not.toThrow(); // 2^32 - 1
+      expect(() => asUint32(2147483648)).not.toThrow(); // 2^31
+    });
+
+    test('rejects values outside uint32 range', () => {
+      expect(() => asUint32(4294967296)).toThrow(TypeError); // 2^32
+      expect(() => asUint32(10000000000)).toThrow(TypeError);
+    });
+
+    test('rejects negative integers', () => {
+      expect(() => asUint32(-1)).toThrow(TypeError);
+      expect(() => asUint32(-42)).toThrow(TypeError);
+    });
+
+    test('rejects non-integers', () => {
+      expect(() => asUint32(Number.NaN)).toThrow(TypeError);
+      expect(() => asUint32(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asUint32(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asUint32(1.2)).toThrow(TypeError);
+      expect(() => asUint32(-3.4)).toThrow(TypeError);
+    });
+
+    test('returns the same value for valid inputs', () => {
+      expect(asUint32(5)).toBe(5);
+      expect(asUint32(0)).toBe(0);
+      expect(asUint32(4294967295)).toBe(4294967295);
+    });
+
+    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: '-1', value: -1 },
+    ] as const)(`asUint32($name) should throw a TypeError`, ({ value }) => {
+      expect(() => asUint32(value)).toThrow(
+        new TypeError(
+          `Expected a non-negative integer less than 2^32, got: ${value}`,
+        ),
+      );
+    });
+  });
+
+  describe('isUint32', () => {
+    test('correctly identifies uint32 values', () => {
+      expect(isUint32(0)).toBe(true);
+      expect(isUint32(1)).toBe(true);
+      expect(isUint32(4294967295)).toBe(true);
+      expect(isUint32(2147483648)).toBe(true);
+    });
+
+    test('correctly identifies values outside uint32 range', () => {
+      expect(isUint32(4294967296)).toBe(false);
+      expect(isUint32(10000000000)).toBe(false);
+    });
+
+    test('correctly identifies negative integers', () => {
+      expect(isUint32(-1)).toBe(false);
+      expect(isUint32(-42)).toBe(false);
+    });
+
+    test('correctly identifies non-integers', () => {
+      expect(isUint32(Number.NaN)).toBe(false);
+      expect(isUint32(Number.POSITIVE_INFINITY)).toBe(false);
+      expect(isUint32(Number.NEGATIVE_INFINITY)).toBe(false);
+      expect(isUint32(1.2)).toBe(false);
+      expect(isUint32(-3.4)).toBe(false);
+    });
+  });
+
+  describe('Uint32.is', () => {
+    test('same as isUint32 function', () => {
+      expect(Uint32.is(5)).toBe(isUint32(5));
+      expect(Uint32.is(4294967296)).toBe(isUint32(4294967296));
+      expect(Uint32.is(-1)).toBe(isUint32(-1));
+    });
+  });
+
+  describe('constants', () => {
+    test('MIN_VALUE and MAX_VALUE', () => {
+      expect(Uint32.MIN_VALUE).toBe(0);
+      expect(Uint32.MAX_VALUE).toBe(4294967295);
+    });
+  });
+
+  describe('mathematical operations', () => {
+    const a = asUint32(1000000);
+    const b = asUint32(500000);
+    const c = asUint32(0);
+
+    test('min and max', () => {
+      expect(Uint32.min(a, b)).toBe(500000);
+      expect(Uint32.max(a, b)).toBe(1000000);
+      expect(Uint32.min(a, c)).toBe(0);
+      expect(Uint32.max(a, c)).toBe(1000000);
+    });
+
+    test('add (with clamping to uint32 range)', () => {
+      const result = Uint32.add(asUint32(4294967000), asUint32(1000));
+      expect(result).toBe(4294967295); // clamped to max
+      expect(Uint32.add(a, b)).toBe(1500000);
+    });
+
+    test('sub (never goes below 0)', () => {
+      expect(Uint32.sub(a, b)).toBe(500000);
+      expect(Uint32.sub(b, a)).toBe(0); // clamped to 0
+      expect(Uint32.sub(c, a)).toBe(0); // clamped to 0
+    });
+
+    test('mul (with clamping to uint32 range)', () => {
+      const result = Uint32.mul(asUint32(100000), asUint32(100000));
+      expect(result).toBe(4294967295); // clamped to max
+      expect(Uint32.mul(asUint32(1000), asUint32(5))).toBe(5000);
+    });
+
+    test('div (floor division, never goes below 0)', () => {
+      expect(Uint32.div(a, asNonZeroUint32(500000))).toBe(2);
+      expect(Uint32.div(asUint32(7), asNonZeroUint32(3))).toBe(2);
+      expect(Uint32.div(asUint32(500000), asNonZeroUint32(1000000))).toBe(0); // floor(500000/1000000) = 0
+    });
+
+    test('pow (with clamping to uint32 range)', () => {
+      const result = Uint32.pow(asUint32(10000), asUint32(3));
+      expect(result).toBe(4294967295); // clamped to max
+      expect(Uint32.pow(asUint32(2), asUint32(3))).toBe(8);
+    });
+  });
+
+  describe('random', () => {
+    test('generates uint32 values within specified range', () => {
+      const min = 0;
+      const max = 20;
+
+      for (let i = 0; i < 10; i++) {
+        const result = Uint32.random(min, max);
+        expect(result).toBeGreaterThanOrEqual(min);
+        expect(result).toBeLessThanOrEqual(max);
+        expect(Uint32.is(result)).toBe(true);
+        expect(Number.isInteger(result)).toBe(true);
+        expect(result).toBeGreaterThanOrEqual(0);
+      }
+    });
+
+    test('generates values within Uint32 range', () => {
+      for (let i = 0; i < 10; i++) {
+        const result = Uint32.random(0, 30);
+        expect(result).toBeGreaterThanOrEqual(0);
+        expect(result).toBeLessThanOrEqual(4294967295);
+      }
+    });
+  });
+
+  describe('type assertions', () => {
+    test('type relationships', () => {
+      expectType<Uint32, number>('<=');
+
+      expectTypeOf(asUint32(1000000)).toExtend<Uint32>();
+    });
+  });
+});

package/src/number/enum/index.mts

@@ -0,0 +1,2 @@
+export * from './int8.mjs';
+export * from './uint8.mjs';

package/src/number/enum/int8.mts

@@ -0,0 +1,344 @@
+import { expectType } from '../../expect-type.mjs';
+import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+
+const typeNameInMessage = 'an integer in [-128, 127]';
+
+const {
+  MIN_VALUE,
+  MAX_VALUE,
+  random: randomImpl,
+  is: isImpl,
+  castType: castTypeImpl,
+  clamp: clampImpl,
+} = TsVerifiedInternals.RefinedNumberUtils.operatorsForInteger<
+  Int16,
+  -128,
+  127
+>({
+  integerOrSafeInteger: 'SafeInteger',
+  MIN_VALUE: -128,
+  MAX_VALUE: 127,
+  typeNameInMessage,
+} as const);
+
+/**
+ * Checks if a number is a valid Int8 (integer in [-128, 127]).
+ * @param x - The number to check
+ * @returns True if x is a valid Int8
+ */
+const is = (x: number): x is Int8 => isImpl(x);
+
+/**
+ * Converts a number to Int8, throwing an error if invalid.
+ * @param x - The number to convert
+ * @returns The number as Int8
+ * @throws TypeError if x is not a valid Int8
+ */
+const castType = (x: number): Int8 =>
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  castTypeImpl(x) as Int8;
+
+/**
+ * Clamps a number to the Int8 range [-128, 127].
+ * @param a - The number to clamp
+ * @returns The clamped value as Int8
+ */
+const clamp = (a: number): Int8 => castType(clampImpl(a));
+
+/**
+ * Returns the absolute value of an Int8.
+ * @param x - The Int8 value
+ * @returns The absolute value
+ */
+const abs = <N extends Int8>(x: N): AbsoluteValue<N> =>
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  Math.abs(x) as unknown as AbsoluteValue<N>;
+
+/**
+ * Returns the minimum of the given Int8 values.
+ * @param values - The Int8 values to compare
+ * @returns The minimum value
+ */
+const min_ = (...values: readonly Int8[]): Int8 =>
+  castType(Math.min(...values));
+
+/**
+ * Returns the maximum of the given Int8 values.
+ * @param values - The Int8 values to compare
+ * @returns The maximum value
+ */
+const max_ = (...values: readonly Int8[]): Int8 =>
+  castType(Math.max(...values));
+
+/**
+ * Raises x to the power of y, clamped to Int8 range.
+ * @param x - The base
+ * @param y - The exponent
+ * @returns x^y clamped to [-128, 127]
+ */
+const pow = (x: Int8, y: Int8): Int8 => clamp(x ** y);
+
+/**
+ * Adds two Int8 values, clamped to Int8 range.
+ * @param x - First operand
+ * @param y - Second operand
+ * @returns x + y clamped to [-128, 127]
+ */
+const add = (x: Int8, y: Int8): Int8 => clamp(x + y);
+
+/**
+ * Subtracts two Int8 values, clamped to Int8 range.
+ * @param x - First operand
+ * @param y - Second operand
+ * @returns x - y clamped to [-128, 127]
+ */
+const sub = (x: Int8, y: Int8): Int8 => clamp(x - y);
+
+/**
+ * Multiplies two Int8 values, clamped to Int8 range.
+ * @param x - First operand
+ * @param y - Second operand
+ * @returns x * y clamped to [-128, 127]
+ */
+const mul = (x: Int8, y: Int8): Int8 => clamp(x * y);
+
+/**
+ * Divides two Int8 values, clamped to Int8 range.
+ * @param x - The dividend
+ * @param y - The divisor (cannot be 0)
+ * @returns ⌊x / y⌋ clamped to [-128, 127]
+ */
+const div = (x: Int8, y: Exclude<Int8, 0>): Int8 => clamp(Math.floor(x / y));
+
+/**
+ * Generates a random Int8 value within the specified range.
+ * @param min - The minimum value (inclusive)
+ * @param max - The maximum value (inclusive)
+ * @returns A random Int8 between min and max
+ */
+const random = (min: Int8, max: Int8): Int8 =>
+  castType(randomImpl(castTypeImpl(min), castTypeImpl(max)));
+
+/**
+ * Type guard that checks if a value is an 8-bit signed integer.
+ *
+ * An Int8 is a signed integer in the range [-128, 127], representing
+ * values that fit in exactly 8 bits of memory.
+ *
+ * @param value - The value to check
+ * @returns `true` if the value is an Int8, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * isInt8(100);   // true
+ * isInt8(-50);   // true
+ * isInt8(127);   // true (max value)
+ * isInt8(-128);  // true (min value)
+ * isInt8(128);   // false (exceeds max)
+ * isInt8(-129);  // false (below min)
+ * isInt8(5.5);   // false (not integer)
+ * ```
+ */
+export const isInt8 = is;
+
+/**
+ * Casts a number to an Int8 branded type.
+ *
+ * This function validates that the input is within the Int8 range [-128, 127]
+ * and is an integer, then returns it with the Int8 brand.
+ *
+ * @param value - The value to cast
+ * @returns The value as an Int8 branded type
+ * @throws {TypeError} If the value is not a valid 8-bit signed integer
+ *
+ * @example
+ * ```typescript
+ * const byte = asInt8(100);     // Int8
+ * const max = asInt8(127);      // Int8 (maximum value)
+ * const min = asInt8(-128);     // Int8 (minimum value)
+ * const zero = asInt8(0);       // Int8
+ *
+ * // These throw TypeError:
+ * // asInt8(128);               // Exceeds maximum (127)
+ * // asInt8(-129);              // Below minimum (-128)
+ * // asInt8(1.5);               // Not an integer
+ * // asInt8(NaN);               // Not a number
+ * ```
+ */
+export const asInt8 = castType;
+
+/**
+ * Namespace providing type-safe operations for Int8 (8-bit signed integer) branded types.
+ *
+ * Int8 represents signed integers in the range [-128, 127], equivalent to a signed
+ * byte in many programming languages. All operations automatically clamp results
+ * to stay within this range, preventing overflow/underflow issues.
+ *
+ * This type is useful for:
+ * - Binary data processing (signed bytes)
+ * - Small integer values with known bounds
+ * - Embedded systems programming
+ * - Memory-efficient integer storage
+ * - Image processing (signed pixel offsets)
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const a = asInt8(100);
+ * const b = asInt8(50);
+ *
+ * // Arithmetic with automatic clamping
+ * const sum = Int8.add(a, b);        // Int8 (127) - clamped to maximum
+ * const diff = Int8.sub(a, b);       // Int8 (50)
+ * const product = Int8.mul(a, b);    // Int8 (127) - clamped due to overflow
+ * const quotient = Int8.div(a, b);   // Int8 (2)
+ *
+ * // Boundary handling
+ * const overflow = Int8.add(asInt8(127), asInt8(10));  // Int8 (127) - clamped
+ * const underflow = Int8.sub(asInt8(-128), asInt8(10)); // Int8 (-128) - clamped
+ *
+ * // Utility operations
+ * const clamped = Int8.clamp(200);          // Int8 (127)
+ * const absolute = Int8.abs(asInt8(-100));  // Int8 (100)
+ * const minimum = Int8.min(a, b);           // Int8 (50)
+ * const maximum = Int8.max(a, b);           // Int8 (100)
+ *
+ * // Random generation
+ * const die = Int8.random(asInt8(1), asInt8(6));        // Random 1-6
+ * const offset = Int8.random(asInt8(-10), asInt8(10));  // Random ±10
+ * ```
+ */
+export const Int8 = {
+  /**
+   * Type guard that checks if a value is an 8-bit signed integer.
+   *
+   * @param value - The value to check
+   * @returns `true` if the value is in range [-128, 127] and is an integer
+   *
+   * @see {@link isInt8} for usage examples
+   */
+  is,
+
+  /**
+   * The minimum value for an 8-bit signed integer.
+   * @readonly
+   */
+  MIN_VALUE,
+
+  /**
+   * The maximum value for an 8-bit signed integer.
+   * @readonly
+   */
+  MAX_VALUE,
+
+  /**
+   * Returns the minimum value from a list of Int8 values.
+   *
+   * @param values - The Int8 values to compare (at least one required)
+   * @returns The smallest value as an Int8
+   *
+   * @example
+   * ```typescript
+   * Int8.min(asInt8(50), asInt8(-30), asInt8(100)); // Int8 (-30)
+   * ```
+   */
+  min: min_,
+
+  /**
+   * Returns the maximum value from a list of Int8 values.
+   *
+   * @param values - The Int8 values to compare (at least one required)
+   * @returns The largest value as an Int8
+   *
+   * @example
+   * ```typescript
+   * Int8.max(asInt8(50), asInt8(-30), asInt8(100)); // Int8 (100)
+   * ```
+   */
+  max: max_,
+
+  /**
+   * Clamps a number to the Int8 range.
+   * @param value The number to clamp.
+   * @returns The value clamped to [-128, 127] as an Int8.
+   */
+  clamp,
+
+  /**
+   * Returns the absolute value of an Int8.
+   * @param value The Int8 value.
+   * @returns The absolute value as an Int8, clamped to valid range.
+   */
+  abs,
+
+  /**
+   * Generates a random Int8 value within the specified range (inclusive).
+   *
+   * Both bounds are inclusive. If min > max, they are automatically swapped.
+   *
+   * @param min - The minimum value (inclusive)
+   * @param max - The maximum value (inclusive)
+   * @returns A random Int8 in the range [min, max]
+   *
+   * @example
+   * ```typescript
+   * // Random signed byte
+   * const randomByte = Int8.random(Int8.MIN_VALUE, Int8.MAX_VALUE);
+   *
+   * // Random small range
+   * const dice = Int8.random(asInt8(1), asInt8(6));  // 1-6
+   *
+   * // Random offset
+   * const offset = Int8.random(asInt8(-10), asInt8(10)); // -10 to 10
+   * ```
+   */
+  random,
+
+  /**
+   * Raises an Int8 to the power of another Int8.
+   * @param a The base Int8.
+   * @param b The exponent Int8.
+   * @returns `a ** b` clamped to [-128, 127] as an Int8.
+   */
+  pow,
+
+  /**
+   * Adds two Int8 values.
+   * @param a The first Int8.
+   * @param b The second Int8.
+   * @returns `a + b` clamped to [-128, 127] as an Int8.
+   */
+  add,
+
+  /**
+   * Subtracts one Int8 from another.
+   * @param a The minuend Int8.
+   * @param b The subtrahend Int8.
+   * @returns `a - b` clamped to [-128, 127] as an Int8.
+   */
+  sub,
+
+  /**
+   * Multiplies two Int8 values.
+   * @param a The first Int8.
+   * @param b The second Int8.
+   * @returns `a * b` clamped to [-128, 127] as an Int8.
+   */
+  mul,
+
+  /**
+   * Divides one Int8 by another using floor division.
+   * @param a The dividend Int8.
+   * @param b The divisor Int8 (cannot be 0).
+   * @returns `⌊a / b⌋` clamped to [-128, 127] as an Int8.
+   */
+  div,
+} as const;
+
+expectType<
+  keyof typeof Int8,
+  keyof TsVerifiedInternals.RefinedNumberUtils.NumberClass<
+    Int16,
+    'int' | 'range'
+  >
+>('=');

package/src/number/enum/int8.test.mts

@@ -0,0 +1,180 @@
+import { expectType } from '../../expect-type.mjs';
+import { Int8, asInt8, isInt8 } from './int8.mjs';
+
+describe('Int8', () => {
+  describe('isInt8', () => {
+    test.each([
+      { value: -128, expected: true },
+      { value: 0, expected: true },
+      { value: 127, expected: true },
+      { value: -129, expected: false },
+      { value: 128, expected: false },
+      { value: 1.5, expected: false },
+      { value: Number.NaN, expected: false },
+      { value: Number.POSITIVE_INFINITY, expected: false },
+      { value: Number.NEGATIVE_INFINITY, expected: false },
+    ])('isInt8($value) should return $expected', ({ value, expected }) => {
+      expect(isInt8(value)).toBe(expected);
+    });
+  });
+
+  describe('asInt8', () => {
+    test.each([
+      { value: -128, expected: -128 },
+      { value: 0, expected: 0 },
+      { value: 127, expected: 127 },
+    ])('asInt8($value) should return $expected', ({ value, expected }) => {
+      expect(asInt8(value)).toBe(expected);
+    });
+
+    test.each([
+      { value: -129, name: '-129' },
+      { value: 128, name: '128' },
+      { value: 1.5, name: '1.5' },
+      { value: Number.NaN, name: 'NaN' },
+      { value: Number.POSITIVE_INFINITY, name: 'Infinity' },
+      { value: Number.NEGATIVE_INFINITY, name: '-Infinity' },
+    ])('asInt8($name) should throw TypeError', ({ value }) => {
+      expect(() => asInt8(value)).toThrow(TypeError);
+    });
+  });
+
+  describe('Int8.is', () => {
+    test('should be the same as isInt8', () => {
+      expect(Int8.is).toBe(isInt8);
+    });
+  });
+
+  describe('Int8.MIN_VALUE', () => {
+    test('should be -128', () => {
+      expect(Int8.MIN_VALUE).toBe(-128);
+      expectType<typeof Int8.MIN_VALUE, -128>('=');
+    });
+  });
+
+  describe('Int8.MAX_VALUE', () => {
+    test('should be 127', () => {
+      expect(Int8.MAX_VALUE).toBe(127);
+      expectType<typeof Int8.MAX_VALUE, 127>('=');
+    });
+  });
+
+  describe('Int8.clamp', () => {
+    test.each([
+      { value: -200, expected: -128 },
+      { value: -128, expected: -128 },
+      { value: 0, expected: 0 },
+      { value: 127, expected: 127 },
+      { value: 200, expected: 127 },
+      { value: 1.5, expected: 2 },
+    ])('Int8.clamp($value) should return $expected', ({ value, expected }) => {
+      expect(Int8.clamp(value)).toBe(expected);
+    });
+  });
+
+  describe('Int8.min', () => {
+    test('should return minimum value', () => {
+      expect(Int8.min(-100, -50, 10)).toBe(-100);
+      expect(Int8.min(1, 2, 3)).toBe(1);
+    });
+  });
+
+  describe('Int8.max', () => {
+    test('should return maximum value', () => {
+      expect(Int8.max(-100, -50, 10)).toBe(10);
+      expect(Int8.max(1, 2, 3)).toBe(3);
+    });
+  });
+
+  describe('Int8.abs', () => {
+    test.each([
+      { value: -100, expected: 100 },
+      { value: 0, expected: 0 },
+      { value: 50, expected: 50 },
+      { value: -128, expected: 128 },
+    ] as const)(
+      'Int8.abs($value) should return $expected',
+      ({ value, expected }) => {
+        const result = Int8.abs(value);
+        expect(result).toBe(expected);
+        expectType<typeof result, typeof expected>('=');
+      },
+    );
+  });
+
+  describe('Int8.add', () => {
+    test.each([
+      { x: 10, y: 20, expected: 30 },
+      { x: 100, y: 50, expected: 127 }, // clamped to max
+      { x: -100, y: -50, expected: -128 }, // clamped to min
+    ] as const)(
+      'Int8.add($x, $y) should return $expected',
+      ({ x, y, expected }) => {
+        expect(Int8.add(x, y)).toBe(expected);
+      },
+    );
+  });
+
+  describe('Int8.sub', () => {
+    test.each([
+      { x: 20, y: 10, expected: 10 },
+      { x: -100, y: 50, expected: -128 }, // clamped to min
+      { x: 100, y: -50, expected: 127 }, // clamped to max
+    ] as const)(
+      'Int8.sub($x, $y) should return $expected',
+      ({ x, y, expected }) => {
+        expect(Int8.sub(x, y)).toBe(expected);
+      },
+    );
+  });
+
+  describe('Int8.mul', () => {
+    test.each([
+      { x: 5, y: 10, expected: 50 },
+      { x: 20, y: 10, expected: 127 }, // clamped to max
+      { x: -20, y: 10, expected: -128 }, // clamped to min
+    ] as const)(
+      'Int8.mul($x, $y) should return $expected',
+      ({ x, y, expected }) => {
+        expect(Int8.mul(x, y)).toBe(expected);
+      },
+    );
+  });
+
+  describe('Int8.div', () => {
+    test.each([
+      { x: 100, y: 2, expected: 50 },
+      { x: 100, y: 3, expected: 33 }, // floor division
+      { x: -100, y: 3, expected: -34 },
+    ] as const)(
+      'Int8.div($x, $y) should return $expected',
+      ({ x, y, expected }) => {
+        expect(Int8.div(x, y)).toBe(expected);
+      },
+    );
+  });
+
+  describe('Int8.pow', () => {
+    test.each([
+      { x: 2, y: 3, expected: 8 },
+      { x: 10, y: 3, expected: 127 }, // clamped to max
+      { x: -10, y: 3, expected: -128 }, // clamped to min
+    ] as const)(
+      'Int8.pow($x, $y) should return $expected',
+      ({ x, y, expected }) => {
+        expect(Int8.pow(x, y)).toBe(expected);
+      },
+    );
+  });
+
+  describe('Int8.random', () => {
+    test('should generate value within range', () => {
+      const min = -10;
+      const max = 10;
+      const result = Int8.random(min, max);
+      expect(result).toBeGreaterThanOrEqual(min);
+      expect(result).toBeLessThanOrEqual(max);
+      expect(Number.isInteger(result)).toBe(true);
+    });
+  });
+});