Add tests on lambdas

Author: ArsenHD

utbot-framework/src/test/kotlin/org/utbot/examples/lambda/CustomPredicateExampleTest.kt

@@ -0,0 +1,57 @@
+package org.utbot.examples.lambda
+
+import org.junit.jupiter.api.Test
+import org.utbot.examples.UtValueTestCaseChecker
+import org.utbot.examples.eq
+
+class CustomPredicateExampleTest : UtValueTestCaseChecker(testClass = CustomPredicateExample::class) {
+    @Test
+    fun testNoCapturedValuesPredicateCheck() {
+        check(
+            CustomPredicateExample::noCapturedValuesPredicateCheck,
+            eq(2),
+            { predicate, x, r -> !predicate.test(x) && !r!! },
+            { predicate, x, r -> predicate.test(x) && r!! },
+        )
+    }
+
+    @Test
+    fun testCapturedLocalVariablePredicateCheck() {
+        check(
+            CustomPredicateExample::capturedLocalVariablePredicateCheck,
+            eq(2),
+            { predicate, x, r -> !predicate.test(x) && !r!! },
+            { predicate, x, r -> predicate.test(x) && r!! },
+        )
+    }
+
+    @Test
+    fun testCapturedParameterPredicateCheck() {
+        check(
+            CustomPredicateExample::capturedParameterPredicateCheck,
+            eq(2),
+            { predicate, x, r -> !predicate.test(x) && !r!! },
+            { predicate, x, r -> predicate.test(x) && r!! },
+        )
+    }
+
+    @Test
+    fun testCapturedStaticFieldPredicateCheck() {
+        check(
+            CustomPredicateExample::capturedStaticFieldPredicateCheck,
+            eq(2),
+            { predicate, x, r -> !predicate.test(x) && !r!! },
+            { predicate, x, r -> predicate.test(x) && r!! },
+        )
+    }
+
+    @Test
+    fun testCapturedNonStaticFieldPredicateCheck() {
+        check(
+            CustomPredicateExample::capturedNonStaticFieldPredicateCheck,
+            eq(2),
+            { predicate, x, r -> !predicate.test(x) && !r!! },
+            { predicate, x, r -> predicate.test(x) && r!! },
+        )
+    }
+}

utbot-sample/src/main/java/org/utbot/examples/lambda/CustomPredicateExample.java

@@ -0,0 +1,65 @@
+package org.utbot.examples.lambda;
+
+public class CustomPredicateExample {
+    static int someStaticField = 5;
+    int someNonStaticField = 10;
+
+    public boolean noCapturedValuesPredicateCheck(PredicateNoCapturedValues<Integer> predicate, int x) {
+        //noinspection RedundantIfStatement
+        if (predicate.test(x)) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public boolean capturedLocalVariablePredicateCheck(PredicateCapturedLocalVariable<Integer> predicate, int x) {
+        //noinspection RedundantIfStatement
+        if (predicate.test(x)) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public boolean capturedParameterPredicateCheck(PredicateCapturedParameter<Integer> predicate, int x) {
+        //noinspection RedundantIfStatement
+        if (predicate.test(x)) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public boolean capturedStaticFieldPredicateCheck(PredicateCapturedStaticField<Integer> predicate, int x) {
+        //noinspection RedundantIfStatement
+        if (predicate.test(x)) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public boolean capturedNonStaticFieldPredicateCheck(PredicateCapturedNonStaticField<Integer> predicate, int x) {
+        //noinspection RedundantIfStatement
+        if (predicate.test(x)) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    // this method contains implementation of functional interface 'CustomPredicate'
+    void someLambdas(int someParameter) {
+        PredicateNoCapturedValues<Integer> predicate1 = (x) -> x == 5;
+
+        int localVariable = 10;
+        PredicateCapturedLocalVariable<Integer> predicate2 = (x) -> x + localVariable == 5;
+
+        PredicateCapturedParameter<Integer> predicate3 = (x) -> x + someParameter == 5;
+
+        PredicateCapturedStaticField<Integer> predicate4 = (x) -> x + someStaticField == 5;
+
+        PredicateCapturedNonStaticField<Integer> predicate5 = (x) -> x + someNonStaticField == 5;
+    }
+}

utbot-sample/src/main/java/org/utbot/examples/lambda/PredicateCapturedLocalVariable.java

@@ -0,0 +1,18 @@
+package org.utbot.examples.lambda;
+
+/**
+ * This functional interface is implemented via one lambda in {@link CustomPredicateExample#someLambdas}.
+ *
+ * DO NOT implement it anymore, because test on {@link CustomPredicateExample#capturedLocalVariablePredicateCheck}
+ * relies on the fact that there is only one implementation and that implementation is lambda.
+ * In addition, in this case we want the implementing lambda to capture some local variable.
+ *
+ * It is important because we want to test how we generate tests when the only available implementation is lambda,
+ * and we want to check different cases: with or without captured values. Note that lambdas may capture
+ * local variables, method parameters, static and non-static fields. That is why we have multiple functional interfaces
+ * in this package: one for each case.
+ */
+@FunctionalInterface
+public interface PredicateCapturedLocalVariable<T> {
+    boolean test(T value);
+}

utbot-sample/src/main/java/org/utbot/examples/lambda/PredicateCapturedNonStaticField.java

@@ -0,0 +1,18 @@
+package org.utbot.examples.lambda;
+
+/**
+ * This functional interface is implemented via one lambda in {@link CustomPredicateExample#someLambdas}.
+ *
+ * DO NOT implement it anymore, because test on {@link CustomPredicateExample#capturedNonStaticFieldPredicateCheck}
+ * relies on the fact that there is only one implementation and that implementation is lambda.
+ * In addition, in this case we want the implementing lambda to capture some non-static field of a class.
+ *
+ * It is important because we want to test how we generate tests when the only available implementation is lambda,
+ * and we want to check different cases: with or without captured values. Note that lambdas may capture
+ * local variables, method parameters, static and non-static fields. That is why we have multiple functional interfaces
+ * in this package: one for each case.
+ */
+@FunctionalInterface
+public interface PredicateCapturedNonStaticField<T> {
+    boolean test(T value);
+}

utbot-sample/src/main/java/org/utbot/examples/lambda/PredicateCapturedParameter.java

@@ -0,0 +1,18 @@
+package org.utbot.examples.lambda;
+
+/**
+ * This functional interface is implemented via one lambda in {@link CustomPredicateExample#someLambdas}.
+ *
+ * DO NOT implement it anymore, because test on {@link CustomPredicateExample#capturedParameterPredicateCheck}
+ * relies on the fact that there is only one implementation and that implementation is lambda.
+ * In addition, in this case we want the implementing lambda to capture some method parameter.
+ *
+ * It is important because we want to test how we generate tests when the only available implementation is lambda,
+ * and we want to check different cases: with or without captured values. Note that lambdas may capture
+ * local variables, method parameters, static and non-static fields. That is why we have multiple functional interfaces
+ * in this package: one for each case.
+ */
+@FunctionalInterface
+public interface PredicateCapturedParameter<T> {
+    boolean test(T value);
+}

utbot-sample/src/main/java/org/utbot/examples/lambda/PredicateCapturedStaticField.java

@@ -0,0 +1,18 @@
+package org.utbot.examples.lambda;
+
+/**
+ * This functional interface is implemented via one lambda in {@link CustomPredicateExample#someLambdas}.
+ *
+ * DO NOT implement it anymore, because test on {@link CustomPredicateExample#capturedStaticFieldPredicateCheck}
+ * relies on the fact that there is only one implementation and that implementation is lambda.
+ * In addition, in this case we want the implementing lambda to capture some static field of some class.
+ *
+ * It is important because we want to test how we generate tests when the only available implementation is lambda,
+ * and we want to check different cases: with or without captured values. Note that lambdas may capture
+ * local variables, method parameters, static and non-static fields. That is why we have multiple functional interfaces
+ * in this package: one for each case.
+ */
+@FunctionalInterface
+public interface PredicateCapturedStaticField<T> {
+    boolean test(T value);
+}

utbot-sample/src/main/java/org/utbot/examples/lambda/PredicateNoCapturedValues.java

@@ -0,0 +1,18 @@
+package org.utbot.examples.lambda;
+
+/**
+ * This functional interface is implemented via one lambda in {@link CustomPredicateExample#someLambdas}.
+ *
+ * DO NOT implement it anymore, because test on {@link CustomPredicateExample#noCapturedValuesPredicateCheck}
+ * relies on the fact that there is only one implementation and that implementation is lambda.
+ * In addition, in this case we want the implementing lambda to not capture any values.
+ *
+ * It is important because we want to test how we generate tests when the only available implementation is lambda,
+ * and we want to check different cases: with or without captured values. Note that lambdas may capture
+ * local variables, method parameters, static and non-static fields. That is why we have multiple functional interfaces
+ * in this package: one for each case.
+ */
+@FunctionalInterface
+public interface PredicateNoCapturedValues<T> {
+    boolean test(T value);
+}