Add RecursiveModelProvider abstraction

volivan239 · volivan239 · commit 16ea1b7b97b7 · 2022-08-23T11:34:03.000+03:00
diff --git a/utbot-fuzzers/src/main/kotlin/org/utbot/fuzzer/Fuzzer.kt b/utbot-fuzzers/src/main/kotlin/org/utbot/fuzzer/Fuzzer.kt
@@ -134,12 +134,11 @@ fun defaultModelProviders(idGenerator: IdentityPreservingIdGenerator<Int>): Mode
 }
 
 /**
- * Creates a model provider for [ObjectModelProvider] that generates values for object constructor.
+ * Creates a model provider consisting of providers that do not make recursive calls inside them
  */
-fun objectModelProviders(idGenerator: IdentityPreservingIdGenerator<Int>): ModelProvider {
+fun nonRecursiveProviders(idGenerator: IdentityPreservingIdGenerator<Int>): ModelProvider {
     return ModelProvider.of(
         CollectionModelProvider(idGenerator),
-        ArrayModelProvider(idGenerator),
         EnumModelProvider(idGenerator),
         StringConstantModelProvider,
         CharToStringModelProvider,
@@ -148,3 +147,13 @@ fun objectModelProviders(idGenerator: IdentityPreservingIdGenerator<Int>): Model
         PrimitiveWrapperModelProvider,
     )
 }
+
+/**
+ * Creates a model provider consisting of providers that will make no more than [recursion] nested recursive calls.
+ */
+fun recursiveModelProviders(idGenerator: IdentityPreservingIdGenerator<Int>, recursion: Int): ModelProvider {
+    return ModelProvider.of(
+        ObjectModelProvider(idGenerator, recursion),
+        ArrayModelProvider(idGenerator, recursion)
+    )
+}
diff --git a/utbot-fuzzers/src/main/kotlin/org/utbot/fuzzer/providers/ArrayModelProvider.kt b/utbot-fuzzers/src/main/kotlin/org/utbot/fuzzer/providers/ArrayModelProvider.kt
@@ -2,62 +2,54 @@ package org.utbot.fuzzer.providers
 
 import org.utbot.framework.plugin.api.ClassId
 import org.utbot.framework.plugin.api.UtArrayModel
+import org.utbot.framework.plugin.api.UtModel
 import org.utbot.framework.plugin.api.UtPrimitiveModel
 import org.utbot.framework.plugin.api.util.defaultValueModel
 import org.utbot.framework.plugin.api.util.intClassId
 import org.utbot.framework.plugin.api.util.isArray
-import org.utbot.framework.plugin.api.util.voidClassId
 import org.utbot.fuzzer.FuzzedMethodDescription
 import org.utbot.fuzzer.FuzzedParameter
 import org.utbot.fuzzer.FuzzedValue
 import org.utbot.fuzzer.IdentityPreservingIdGenerator
-import org.utbot.fuzzer.ModelProvider
 import org.utbot.fuzzer.ModelProvider.Companion.yieldAllValues
-import org.utbot.fuzzer.defaultModelProviders
-import org.utbot.fuzzer.fuzz
 
 class ArrayModelProvider(
-    private val idGenerator: IdentityPreservingIdGenerator<Int>
-) : ModelProvider {
+    idGenerator: IdentityPreservingIdGenerator<Int>,
+    recursion: Int = 1
+) : RecursiveModelProvider(idGenerator, recursion) {
 
-    private val defaultArraySize: Int = 3
+    private val defaultArraySize: Int
+        get() = when(recursion) {
+            1 -> 3
+            else -> 1
+        }
 
     override fun generate(description: FuzzedMethodDescription): Sequence<FuzzedParameter> = sequence {
         description.parametersMap
             .asSequence()
             .filter { (classId, _) -> classId.isArray }
             .forEach { (arrayClassId, indices) ->
-                val lengths = generateArrayLengths(description)
 
                 // Fuzz small arrays with interesting elements
                 yieldAllValues(indices, generateArrayRecursively(arrayClassId, description, defaultArraySize))
 
                 // Fuzz arrays with interesting lengths and default-valued elements
+                val lengths = generateArrayLengths(description)
                 yieldAllValues(indices, lengths.asSequence().map { length ->
-                        UtArrayModel(
-                            id = idGenerator.createId(),
-                            arrayClassId,
-                            length = length,
-                            arrayClassId.elementClassId!!.defaultValueModel(),
-                            mutableMapOf()
-                        ).fuzzed {
-                            this.summary = "%var% = ${arrayClassId.elementClassId!!.simpleName}[$length]"
-                        }
+                    createFuzzedArrayModel(arrayClassId, length, null)
                 })
             }
     }
 
     private fun generateArrayLengths(description: FuzzedMethodDescription): Set<Int> {
-        val syntheticArrayLengthMethodDescription = FuzzedMethodDescription(
-            "<syntheticArrayLength>",
-            voidClassId,
-            listOf(intClassId),
-            description.concreteValues
-        ).apply {
-            packageName = description.packageName
-        }
+        val fuzzedLengths = fuzzValuesRecursively(
+            types = listOf(intClassId),
+            baseMethodDescription = description,
+            modelProvider = ConstantsModelProvider,
+            generatedValuesName = "array length"
+        )
 
-        return fuzz(syntheticArrayLengthMethodDescription, ConstantsModelProvider)
+        return fuzzedLengths
             .map { (it.single().model as UtPrimitiveModel).value as Int }
             .filter { it in 0..10 }
             .toSet()
@@ -66,24 +58,24 @@ class ArrayModelProvider(
 
     private fun generateArrayRecursively(arrayClassId: ClassId, description: FuzzedMethodDescription, length: Int): Sequence<FuzzedValue> {
         val elementClassId = arrayClassId.elementClassId ?: error("expected ClassId for array but got ${arrayClassId.name}")
-        val syntheticArrayElementSetterMethodDescription = FuzzedMethodDescription(
-            "${arrayClassId.simpleName}OfLength$length<syntheticArrayElementSetter>",
-            voidClassId,
-            List(length) { elementClassId },
-            description.concreteValues
-        ).apply {
-            packageName = description.packageName
-        }
-        return fuzz(syntheticArrayElementSetterMethodDescription, defaultModelProviders(idGenerator)).map {
-            FuzzedValue(
-                UtArrayModel(
-                    idGenerator.createId(),
-                    arrayClassId,
-                    length,
-                    elementClassId.defaultValueModel(),
-                    it.withIndex().associate { it.index to it.value.model }.toMutableMap()
-                )
-            )
+        return fuzzValuesRecursively(
+            types = List(length) { elementClassId },
+            baseMethodDescription = description,
+            modelProvider = generateRecursiveProvider(),
+            generatedValuesName = "elements of array"
+        ).map { elements ->
+            createFuzzedArrayModel(arrayClassId, length, elements.map { it.model })
         }
     }
+
+    private fun createFuzzedArrayModel(arrayClassId: ClassId, length: Int, values: List<UtModel>?) =
+        UtArrayModel(
+            idGenerator.createId(),
+            arrayClassId,
+            length,
+            arrayClassId.elementClassId!!.defaultValueModel(),
+            values?.withIndex()?.associate { it.index to it.value }?.toMutableMap() ?: mutableMapOf()
+        ).fuzzed {
+            this.summary = "%var% = ${arrayClassId.elementClassId!!.simpleName}[$length]"
+        }
 }
diff --git a/utbot-fuzzers/src/main/kotlin/org/utbot/fuzzer/providers/ObjectModelProvider.kt b/utbot-fuzzers/src/main/kotlin/org/utbot/fuzzer/providers/ObjectModelProvider.kt
@@ -14,18 +14,14 @@ import org.utbot.framework.plugin.api.util.isPrimitive
 import org.utbot.framework.plugin.api.util.isPrimitiveWrapper
 import org.utbot.framework.plugin.api.util.jClass
 import org.utbot.framework.plugin.api.util.stringClassId
-import org.utbot.framework.plugin.api.util.voidClassId
 import org.utbot.fuzzer.IdentityPreservingIdGenerator
-import org.utbot.fuzzer.FuzzedConcreteValue
 import org.utbot.fuzzer.FuzzedMethodDescription
 import org.utbot.fuzzer.FuzzedParameter
 import org.utbot.fuzzer.FuzzedValue
 import org.utbot.fuzzer.ModelProvider
 import org.utbot.fuzzer.ModelProvider.Companion.yieldValue
 import org.utbot.fuzzer.TooManyCombinationsException
-import org.utbot.fuzzer.exceptIsInstance
 import org.utbot.fuzzer.fuzz
-import org.utbot.fuzzer.objectModelProviders
 import org.utbot.fuzzer.providers.ConstantsModelProvider.fuzzed
 import java.lang.reflect.Constructor
 import java.lang.reflect.Field
@@ -39,25 +35,20 @@ private val logger by lazy { KotlinLogging.logger {} }
  * Creates [UtAssembleModel] for objects which have public constructors with primitives types and String as parameters.
  */
 class ObjectModelProvider(
-    private val idGenerator: IdentityPreservingIdGenerator<Int>,
-    private val limit: Int = Int.MAX_VALUE,
-    private val recursion: Int = 1
-) : ModelProvider {
+    idGenerator: IdentityPreservingIdGenerator<Int>,
+    recursion: Int = 1,
+) : RecursiveModelProvider(idGenerator, recursion) {
 
-    var modelProvider: ModelProvider = objectModelProviders(idGenerator)
+    // TODO: can we make it private val (maybe depending on recursion)?
     var limitValuesCreatedByFieldAccessors: Int = 100
         set(value) {
             field = maxOf(0, value)
         }
 
-    private val nonRecursiveModelProvider: ModelProvider
-        get() {
-            val modelProviderWithoutRecursion = modelProvider.exceptIsInstance<ObjectModelProvider>()
-            return if (recursion > 0) {
-                ObjectModelProvider(idGenerator, limit = 1, recursion - 1).with(modelProviderWithoutRecursion)
-            } else {
-                modelProviderWithoutRecursion.withFallback(NullModelProvider)
-            }
+    private val limit: Int =
+        when(recursion) {
+            1 -> Int.MAX_VALUE
+            else -> 1
         }
 
     override fun generate(description: FuzzedMethodDescription): Sequence<FuzzedParameter> = sequence {
@@ -74,14 +65,14 @@ class ObjectModelProvider(
                 .associateWith { constructorId ->
                     fuzzParameters(
                         constructorId,
-                        nonRecursiveModelProvider
+                        generateRecursiveProvider()
                     )
                 }
                 .asSequence()
                 .flatMap { (constructorId, fuzzedParameters) ->
                     if (constructorId.parameters.isEmpty()) {
                         sequenceOf(assembleModel(idGenerator.createId(), constructorId, emptyList())) +
-                                generateModelsWithFieldsInitialization(constructorId, description, concreteValues)
+                                generateModelsWithFieldsInitialization(constructorId, description)
                     }
                     else {
                         fuzzedParameters.map { params ->
@@ -98,20 +89,18 @@ class ObjectModelProvider(
         }
     }
 
-    private fun generateModelsWithFieldsInitialization(constructorId: ConstructorId, description: FuzzedMethodDescription, concreteValues: Collection<FuzzedConcreteValue>): Sequence<FuzzedValue> {
+    private fun generateModelsWithFieldsInitialization(constructorId: ConstructorId, description: FuzzedMethodDescription): Sequence<FuzzedValue> {
         if (limitValuesCreatedByFieldAccessors == 0) return emptySequence()
         val fields = findSuitableFields(constructorId.classId, description)
-        val syntheticClassFieldsSetterMethodDescription = FuzzedMethodDescription(
-            "${constructorId.classId.simpleName}<syntheticClassFieldSetter>",
-            voidClassId,
-            fields.map { it.classId },
-            concreteValues
-        ).apply {
-            packageName = description.packageName
-        }
 
-        return fuzz(syntheticClassFieldsSetterMethodDescription, nonRecursiveModelProvider)
-            .take(limitValuesCreatedByFieldAccessors) // limit the number of fuzzed values in this particular case
+        val fieldValuesSets = fuzzValuesRecursively(
+            types = fields.map { it.classId },
+            baseMethodDescription = description,
+            modelProvider = generateRecursiveProvider(),
+            generatedValuesName = "${constructorId.classId.simpleName} fields"
+        ).take(limitValuesCreatedByFieldAccessors) // limit the number of fuzzed values in this particular case
+
+        return fieldValuesSets
             .map { fieldValues ->
                 val fuzzedModel = assembleModel(idGenerator.createId(), constructorId, emptyList())
                 val assembleModel = fuzzedModel.model as? UtAssembleModel ?: error("Expected UtAssembleModel but ${fuzzedModel.model::class.java} found")
diff --git a/utbot-fuzzers/src/main/kotlin/org/utbot/fuzzer/providers/RecursiveModelProvider.kt b/utbot-fuzzers/src/main/kotlin/org/utbot/fuzzer/providers/RecursiveModelProvider.kt
@@ -0,0 +1,51 @@
+package org.utbot.fuzzer.providers
+
+import org.utbot.framework.plugin.api.ClassId
+import org.utbot.framework.plugin.api.util.voidClassId
+import org.utbot.fuzzer.FuzzedMethodDescription
+import org.utbot.fuzzer.FuzzedValue
+import org.utbot.fuzzer.IdentityPreservingIdGenerator
+import org.utbot.fuzzer.ModelProvider
+import org.utbot.fuzzer.fuzz
+import org.utbot.fuzzer.nonRecursiveProviders
+import org.utbot.fuzzer.recursiveModelProviders
+
+// TODO: maybe use `recursionDepth` instead of `recursion` here and in [recursiveModelProviders]?
+abstract class RecursiveModelProvider(
+    protected val idGenerator: IdentityPreservingIdGenerator<Int>,
+    protected val recursion: Int
+): ModelProvider {
+    // TODO: currently it is var due to tests, maybe we can make it private val?
+    var modelProviderForRecursiveCalls: ModelProvider =
+        if (recursion > 0)
+            nonRecursiveProviders(idGenerator).with(recursiveModelProviders(idGenerator, recursion - 1))
+        else
+            nonRecursiveProviders(idGenerator)
+
+    protected fun generateRecursiveProvider(
+        baseProvider: ModelProvider = modelProviderForRecursiveCalls,
+        fallbackProvider: ModelProvider = NullModelProvider
+    ): ModelProvider {
+        return if (recursion > 0)
+            baseProvider
+        else
+            baseProvider.withFallback(fallbackProvider)
+    }
+
+    protected fun fuzzValuesRecursively(
+        types: List<ClassId>,
+        baseMethodDescription: FuzzedMethodDescription,
+        modelProvider: ModelProvider,
+        generatedValuesName: String
+    ): Sequence<List<FuzzedValue>> {
+        val syntheticMethodDescription = FuzzedMethodDescription(
+            "<synthetic method for fuzzing $generatedValuesName",
+            voidClassId,
+            types,
+            baseMethodDescription.concreteValues
+        ).apply {
+            packageName = baseMethodDescription.packageName
+        }
+        return fuzz(syntheticMethodDescription, modelProvider)
+    }
+}
diff --git a/utbot-fuzzers/src/test/kotlin/org/utbot/framework/plugin/api/ModelProviderTest.kt b/utbot-fuzzers/src/test/kotlin/org/utbot/framework/plugin/api/ModelProviderTest.kt
@@ -194,7 +194,7 @@ class ModelProviderTest {
             val classId = A::class.java.id
             val models = collect(
                 ObjectModelProvider(ReferencePreservingIntIdGenerator(0)).apply {
-                    modelProvider = ModelProvider.of(PrimitiveDefaultsModelProvider)
+                    modelProviderForRecursiveCalls = ModelProvider.of(PrimitiveDefaultsModelProvider)
                 },
                 parameters = listOf(classId)
             )
@@ -480,7 +480,7 @@ class ModelProviderTest {
 
         withUtContext(UtContext(this::class.java.classLoader)) {
             val result = collect(ObjectModelProvider(ReferencePreservingIntIdGenerator(0)).apply {
-                modelProvider = PrimitiveDefaultsModelProvider
+                modelProviderForRecursiveCalls = PrimitiveDefaultsModelProvider
             }, parameters = listOf(FieldSetterClass::class.java.id))
             assertEquals(1, result.size)
             assertEquals(2, result[0]!!.size)
@@ -508,7 +508,7 @@ class ModelProviderTest {
 
         withUtContext(UtContext(this::class.java.classLoader)) {
             val result = collect(ObjectModelProvider(ReferencePreservingIntIdGenerator(0)).apply {
-                modelProvider = PrimitiveDefaultsModelProvider
+                modelProviderForRecursiveCalls = PrimitiveDefaultsModelProvider
             }, parameters = listOf(PackagePrivateFieldAndClass::class.java.id)) {
                 packageName = PackagePrivateFieldAndClass::class.java.`package`.name
             }
