Enhance fuzzing for arrays #738 (#755)

Author: volivan239

utbot-framework/src/main/kotlin/org/utbot/engine/UtBotSymbolicEngine.kt

@@ -439,7 +439,7 @@ class UtBotSymbolicEngine(
  packageName = executableId.classId.packageName
  }
  fuzz(thisMethodDescription, ObjectModelProvider(defaultIdGenerator).apply {
- limitValuesCreatedByFieldAccessors = 500
+ totalLimit = 500
  })
  }.withMutations(
  TrieBasedFuzzerStatistics(coveredInstructionValues), methodUnderTestDescription, *defaultModelMutators().toTypedArray()

utbot-fuzzers/src/main/kotlin/org/utbot/fuzzer/Fuzzer.kt

@@ -164,22 +164,28 @@ fun defaultModelProviders(idGenerator: IdentityPreservingIdGenerator<Int>): Mode
 }
 
 /**
- * Creates a model provider for [ObjectModelProvider] that generates values for object constructor.
+ * Creates a model provider from a list of providers that we want to use by default in [RecursiveModelProvider]
  */
-fun objectModelProviders(idGenerator: IdentityPreservingIdGenerator<Int>): ModelProvider {
- return ModelProvider.of(
+internal fun modelProviderForRecursiveCalls(idGenerator: IdentityPreservingIdGenerator<Int>, recursionDepth: Int): ModelProvider {
+ val nonRecursiveProviders = ModelProvider.of(
  CollectionModelProvider(idGenerator),
- ArrayModelProvider(idGenerator),
  EnumModelProvider(idGenerator),
  StringConstantModelProvider,
- RegexModelProvider,
  CharToStringModelProvider,
  ConstantsModelProvider,
  PrimitiveDefaultsModelProvider,
  PrimitiveWrapperModelProvider,
  )
+
+ return if (recursionDepth >= 0)
+ nonRecursiveProviders
+ .with(ObjectModelProvider(idGenerator, recursionDepth))
+ .with(ArrayModelProvider(idGenerator, recursionDepth))
+ else
+ nonRecursiveProviders
 }
 
+
 fun defaultModelMutators(): List<ModelMutator> = listOf(
  StringRandomMutator,
  RegexStringModelMutator,

utbot-fuzzers/src/main/kotlin/org/utbot/fuzzer/ModelProvider.kt

@@ -41,6 +41,17 @@ fun interface ModelProvider {
  }
  }
 
+ /**
+ * Applies [transform] for current provider
+ */
+ fun map(transform: (ModelProvider) -> ModelProvider): ModelProvider {
+ return if (this is Combined) {
+ Combined(providers.map(transform))
+ } else {
+ transform(this)
+ }
+ }
+
  /**
  * Creates [ModelProvider] that passes unprocessed classes to `modelProvider`.
  *
@@ -123,7 +134,19 @@ fun interface ModelProvider {
  /**
  * Wrapper class that delegates implementation to the [providers].
  */
- private class Combined(val providers: List<ModelProvider>): ModelProvider {
+ private class Combined(providers: List<ModelProvider>): ModelProvider {
+ val providers: List<ModelProvider>
+
+ init {
+ // Flattening to avoid Combined inside Combined (for correct work of except, map, etc.)
+ this.providers = providers.flatMap {
+ if (it is Combined)
+ it.providers
+ else
+ listOf(it)
+ }
+ }
+
  override fun generate(description: FuzzedMethodDescription): Sequence<FuzzedParameter> = sequence {
  providers.forEach { provider ->
  provider.generate(description).forEach {

utbot-fuzzers/src/main/kotlin/org/utbot/fuzzer/providers/ArrayModelProvider.kt

@@ -1,34 +1,65 @@
 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.fuzzer.FuzzedMethodDescription
-import org.utbot.fuzzer.FuzzedParameter
-import org.utbot.fuzzer.IdGenerator
-import org.utbot.fuzzer.ModelProvider
-import org.utbot.fuzzer.ModelProvider.Companion.yieldAllValues
-import java.util.function.IntSupplier
+import org.utbot.fuzzer.IdentityPreservingIdGenerator
 
 class ArrayModelProvider(
- private val idGenerator: IdGenerator<Int>
-) : ModelProvider {
- override fun generate(description: FuzzedMethodDescription): Sequence<FuzzedParameter> = sequence {
- description.parametersMap
- .asSequence()
- .filter { (classId, _) -> classId.isArray }
- .forEach { (arrayClassId, indices) ->
- yieldAllValues(indices, listOf(0, 10).map { arraySize ->
- UtArrayModel(
- id = idGenerator.createId(),
- arrayClassId,
- length = arraySize,
- arrayClassId.elementClassId!!.defaultValueModel(),
- mutableMapOf()
- ).fuzzed {
- this.summary = "%var% = ${arrayClassId.elementClassId!!.simpleName}[$arraySize]"
- }
- })
+ idGenerator: IdentityPreservingIdGenerator<Int>,
+ recursionDepthLeft: Int = 1
+) : RecursiveModelProvider(idGenerator, recursionDepthLeft) {
+ override fun createNewInstance(parentProvider: RecursiveModelProvider, newTotalLimit: Int): RecursiveModelProvider =
+ ArrayModelProvider(parentProvider.idGenerator, parentProvider.recursionDepthLeft - 1)
+ .copySettingsFrom(parentProvider)
+ .apply {
+ totalLimit = newTotalLimit
+ if (parentProvider is ArrayModelProvider)
+ branchingLimit = 1 // This improves performance but also forbids generating "jagged" arrays
  }
+
+ override fun generateModelConstructors(
+ description: FuzzedMethodDescription,
+ classId: ClassId
+ ): List<ModelConstructor> {
+ if (!classId.isArray)
+ return listOf()
+ val lengths = generateArrayLengths(description)
+ return lengths.map { length ->
+ ModelConstructor(List(length) { classId.elementClassId!! }) { values ->
+ createFuzzedArrayModel(classId, length, values.map { it.model } )
+ }
+ }
+ }
+
+ private fun generateArrayLengths(description: FuzzedMethodDescription): List<Int> {
+ val fuzzedLengths = fuzzValuesRecursively(
+ types = listOf(intClassId),
+ baseMethodDescription = description,
+ modelProvider = ConstantsModelProvider
+ )
+
+ // Firstly we will use most "interesting" default sizes, then we will use small sizes obtained from src
+ return listOf(3, 0) + fuzzedLengths
+ .map { (it.single().model as UtPrimitiveModel).value as Int }
+ .filter { it in 1..10 && it != 3 }
+ .toSortedSet()
+ .toList()
  }
+
+ 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]"
+ }
 }