Primitive Stream wrappers (no laziness and source mutations support)

utbot-api/src/main/java/org/utbot/api/mock/UtMock.java

@@ -23,4 +23,7 @@ public static void assumeOrExecuteConcretely(boolean predicate) {
         // In oppose to assume, we don't have predicate check here
         // to avoid RuntimeException during concrete execution
     }
+
+    @SuppressWarnings("unused")
+    public static void disableClassCastExceptionCheck(Object object) {}
 }

utbot-framework-api/src/main/kotlin/org/utbot/testcheckers/SettingsModificators.kt

@@ -121,3 +121,13 @@ inline fun <reified T> withoutSandbox(block: () -> T): T {
         UtSettings.useSandbox = prev
     }
 }
+
+inline fun <reified T> withPathSelectorStepsLimit(stepsLimit: Int, block: () -> T): T {
+    val prev = UtSettings.pathSelectorStepsLimit
+    UtSettings.pathSelectorStepsLimit = stepsLimit
+    try {
+        return block()
+    } finally {
+        UtSettings.pathSelectorStepsLimit = prev
+    }
+}

utbot-framework-test/src/test/kotlin/org/utbot/examples/stream/BaseStreamExampleTest.kt

@@ -13,6 +13,7 @@ import org.utbot.tests.infrastructure.isException
 import org.utbot.framework.plugin.api.CodegenLanguage
 import org.utbot.testcheckers.eq
 import org.utbot.testcheckers.withoutConcrete
+import org.utbot.tests.infrastructure.AtLeast
 import org.utbot.tests.infrastructure.CodeGeneration
 import java.util.Optional
 import java.util.stream.Stream
@@ -69,10 +70,46 @@ class BaseStreamExampleTest : UtValueTestCaseChecker(
     fun testMapExample() {
         checkWithException(
             BaseStreamExample::mapExample,
-            eq(2),
+            ignoreExecutionsNumber,
             { c, r -> null in c && r.isException<NullPointerException>() },
             { c, r -> r.getOrThrow().contentEquals(c.map { it * 2 }.toTypedArray()) },
-            coverage = DoNotCalculate
+            coverage = AtLeast(90)
+        )
+    }
+
+    @Test
+    @Tag("slow")
+    fun testMapToIntExample() {
+        checkWithException(
+            BaseStreamExample::mapToIntExample,
+            ignoreExecutionsNumber,
+            { c, r -> null in c && r.isException<NullPointerException>() },
+            { c, r -> r.getOrThrow().contentEquals(c.map { it.toInt() }.toIntArray()) },
+            coverage = AtLeast(90)
+        )
+    }
+
+    @Test
+    @Tag("slow")
+    fun testMapToLongExample() {
+        checkWithException(
+            BaseStreamExample::mapToLongExample,
+            ignoreExecutionsNumber,
+            { c, r -> null in c && r.isException<NullPointerException>() },
+            { c, r -> r.getOrThrow().contentEquals(c.map { it.toLong() }.toLongArray()) },
+            coverage = AtLeast(90)
+        )
+    }
+
+    @Test
+    @Tag("slow")
+    fun testMapToDoubleExample() {
+        checkWithException(
+            BaseStreamExample::mapToDoubleExample,
+            ignoreExecutionsNumber,
+            { c, r -> null in c && r.isException<NullPointerException>() },
+            { c, r -> r.getOrThrow().contentEquals(c.map { it.toDouble() }.toDoubleArray()) },
+            coverage = AtLeast(90)
         )
     }
 
@@ -86,6 +123,37 @@ class BaseStreamExampleTest : UtValueTestCaseChecker(
         )
     }
 
+    @Test
+    @Tag("slow")
+    fun testFlatMapToIntExample() {
+        check(
+            BaseStreamExample::flatMapToIntExample,
+            ignoreExecutionsNumber,
+            { c, r -> r.contentEquals(c.flatMap { listOf(it?.toInt() ?: 0, it?.toInt() ?: 0) }.toIntArray()) },
+            coverage = FullWithAssumptions(assumeCallsNumber = 1)
+        )
+    }
+
+    @Test
+    fun testFlatMapToLongExample() {
+        check(
+            BaseStreamExample::flatMapToLongExample,
+            ignoreExecutionsNumber,
+            { c, r -> r.contentEquals(c.flatMap { listOf(it?.toLong() ?: 0L, it?.toLong() ?: 0L) }.toLongArray()) },
+            coverage = FullWithAssumptions(assumeCallsNumber = 1)
+        )
+    }
+
+    @Test
+    fun testFlatMapToDoubleExample() {
+        check(
+            BaseStreamExample::flatMapToDoubleExample,
+            ignoreExecutionsNumber,
+            { c, r -> r.contentEquals(c.flatMap { listOf(it?.toDouble() ?: 0.0, it?.toDouble() ?: 0.0) }.toDoubleArray()) },
+            coverage = FullWithAssumptions(assumeCallsNumber = 1)
+        )
+    }
+
     @Test
     @Tag("slow")
     fun testDistinctExample() {
@@ -146,17 +214,17 @@ class BaseStreamExampleTest : UtValueTestCaseChecker(
     fun testForEachExample() {
         checkThisAndStaticsAfter(
             BaseStreamExample::forEachExample,
-            eq(2),
+            ignoreExecutionsNumber,
             *streamConsumerStaticsMatchers,
-            coverage = DoNotCalculate
+            coverage = AtLeast(92)
         )
     }
 
     @Test
     fun testToArrayExample() {
         check(
             BaseStreamExample::toArrayExample,
-            ignoreExecutionsNumber,
+            eq(2),
             { c, r -> c.toTypedArray().contentEquals(r) },
             coverage = FullWithAssumptions(assumeCallsNumber = 1)
         )
@@ -311,10 +379,11 @@ class BaseStreamExampleTest : UtValueTestCaseChecker(
     fun testIteratorExample() {
         checkWithException(
             BaseStreamExample::iteratorSumExample,
-            eq(2),
+            ignoreExecutionsNumber,
+            { c, r -> c.isEmpty() && r.getOrThrow() == 0 },
             { c, r -> null in c && r.isException<NullPointerException>() },
-            { c, r -> null !in c && r.getOrThrow() == c.sum() },
-            coverage = DoNotCalculate
+            { c, r -> c.isNotEmpty() && null !in c && r.getOrThrow() == c.sum() },
+            coverage = AtLeast(75)
         )
     }
 
@@ -393,15 +462,15 @@ class BaseStreamExampleTest : UtValueTestCaseChecker(
             coverage = Full
         )
     }
+}
 
-    private val streamConsumerStaticsMatchers = arrayOf(
-        { _: BaseStreamExample, c: List<Int?>, _: StaticsType, _: Int? -> null in c },
-        { _: BaseStreamExample, c: List<Int?>, statics: StaticsType, r: Int? ->
-            val x = statics.values.single().value as Int
+internal val streamConsumerStaticsMatchers = arrayOf(
+    { _: Any, c: List<Int?>, _: StaticsType, _: Int? -> null in c },
+    { _: Any, c: List<Int?>, statics: StaticsType, r: Int? ->
+        val x = statics.values.single().value as Int
 
-            r!! + c.sumOf { it ?: 0 } == x
-        }
-    )
-}
+        r!! + c.sumOf { it ?: 0 } == x
+    }
+)
 
-private fun <E : Comparable<E>> Sequence<E>.isSorted(): Boolean = zipWithNext { a, b -> a <= b }.all { it }
+internal fun <E : Comparable<E>> Sequence<E>.isSorted(): Boolean = zipWithNext { a, b -> a <= b }.all { it }