@fincity/kirun-js 1.1.1 → 1.1.4

package/__tests__/engine/function/system/math/MinimumTest.ts

@@ -0,0 +1,38 @@
+import { Minimum } from "../../../../../src/engine/function/system/math/Minimum";
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
+
+const min = new Minimum();
+
+test('Minimum Test 1', async () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository,
+        new KIRunSchemaRepository
+    ).setArguments(
+        new Map([['value', [3, 2, 3, 5, 3]]]),
+    )
+
+    expect((await min.execute(fep)).allResults()[0].getResult().get('value')).toBe(2);
+})
+
+test('Minimum Test 2', () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository,
+        new KIRunSchemaRepository
+    ).setArguments(
+        new Map([['value', ["3", 2, 3, 5, 3]]]),
+    )
+
+    expect(async () => (await min.execute(fep)).allResults()[0].getResult().get('value')).rejects.toThrowError("Value \"3\" is not of valid type(s)\n3 is not a Integer\n3 is not a Long\n3 is not a Float\n3 is not a Double");
+})
+
+test('Minimum Test 3', async () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository,
+        new KIRunSchemaRepository
+    ).setArguments(
+        new Map([['value', [-1, -2, -3, -5, -3]]]),
+    )
+
+    expect((await min.execute(fep)).allResults()[0].getResult().get('value')).toBe(-5);
+})

package/__tests__/engine/function/system/math/RandomFloatTest.ts

@@ -0,0 +1,83 @@
+import { RandomFloat } from "../../../../../src/engine/function/system/math/RandomFloat";
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
+
+const rand = new RandomFloat();
+
+test('rand Float 1', async () => {
+    let min = 1,
+        max = 10;
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository,
+        new KIRunSchemaRepository
+    ).setArguments(
+        new Map([
+            ['minValue', min],
+            ['maxValue', max],
+        ]),
+    );
+
+    let num: number = (await rand.execute(fep)).allResults()[0].getResult().get('value');
+
+    expect(num).toBeLessThanOrEqual(max);
+    expect(num).toBeGreaterThanOrEqual(min);
+})
+
+test('rand Float 2', async () => {
+    let min = 0.1,
+        max = 0.9;
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository,
+        new KIRunSchemaRepository
+    ).setArguments(
+        new Map([
+            ['minValue', min],
+            ['maxValue', max],
+        ]),
+    );
+
+    let num: number = (await rand.execute(fep)).allResults()[0].getResult().get('value');
+
+    expect(num).toBeLessThanOrEqual(max);
+    expect(num).toBeGreaterThanOrEqual(min);
+})
+
+test('rand Float 3', async () => {
+    let min = 1, max = 2147483647;
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository,
+        new KIRunSchemaRepository
+    ).setArguments(
+        new Map([
+            ['minValue', min],
+        ]),
+    );
+
+    let num: number = (await rand.execute(fep)).allResults()[0].getResult().get('value');
+
+    expect(num).toBeLessThanOrEqual(max);
+    expect(num).toBeGreaterThanOrEqual(min);
+})
+
+test('rand Float 4', async () => {
+    let min = 1.1,
+        max = 1.2;
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository,
+        new KIRunSchemaRepository
+    ).setArguments(
+        new Map([
+            ['minValue', min],
+            ['maxValue', max],
+        ]),
+    );
+
+    let num: number = (await rand.execute(fep)).allResults()[0].getResult().get('value');
+
+    expect(num).toBeLessThanOrEqual(max);
+    expect(num).toBeGreaterThanOrEqual(min);
+})

package/__tests__/engine/function/system/math/RandomIntTest.ts

@@ -1,44 +1,52 @@
 import { RandomInt } from '../../../../../src/engine/function/system/math/RandomInt';
 import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
 
 const rand = new RandomInt();
 
-test(' rand int 1', () => {
+test(' rand int 1', async () => {
     let min = 100,
         max = 1000123;
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters().setArguments(
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    ).setArguments(
         new Map([
             ['minValue', min],
             ['maxValue', max],
         ]),
     );
-    let num: number = rand.execute(fep).allResults()[0].getResult().get('value');
+    let num: number = (await rand.execute(fep)).allResults()[0].getResult().get('value');
 
     expect(num).toBeLessThanOrEqual(max);
     expect(num).toBeGreaterThanOrEqual(min);
 });
 
-test(' rand int 2', () => {
+test(' rand int 2', async () => {
     let min = 100;
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters().setArguments(
-        new Map([['minValue', min]]),
-    );
-    let num: number = rand.execute(fep).allResults()[0].getResult().get('value');
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    ).setArguments(new Map([['minValue', min]]));
+    let num: number = (await rand.execute(fep)).allResults()[0].getResult().get('value');
 
     expect(num).toBeLessThanOrEqual(2147483647);
     expect(num).toBeGreaterThanOrEqual(min);
 });
 
-test(' rand int 3', () => {
+test(' rand int 3', async () => {
     let min = 100,
         max = 101;
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters().setArguments(
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    ).setArguments(
         new Map([
             ['minValue', min],
             ['maxValue', max],
         ]),
     );
-    let num: number = rand.execute(fep).allResults()[0].getResult().get('value');
+    let num: number = (await rand.execute(fep)).allResults()[0].getResult().get('value');
 
     console.log(num);
     expect(num).toBeLessThanOrEqual(max);

package/__tests__/engine/function/system/string/ConcatenateTest.ts

@@ -1,3 +1,4 @@
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
 import { Concatenate } from '../../../../../src/engine/function/system/string/Concatenate';
 import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
 import { MapUtil } from '../../../../../src/engine/util/MapUtil';
@@ -5,7 +6,10 @@ import { MapUtil } from '../../../../../src/engine/util/MapUtil';
 const cat: Concatenate = new Concatenate();
 
 test('conatenate test1', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     let array: string[] = [];
     array.push('I ');
@@ -37,7 +41,10 @@ test('conatenate test2', async () => {
     list.push(' PLATform ');
     list.push('2');
 
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(MapUtil.of('value', list));
     expect((await cat.execute(fep)).allResults()[0].getResult().get('value')).toBe(

package/__tests__/engine/function/system/string/DeleteForGivenLengthTest.ts

@@ -1,3 +1,4 @@
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
 import { DeleteForGivenLength } from '../../../../../src/engine/function/system/string/DeleteForGivenLength';
 import { SchemaValidationException } from '../../../../../src/engine/json/schema/validator/exception/SchemaValidationException';
 import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
@@ -6,7 +7,10 @@ import { MapUtil } from '../../../../../src/engine/util/MapUtil';
 const deleteT: DeleteForGivenLength = new DeleteForGivenLength();
 
 test('DeleteForGivenLength test1', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(
         new Map<string, string | number>([
@@ -24,7 +28,10 @@ test('DeleteForGivenLength test1', async () => {
 });
 
 test('DeleteForGivenLength test2', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(
         new Map<string, string | number>([

package/__tests__/engine/function/system/string/InsertAtGivenPositionTest.ts

@@ -1,11 +1,15 @@
 import { InsertAtGivenPosition } from '../../../../../src/engine/function/system/string/InsertAtGivenPosition';
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
 
 import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
 
 const reve: InsertAtGivenPosition = new InsertAtGivenPosition();
 
 test('InsertATGivenPositions test1', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(
         new Map<string, string | number>([
@@ -21,7 +25,10 @@ test('InsertATGivenPositions test1', async () => {
 });
 
 test('InsertATGivenPositions test2', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(
         new Map<string, string | number>([
@@ -37,7 +44,10 @@ test('InsertATGivenPositions test2', async () => {
 });
 
 test('InsertATGivenPositions test3', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(
         new Map<string, string | number>([

package/__tests__/engine/function/system/string/PostPadTest.ts

@@ -1,11 +1,15 @@
 import { PostPad } from '../../../../../src/engine/function/system/string/PostPad';
 import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
 import { MapEntry, MapUtil } from '../../../../../src/engine/util/MapUtil';
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
 
 const reve: PostPad = new PostPad();
 
 test('postpad test1', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(
         new Map<string, string | number>([
@@ -21,7 +25,10 @@ test('postpad test1', async () => {
 });
 
 test('postpad test2', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(
         new Map<string, string | number>([
@@ -37,7 +44,10 @@ test('postpad test2', async () => {
 });
 
 test('postpad test3', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(
         new Map<string, string | number>([

package/__tests__/engine/function/system/string/PrePadTest.ts

@@ -1,11 +1,15 @@
 import { PrePad } from '../../../../../src/engine/function/system/string/PrePad';
 import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
 import { MapEntry, MapUtil } from '../../../../../src/engine/util/MapUtil';
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
 
 const prepad: PrePad = new PrePad();
 
 test('prepad test1', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(
         new Map<string, string | number>([
@@ -23,7 +27,10 @@ test('prepad test1', async () => {
 });
 
 test('prepad test2', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(
         new Map<string, string | number>([
@@ -39,7 +46,10 @@ test('prepad test2', async () => {
 });
 
 test('prepad test3', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(
         new Map<string, string | number>([

package/__tests__/engine/function/system/string/RegionMatchesTest.ts

@@ -2,10 +2,14 @@ import { RegionMatches } from '../../../../../src/engine/function/system/string/
 import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
 import { MapUtil } from '../../../../../src/engine/util/MapUtil';
 
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
 const region: RegionMatches = new RegionMatches();
 
 test('toString test1', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(
         MapUtil.of<string, string | number | boolean>(
@@ -33,7 +37,10 @@ test('toString test1', async () => {
 });
 
 test('toString test2', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
     fep.setArguments(
         MapUtil.of<string, string | number | boolean>(
             RegionMatches.PARAMETER_BOOLEAN_NAME,
@@ -60,7 +67,10 @@ test('toString test2', async () => {
 });
 
 test('toString test3', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
     fep.setArguments(
         MapUtil.of<string, string | number | boolean>(
             RegionMatches.PARAMETER_BOOLEAN_NAME,

package/__tests__/engine/function/system/string/ReverseTest.ts

@@ -2,11 +2,15 @@ import { Reverse } from '../../../../../src/engine/function/system/string/Revers
 import { SchemaValidationException } from '../../../../../src/engine/json/schema/validator/exception/SchemaValidationException';
 import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
 import { MapUtil } from '../../../../../src/engine/util/MapUtil';
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
 
 const reve: Reverse = new Reverse();
 
 test('reverse test1', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(MapUtil.of('value', ' mr"ofta"lp edoc on a si sihT'));
 
@@ -16,7 +20,10 @@ test('reverse test1', async () => {
 });
 
 test('reverse test2', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(MapUtil.of('value', ' '));
 
@@ -26,7 +33,7 @@ test('reverse test2', async () => {
 });
 
 // test('reverse test3', async () => {
-//     let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+//     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(new KIRunFunctionRepository(), new KIRunSchemaRepository());
 
 //     fep.setArguments(MapUtil.of('value', null));
 

package/__tests__/engine/function/system/string/SplitTest.ts

@@ -1,11 +1,15 @@
 import { Split } from '../../../../../src/engine/function/system/string/Split';
 import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
 import { MapUtil } from '../../../../../src/engine/util/MapUtil';
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
 
 const Spli: Split = new Split();
 
 test('split test1', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
     fep.setArguments(
         MapUtil.of(
             'string',
@@ -35,7 +39,10 @@ test('split test1', async () => {
 });
 
 test('split test2', async () => {
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
     fep.setArguments(
         MapUtil.of(
             'string',

package/__tests__/engine/function/system/string/StringFunctionRepoTest2.ts

@@ -1,3 +1,4 @@
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
 import { AbstractStringFunction } from '../../../../../src/engine/function/system/string/AbstractStringFunction';
 import { StringFunctionRepository } from '../../../../../src/engine/function/system/string/StringFunctionRepository';
 import { Namespaces } from '../../../../../src/engine/namespaces/Namespaces';
@@ -8,7 +9,10 @@ const stringRepo = new StringFunctionRepository();
 
 test('StringRepo - contains', async () => {
     let fun = stringRepo.find(Namespaces.STRING, 'Contains');
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     if (!fun) {
         throw new Error('Function not available');
@@ -84,7 +88,10 @@ test('string function repo 2', async () => {
         throw new Error('Function not available');
     }
 
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
     fep.setArguments(
         MapUtil.of(
             AbstractStringFunction.PARAMETER_STRING_NAME,
@@ -140,7 +147,10 @@ test('string function repo 3', async () => {
         throw new Error('Function not available');
     }
 
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(
         MapUtil.of(

package/__tests__/engine/function/system/string/StringFunctionRepoTest3.ts

@@ -3,12 +3,16 @@ import { StringFunctionRepository } from '../../../../../src/engine/function/sys
 import { Namespaces } from '../../../../../src/engine/namespaces/Namespaces';
 import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
 import { MapUtil } from '../../../../../src/engine/util/MapUtil';
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
 
 const stringRepo = new StringFunctionRepository();
 
 test('StringRepo3 - EqualsIgnoreCase', async () => {
     let fun = stringRepo.find(Namespaces.STRING, 'EqualsIgnoreCase');
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     if (!fun) {
         throw new Error('Function not available');
@@ -48,7 +52,10 @@ test('StringRepo3 - EqualsIgnoreCase', async () => {
 
 test('StringRepo3 - EqualsIgnoreCase', async () => {
     let fun = stringRepo.find(Namespaces.STRING, 'EqualsIgnoreCase');
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters().setArguments(
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    ).setArguments(
         new Map([
             [AbstractStringFunction.PARAMETER_STRING_NAME, '         no code  Kirun  PLATform   '],
             [

package/__tests__/engine/function/system/string/StringFunctionRepositoryTest.ts

@@ -3,6 +3,7 @@ import { StringFunctionRepository } from '../../../../../src/engine/function/sys
 import { Namespaces } from '../../../../../src/engine/namespaces/Namespaces';
 import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
 import { MapUtil } from '../../../../../src/engine/util/MapUtil';
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
 
 const repo = new StringFunctionRepository();
 
@@ -11,7 +12,10 @@ test('StringFunctionRepository - Trim', async () => {
     if (!fun) {
         throw new Error('Function not available');
     }
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
     fep.setArguments(MapUtil.of(AbstractStringFunction.PARAMETER_STRING_NAME, ' Kiran '));
     expect(
         (await fun.execute(fep))
@@ -26,7 +30,10 @@ test('StringFunctionRepo -Repeat', async () => {
     if (!fun) {
         throw new Error('Function not available');
     }
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(
         MapUtil.of<string, string | number>(
@@ -51,7 +58,10 @@ test('StringFunctionRepo -Lowercase', async () => {
         throw new Error('Function not available');
     }
 
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(
         MapUtil.of<string, string | number>(
@@ -73,7 +83,10 @@ test('StringFunctionRepo -UpperCase', async () => {
     if (!fun) {
         throw new Error('Function not available');
     }
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(
         MapUtil.of<string, string | number>(
@@ -95,7 +108,10 @@ test('StringFunctionRepo -Blank1', async () => {
     if (!fun) {
         throw new Error('Function not available');
     }
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(MapUtil.of<string, string>(AbstractStringFunction.PARAMETER_STRING_NAME, ''));
 
@@ -112,7 +128,10 @@ test('StringFunctionRepo -Blank2', async () => {
     if (!fun) {
         throw new Error('Function not available');
     }
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(
         MapUtil.of<string, string | number>(
@@ -134,7 +153,10 @@ test('StringFunctionRepo -Empty1', async () => {
     if (!fun) {
         throw new Error('Function not available');
     }
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(
         MapUtil.of<string, string | number>(AbstractStringFunction.PARAMETER_STRING_NAME, ''),
@@ -153,7 +175,10 @@ test('StringFunctionRepo -Empty2', async () => {
     if (!fun) {
         throw new Error('Function not available');
     }
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
     fep.setArguments(
         MapUtil.of<string, string | number>(AbstractStringFunction.PARAMETER_STRING_NAME, ' '),