@fincity/kirun-js 1.0.0

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

@@ -0,0 +1,46 @@
+import { Concatenate } from '../../../../../src/engine/function/system/string/Concatenate';
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../../../src/engine/util/MapUtil';
+
+const cat: Concatenate = new Concatenate();
+
+test('conatenate test1', () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+    let array: string[] = [];
+    array.push('I ');
+    array.push('am ');
+    array.push('using ');
+    array.push('eclipse ');
+    array.push('to ');
+    array.push('test ');
+    array.push('the ');
+    array.push('changes ');
+    array.push('with ');
+    array.push('test ');
+    array.push('Driven ');
+    array.push('developement');
+
+    fep.setArguments(MapUtil.of('value', array));
+
+    expect(cat.execute(fep).allResults()[0].getResult().get('value')).toBe(
+        'I am using eclipse to test the changes with test Driven developement',
+    );
+});
+
+test('conatenate test2', () => {
+    let list: string[] = [];
+    list.push('no code ');
+    list.push(' Kirun ');
+    list.push(' true ');
+    list.push('"\'this is between the strings qith special characters\'"');
+    list.push(' PLATform ');
+    list.push('2');
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+    fep.setArguments(MapUtil.of('value', list));
+    expect(cat.execute(fep).allResults()[0].getResult().get('value')).toBe(
+        'no code  Kirun  true "\'this is between the strings qith special characters\'" PLATform 2',
+    );
+});

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

@@ -0,0 +1,38 @@
+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';
+import { MapUtil } from '../../../../../src/engine/util/MapUtil';
+
+const deleteT: DeleteForGivenLength = new DeleteForGivenLength();
+
+test('DeleteForGivenLength test1', () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+    fep.setArguments(
+        new Map<string, string | number>([
+            [DeleteForGivenLength.PARAMETER_STRING_NAME, ' THIScompatY IS A NOcoDE plATFNORM'],
+            [DeleteForGivenLength.PARAMETER_AT_START_NAME, 10],
+            [DeleteForGivenLength.PARAMETER_AT_END_NAME, 18],
+        ]),
+    );
+
+    let outputString: string = ' THIScompaNOcoDE plATFNORM';
+
+    expect(deleteT.execute(fep).allResults()[0].getResult().get('result')).toBe(outputString);
+});
+
+test('DeleteForGivenLength test2', () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+    fep.setArguments(
+        new Map<string, string | number>([
+            [DeleteForGivenLength.PARAMETER_STRING_NAME, ' THIScompatY IS A NOcoDE plATFNORM'],
+            [DeleteForGivenLength.PARAMETER_AT_START_NAME, 4],
+            [DeleteForGivenLength.PARAMETER_AT_END_NAME, 10],
+        ]),
+    );
+
+    let outputString: string = ' THItY IS A NOcoDE plATFNORM';
+
+    expect(deleteT.execute(fep).allResults()[0].getResult().get('result')).toBe(outputString);
+});

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

@@ -0,0 +1,53 @@
+import { InsertAtGivenPosition } from '../../../../../src/engine/function/system/string/InsertATGivenPosition';
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+import { MapEntry, MapUtil } from '../../../../../src/engine/util/MapUtil';
+
+const reve: InsertAtGivenPosition = new InsertAtGivenPosition();
+
+test('InsertATGivenPositions test1', () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+    fep.setArguments(
+        new Map<string, string | number>([
+            [InsertAtGivenPosition.PARAMETER_STRING_NAME, ' THIScompatY IS A NOcoDE plATFNORM'],
+            [InsertAtGivenPosition.PARAMETER_AT_POSITION_NAME, 6],
+            [InsertAtGivenPosition.PARAMETER_INSERT_STRING_NAME, 'surendhar'],
+        ]),
+    );
+
+    let padded: string = ' THIScsurendharompatY IS A NOcoDE plATFNORM';
+
+    expect(reve.execute(fep).allResults()[0].getResult().get('result')).toBe(padded);
+});
+
+test('InsertATGivenPositions test2', () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+    fep.setArguments(
+        new Map<string, string | number>([
+            [InsertAtGivenPosition.PARAMETER_STRING_NAME, ' THIScompatY IS A NOcoDE plATFNORM'],
+            [InsertAtGivenPosition.PARAMETER_AT_POSITION_NAME, 6],
+            [InsertAtGivenPosition.PARAMETER_INSERT_STRING_NAME, 'surendhar'],
+        ]),
+    );
+
+    let padded: string = ' THIScsurendharompatY IS A NOcoDE plATFNORM';
+
+    expect(reve.execute(fep).allResults()[0].getResult().get('result')).toBe(padded);
+});
+
+test('InsertATGivenPositions test3', () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+    fep.setArguments(
+        new Map<string, string | number>([
+            [InsertAtGivenPosition.PARAMETER_STRING_NAME, ' THIScompatY IS A NOcoDE plATFNORM'],
+            [InsertAtGivenPosition.PARAMETER_AT_POSITION_NAME, 29],
+            [InsertAtGivenPosition.PARAMETER_INSERT_STRING_NAME, 'surendhar'],
+        ]),
+    );
+
+    let padded: string = ' THIScompatY IS A NOcoDE plATsurendharFNORM';
+
+    expect(reve.execute(fep).allResults()[0].getResult().get('result')).toBe(padded);
+});

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

@@ -0,0 +1,54 @@
+import { PostPad } from '../../../../../src/engine/function/system/string/PostPad';
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+import { MapEntry, MapUtil } from '../../../../../src/engine/util/MapUtil';
+
+const reve: PostPad = new PostPad();
+
+test('postpad test1', () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+    fep.setArguments(
+        new Map<string, string | number>([
+            ['string', ' THIScompatY IS A NOcoDE plATFNORM'],
+            ['postpadString', 'hiran'],
+            ['length', 12],
+        ]),
+    );
+
+    let padded: string = ' THIScompatY IS A NOcoDE plATFNORMhiranhiranhi';
+
+    expect(reve.execute(fep).allResults()[0].getResult().get('result')).toBe(padded);
+});
+
+test('postpad test2', () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+    fep.setArguments(
+        new Map<string, string | number>([
+            ['string', ' THIScompatY IS A NOcoDE plATFNORM'],
+            ['postpadString', ' h '],
+            ['length', 15],
+        ]),
+    );
+
+    let reveresed: string = ' THIScompatY IS A NOcoDE plATFNORM h  h  h  h  h ';
+
+    expect(reve.execute(fep).allResults()[0].getResult().get('result')).toBe(reveresed);
+});
+
+test('postpad test3', () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+    fep.setArguments(
+        new Map<string, string | number>([
+            ['string', ' THIScompatY IS A NOcoDE plATFNORM'],
+            ['postpadString', ' surendhar '],
+            ['length', 100],
+        ]),
+    );
+
+    let reveresed: string =
+        ' THIScompatY IS A NOcoDE plATFNORM surendhar  surendhar  surendhar  surendhar  surendhar  surendhar  surendhar  surendhar  surendhar  ';
+
+    expect(reve.execute(fep).allResults()[0].getResult().get('result')).toBe(reveresed);
+});

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

@@ -0,0 +1,54 @@
+import { PrePad } from '../../../../../src/engine/function/system/string/PrePad';
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+import { MapEntry, MapUtil } from '../../../../../src/engine/util/MapUtil';
+
+const prepad: PrePad = new PrePad();
+
+test('prepad test1', () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+    fep.setArguments(
+        new Map<string, string | number>([
+            [PrePad.PARAMETER_STRING_NAME, ' THIScompatY IS A NOcoDE plATFNORM'],
+            [PrePad.PARAMETER_PREPAD_STRING_NAME, 'hiran'],
+            [PrePad.PARAMETER_LENGTH_NAME, 12],
+        ]),
+    );
+
+    let padded: string = 'hiranhiranhi THIScompatY IS A NOcoDE plATFNORM';
+
+    expect(prepad.execute(fep).allResults()[0].getResult().get(PrePad.EVENT_RESULT_NAME)).toBe(
+        padded,
+    );
+});
+
+test('prepad test2', () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+    fep.setArguments(
+        new Map<string, string | number>([
+            [PrePad.PARAMETER_STRING_NAME, ' THIScompatY IS A NOcoDE plATFNORM'],
+            [PrePad.PARAMETER_PREPAD_STRING_NAME, ' h '],
+            [PrePad.PARAMETER_LENGTH_NAME, 11],
+        ]),
+    );
+
+    let padded: string = ' h  h  h  h THIScompatY IS A NOcoDE plATFNORM';
+
+    expect(prepad.execute(fep).allResults()[0].getResult().get('result')).toBe(padded);
+});
+
+test('prepad test3', () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+    fep.setArguments(
+        new Map<string, string | number>([
+            [PrePad.PARAMETER_STRING_NAME, ' THIScompatY IS A NOcoDE plATFNORM'],
+            [PrePad.PARAMETER_PREPAD_STRING_NAME, 'hiran'],
+            [PrePad.PARAMETER_LENGTH_NAME, 4],
+        ]),
+    );
+
+    let reveresed: string = 'hira THIScompatY IS A NOcoDE plATFNORM';
+    expect(prepad.execute(fep).allResults()[0].getResult().get('result')).toBe(reveresed);
+});

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

@@ -0,0 +1,78 @@
+import { RegionMatches } from '../../../../../src/engine/function/system/string/RegionMatches';
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../../../src/engine/util/MapUtil';
+
+const region: RegionMatches = new RegionMatches();
+
+test('toString test1', () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+    fep.setArguments(
+        MapUtil.of<string, string | number | boolean>(
+            RegionMatches.PARAMETER_BOOLEAN_NAME,
+            true,
+            RegionMatches.PARAMETER_STRING_NAME,
+            ' THIScompatY IS A NOcoDE plATFNORM',
+            RegionMatches.PARAMETER_FIRST_OFFSET_NAME,
+            5,
+            RegionMatches.PARAMETER_OTHER_STRING_NAME,
+            ' fincitY compatY ',
+            RegionMatches.PARAMETER_SECOND_OFFSET_NAME,
+            9,
+            RegionMatches.PARAMETER_INTEGER_NAME,
+            7,
+        ),
+    );
+
+    expect(
+        region.execute(fep).allResults()[0].getResult().get(RegionMatches.EVENT_RESULT_NAME),
+    ).toBe(true);
+});
+
+test('toString test2', () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    fep.setArguments(
+        MapUtil.of<string, string | number | boolean>(
+            RegionMatches.PARAMETER_BOOLEAN_NAME,
+            false,
+            RegionMatches.PARAMETER_STRING_NAME,
+            ' THIScompatY IS A NOcoDE plATFNORM',
+            RegionMatches.PARAMETER_FIRST_OFFSET_NAME,
+            5,
+            RegionMatches.PARAMETER_OTHER_STRING_NAME,
+            ' fincitY compatY ',
+            RegionMatches.PARAMETER_SECOND_OFFSET_NAME,
+            1,
+            RegionMatches.PARAMETER_INTEGER_NAME,
+            7,
+        ),
+    );
+
+    expect(
+        region.execute(fep).allResults()[0].getResult().get(RegionMatches.EVENT_RESULT_NAME),
+    ).toBe(false);
+});
+
+test('toString test3', () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    fep.setArguments(
+        MapUtil.of<string, string | number | boolean>(
+            RegionMatches.PARAMETER_BOOLEAN_NAME,
+            true,
+            RegionMatches.PARAMETER_STRING_NAME,
+            ' THIScompatY IS A NOcoDE plATFNORM',
+            RegionMatches.PARAMETER_FIRST_OFFSET_NAME,
+            10,
+            RegionMatches.PARAMETER_OTHER_STRING_NAME,
+            ' fincitY compatY ',
+            RegionMatches.PARAMETER_SECOND_OFFSET_NAME,
+            6,
+            RegionMatches.PARAMETER_INTEGER_NAME,
+            3,
+        ),
+    );
+
+    expect(
+        region.execute(fep).allResults()[0].getResult().get(RegionMatches.EVENT_RESULT_NAME),
+    ).toBe(true);
+});

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

@@ -0,0 +1,36 @@
+import { Reverse } from '../../../../../src/engine/function/system/string/Reverse';
+import { SchemaValidationException } from '../../../../../src/engine/json/schema/validator/exception/SchemaValidationException';
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../../../src/engine/util/MapUtil';
+
+const reve: Reverse = new Reverse();
+
+test('reverse test1', () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+    fep.setArguments(MapUtil.of('value', ' mr"ofta"lp edoc on a si sihT'));
+
+    let reveresed: string = 'This is a no code pl"atfo"rm ';
+
+    expect(reve.execute(fep).allResults()[0].getResult().get('value')).toBe(reveresed);
+});
+
+test('reverse test2', () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+    fep.setArguments(MapUtil.of('value', ' '));
+
+    let reveresed: string = ' ';
+
+    expect(reve.execute(fep).allResults()[0].getResult().get('value')).toBe(reveresed);
+});
+
+// test('reverse test3', () => {
+//     let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+//     fep.setArguments(MapUtil.of('value', null));
+
+//     let reveresed: string = ' ';
+
+//     expect(reve.execute(fep).allResults()[0].getResult().get('value')).toBe(reveresed);
+// });

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

@@ -0,0 +1,61 @@
+import { Split } from '../../../../../src/engine/function/system/string/Split';
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../../../src/engine/util/MapUtil';
+
+const Spli: Split = new Split();
+
+test('split test1', () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    fep.setArguments(
+        MapUtil.of(
+            'string',
+            'I am using eclipse to test the changes with test Driven developement',
+            'searchString',
+            ' ',
+        ),
+    );
+
+    let array: string[] = [];
+    array.push('I');
+    array.push('am');
+    array.push('using');
+    array.push('eclipse');
+    array.push('to');
+    array.push('test');
+    array.push('the');
+    array.push('changes');
+    array.push('with');
+    array.push('test');
+    array.push('Driven');
+    array.push('developement');
+
+    expect(Spli.execute(fep).allResults()[0].getResult().get('output')).toStrictEqual(array);
+});
+
+test('split test2', () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    fep.setArguments(
+        MapUtil.of(
+            'string',
+            'I am using eclipse to test the changes with test Driven developement',
+            'searchString',
+            'e',
+        ),
+    );
+
+    let array: string[] = [];
+    array.push('I am using ');
+    array.push('clips');
+    array.push(' to t');
+    array.push('st th');
+    array.push(' chang');
+    array.push('s with t');
+    array.push('st Driv');
+    array.push('n d');
+    array.push('v');
+    array.push('lop');
+    array.push('m');
+    array.push('nt');
+
+    expect(Spli.execute(fep).allResults()[0].getResult().get('output')).toStrictEqual(array);
+});

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

@@ -0,0 +1,126 @@
+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';
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../../../src/engine/util/MapUtil';
+
+const stringRepo = new StringFunctionRepository();
+
+test('StringRepo - contains', () => {
+    let fun = stringRepo.find(Namespaces.STRING, 'Contains');
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+    if (!fun) {
+        throw new Error('Function not available');
+    }
+
+    fep.setArguments(
+        MapUtil.of(
+            AbstractStringFunction.PARAMETER_STRING_NAME,
+            '			no code  Kirun  PLATform		',
+            AbstractStringFunction.PARAMETER_SEARCH_STRING_NAME,
+            'no code',
+        ),
+    );
+    expect(
+        fun.execute(fep).allResults()[0].getResult().get(AbstractStringFunction.EVENT_RESULT_NAME),
+    ).toBe(true);
+
+    fep.setArguments(
+        MapUtil.of(
+            AbstractStringFunction.PARAMETER_STRING_NAME,
+            '   ',
+            AbstractStringFunction.PARAMETER_SEARCH_STRING_NAME,
+            ' ',
+        ),
+    );
+    expect(
+        fun.execute(fep).allResults()[0].getResult().get(AbstractStringFunction.EVENT_RESULT_NAME),
+    ).toBe(true);
+
+    fep.setArguments(
+        MapUtil.of(
+            AbstractStringFunction.PARAMETER_STRING_NAME,
+            '{20934 123 1[[23 245-0 34\\\\\\" 3434 \\\\\\" 123]]}',
+            AbstractStringFunction.PARAMETER_SEARCH_STRING_NAME,
+            '4 123 1[[23 245-0 34',
+        ),
+    );
+
+    expect(
+        fun.execute(fep).allResults()[0].getResult().get(AbstractStringFunction.EVENT_RESULT_NAME),
+    ).toBe(true);
+
+    fep.setArguments(
+        MapUtil.of(
+            AbstractStringFunction.PARAMETER_STRING_NAME,
+            '{20934 123 1[[23 245-0 34\\\\\\" 3434 \\\\\\" 123]]}',
+            AbstractStringFunction.PARAMETER_SEARCH_STRING_NAME,
+            '2093(.*)',
+        ),
+    );
+
+    expect(
+        fun.execute(fep).allResults()[0].getResult().get(AbstractStringFunction.EVENT_RESULT_NAME),
+    ).toBe(false);
+});
+
+test('string function repo 2', () => {
+    let fun = stringRepo.find(Namespaces.STRING, 'EndsWith');
+
+    if (!fun) {
+        throw new Error('Function not available');
+    }
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+    fep.setArguments(
+        MapUtil.of(
+            AbstractStringFunction.PARAMETER_STRING_NAME,
+            '			no code  Kirun  PLATform		',
+            AbstractStringFunction.PARAMETER_SEARCH_STRING_NAME,
+            'PLATform		',
+        ),
+    );
+    expect(
+        fun.execute(fep).allResults()[0].getResult().get(AbstractStringFunction.EVENT_RESULT_NAME),
+    ).toBe(true);
+
+    fep.setArguments(
+        MapUtil.of(
+            AbstractStringFunction.PARAMETER_STRING_NAME,
+            'this is a new job\t',
+            AbstractStringFunction.PARAMETER_SEARCH_STRING_NAME,
+            'job\t',
+        ),
+    );
+
+    expect(
+        fun.execute(fep).allResults()[0].getResult().get(AbstractStringFunction.EVENT_RESULT_NAME),
+    ).toBe(true);
+
+    fep.setArguments(
+        MapUtil.of(
+            AbstractStringFunction.PARAMETER_STRING_NAME,
+            '{20934 123 1[[23 245-0 34\\\\\\" 3434 \\\\\\" 123]]}',
+            AbstractStringFunction.PARAMETER_SEARCH_STRING_NAME,
+            '" 123]]}',
+        ),
+    );
+
+    expect(
+        fun.execute(fep).allResults()[0].getResult().get(AbstractStringFunction.EVENT_RESULT_NAME),
+    ).toBe(true);
+
+    fep.setArguments(
+        MapUtil.of(
+            AbstractStringFunction.PARAMETER_STRING_NAME,
+            '{20934 123 1[[23 245-0 34\\\\\\" 3434 \\\\\\" 123]]}',
+            AbstractStringFunction.PARAMETER_SEARCH_STRING_NAME,
+            ']]20934}',
+        ),
+    );
+
+    expect(
+        fun.execute(fep).allResults()[0].getResult().get(AbstractStringFunction.EVENT_RESULT_NAME),
+    ).toBe(false);
+});

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

@@ -0,0 +1,54 @@
+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';
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../../../src/engine/util/MapUtil';
+
+const stringRepo = new StringFunctionRepository();
+
+test('StringRepo3 - EqualsIgnoreCase', () => {
+    let fun = stringRepo.find(Namespaces.STRING, 'EqualsIgnoreCase');
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters();
+
+    if (!fun) {
+        throw new Error('Function not available');
+    }
+
+    fep.setArguments(
+        MapUtil.of(
+            AbstractStringFunction.PARAMETER_STRING_NAME,
+            ' THIS IS A NOcoDE plATFORM		',
+            AbstractStringFunction.PARAMETER_SEARCH_STRING_NAME,
+            ' THIS IS A NOCODE PLATFORM		',
+        ),
+    );
+    expect(
+        fun.execute(fep).allResults()[0].getResult().get(AbstractStringFunction.EVENT_RESULT_NAME),
+    ).toBeTruthy();
+
+    fep.setArguments(
+        MapUtil.of(
+            AbstractStringFunction.PARAMETER_STRING_NAME,
+            '    20934 123 123 245-0 34" 3434 " 123',
+            AbstractStringFunction.PARAMETER_SEARCH_STRING_NAME,
+            '  w20934 123 123 245-0 34" 3434 " 123   ',
+        ),
+    );
+
+    expect(
+        fun.execute(fep).allResults()[0].getResult().get(AbstractStringFunction.EVENT_RESULT_NAME),
+    ).toBe(false);
+
+    fep.setArguments(
+        MapUtil.of(
+            AbstractStringFunction.PARAMETER_STRING_NAME,
+            '			no code  Kirun  PLATform		',
+            AbstractStringFunction.PARAMETER_SEARCH_STRING_NAME,
+            '			NO CODE  KIRUN  PLATFORM	',
+        ),
+    );
+
+    expect(
+        fun.execute(fep).allResults()[0].getResult().get(AbstractStringFunction.EVENT_RESULT_NAME),
+    ).toBe(false);
+});