[incubator-kie-issues-1752] TCK failure-Lambda function returns null

kie-dmn/kie-dmn-feel/src/main/java/org/kie/dmn/feel/lang/types/GenFnType.java

@@ -16,11 +16,11 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+
 package org.kie.dmn.feel.lang.types;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
 import org.kie.dmn.feel.lang.SimpleType;
@@ -40,18 +40,15 @@ public GenFnType(List<Type> argsGen, Type returnGen) {
 
     @Override
     public boolean isInstanceOf(Object o) {
-        if (o instanceof FEELFunction) {
-            FEELFunction oFn = (FEELFunction) o;
-            List<List<Param>> signatures = oFn.getParameters().stream().filter(signature -> signature.size() == argsGen.size()).collect(Collectors.toList());
-            for (List<Param> signature : signatures) {
-                if (signature.size() == argsGen.size() && IntStream.range(0, argsGen.size()).allMatch(i -> argsGen.get(i).conformsTo(signature.get(i).type))) {
-                    return true;
-                }
+        if (o instanceof FEELFunction oFn) {
+            List<List<Param>> parameters = oFn.getParameters();
+            if(parameters.isEmpty()){
+                //this is used to consider function as parameter
+                return true;
             }
-            return false;
-        } else {
-            return false;
+            return checkSignatures(parameters,argsGen);
         }
+        return false;
     }
 
     @Override
@@ -69,13 +66,22 @@ public String getName() {
 
     @Override
     public boolean conformsTo(Type t) {
-        if (t instanceof GenFnType) {
-            GenFnType fnT = (GenFnType) t;
+        if (t instanceof GenFnType fnT) {
             return fnT.argsGen.size() == this.argsGen.size() &&
-                   IntStream.range(0, argsGen.size()).allMatch(i -> fnT.argsGen.get(i).conformsTo(this.argsGen.get(i))) &&
-                   this.returnGen.conformsTo(fnT.returnGen);
+                    IntStream.range(0, argsGen.size()).allMatch(i -> fnT.argsGen.get(i).conformsTo(this.argsGen.get(i))) &&
+                    this.returnGen.conformsTo(fnT.returnGen);
         } else {
             return t == BuiltInType.FUNCTION;
         }
     }
-}
+
+    static boolean checkSignatures(List<List<Param>> parameters, List<Type> argsGen){
+        List<List<Param>> signatures = parameters.stream().filter(signature -> signature.size() == argsGen.size()).toList();
+        for (List<Param> signature : signatures) {
+            if (signature.size() == argsGen.size() && IntStream.range(0, argsGen.size()).allMatch(i -> argsGen.get(i).conformsTo(signature.get(i).type))) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

kie-dmn/kie-dmn-feel/src/test/java/org/kie/dmn/feel/lang/types/GenFnTypeTest.java

@@ -0,0 +1,208 @@
+package org.kie.dmn.feel.lang.types;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.Test;
+import org.kie.dmn.feel.lang.Type;
+import org.kie.dmn.feel.runtime.functions.AbsFunction;
+import org.kie.dmn.feel.runtime.functions.AnyFunction;
+import org.kie.dmn.feel.runtime.functions.FEELFnResult;
+import org.kie.dmn.feel.runtime.FEELFunction.Param;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.ArrayList;
+
+class GenFnTypeTest {
+
+    private static final AbsFunction absFunctionInstance = AbsFunction.INSTANCE;
+    private static final AnyFunction anyFunctionInstance = AnyFunction.INSTANCE;
+
+    private final GenFnType genFnType = new GenFnType(
+            Arrays.asList(new SomeType(), new AnotherType()),
+            new SomeType()
+    );
+
+    @Test
+    public void testIsInstanceOfWithNoParameters() {
+        assertThat(genFnType.isInstanceOf(absFunctionInstance)).isTrue();
+    }
+
+    @Test
+    public void testIsInstanceOfWithNonMatchingParameters() {
+        FEELFnResult<Boolean> feelFn = anyFunctionInstance.invoke(new Object[]{Boolean.TRUE, Boolean.TRUE});
+        assertThat(genFnType.isInstanceOf(feelFn)).isFalse();
+    }
+
+    @Test
+    public void testIsInstanceOfWithMatchingFunctionSignature() {
+        GenFnType matchingGenFnType = new GenFnType(
+                Arrays.asList(new SomeType(), new AnotherType()),
+                new SomeType()
+        );
+        assertThat(matchingGenFnType.isInstanceOf(absFunctionInstance)).isTrue();
+    }
+
+    @Test
+    public void testIsAssignableValueWithNullValue() {
+        assertThat(genFnType.isAssignableValue(null)).isTrue();
+    }
+
+    @Test
+    public void testIsAssignableValueWithFunction() {
+        assertThat(genFnType.isAssignableValue(absFunctionInstance)).isTrue();
+    }
+
+    @Test
+    public void testConformsToWithSignature() {
+        GenFnType matchingGenFnType = new GenFnType(
+                Collections.singletonList(new SomeType()),
+                new SomeType()
+        );
+        assertThat(genFnType.conformsTo(matchingGenFnType)).isFalse();
+    }
+
+    @Test
+    public void testConformsToWithFunctionType() {
+        assertThat(genFnType.conformsTo(BuiltInType.FUNCTION)).isTrue();
+    }
+
+    @Test
+    void testCheckSignatures_withMatchingSignatures() {
+        List<Type> argsGen = Arrays.asList(new SomeType(), new AnotherType());
+        List<Type> paramTypes = Arrays.asList(new SomeType(), new AnotherType());
+        List<String> paramNames = Arrays.asList("param1", "param2");
+        List<List<Param>> params = createParams(paramTypes, paramNames);
+
+        assertThat(GenFnType.checkSignatures(params, argsGen)).isTrue();
+    }
+
+    @Test
+    void testCheckSignatures_withNonMatchingSignatures() {
+        List<Type> argsGen = Arrays.asList(new SomeType(), new AnotherType());
+        List<Type> paramTypes = Arrays.asList(new SomeType(), new YetAnotherType());
+        List<String> paramNames = Arrays.asList("param1", "param2");
+        List<List<Param>> params = createParams(paramTypes, paramNames);
+
+        assertThat(GenFnType.checkSignatures(params, argsGen)).isFalse();
+    }
+
+    @Test
+    void testCheckSignatures_withSignatureSizeMismatch() {
+        List<Type> argsGen = Arrays.asList(new SomeType(), new AnotherType());
+        List<Type> paramTypes = List.of(new SomeType());
+        List<String> paramNames = List.of("param1");
+        List<List<Param>> params = createParams(paramTypes, paramNames);
+
+        assertThat(GenFnType.checkSignatures(params, argsGen)).isFalse();
+    }
+
+    @Test
+    void testCheckSignatures_withEmptyParams() {
+        List<Type> argsGen = Arrays.asList(new SomeType(), new AnotherType());
+        List<List<Param>> params = List.of();
+
+        assertThat(GenFnType.checkSignatures(params, argsGen)).isFalse();
+    }
+
+    @Test
+    void testCheckSignatures_withEmptyArgsGen() {
+        List<Type> argsGen = List.of();
+        List<Type> paramTypes = Arrays.asList(new SomeType(), new AnotherType());
+        List<String> paramNames = Arrays.asList("param1", "param2");
+        List<List<Param>> params = createParams(paramTypes, paramNames);
+
+        assertThat(GenFnType.checkSignatures(params, argsGen)).isFalse();
+    }
+
+    @Test
+    void testCheckSignatures_withMatchingEmptySignature() {
+        List<Type> argsGen = List.of();
+        List<List<Param>> params = List.of();
+
+        assertThat(GenFnType.checkSignatures(params, argsGen)).isFalse();
+    }
+
+    static class SomeType implements Type {
+        @Override
+        public String getName() {
+            return "SomeType";
+        }
+
+        @Override
+        public boolean isInstanceOf(Object o) {
+            return o instanceof SomeType;
+        }
+
+        @Override
+        public boolean isAssignableValue(Object value) {
+            return value instanceof SomeType;
+        }
+
+        @Override
+        public boolean conformsTo(Type t) {
+            return t instanceof SomeType;
+        }
+    }
+
+    static class AnotherType implements Type {
+        @Override
+        public String getName() {
+            return "AnotherType";
+        }
+
+        @Override
+        public boolean isInstanceOf(Object o) {
+            return o instanceof AnotherType;
+        }
+
+        @Override
+        public boolean isAssignableValue(Object value) {
+            return value instanceof AnotherType;
+        }
+
+        @Override
+        public boolean conformsTo(Type t) {
+            return t instanceof AnotherType;
+        }
+    }
+
+    static class YetAnotherType implements Type {
+        @Override
+        public String getName() {
+            return "YetAnotherType";
+        }
+
+        @Override
+        public boolean isInstanceOf(Object o) {
+            return o instanceof YetAnotherType;
+        }
+
+        @Override
+        public boolean isAssignableValue(Object value) {
+            return value instanceof YetAnotherType;
+        }
+
+        @Override
+        public boolean conformsTo(Type t) {
+            return t instanceof YetAnotherType;
+        }
+    }
+
+    private List<List<Param>> createParams(List<Type> types, List<String> names) {
+        if (types.size() != names.size()) {
+            throw new IllegalArgumentException("The number of types and names must match");
+        }
+
+        List<List<Param>> params = new ArrayList<>();
+        List<Param> paramList = new ArrayList<>();
+
+        for (int i = 0; i < types.size(); i++) {
+            paramList.add(new Param(names.get(i), types.get(i)));
+        }
+
+        params.add(paramList);
+        return params;
+    }
+}