Update fuzzing

Author: tamarinvs19

utbot-python/src/main/kotlin/org/utbot/python/PythonEngine.kt

@@ -215,9 +215,17 @@ class PythonEngine(
             emptyList()
         )
 
+        var coverageLimit = 15
         val coveredLines = initialCoveredLines.toMutableSet()
 
         PythonFuzzing(pythonTypeStorage!!) { description, parameterValues ->
+            if (coverageLimit < 0)
+                return@PythonFuzzing PythonFeedback(control = Control.STOP)
+
+            if (parameterValues.all { it.classId.name == "UNDEF_VALUE" }) {
+                coverageLimit--
+                return@PythonFuzzing PythonFeedback(control = Control.PASS)
+            }
 
             val (thisObject, modelList) =
                 if (methodUnderTest.containingPythonClassId == null)
@@ -286,9 +294,12 @@ class PythonEngine(
             val coveredAfter = coveredLines.size
 
             if (coveredAfter == coveredBefore)
+                coverageLimit -= 1
+
+            if (coverageLimit == 0)
                 return@PythonFuzzing PythonFeedback(control = Control.STOP)
 
-            return@PythonFuzzing PythonFeedback(control = Control.PASS)
+            return@PythonFuzzing PythonFeedback(control = Control.CONTINUE)
 
         }.fuzz(pmd)
     }

utbot-python/src/main/kotlin/org/utbot/python/PythonTestCaseGenerator.kt

@@ -97,7 +97,7 @@ object PythonTestCaseGenerator {
             PythonTypeStorage.get(storage)
         )
 
-        var coverageLimit = 10
+//        var coverageLimit = 10
 
         runBlockingWithCancellationPredicate(isCancelled) {
             engine.newFuzzing(args).collect {
@@ -118,16 +118,16 @@ object PythonTestCaseGenerator {
                 }
                 val coveredAfter = coveredLines.size
 
-                if (coveredAfter == coveredBefore)
-                    coverageLimit -= 1
+//                if (coveredAfter == coveredBefore)
+//                    coverageLimit -= 1
+//
+//                if (withMinimization && missingLines?.isEmpty() == true) {//&& generated % CHUNK_SIZE == 0)
+//                    coverageLimit = 0
+//                }
 
-                if (withMinimization && missingLines?.isEmpty() == true) {//&& generated % CHUNK_SIZE == 0)
-                    coverageLimit = 0
-                }
-
-                if (coverageLimit == 0) {
-                    isCancelled = {true}
-                }
+//                if (coverageLimit == 0) {
+//                    isCancelled = {true}
+//                }
             }
         }
 

utbot-python/src/main/kotlin/org/utbot/python/fuzzing/PythonApi.kt

@@ -8,7 +8,10 @@ import org.utbot.fuzzing.Description
 import org.utbot.fuzzing.Feedback
 import org.utbot.fuzzing.Fuzzing
 import org.utbot.fuzzing.Seed
+import org.utbot.python.framework.api.python.PythonClassId
+import org.utbot.python.framework.api.python.PythonTree
 import org.utbot.python.framework.api.python.PythonTreeModel
+import org.utbot.python.framework.api.python.util.pythonNoneClassId
 import org.utbot.python.fuzzing.provider.BoolValueProvider
 import org.utbot.python.fuzzing.provider.DictValueProvider
 import org.utbot.python.fuzzing.provider.FloatValueProvider
@@ -21,6 +24,7 @@ import org.utbot.python.fuzzing.provider.StrValueProvider
 import org.utbot.python.fuzzing.provider.TupleFixSizeValueProvider
 import org.utbot.python.fuzzing.provider.TupleValueProvider
 import org.utbot.python.fuzzing.provider.UnionValueProvider
+import org.utbot.python.fuzzing.value.UndefValue
 import org.utbot.python.newtyping.PythonProtocolDescription
 import org.utbot.python.newtyping.PythonSubtypeChecker
 import org.utbot.python.newtyping.PythonTypeStorage
@@ -67,31 +71,47 @@ fun pythonDefaultValueProviders(idGenerator: IdGenerator<Long>) = listOf(
 )
 
 class PythonFuzzing(
-    val pythonTypeStorage: PythonTypeStorage,
+    private val pythonTypeStorage: PythonTypeStorage,
     val execute: suspend (description: PythonMethodDescription, values: List<PythonTreeModel>) -> PythonFeedback,
 ) : Fuzzing<Type, PythonTreeModel, PythonMethodDescription, PythonFeedback> {
-    fun generateDefault(description: PythonMethodDescription, type: Type): Sequence<Seed<Type, PythonTreeModel>> {
-        val idGenerator = PythonIdGenerator()
-        return pythonDefaultValueProviders(idGenerator).asSequence().flatMap { provider ->
+    private fun generateDefault(description: PythonMethodDescription, type: Type, idGenerator: IdGenerator<Long>): Sequence<Seed<Type, PythonTreeModel>> {
+        var providers = emptyList<Seed<Type, PythonTreeModel>>().asSequence()
+        pythonDefaultValueProviders(idGenerator).asSequence().forEach { provider ->
             if (provider.accept(type)) {
-                provider.generate(description, type)
-            } else {
-                emptySequence()
+                providers += provider.generate(description, type)
             }
         }
+        return providers
     }
 
-    override fun generate(description: PythonMethodDescription, type: Type): Sequence<Seed<Type, PythonTreeModel>> {
-        var providers = generateDefault(description, type)
+    private fun generateSubtype(description: PythonMethodDescription, type: Type, idGenerator: IdGenerator<Long>): Sequence<Seed<Type, PythonTreeModel>> {
+        var providers = emptyList<Seed<Type, PythonTreeModel>>().asSequence()
         if (type.meta is PythonProtocolDescription) {
             val subtypes = pythonTypeStorage.allTypes.filter {
                 PythonSubtypeChecker.checkIfRightIsSubtypeOfLeft(type, it, pythonTypeStorage)
             }
-            subtypes.forEach { providers += generateDefault(description, it) }
+            subtypes.forEach {
+                providers += generateDefault(description, it, idGenerator)
+//                providers += generateSubtype(description, it, idGenerator)
+            }
         }
         return providers
     }
 
+    override fun generate(description: PythonMethodDescription, type: Type): Sequence<Seed<Type, PythonTreeModel>> {
+        val idGenerator = PythonIdGenerator()
+        var providers = emptyList<Seed<Type, PythonTreeModel>>().asSequence()
+
+        providers += generateDefault(description, type, idGenerator)
+        providers += generateSubtype(description, type, idGenerator)
+
+        if (providers.toList().isEmpty()) {
+            providers += Seed.Known(UndefValue()) {PythonTreeModel(PythonTree.fromNone(), PythonClassId("UNDEF_VALUE"))}
+        }
+
+        return providers
+    }
+
     override suspend fun handle(description: PythonMethodDescription, values: List<PythonTreeModel>): PythonFeedback {
         return execute(description, values)
     }

utbot-python/src/main/kotlin/org/utbot/python/fuzzing/provider/StrValueProvider.kt

@@ -18,8 +18,9 @@ object StrValueProvider : ValueProvider<Type, PythonTreeModel, PythonMethodDescr
     }
 
     override fun generate(description: PythonMethodDescription, type: Type) = sequence {
-        yieldStrings(StringValue("\"\"")) { value }
+        yieldStrings(StringValue("\"test\"")) { value }
         yieldStrings(StringValue("\"abc\"")) { value }
+        yieldStrings(StringValue("\"\"")) { value }
     }
 
     private suspend fun <T : KnownValue> SequenceScope<Seed<Type, PythonTreeModel>>.yieldStrings(value: T, block: T.() -> Any) {

utbot-python/src/main/kotlin/org/utbot/python/fuzzing/value/UndefValue.kt

@@ -0,0 +1,10 @@
+package org.utbot.python.fuzzing.value
+
+import org.utbot.fuzzing.Mutation
+import org.utbot.fuzzing.seeds.KnownValue
+
+class UndefValue : KnownValue {
+    override fun mutations(): List<Mutation<KnownValue>> {
+        return emptyList()
+    }
+}