maps

UnitTestBot · AbdullinAM · Jun 20, 2022 · Jun 20, 2022 · Jun 22, 2022 · Jun 28, 2022
commit 1dd4b25234138be7e73260965dd6a8f807275424
diff --git a/utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/Api.kt b/utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/Api.kt
@@ -511,6 +511,14 @@ data class UtSetConstraintModel(
     override val utConstraints: Set<UtConstraint> = emptySet()
 ) : UtElementContainerConstraintModel(variable, length, elements, utConstraints)
 
+data class UtMapConstraintModel(
+    override val variable: UtConstraintVariable,
+    override val length: UtModel,
+    override val elements: Map<UtModel, UtModel>,
+    override val utConstraints: Set<UtConstraint> = emptySet()
+) : UtElementContainerConstraintModel(variable, length, elements, utConstraints)
+
+
 /**
  * Model for complex objects with assemble instructions.
  *

diff --git a/utbot-framework/src/main/kotlin/org/utbot/engine/constraints/ConstraintResolver.kt b/utbot-framework/src/main/kotlin/org/utbot/engine/constraints/ConstraintResolver.kt
@@ -294,6 +294,7 @@ class ConstraintResolver(
     ): UtModel = when (concrete.value) {
         is ListWrapper -> buildListModel(concrete.value, variable, atoms, aliases)
         is SetWrapper -> buildSetModel(concrete.value, variable, atoms, aliases)
+        is MapWrapper -> buildMapModel(concrete.value, variable, atoms, aliases)
         else -> buildObjectModel(variable, atoms, aliases)
     }
 
@@ -371,6 +372,61 @@ class ConstraintResolver(
         )
     }
 
+    private fun buildMapModel(
+        concrete: MapWrapper,
+        variable: UtConstraintVariable,
+        atoms: Set<UtConstraint>,
+        aliases: Set<UtConstraintVariable>
+    ): UtModel {
+        val allAliases = aliases + variable
+        val refConstraints = atoms.filter { constraint ->
+            allAliases.any { it in constraint }
+        }.toSet()
+
+        val default = { buildObjectModel(variable, atoms, aliases) }
+        val keysField = atoms
+            .flatten { it is UtConstraintFieldAccess && it.instance == variable && it.fieldId.name == "keys" }
+            .firstOrNull() as? UtConstraintFieldAccess ?: return default()
+        val keysStorageArray = atoms
+            .flatten { it is UtConstraintFieldAccess && it.instance == keysField && it.fieldId.name == "storage" }
+            .firstOrNull() as? UtConstraintFieldAccess ?: return default()
+        val keysAliasArrays = aliases.map {
+            UtConstraintFieldAccess(UtConstraintFieldAccess(it, keysField.fieldId), keysStorageArray.fieldId)
+        }.toSet()
+        val keys = buildArrayModel(keysStorageArray, atoms, keysAliasArrays) as UtArrayConstraintModel
+        val concreteKeys = keys.elements.toList().associate { (index, value) ->
+            (index as UtPrimitiveConstraintModel).concrete as Int to ((index as UtModel) to value)
+        }
+
+        val valuesField =
+            atoms.flatten { it is UtConstraintFieldAccess && it.instance == variable && it.fieldId.name == "values" }
+                .firstOrNull() as? UtConstraintFieldAccess ?: return default()
+        val valuesStorageArray = atoms
+            .flatten { it is UtConstraintFieldAccess && it.instance == valuesField && it.fieldId.name == "storage" }
+            .firstOrNull() as? UtConstraintFieldAccess ?: return default()
+        val valuesAliasArrays = aliases.map {
+            UtConstraintFieldAccess(UtConstraintFieldAccess(it, valuesField.fieldId), valuesStorageArray.fieldId)
+        }.toSet()
+        val values = buildArrayModel(valuesStorageArray, atoms, valuesAliasArrays) as UtArrayConstraintModel
+        val concreteValues = values.elements.toList().associate { (index, value) ->
+            (index as UtPrimitiveConstraintModel).concrete as Int to ((index as UtModel) to value)
+        }
+
+        val mapElements = concreteKeys.mapValues { (key, values) ->
+            values.second to concreteValues.getOrDefault(
+                key,
+                UtNullModel(objectClassId) to UtNullModel(objectClassId)
+            ).second
+        }.values.toMap()
+
+        return UtMapConstraintModel(
+            variable,
+            keys.length,
+            mapElements,
+            refConstraints
+        )
+    }
+
     private val UtExpression.variable get() = accept(variableContext)
     private val UtConstraintVariable.expr get() = variableContext[this]
 

diff --git a/utbot-framework/src/main/kotlin/org/utbot/engine/pc/constraint/UtConstraintBuilder.kt b/utbot-framework/src/main/kotlin/org/utbot/engine/pc/constraint/UtConstraintBuilder.kt
@@ -17,7 +17,9 @@ class NotSupportedByConstraintResolverException : Exception()
 
 class UtConstraintBuilder(
     val variableContext: UtVarContext
-) : UtDefaultExpressionVisitor<UtConstraint?>({ throw NotSupportedByConstraintResolverException() }) {
+) : UtDefaultExpressionVisitor<UtConstraint?>({
+    throw NotSupportedByConstraintResolverException()
+}) {
     val holder get() = variableContext.holder
 
     private fun shouldSkip(expr: UtExpression): Boolean {
@@ -63,33 +65,29 @@ class UtConstraintBuilder(
         UtBoolConstraint(expr.accept(variableContext))
     }!!
 
-    override fun visit(expr: NotBoolExpression): UtConstraint = applyConstraint(expr) {
-        UtBoolConstraint(
-            UtConstraintNot(expr.expr.accept(variableContext))
-        )
-    }!!
+    override fun visit(expr: NotBoolExpression): UtConstraint? = applyConstraint(expr) {
+        expr.expr.accept(this)?.let {
+            UtNegatedConstraint(it)
+        }
+    }
 
-    override fun visit(expr: UtOrBoolExpression): UtConstraint = applyConstraint(expr) {
-        val vars = expr.exprs.map { it.accept(variableContext) }
-        UtBoolConstraint(
-            when {
-                vars.isEmpty() -> UtConstraintBoolConstant(true)
-                vars.size == 1 -> vars.first()
-                else -> vars.reduce { acc, variable -> UtConstraintOr(acc, variable) }
-            }
-        )
-    }!!
+    override fun visit(expr: UtOrBoolExpression): UtConstraint? = applyConstraint(expr) {
+        val vars = expr.exprs.mapNotNull { it.accept(this) }
+        when {
+            vars.isEmpty() -> null
+            vars.size == 1 -> vars.first()
+            else -> vars.reduce { acc, variable -> UtOrConstraint(acc, variable) }
+        }
+    }
 
-    override fun visit(expr: UtAndBoolExpression): UtConstraint = applyConstraint(expr) {
-        val vars = expr.exprs.map { it.accept(variableContext) }
-        UtBoolConstraint(
-            when {
-                vars.isEmpty() -> UtConstraintBoolConstant(true)
-                vars.size == 1 -> vars.first()
-                else -> vars.reduce { acc, variable -> UtConstraintAnd(acc, variable) }
-            }
-        )
-    }!!
+    override fun visit(expr: UtAndBoolExpression): UtConstraint? = applyConstraint(expr) {
+        val vars = expr.exprs.mapNotNull { it.accept(this) }
+        when {
+            vars.isEmpty() -> null
+            vars.size == 1 -> vars.first()
+            else -> vars.reduce { acc, variable -> UtAndConstraint(acc, variable) }
+        }
+    }
 
     override fun visit(expr: UtBoolOpExpression): UtConstraint? = applyConstraint(expr) {
         if (shouldSkip(expr)) return@applyConstraint null
@@ -146,13 +144,14 @@ class UtConstraintBuilder(
         throw NotSupportedByConstraintResolverException()
     }
 
-    override fun visit(expr: UtIsGenericTypeExpression): UtConstraint = applyConstraint(expr) {
+    override fun visit(expr: UtIsGenericTypeExpression): UtConstraint? = applyConstraint(expr) {
+        if (shouldSkip(expr)) return@applyConstraint null
         UtRefGenericTypeConstraint(
             expr.addr.accept(variableContext),
             expr.baseAddr.accept(variableContext),
             expr.parameterTypeIndex
         )
-    }!!
+    }
 
     override fun visit(expr: UtEqGenericTypeParametersExpression): UtConstraint? = applyConstraint(expr) {
         if (shouldSkip(expr)) return@applyConstraint null
@@ -175,4 +174,6 @@ class UtConstraintBuilder(
             else -> expr.elseExpr.accept(this)
         }
     }
+
+    override fun visit(expr: UtMkTermArrayExpression): UtConstraint? = null
 }
diff --git a/utbot-framework/src/main/kotlin/org/utbot/engine/pc/constraint/UtVarContext.kt b/utbot-framework/src/main/kotlin/org/utbot/engine/pc/constraint/UtVarContext.kt
@@ -18,7 +18,9 @@ class UtVarContext(
     val holder: UtSolverStatusSAT,
     val typeRegistry: TypeRegistry,
     val typeResolver: TypeResolver,
-) : UtDefaultExpressionVisitor<UtConstraintVariable>({ throw NotSupportedByConstraintResolverException() }) {
+) : UtDefaultExpressionVisitor<UtConstraintVariable>({
+    throw NotSupportedByConstraintResolverException()
+}) {
     private val internalAddrs = mutableMapOf<Address, UtConstraintVariable>()
     private val var2Expression = mutableMapOf<UtConstraintVariable, UtExpression>()
 

diff --git a/utbot-framework/src/main/kotlin/org/utbot/framework/synthesis/Resolver.kt b/utbot-framework/src/main/kotlin/org/utbot/framework/synthesis/Resolver.kt
@@ -25,6 +25,7 @@ class Resolver(
             is ArrayUnit -> unitToModel.getOrPut(unit) { resolveArray(unit) }
             is ListUnit -> unitToModel.getOrPut(unit) { resolveList(unit) }
             is SetUnit -> unitToModel.getOrPut(unit) { resolveSet(unit) }
+            is MapUnit -> unitToModel.getOrPut(unit) { resolveMap(unit) }
         }
 
     private fun resolveMethodUnit(unit: MethodUnit): UtModel =
@@ -115,6 +116,37 @@ class Resolver(
 
     private fun resolveSet(unit: SetUnit): UtModel = resolveCollection(unit, unit.constructorId, unit.addId)
 
+    private fun resolveMap(unit: MapUnit): UtModel {
+        val elements = unit.elements.map {
+            resolve(synthesisUnitContext[it.first]) to resolve(synthesisUnitContext[it.second])
+        }
+
+        val instantiationChain = mutableListOf<UtStatementModel>()
+        val modificationChain = mutableListOf<UtStatementModel>()
+
+        val model = UtAssembleModel(
+            nextDefaultModelId++,
+            unit.classId,
+            nextModelName("refModel_${unit.classId.simpleName}"),
+            instantiationChain,
+            modificationChain
+        )
+
+        instantiationChain.add(
+            UtExecutableCallModel(model, unit.constructorId, listOf(), model)
+        )
+
+        for ((key, value) in elements) {
+            modificationChain.add(
+                UtExecutableCallModel(
+                    model, unit.putId, listOf(key, value),
+                )
+            )
+        }
+
+        return model
+    }
+
     private fun resolveArray(unit: ArrayUnit): UtModel {
         val lengthModel = resolve(synthesisUnitContext[unit.length]) as UtPrimitiveModel
         val elements = unit.elements.associate {

diff --git a/utbot-framework/src/main/kotlin/org/utbot/framework/synthesis/StateProducer.kt b/utbot-framework/src/main/kotlin/org/utbot/framework/synthesis/StateProducer.kt
@@ -2,6 +2,7 @@ package org.utbot.framework.synthesis
 
 import org.utbot.framework.modifications.StatementsStorage
 import org.utbot.framework.plugin.api.ClassId
+import org.utbot.framework.plugin.api.ConstructorId
 import org.utbot.framework.plugin.api.ExecutableId
 import org.utbot.framework.plugin.api.MethodId
 
@@ -15,7 +16,7 @@ class CompositeUnitExpander(
         if (objectUnit.classId !in statementsStorage.items.keys.map { it.classId }.toSet()) {
             statementsStorage.update(setOf(objectUnit.classId).expandable())
         }
-        val mutators = findMutators(objectUnit.classId)
+        val mutators = findAllMutators(objectUnit.classId)
 
         val expanded = mutators.map { method ->
             MethodUnit(
@@ -27,13 +28,22 @@ class CompositeUnitExpander(
         return expanded
     }
 
+    private fun findAllMutators(classId: ClassId) = findConstructors(classId) + findMutators(classId)
+
+    private fun findConstructors(classId: ClassId): List<ExecutableId> =
+        statementsStorage.items
+            .filter { (method, _) -> method.classId == classId }
+            .keys
+            .filterIsInstance<ConstructorId>()
+            .toList()
 
     private fun findMutators(classId: ClassId): List<ExecutableId> =
         statementsStorage.items
             .filter { (method, info) ->
                 val sameClass = method.classId == classId
-                val modifiesSomething = true//info.modifiedFields.any { it.declaringClass == classId }
-                sameClass && modifiesSomething
+                val modifiesSomething = info.modifiedFields.any { it.declaringClass == classId }
+                val isStaticInit = method.name == "<clinit>"
+                sameClass && modifiesSomething && !isStaticInit
             }
             .keys
             .filterIsInstance<ExecutableId>()

diff --git a/utbot-framework/src/main/kotlin/org/utbot/framework/synthesis/SynthesisMethodContext.kt b/utbot-framework/src/main/kotlin/org/utbot/framework/synthesis/SynthesisMethodContext.kt
@@ -142,6 +142,7 @@ class SynthesisMethodContext(
 
         is ListUnit -> synthesizeConstructorInvoke(unit.constructorId, listOf())
         is SetUnit -> synthesizeConstructorInvoke(unit.constructorId, listOf())
+        is MapUnit -> synthesizeConstructorInvoke(unit.constructorId, listOf())
     }
 
     private fun synthesizeSetExpr(
@@ -158,6 +159,8 @@ class SynthesisMethodContext(
         is ListUnit -> synthesizeVirtualInvoke(unit.addId, listOf(unitLocal, value))
 
         is SetUnit -> synthesizeVirtualInvoke(unit.addId, listOf(unitLocal, value))
+
+        is MapUnit -> synthesizeVirtualInvoke(unit.putId, listOf(unitLocal, key, value))
     }
 
     private fun synthesizeVirtualInvoke(method: MethodId, parameterLocals: List<JimpleLocal>): JimpleLocal {

diff --git a/utbot-framework/src/main/kotlin/org/utbot/framework/synthesis/SynthesisUnit.kt b/utbot-framework/src/main/kotlin/org/utbot/framework/synthesis/SynthesisUnit.kt
@@ -52,6 +52,17 @@ data class SetUnit(
     }
 }
 
+data class MapUnit(
+    override val classId: ClassId,
+    override val elements: List<Pair<UtModel, UtModel>>,
+    override val length: UtModel
+) : ElementContainingUnit(classId, elements, length) {
+    val constructorId get() = classId.allConstructors.first { it.parameters.isEmpty() }
+    val putId get() = classId.allMethods.first {
+        it.name == "put" && it.parameters == listOf(objectClassId, objectClassId)
+    }
+}
+
 data class NullUnit(
     override val classId: ClassId
 ) : SynthesisUnit()

diff --git a/utbot-framework/src/main/kotlin/org/utbot/framework/synthesis/Synthesizer.kt b/utbot-framework/src/main/kotlin/org/utbot/framework/synthesis/Synthesizer.kt
@@ -102,6 +102,12 @@ class SynthesisUnitContext(
                     this.length
                 )
 
+                is UtMapConstraintModel -> MapUnit(
+                    this.classId,
+                    this.elements.toList(),
+                    this.length
+                )
+
                 is UtReferenceToConstraintModel -> ReferenceToUnit(this.classId, this.reference)
                 else -> error("Only UtSynthesisModel supported")
             }
@@ -192,19 +198,26 @@ class SynthesisUnitContextQueue(
 
                 while (true) {
                     model as UtElementContainerConstraintModel
-                    val current = currentContext[model] as ElementContainingUnit
-                    val elements = current.elements
-                    if (index >= elements.size) break
-
-                    val currentModel = model.elements[unit.elements[index].first]!!
-                    val newLeafs = produce(context, currentModel)
-                    if (newLeafs.isEmpty()) {
-                        for (i in 0..index) {
-                            currentContext = currentContext.set(currentModel, currentContext[currentModel])
+                    if (index >= unit.elements.size) break
+
+                    val currentKeyModel = unit.elements[index].first
+                    val currentValueModel = unit.elements[index].second
+
+                    val newKeyLeafs = produce(context, currentKeyModel)
+                    if (newKeyLeafs.isEmpty()) {
+                        val newValueLeafs = produce(context, currentValueModel)
+                        if (newValueLeafs.isEmpty()) {
+                            for (i in 0..index) {
+                                currentContext = currentContext.set(currentKeyModel, currentContext[currentValueModel])
+                                currentContext = currentContext.set(currentValueModel, currentContext[currentValueModel])
+                            }
+                            index++
+                        } else {
+                            result = newValueLeafs
+                            break
                         }
-                        index++
                     } else {
-                        result = newLeafs
+                        result = newKeyLeafs
                         break
                     }
                 }