ts-data-forge 4.0.0 → 5.0.0

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

@@ -3,8 +3,8 @@ import { range } from '../../iterator/index.mjs';
 import { asNonZeroUint32 } from './non-zero-uint32.mjs';
 import { asUint32, isUint32, Uint32 } from './uint32.mjs';
 
-describe('Uint32', () => {
-  describe('asUint32', () => {
+describe('Uint32 test', () => {
+  describe(asUint32, () => {
     test('accepts valid uint32 values', () => {
       expect(() => asUint32(0)).not.toThrow();
       expect(() => asUint32(1)).not.toThrow();
@@ -52,7 +52,7 @@ describe('Uint32', () => {
     });
   });
 
-  describe('isUint32', () => {
+  describe(isUint32, () => {
     test('correctly identifies uint32 values', () => {
       expect(isUint32(0)).toBe(true);
       expect(isUint32(1)).toBe(true);
@@ -108,6 +108,7 @@ describe('Uint32', () => {
 
     test('add (with clamping to uint32 range)', () => {
       const result = Uint32.add(asUint32(4_294_967_000), asUint32(1000));
+
       expect(result).toBe(4_294_967_295); // clamped to max
       expect(Uint32.add(a, b)).toBe(1_500_000);
     });
@@ -120,6 +121,7 @@ describe('Uint32', () => {
 
     test('mul (with clamping to uint32 range)', () => {
       const result = Uint32.mul(asUint32(100_000), asUint32(100_000));
+
       expect(result).toBe(4_294_967_295); // clamped to max
       expect(Uint32.mul(asUint32(1000), asUint32(5))).toBe(5000);
     });
@@ -132,6 +134,7 @@ describe('Uint32', () => {
 
     test('pow (with clamping to uint32 range)', () => {
       const result = Uint32.pow(asUint32(10_000), asUint32(3));
+
       expect(result).toBe(4_294_967_295); // clamped to max
       expect(Uint32.pow(asUint32(2), asUint32(3))).toBe(8);
     });
@@ -144,6 +147,7 @@ describe('Uint32', () => {
 
       for (const _ of range(10)) {
         const result = Uint32.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(Uint32.is(result)).toBe(true);
@@ -155,6 +159,7 @@ describe('Uint32', () => {
     test('generates values within Uint32 range', () => {
       for (const _ of range(10)) {
         const result = Uint32.random(0, 30);
+
         expect(result).toBeGreaterThanOrEqual(0);
         expect(result).toBeLessThanOrEqual(4_294_967_295);
       }

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

@@ -1,8 +1,8 @@
 import { expectType } from '../../expect-type.mjs';
 import { Int8, asInt8, isInt8 } from './int8.mjs';
 
-describe('Int8', () => {
-  describe('isInt8', () => {
+describe('Int8 test', () => {
+  describe(isInt8, () => {
     test.each([
       { value: -128, expected: true },
       { value: 0, expected: true },
@@ -18,7 +18,7 @@ describe('Int8', () => {
     });
   });
 
-  describe('asInt8', () => {
+  describe(asInt8, () => {
     test.each([
       { value: -128, expected: -128 },
       { value: 0, expected: 0 },
@@ -48,6 +48,7 @@ describe('Int8', () => {
   describe('Int8.MIN_VALUE', () => {
     test('should be -128', () => {
       expect(Int8.MIN_VALUE).toBe(-128);
+
       expectType<typeof Int8.MIN_VALUE, -128>('=');
     });
   });
@@ -55,6 +56,7 @@ describe('Int8', () => {
   describe('Int8.MAX_VALUE', () => {
     test('should be 127', () => {
       expect(Int8.MAX_VALUE).toBe(127);
+
       expectType<typeof Int8.MAX_VALUE, 127>('=');
     });
   });
@@ -96,7 +98,9 @@ describe('Int8', () => {
       'Int8.abs($value) should return $expected',
       ({ expected, value }) => {
         const result = Int8.abs(value);
+
         expect(result).toBe(expected);
+
         expectType<typeof result, typeof expected>('=');
       },
     );
@@ -172,6 +176,7 @@ describe('Int8', () => {
       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);

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

@@ -1,8 +1,8 @@
 import { expectType } from '../../expect-type.mjs';
 import { Uint8, asUint8, isUint8 } from './uint8.mjs';
 
-describe('Uint8', () => {
-  describe('isUint8', () => {
+describe('Uint8 test', () => {
+  describe(isUint8, () => {
     test.each([
       { value: 0, expected: true },
       { value: 128, expected: true },
@@ -18,7 +18,7 @@ describe('Uint8', () => {
     });
   });
 
-  describe('asUint8', () => {
+  describe(asUint8, () => {
     test.each([
       { value: 0, expected: 0 },
       { value: 128, expected: 128 },
@@ -48,6 +48,7 @@ describe('Uint8', () => {
   describe('Uint8.MIN_VALUE', () => {
     test('should be 0', () => {
       expect(Uint8.MIN_VALUE).toBe(0);
+
       expectType<typeof Uint8.MIN_VALUE, 0>('=');
     });
   });
@@ -55,6 +56,7 @@ describe('Uint8', () => {
   describe('Uint8.MAX_VALUE', () => {
     test('should be 255', () => {
       expect(Uint8.MAX_VALUE).toBe(255);
+
       expectType<typeof Uint8.MAX_VALUE, 255>('=');
     });
   });
@@ -156,6 +158,7 @@ describe('Uint8', () => {
       const min = 10;
       const max = 50;
       const result = Uint8.random(min, max);
+
       expect(result).toBeGreaterThanOrEqual(min);
       expect(result).toBeLessThanOrEqual(max);
       expect(Number.isInteger(result)).toBe(true);

package/src/number/num.test.mts

@@ -1,6 +1,6 @@
 import { expectType } from '../expect-type.mjs';
 import { pipe } from '../functional/index.mjs';
-import { asNonZeroFiniteNumber } from './index.mjs';
+import { asNonZeroFiniteNumber } from './branded-types/index.mjs';
 import { Num } from './num.mjs';
 
 const testClamp = (
@@ -13,7 +13,7 @@ const testClamp = (
   });
 };
 
-describe('Num', () => {
+describe('Num test', () => {
   describe('clamp', () => {
     testClamp([0, 2], 2.3, 2);
     testClamp([0, 2], -0.5, 0);
@@ -22,6 +22,7 @@ describe('Num', () => {
 
     test('should support regular usage with three parameters', () => {
       expectTypeOf(Num.clamp(15, 0, 10)).toEqualTypeOf<number>();
+
       expect(Num.clamp(15, 0, 10)).toBe(10);
       expect(Num.clamp(-5, 0, 10)).toBe(0);
       expect(Num.clamp(5, 0, 10)).toBe(5);
@@ -32,12 +33,15 @@ describe('Num', () => {
       const clampTo0_10 = Num.clamp(0, 10);
 
       const result1 = pipe(15).map(clampTo0_10).value;
+
       expect(result1).toBe(10);
 
       const result2 = pipe(-5).map(clampTo0_10).value;
+
       expect(result2).toBe(0);
 
       const result3 = pipe(7.5).map(clampTo0_10).value;
+
       expect(result3).toBe(7.5);
     });
 
@@ -58,6 +62,7 @@ describe('Num', () => {
       expect(Num.clamp(0, -10, -5)).toBe(-5);
 
       const clampNegative = Num.clamp(-10, -5);
+
       expect(clampNegative(-15)).toBe(-10);
       expect(clampNegative(-7)).toBe(-7);
       expect(clampNegative(0)).toBe(-5);
@@ -73,6 +78,7 @@ describe('Num', () => {
       } else {
         expectType<typeof x, number>('=');
       }
+
       expect(f(x)).toBe(true);
     });
 
@@ -84,6 +90,7 @@ describe('Num', () => {
       } else {
         expectType<typeof x, number>('=');
       }
+
       expect(f(x)).toBe(false);
     });
   });
@@ -106,6 +113,7 @@ describe('Num', () => {
   describe('isInRange', () => {
     test('checks range (lower inclusive, upper exclusive)', () => {
       const inRange = Num.isInRange(0, 10);
+
       expect(inRange(5)).toBe(true);
       expect(inRange(0)).toBe(true); // inclusive lower bound
       expect(inRange(10)).toBe(false); // exclusive upper bound
@@ -117,6 +125,7 @@ describe('Num', () => {
   describe('isInRangeInclusive', () => {
     test('checks range (inclusive)', () => {
       const inRange = Num.isInRangeInclusive(0, 10);
+
       expect(inRange(5)).toBe(true);
       expect(inRange(0)).toBe(true); // inclusive
       expect(inRange(10)).toBe(true); // inclusive
@@ -128,6 +137,7 @@ describe('Num', () => {
   describe('isUintInRange', () => {
     test('checks uint range (lower inclusive, upper exclusive)', () => {
       const inRange = Num.isUintInRange(0, 5);
+
       expect(inRange(2)).toBe(true);
       expect(inRange(0)).toBe(true); // inclusive lower bound
       expect(inRange(5)).toBe(false); // exclusive upper bound
@@ -141,6 +151,7 @@ describe('Num', () => {
       if (Num.isNonZero(x)) {
         expectType<typeof x, NonZeroNumber>('=');
       }
+
       expect(Num.isNonZero(5)).toBe(true);
       expect(Num.isNonZero(-3)).toBe(true);
       expect(Num.isNonZero(0)).toBe(false);
@@ -203,14 +214,17 @@ describe('Num', () => {
   describe('round', () => {
     test('creates rounding function with specified precision', () => {
       const round2 = Num.round(2);
+
       expect(round2(3.141_59)).toBe(3.14);
       expect(round2(2.556)).toBe(2.56);
 
       const round1 = Num.round(1);
+
       expect(round1(3.141_59)).toBe(3.1);
       expect(round1(2.56)).toBe(2.6);
 
       const round3 = Num.round(3);
+
       expect(round3(3.1416)).toBe(3.142);
       expect(round3(2.7182)).toBe(2.718);
     });

package/src/object/object.test.mts

@@ -30,7 +30,7 @@ describe('shallowEq', () => {
 
 describe('pick', () => {
   test('should pick specified keys', () => {
-    expect(Obj.pick({ a: 1, b: 2, c: 3 }, ['a', 'b'])).toStrictEqual({
+    assert.deepStrictEqual(Obj.pick({ a: 1, b: 2, c: 3 }, ['a', 'b']), {
       a: 1,
       b: 2,
     });
@@ -39,7 +39,8 @@ describe('pick', () => {
   test('pick should support curried form', () => {
     const pickAB = Obj.pick(['a', 'b']);
     const result = pickAB({ a: 1, b: 2, c: 3, d: 4 });
-    expect(result).toStrictEqual({ a: 1, b: 2 });
+
+    assert.deepStrictEqual(result, { a: 1, b: 2 });
   });
 
   test('pick should work with pipe when curried', () => {
@@ -47,13 +48,15 @@ describe('pick', () => {
     const user = { id: 1, name: 'Alice', email: 'alice@example.com', age: 30 };
 
     const result = pipe(user).map(pickIdAndName).value;
-    expect(result).toStrictEqual({ id: 1, name: 'Alice' });
+
+    assert.deepStrictEqual(result, { id: 1, name: 'Alice' });
   });
 
   test('pick should handle empty keys in curried form', () => {
     const pickNone = Obj.pick([]);
     const result = pickNone({ a: 1, b: 2 });
-    expect(result).toStrictEqual({});
+
+    assert.deepStrictEqual(result, {});
   });
 
   test('pick should work for records that only partially contain the key in curried form', () => {
@@ -67,19 +70,24 @@ describe('pick', () => {
     const result = pipe(user).map(pickVisible).value satisfies {
       name: string;
     };
-    expect(result).toStrictEqual({ name: 'Alice' });
+
+    assert.deepStrictEqual(result, { name: 'Alice' });
   });
 });
 
 describe('omit', () => {
   test('should omit specified keys', () => {
-    expect(Obj.omit({ a: 1, b: 2, c: 3 }, ['c'])).toStrictEqual({ a: 1, b: 2 });
+    assert.deepStrictEqual(Obj.omit({ a: 1, b: 2, c: 3 }, ['c']), {
+      a: 1,
+      b: 2,
+    });
   });
 
   test('omit should support curried form', () => {
     const omitC = Obj.omit(['c']);
     const result = omitC({ a: 1, b: 2, c: 3, d: 4 });
-    expect(result).toStrictEqual({ a: 1, b: 2, d: 4 });
+
+    assert.deepStrictEqual(result, { a: 1, b: 2, d: 4 });
   });
 
   test('omit should work with pipe when curried', () => {
@@ -92,20 +100,23 @@ describe('omit', () => {
     };
 
     const result = pipe(user).map(omitSensitive).value;
-    expect(result).toStrictEqual({ id: 1, name: 'Alice' });
+
+    assert.deepStrictEqual(result, { id: 1, name: 'Alice' });
   });
 
   test('omit should handle empty keys in curried form', () => {
     const omitNone = Obj.omit([]);
     const original = { a: 1, b: 2, c: 3 };
     const result = omitNone(original);
-    expect(result).toStrictEqual(original);
+
+    assert.deepStrictEqual(result, original);
   });
 
   test('should omit multiple keys in curried form', () => {
     const omitBAndD = Obj.omit(['b', 'd']);
     const result = omitBAndD({ a: 1, b: 2, c: 3, d: 4, e: 5 });
-    expect(result).toStrictEqual({ a: 1, c: 3, e: 5 });
+
+    assert.deepStrictEqual(result, { a: 1, c: 3, e: 5 });
   });
 
   test('omit should work for records that only partially contain the key in curried form', () => {
@@ -120,7 +131,8 @@ describe('omit', () => {
       id: number;
       name: string;
     };
-    expect(result).toStrictEqual({ id: 1, name: 'Alice' });
+
+    assert.deepStrictEqual(result, { id: 1, name: 'Alice' });
   });
 });
 
@@ -138,7 +150,8 @@ describe('fromEntries', () => {
       typeof result,
       Readonly<{ name: 'Alice'; age: 30; active: true }>
     >('=');
-    expect(result).toStrictEqual({ name: 'Alice', age: 30, active: true });
+
+    assert.deepStrictEqual(result, { name: 'Alice', age: 30, active: true });
   });
 
   test('should produce partial record when keys are unions', () => {
@@ -148,6 +161,6 @@ describe('fromEntries', () => {
       Readonly<Record<'name' | 'email', string>>
     >;
 
-    expect(result).toStrictEqual({ name: 'Alice' });
+    assert.deepStrictEqual(result, { name: 'Alice' });
   });
 });

package/src/others/cast-mutable.test.mts

@@ -1,7 +1,7 @@
 import { expectType } from '../expect-type.mjs';
 import { castDeepMutable, castMutable } from './cast-mutable.mjs';
 
-describe('castMutable', () => {
+describe(castMutable, () => {
   test('should allow mutating arrays that were readonly', () => {
     const readonlyArray: readonly number[] = [1, 2, 3];
     const mut_array = castMutable(readonlyArray);
@@ -9,8 +9,9 @@ describe('castMutable', () => {
     expectType<typeof mut_array, number[]>('=');
 
     mut_array.push(4);
-    expect(mut_array).toStrictEqual([1, 2, 3, 4]);
-    expect(readonlyArray).toStrictEqual([1, 2, 3, 4]);
+
+    assert.deepStrictEqual(mut_array, [1, 2, 3, 4]);
+    assert.deepStrictEqual(readonlyArray, [1, 2, 3, 4]);
   });
 
   test('should allow mutating objects that were readonly', () => {
@@ -25,12 +26,12 @@ describe('castMutable', () => {
     mut_user.age = 31;
     mut_user.name = 'Bob';
 
-    expect(mut_user).toStrictEqual({ name: 'Bob', age: 31 });
-    expect(readonlyUser).toStrictEqual({ name: 'Bob', age: 31 });
+    assert.deepStrictEqual(mut_user, { name: 'Bob', age: 31 });
+    assert.deepStrictEqual(readonlyUser, { name: 'Bob', age: 31 });
   });
 });
 
-describe('castDeepMutable', () => {
+describe(castDeepMutable, () => {
   test('should enable deep mutations on nested readonly structures', () => {
     type ReadonlyState = Readonly<{
       user: {
@@ -66,15 +67,16 @@ describe('castDeepMutable', () => {
     mut_state.user.profile.tags.push('editor');
     mut_state.user.profile.name = 'Bob';
 
-    expect(mut_state.user.profile).toStrictEqual({
+    assert.deepStrictEqual(mut_state.user.profile, {
       name: 'Bob',
       tags: ['admin', 'owner', 'editor'],
     });
-    expect(readonlyState.user.profile.tags).toStrictEqual([
+    assert.deepStrictEqual(readonlyState.user.profile.tags, [
       'admin',
       'owner',
       'editor',
     ]);
+
     expect(readonlyState.user.profile.name).toBe('Bob');
   });
 });

package/src/others/cast-readonly.test.mts

@@ -1,12 +1,13 @@
 import { castDeepReadonly, castReadonly } from './cast-readonly.mjs';
 
-describe('castReadonly', () => {
+describe(castReadonly, () => {
   test('should cast mutable array to readonly', () => {
     const mutableArr = [1, 2, 3];
     const readonlyArr = castReadonly(mutableArr);
 
     expect(readonlyArr).toBe(mutableArr); // Same reference
-    expect(readonlyArr).toStrictEqual([1, 2, 3]);
+
+    assert.deepStrictEqual(readonlyArr, [1, 2, 3]);
   });
 
   test('should cast mutable object to readonly', () => {
@@ -14,7 +15,8 @@ describe('castReadonly', () => {
     const readonlyObj = castReadonly(mutableObj);
 
     expect(readonlyObj).toBe(mutableObj); // Same reference
-    expect(readonlyObj).toStrictEqual({ x: 1, y: 2 });
+
+    assert.deepStrictEqual(readonlyObj, { x: 1, y: 2 });
   });
 
   test('should preserve the runtime value', () => {
@@ -38,7 +40,7 @@ describe('castReadonly', () => {
   });
 });
 
-describe('castDeepReadonly', () => {
+describe(castDeepReadonly, () => {
   test('should cast deeply nested structure to readonly', () => {
     const mutableNested = {
       a: { b: [1, 2, 3] },
@@ -47,7 +49,9 @@ describe('castDeepReadonly', () => {
     const readonlyNested = castDeepReadonly(mutableNested);
 
     expect(readonlyNested).toBe(mutableNested); // Same reference
-    expect(readonlyNested.a.b).toStrictEqual([1, 2, 3]);
+
+    assert.deepStrictEqual(readonlyNested.a.b, [1, 2, 3]);
+
     expect(readonlyNested.c.d.e).toBe('value');
   });
 

package/src/others/if-then.test.mts

@@ -1,6 +1,6 @@
 import { ifThen } from './if-then.mjs';
 
-describe('ifThen', () => {
+describe(ifThen, () => {
   test('should implement logical implication truth table', () => {
     // True antecedent, true consequent -> true
     expect(ifThen(true, true)).toBe(true);
@@ -34,6 +34,7 @@ describe('ifThen', () => {
     ): boolean =>
       // If admin, then must have permission
       ifThen(isAdmin, hasPermission);
+
     expect(checkPermission(true, true)).toBe(true); // admin with permission
     expect(checkPermission(true, false)).toBe(false); // admin without permission
     expect(checkPermission(false, true)).toBe(true); // non-admin with permission
@@ -47,6 +48,7 @@ describe('ifThen', () => {
     ): boolean =>
       // If premium, then all premium features must be enabled
       ifThen(isPremium, hasAllFeatures);
+
     expect(validateSubscription(true, true)).toBe(true); // premium with all features
     expect(validateSubscription(true, false)).toBe(false); // premium without all features
     expect(validateSubscription(false, true)).toBe(true); // non-premium with features
@@ -67,6 +69,7 @@ describe('ifThen', () => {
     const checkExpiredLogic = (isExpired: boolean, isValid: boolean): boolean =>
       // "If not expired then valid" is equivalent to "expired OR valid"
       ifThen(!isExpired, isValid);
+
     expect(checkExpiredLogic(false, true)).toBe(true); // not expired and valid
     expect(checkExpiredLogic(false, false)).toBe(false); // not expired but invalid
     expect(checkExpiredLogic(true, true)).toBe(true); // expired but valid (vacuous)

package/src/others/map-nullable.test.mts

@@ -2,29 +2,37 @@ import { expectType } from '../expect-type.mjs';
 import { pipe } from '../functional/index.mjs';
 import { mapNullable } from './map-nullable.mjs';
 
-describe('mapNullable', () => {
+describe(mapNullable, () => {
   describe('regular usage', () => {
     test('should apply function to non-null value', () => {
       const result = mapNullable('hello', (s) => s.toUpperCase());
+
       expect(result).toBe('HELLO');
+
       expectType<typeof result, string | undefined>('=');
     });
 
     test('should apply function to non-undefined value', () => {
       const result = mapNullable(42, (n) => n * 2);
+
       expect(result).toBe(84);
+
       expectType<typeof result, number | undefined>('=');
     });
 
     test('should return undefined for null input', () => {
       const result = mapNullable(null, (s: string) => s.toUpperCase());
+
       expect(result).toBeUndefined();
+
       expectType<typeof result, string | undefined>('=');
     });
 
     test('should return undefined for undefined input', () => {
       const result = mapNullable(undefined, (s: string) => s.toUpperCase());
+
       expect(result).toBeUndefined();
+
       expectType<typeof result, string | undefined>('=');
     });
 
@@ -34,18 +42,21 @@ describe('mapNullable', () => {
         user,
         (u) => `${u.name} is ${u.age} years old`,
       );
+
       expect(result).toBe('Alice is 30 years old');
     });
 
     test('should work with nullable object properties', () => {
       const user: { name?: string } = { name: 'Bob' };
       const result = mapNullable(user.name, (name) => name.toUpperCase());
+
       expect(result).toBe('BOB');
 
       const userWithoutName: { name?: string } = {};
       const resultEmpty = mapNullable(userWithoutName.name, (name) =>
         name.toUpperCase(),
       );
+
       expect(resultEmpty).toBeUndefined();
     });
   });
@@ -55,12 +66,15 @@ describe('mapNullable', () => {
       const toUpperCase = mapNullable((s: string) => s.toUpperCase());
 
       const result1 = toUpperCase('hello');
+
       expect(result1).toBe('HELLO');
 
       const result2 = toUpperCase(null);
+
       expect(result2).toBeUndefined();
 
       const result3 = toUpperCase(undefined);
+
       expect(result3).toBeUndefined();
     });
 
@@ -68,12 +82,15 @@ describe('mapNullable', () => {
       const double = mapNullable((n: number) => n * 2);
 
       const result1 = double(21);
+
       expect(result1).toBe(42);
 
       const result2 = double(null);
+
       expect(result2).toBeUndefined();
 
       const result3 = double(undefined);
+
       expect(result3).toBeUndefined();
     });
 
@@ -84,9 +101,11 @@ describe('mapNullable', () => {
 
       const user = { name: 'Charlie', age: 25 };
       const result1 = getName(user);
+
       expect(result1).toBe('Charlie');
 
       const result2 = getName(null);
+
       expect(result2).toBeUndefined();
     });
 
@@ -141,27 +160,32 @@ describe('mapNullable', () => {
 
     test('should work with zero values', () => {
       const result = mapNullable(0, (n) => n + 1);
+
       expect(result).toBe(1);
     });
 
     test('should work with empty string', () => {
       const result = mapNullable('', (s) => s.length);
+
       expect(result).toBe(0);
     });
 
     test('should work with false boolean', () => {
       const result = mapNullable(false, (b) => !b);
+
       expect(result).toBe(true);
     });
 
     test('should work with arrays', () => {
       const result = mapNullable([1, 2, 3], (arr) => arr.length);
+
       expect(result).toBe(3);
 
       const nullResult = mapNullable(
         null as number[] | null,
         (arr) => arr.length,
       );
+
       expect(nullResult).toBeUndefined();
     });
 
@@ -172,6 +196,7 @@ describe('mapNullable', () => {
       };
 
       const result = mapNullable(data, (d) => d.user.profile.name);
+
       expect(result).toBe('Alice');
     });
   });
@@ -206,10 +231,12 @@ describe('mapNullable', () => {
 
       const input1 = 'hello';
       const result1 = double(getLength(toUpperCase(input1)));
+
       expect(result1).toBe(10);
 
       const input2: string | null = null;
       const result2 = double(getLength(toUpperCase(input2)));
+
       expect(result2).toBeUndefined();
     });
   });