Use mutating methods that affect the same fields as MUT

Author: sofurihafe

utbot-framework-test/src/test/kotlin/org/utbot/framework/modificators/UtBotFieldModificatorsTest.kt

@@ -24,9 +24,10 @@ import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
-import org.utbot.common.nameOfPackage
 import org.utbot.framework.plugin.services.JdkInfoDefaultProvider
 import org.utbot.framework.util.SootUtils
+import soot.jimple.internal.JAssignStmt
+import soot.jimple.internal.JInstanceFieldRef
 
 internal class UtBotFieldModificatorsTest {
     private lateinit var fieldsModificatorsSearcher: UtBotFieldsModificatorsSearcher
@@ -176,7 +177,9 @@ internal class UtBotFieldModificatorsTest {
             forceReload = false,
             jdkInfo = JdkInfoDefaultProvider().info
         )
-        fieldsModificatorsSearcher = UtBotFieldsModificatorsSearcher()
+        fieldsModificatorsSearcher = UtBotFieldsModificatorsSearcher(
+            modificationsPredicate = { (it as JAssignStmt).leftOp as? JInstanceFieldRef }
+        )
     }
 
     private fun runUpdate(classes: Set<KClass<*>>) {

utbot-framework/src/main/kotlin/org/utbot/framework/assemble/AssembleModelGenerator.kt

@@ -48,6 +48,8 @@ import org.utbot.framework.plugin.api.util.jClass
 import org.utbot.framework.util.nextModelName
 import java.lang.reflect.Constructor
 import java.util.IdentityHashMap
+import soot.jimple.internal.JAssignStmt
+import soot.jimple.internal.JInstanceFieldRef
 
 /**
  * Creates [UtAssembleModel] from any [UtModel] or it's inner models if possible
@@ -72,7 +74,10 @@ class AssembleModelGenerator(private val basePackageName: String) {
     //Call chain of statements to create assemble model
     private var callChain = mutableListOf<UtStatementModel>()
 
-    private val modificatorsSearcher = UtBotFieldsModificatorsSearcher()
+    private val modificatorsSearcher =
+        UtBotFieldsModificatorsSearcher(
+            modificationsPredicate = { (it as JAssignStmt).leftOp as? JInstanceFieldRef }
+        )
     private val constructorAnalyzer = ConstructorAnalyzer()
 
     /**

utbot-framework/src/main/kotlin/org/utbot/framework/context/spring/SpringIntegrationTestConcreteExecutionContext.kt

@@ -40,6 +40,8 @@ import org.utbot.instrumentation.instrumentation.execution.UtExecutionInstrument
 import org.utbot.instrumentation.instrumentation.spring.SpringUtExecutionInstrumentation
 import org.utbot.instrumentation.tryLoadingSpringContext
 import java.io.File
+import org.utbot.fuzzing.providers.ObjectValueProvider
+import org.utbot.fuzzing.providers.anyObjectValueProvider
 
 class SpringIntegrationTestConcreteExecutionContext(
     private val delegateContext: ConcreteExecutionContext,
@@ -107,6 +109,8 @@ class SpringIntegrationTestConcreteExecutionContext(
             .withFallback(NotEmptyStringValueProvider())
             .withFallback(
                 delegateContext.tryCreateValueProvider(concreteExecutor, classUnderTest, idGenerator)
+                    .except { p -> p is ObjectValueProvider }
+                    .with(anyObjectValueProvider(idGenerator, shouldMutateWithMethods = true))
                     .with(ValidEntityValueProvider(idGenerator, onlyAcceptWhenValidIsRequired = false))
                     .with(createGeneratedFieldValueProviders(relevantRepositories, idGenerator))
                     .withFallback(AnyDepthNullValueProvider)

utbot-java-fuzzing/src/main/kotlin/org/utbot/fuzzing/JavaLanguage.kt

@@ -42,7 +42,7 @@ fun defaultValueProviders(idGenerator: IdentityPreservingIdGenerator<Int>) = lis
     FloatValueProvider,
     StringValueProvider,
     NumberValueProvider,
-    anyObjectValueProvider(idGenerator),
+    anyObjectValueProvider(idGenerator, shouldMutateWithMethods = false),
     ArrayValueProvider(idGenerator),
     EnumValueProvider(idGenerator),
     ListSetValueProvider(idGenerator),

utbot-java-fuzzing/src/main/kotlin/org/utbot/fuzzing/providers/Objects.kt

@@ -16,6 +16,8 @@ import java.lang.reflect.Modifier
 import java.lang.reflect.TypeVariable
 import org.utbot.modifications.AnalysisMode
 import org.utbot.modifications.UtBotFieldsModificatorsSearcher
+import soot.jimple.internal.JAssignStmt
+import soot.jimple.internal.JInstanceFieldRef
 
 private val logger = KotlinLogging.logger {}
 
@@ -264,11 +266,12 @@ internal fun findAccessibleModifiableFields(description: FuzzedDescription?, cla
 }
 
 internal fun findAllAvailableMethods(
-    description: FuzzedDescription?,
+    description: FuzzedDescription,
     classId: ClassId,
     packageName: String?
 ): List<MethodDescription> {
-    val modifyingMethods = findModifyingMethodNames(classId)
+    val methodUnderTestName = description.description.name.substringAfter(description.description.className + ".")
+    val modifyingMethods = findModifyingMethodNames(methodUnderTestName, classId)
     return classId.jClass.declaredMethods.mapNotNull { method ->
         if (isAccessible(method, packageName)) {
             if (method.name !in modifyingMethods) return@mapNotNull null
@@ -278,12 +281,7 @@ internal fun findAllAvailableMethods(
                 method
                     .parameterTypes
                     .map {
-                        if (description != null) {
-                            toFuzzerType(
-                                it,
-                                description.typeCache
-                            )
-                        } else FuzzedType(it.id)
+                        toFuzzerType(it, description.typeCache)
                     }
 
             MethodDescription(
@@ -327,13 +325,22 @@ internal fun isAccessible(clazz: Class<*>, packageName: String?): Boolean {
             (packageName != null && isNotPrivateOrProtected(clazz.modifiers) && clazz.`package`?.name == packageName)
 }
 
-private fun findModifyingMethodNames(classId: ClassId) =
-    UtBotFieldsModificatorsSearcher()
+private fun findModifyingMethodNames(methodUnderTestName: String, classId: ClassId) =
+    UtBotFieldsModificatorsSearcher(
+        modificationsPredicate = { (it as JAssignStmt).leftOp as? JInstanceFieldRef ?: it.rightOp as? JInstanceFieldRef }
+    )
         .let { searcher ->
             searcher.update(setOf(classId))
-            searcher.getModificatorToFields(AnalysisMode.Methods)
-                .keys
-                .mapTo(mutableSetOf()) { it.name }
+            val modificatorsToFields = searcher.getModificatorToFields(AnalysisMode.Methods)
+
+            modificatorsToFields[methodUnderTestName]
+                ?.let { fieldsModifiedByMUT ->
+                    modificatorsToFields.mapNotNull {
+                        if (it.key == methodUnderTestName || it.value.intersect(fieldsModifiedByMUT).isEmpty()) null
+                        else it.key
+                    }
+                }
+                ?: setOf()
         }
 
 private fun isNotPrivateOrProtected(modifiers: Int): Boolean {

utbot-java-fuzzing/src/main/kotlin/org/utbot/fuzzing/spring/SpringBeanValueProvider.kt

@@ -12,13 +12,11 @@ import org.utbot.fuzzer.FuzzedValue
 import org.utbot.fuzzer.IdGenerator
 import org.utbot.fuzzer.fuzzed
 import org.utbot.fuzzing.*
-import org.utbot.fuzzing.providers.MethodDescription
 import org.utbot.fuzzing.providers.SPRING_BEAN_PROP
 import org.utbot.fuzzing.providers.findAllAvailableMethods
 import org.utbot.fuzzing.providers.nullRoutine
 import org.utbot.fuzzing.spring.valid.EntityLifecycleState
 import org.utbot.fuzzing.spring.valid.EntityLifecycleStateProperty
-import org.utbot.fuzzing.providers.removeSetters
 
 class SpringBeanValueProvider(
     private val idGenerator: IdGenerator<Int>,

utbot-modificators-analyzer/src/main/kotlin/org/utbot/modifications/ExecutablesAnalyzer.kt

@@ -56,15 +56,17 @@ class ExecutablesAnalyzer {
     /**
      * Finds fields modified in Jimple code of this method.
      */
-    fun findModificationsInJimple(executableId: ExecutableId): Set<FieldId> {
+    fun findModificationsInJimple(
+        executableId: ExecutableId,
+        predicate: (Any) -> Any?
+    ): Set<FieldId> {
         val sootMethod = executablesCache[executableId] ?: error("No method ${executableId.name} in soot cache")
 
         val jimpleBody = retrieveJimpleBody(sootMethod) ?: return emptySet()
         return jimpleBody.units
             .filterIsInstance<JAssignStmt>()
-            .mapNotNull { it.leftOp as? JInstanceFieldRef }
-            .map { it.field.fieldId }
-            .toSet()
+            .mapNotNull { predicate(it) as? JInstanceFieldRef }
+            .mapTo(mutableSetOf()) { it.field.fieldId }
     }
 
     /**

utbot-modificators-analyzer/src/main/kotlin/org/utbot/modifications/StatementsStorage.kt

@@ -19,7 +19,9 @@ import org.utbot.framework.plugin.api.StatementId
  * - cleanup all statements of deleted or modified classes
  * - build invocation graph (with nested calls) and find field modificators on request
  */
-class StatementsStorage {
+class StatementsStorage(
+    private val modificationsPredicate: (Any) -> Any?
+) {
     /** Statements with their detailed information */
     val items: MutableMap<StatementId, StatementInfo> = mutableMapOf()
 
@@ -43,7 +45,7 @@ class StatementsStorage {
             items[executableId] = StatementInfo(
                 isRoot = true,
                 executablesAnalyzer.findDeclaringClass(executableId),
-                executablesAnalyzer.findModificationsInJimple(executableId),
+                executablesAnalyzer.findModificationsInJimple(executableId, modificationsPredicate),
                 executablesAnalyzer.findInvocationsInJimple(executableId),
                 storageDataVersion,
             )
@@ -155,7 +157,7 @@ class StatementsStorage {
 
             val executableId = statementId as? ExecutableId ?: return
 
-            val modifications = executablesAnalyzer.findModificationsInJimple(executableId)
+            val modifications = executablesAnalyzer.findModificationsInJimple(executableId, modificationsPredicate)
             val successors = executablesAnalyzer.findInvocationsInJimple(executableId)
 
             for (successor in successors) {

utbot-modificators-analyzer/src/main/kotlin/org/utbot/modifications/UtBotFieldsModificatorsSearcher.kt

@@ -4,9 +4,11 @@ import org.utbot.framework.plugin.api.ClassId
 import org.utbot.framework.plugin.api.FieldId
 import org.utbot.framework.plugin.api.StatementId
 
-class UtBotFieldsModificatorsSearcher {
+class UtBotFieldsModificatorsSearcher(
+    modificationsPredicate: (Any) -> Any?
+) {
 
-    private var statementsStorage = StatementsStorage()
+    private var statementsStorage = StatementsStorage(modificationsPredicate)
 
     fun update(classIds: Set<ClassId>) = statementsStorage.update(classIds)
 
@@ -22,7 +24,7 @@ class UtBotFieldsModificatorsSearcher {
         return findModificatorsInCacheInverted(analysisMode)
     }
 
-    fun getModificatorToFields(analysisMode: AnalysisMode): Map<StatementId, Set<FieldId>> {
+    fun getModificatorToFields(analysisMode: AnalysisMode): Map<String, Set<FieldId>> {
         statementsStorage.updateCaches()
         return findModificatorsInCache(analysisMode)
     }
@@ -47,7 +49,7 @@ class UtBotFieldsModificatorsSearcher {
         return modifications
     }
 
-    private fun findModificatorsInCache(analysisMode: AnalysisMode): Map<StatementId, Set<FieldId>> =
+    private fun findModificatorsInCache(analysisMode: AnalysisMode): Map<String, Set<FieldId>> =
         statementsStorage
             .items
             .mapNotNull {
@@ -56,7 +58,7 @@ class UtBotFieldsModificatorsSearcher {
                 statementsStorage.find(it.key, analysisMode)
                     .let { modifiedFields ->
                         if (modifiedFields.isEmpty()) return@mapNotNull null
-                        else it.key to modifiedFields
+                        else it.key.name to modifiedFields
                     }
             }.toMap()
 }