Improve UTestValueDescriptor to UtModel conversion and state change asserts generation

utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/mapper/UtModelDeepMapper.kt

@@ -12,6 +12,7 @@ import org.utbot.framework.plugin.api.UtNullModel
 import org.utbot.framework.plugin.api.UtPrimitiveModel
 import org.utbot.framework.plugin.api.UtReferenceModel
 import org.utbot.framework.plugin.api.UtVoidModel
+import java.util.IdentityHashMap
 
 /**
  * Performs deep mapping of [UtModel]s.
@@ -30,7 +31,7 @@ class UtModelDeepMapper private constructor(
  * Values are models that have been deeply mapped by this [UtModelDeepMapper].
  * Models are only associated with models of the same type (i.e. the cache type is actually `MutableMap<T, T>`)
  */
- private val cache = mutableMapOf<UtModel, UtModel>()
+ private val cache = IdentityHashMap<UtModel, UtModel>()
 
  private val allInputtedModels get() = cache.keys
  private val allOutputtedModels get() = cache.values

utbot-framework/src/main/kotlin/org/utbot/framework/fields/ExecutionStateAnalyzer.kt

@@ -21,6 +21,8 @@ import org.utbot.framework.plugin.api.UtPrimitiveModel
 import org.utbot.framework.plugin.api.UtReferenceModel
 import org.utbot.framework.plugin.api.UtSymbolicExecution
 import org.utbot.framework.plugin.api.UtVoidModel
+import org.utbot.framework.plugin.api.util.id
+import org.utbot.framework.plugin.api.util.isSubtypeOf
 import org.utbot.framework.util.UtModelVisitor
 import org.utbot.framework.util.hasThisInstance
 import org.utbot.fuzzer.UtFuzzedExecution
@@ -104,31 +106,23 @@ class ExecutionStateAnalyzer(val execution: UtExecution) {
  initialPath: FieldPath = FieldPath()
  ): FieldStatesInfo {
  var modelBefore = before
+ var modelAfter = after
 
  if (before::class != after::class) {
- if (before is UtModelWithCompositeOrigin && after is UtModelWithCompositeOrigin && before.origin != null) {
- modelBefore = before.origin ?: unreachableBranch("We have already checked the origin for a null value")
- } else {
- doNotRun {
- // it is ok because we might have modelBefore with some absent fields (i.e. statics), but
- // modelAfter (constructed by concrete executor) will consist all these fields,
- // therefore, AssembleModelGenerator won't be able to transform the given composite model
-
- val reason = if (before is UtModelWithCompositeOrigin && after is UtCompositeModel) {
- "ModelBefore is an UtModelWithOrigin and ModelAfter " +
- "is a CompositeModel, but modelBefore doesn't have an origin model."
- } else {
- "The model before and the model after have different types: " +
- "model before is ${before::class}, but model after is ${after::class}."
- }
+ if (before is UtModelWithCompositeOrigin)
+ modelBefore = before.origin ?: before
+ if (after is UtModelWithCompositeOrigin)
+ modelAfter = after.origin ?: after
+ }
 
- error("Cannot analyze fields modification. $reason")
- }
+ if (modelBefore::class != modelAfter::class) {
+ doNotRun {
+ error("Cannot analyze model fields modification, before: [$before], after: [$after]")
+ }
 
- // remove it when we will fix assemble models in the resolver JIRA:1464
- workaround(WorkaroundReason.IGNORE_MODEL_TYPES_INEQUALITY) {
- return FieldStatesInfo(fieldsBefore = emptyMap(), fieldsAfter = emptyMap())
- }
+ // remove it when we will fix assemble models in the resolver JIRA:1464
+ workaround(WorkaroundReason.IGNORE_MODEL_TYPES_INEQUALITY) {
+ return FieldStatesInfo(fieldsBefore = emptyMap(), fieldsAfter = emptyMap())
  }
  }
 
@@ -139,7 +133,7 @@ class ExecutionStateAnalyzer(val execution: UtExecution) {
  modelBefore.accept(FieldStateVisitor(), dataBefore)
 
  val dataAfter = FieldData(FieldsVisitorMode.AFTER, fieldsAfter, initialPath, previousFields = fieldsBefore)
- after.accept(FieldStateVisitor(), dataAfter)
+ modelAfter.accept(FieldStateVisitor(), dataAfter)
 
  return FieldStatesInfo(fieldsBefore, fieldsAfter)
  }
@@ -260,6 +254,13 @@ private class FieldStateVisitor : UtModelVisitor<FieldData>() {
  // sometimes we don't have initial state of the field, e.g. if it is static and we didn't `touch` it
  // during the analysis, but the concrete executor included it in the modelAfter
  val initial = previousFields[path] ?: return false
+
+ // TODO usvm-sbft: In USVM descriptors for classes, enums, and throwables don't implement `UTestRefDescriptor`
+ // and don't have `refId`, which causes `UtReferenceModel.id` to diverge in `stateBefore` and `stateAfter`
+ if (initial is UtClassRefModel) return initial.value != ((model as? UtClassRefModel)?.value)
+ if (initial is UtEnumConstantModel) return initial.value != ((model as? UtEnumConstantModel)?.value)
+ if (initial.classId isSubtypeOf java.lang.Throwable::class.id) return initial.classId != model.classId
+
  return initial != model
  }
 }

utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/EnvironmentStateKind.kt

@@ -0,0 +1,5 @@
+package org.utbot.contest.usvm
+
+enum class EnvironmentStateKind {
+ INITIAL, FINAL
+}

utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt

@@ -25,6 +25,7 @@ import org.utbot.framework.plugin.api.Coverage
 import org.utbot.framework.plugin.api.EnvironmentModels
 import org.utbot.framework.plugin.api.ExecutableId
 import org.utbot.framework.plugin.api.Instruction
+import org.utbot.framework.plugin.api.UtArrayModel
 import org.utbot.framework.plugin.api.UtAssembleModel
 import org.utbot.framework.plugin.api.UtExecutableCallModel
 import org.utbot.framework.plugin.api.UtExecution
@@ -34,12 +35,14 @@ import org.utbot.framework.plugin.api.UtExplicitlyThrownException
 import org.utbot.framework.plugin.api.UtImplicitlyThrownException
 import org.utbot.framework.plugin.api.UtInstrumentation
 import org.utbot.framework.plugin.api.UtPrimitiveModel
+import org.utbot.framework.plugin.api.UtStatementCallModel
 import org.utbot.framework.plugin.api.UtVoidModel
 import org.utbot.framework.plugin.api.mapper.UtModelDeepMapper
 import org.utbot.framework.plugin.api.util.executableId
 import org.utbot.framework.plugin.api.util.jClass
 import org.utbot.framework.plugin.api.util.utContext
 import org.utbot.fuzzer.IdGenerator
+import java.util.IdentityHashMap
 
 private val logger = KotlinLogging.logger {}
 
@@ -68,17 +71,19 @@ class JcToUtExecutionConverter(
 
  val utUsvmExecution: UtUsvmExecution = when (val executionResult = jcExecution.uTestExecutionResult) {
  is UTestExecutionSuccessResult -> UtUsvmExecution(
- stateBefore = convertState(executionResult.initialState, jcExecution.method, jcToUtModelConverter),
- stateAfter = convertState(executionResult.resultState, jcExecution.method, jcToUtModelConverter),
+ stateBefore = convertState(executionResult.initialState, EnvironmentStateKind.INITIAL, jcExecution.method),
+ stateAfter = convertState(executionResult.resultState, EnvironmentStateKind.FINAL, jcExecution.method),
  // TODO usvm-sbft: ask why `UTestExecutionSuccessResult.result` is nullable
- result = UtExecutionSuccess(executionResult.result?.let { jcToUtModelConverter.convert(it) } ?: UtVoidModel),
+ result = UtExecutionSuccess(executionResult.result?.let {
+ jcToUtModelConverter.convert(it, EnvironmentStateKind.FINAL)
+ } ?: UtVoidModel),
  coverage = coverage,
  instrumentation = instrumentation,
  )
  is UTestExecutionExceptionResult -> {
  UtUsvmExecution(
- stateBefore = convertState(executionResult.initialState, jcExecution.method, jcToUtModelConverter),
- stateAfter = convertState(executionResult.resultState, jcExecution.method, jcToUtModelConverter),
+ stateBefore = convertState(executionResult.initialState, EnvironmentStateKind.INITIAL, jcExecution.method),
+ stateAfter = convertState(executionResult.resultState, EnvironmentStateKind.FINAL, jcExecution.method),
  result = createExecutionFailureResult(
  executionResult.cause,
  jcExecution.method,
@@ -108,7 +113,10 @@ class JcToUtExecutionConverter(
  }
  } ?: return null
 
- return utUsvmExecution.mapModels(constructAssemblingMapper())
+ return utUsvmExecution
+ .mapModels(constructAssemblingMapper())
+ .mapModels(constructAssembleToCompositeModelMapper())
+ .mapModels(constructConstArrayModelMapper())
  }
 
  private fun constructAssemblingMapper(): UtModelDeepMapper = UtModelDeepMapper { model ->
@@ -145,6 +153,31 @@ class JcToUtExecutionConverter(
  } ?: model
  }
 
+ private fun constructConstArrayModelMapper(): UtModelDeepMapper = UtModelDeepMapper { model ->
+ if (model is UtArrayModel) {
+ val storeGroups = model.stores.entries.groupByTo(IdentityHashMap()) { it.value }
+ val mostCommonStore = storeGroups.maxBy { it.value.size }
+ if (mostCommonStore.value.size > 1) {
+ model.constModel = mostCommonStore.key
+ mostCommonStore.value.forEach { (index, _) -> model.stores.remove(index) }
+ }
+ }
+ model
+ }
+
+ private fun constructAssembleToCompositeModelMapper(): UtModelDeepMapper = UtModelDeepMapper { model ->
+ if (model is UtAssembleModel
+ && utilMethodProvider.createInstanceMethodId == model.instantiationCall.statement
+ && model.modificationsChain.all {
+ utilMethodProvider.setFieldMethodId == (it as? UtStatementCallModel)?.statement
+ }
+ ) {
+ model.origin ?: model
+ } else {
+ model
+ }
+ }
+
  private fun convertException(exceptionDescriptor: UTestExceptionDescriptor): Throwable =
  toValueConverter.buildObjectFromDescriptor(exceptionDescriptor.dropStaticFields(
  cache = mutableMapOf()
@@ -160,18 +193,20 @@ class JcToUtExecutionConverter(
 
  private fun convertState(
  state: UTestExecutionState,
+ stateKind: EnvironmentStateKind,
  method: JcTypedMethod,
- modelConverter: JcToUtModelConverter,
- ): EnvironmentModels {
+ ): EnvironmentModels {
  val thisInstance =
  if (method.isStatic) null
  else if (method.method.isConstructor) null
- else modelConverter.convert(state.instanceDescriptor ?: error("Unexpected null instanceDescriptor"))
- val parameters = state.argsDescriptors.map { modelConverter.convert(it ?: error("Unexpected null argDescriptor")) }
+ else jcToUtModelConverter.convert(state.instanceDescriptor ?: error("Unexpected null instanceDescriptor"), stateKind)
+ val parameters = state.argsDescriptors.map {
+ jcToUtModelConverter.convert(it ?: error("Unexpected null argDescriptor"), stateKind)
+ }
  val statics = state.statics
  .entries
  .associate { (jcField, uTestDescr) ->
- jcField.fieldId to modelConverter.convert(uTestDescr)
+ jcField.fieldId to jcToUtModelConverter.convert(uTestDescr, stateKind)
  }
  val executableId: ExecutableId = method.method.toExecutableId(jcClasspath)
  return EnvironmentModels(thisInstance, parameters, statics, executableId)