Support Spring guided type replacements in symbolic engine (#1908)

Author: EgorkaKulikov

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

@@ -55,6 +55,9 @@ import java.io.File
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.contract
 import org.utbot.common.isAbstract
+import org.utbot.common.isStatic
+import org.utbot.framework.plugin.api.TypeReplacementMode.*
+import org.utbot.framework.plugin.api.util.isSubtypeOf
 import org.utbot.framework.plugin.api.util.utContext
 import org.utbot.framework.process.OpenModulesContainer
 
@@ -1149,13 +1152,36 @@ open class TypeParameters(val parameters: List<ClassId> = emptyList())
 
 class WildcardTypeParameter : TypeParameters(emptyList())
 
+/**
+ * Describes the way to replace abstract types with concrete implementors.
+ */
+enum class TypeReplacementMode {
+    /**
+     * Any possible implementor (that is preferred by solver) may be used.
+     */
+    AnyImplementor,
+
+    /**
+     * There is a known implementor to be used.
+     * For example, it is obtained from bean definitions in Spring application.
+     */
+    KnownImplementor,
+
+    /**
+     * Using implementors is not allowed.
+     * If mocking is allowed, mock of this type will be used.
+     * Otherwise, branch will be pruned as unsatisfiable.
+     */
+    NoImplementors,
+}
+
 /**
  * A context to use when no specific data is required.
  *
  * @param mockFrameworkInstalled shows if we have installed framework dependencies
  * @param staticsMockingIsConfigured shows if we have installed static mocking tools
  */
-open class StandardApplicationContext(
+open class ApplicationContext(
     val mockFrameworkInstalled: Boolean = true,
     staticsMockingIsConfigured: Boolean = true,
 ) {
@@ -1177,22 +1203,53 @@ open class StandardApplicationContext(
             this.staticsMockingIsConfigured = false
         }
     }
+
+    /**
+     * Shows if there are any restrictions on type implementors.
+     */
+    open val typeReplacementMode: TypeReplacementMode = AnyImplementor
+
+    /**
+     * Finds a type to replace the original abstract type
+     * if it is guided with some additional information.
+     */
+    open fun replaceTypeIfNeeded(type: RefType): ClassId? = null
 }
 
 /**
  * Data we get from Spring application context
  * to manage engine and code generator behaviour.
  *
- * @param beanQualifiedNames describes fqn of injected classes
+ * @param beanQualifiedNames describes fqn of types from bean definitions
+ * @param shouldUseImplementors describes it we want to replace interfaces with injected types or not
  */
 class SpringApplicationContext(
     mockInstalled: Boolean,
     staticsMockingIsConfigured: Boolean,
-    val beanQualifiedNames: List<String> = emptyList(),
-): StandardApplicationContext(mockInstalled, staticsMockingIsConfigured) {
+    private val beanQualifiedNames: List<String> = emptyList(),
+    private val shouldUseImplementors: Boolean,
+): ApplicationContext(mockInstalled, staticsMockingIsConfigured) {
+    
     private val springInjectedClasses: List<ClassId> by lazy {
-        beanQualifiedNames.map { fqn -> utContext.classLoader.loadClass(fqn).id }
+        beanQualifiedNames
+            .map { fqn -> utContext.classLoader.loadClass(fqn) }
+            .filterNot { it.isAbstract || it.isInterface || it.isLocalClass || it.isMemberClass && !it.isStatic }
+            .map { it.id }
     }
+
+    override val typeReplacementMode: TypeReplacementMode
+        get() = if (shouldUseImplementors) KnownImplementor else NoImplementors
+
+    /**
+     * Replaces an interface type with its implementor type
+     * if there is the unique implementor in bean definitions.
+     */
+    override fun replaceTypeIfNeeded(type: RefType): ClassId? =
+        if (type.sootClass.isInterface || type.sootClass.isAbstract) {
+            springInjectedClasses.singleOrNull { it.isSubtypeOf(type.id) }
+        } else {
+            null
+        }
 }
 
 interface CodeGenerationSettingItem {

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

@@ -19,7 +19,7 @@ import kotlinx.collections.immutable.persistentListOf
 import org.utbot.common.nameOfPackage
 import org.utbot.engine.types.OBJECT_TYPE
 import org.utbot.engine.util.mockListeners.MockListenerController
-import org.utbot.framework.plugin.api.StandardApplicationContext
+import org.utbot.framework.plugin.api.ApplicationContext
 import org.utbot.framework.plugin.api.util.isInaccessibleViaReflection
 import soot.BooleanType
 import soot.RefType
@@ -168,7 +168,7 @@ class Mocker(
     private val hierarchy: Hierarchy,
     chosenClassesToMockAlways: Set<ClassId>,
     internal val mockListenerController: MockListenerController? = null,
-    private val applicationContext: StandardApplicationContext,
+    private val applicationContext: ApplicationContext,
 ) {
     private val mocksAreDesired: Boolean = strategy != MockStrategy.NO_MOCKS
 

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

@@ -116,11 +116,14 @@ import org.utbot.framework.UtSettings
 import org.utbot.framework.UtSettings.maximizeCoverageUsingReflection
 import org.utbot.framework.UtSettings.preferredCexOption
 import org.utbot.framework.UtSettings.substituteStaticsWithSymbolicVariable
-import org.utbot.framework.plugin.api.StandardApplicationContext
+import org.utbot.framework.plugin.api.ApplicationContext
 import org.utbot.framework.plugin.api.ClassId
 import org.utbot.framework.plugin.api.ExecutableId
 import org.utbot.framework.plugin.api.FieldId
 import org.utbot.framework.plugin.api.MethodId
+import org.utbot.framework.plugin.api.TypeReplacementMode.AnyImplementor
+import org.utbot.framework.plugin.api.TypeReplacementMode.KnownImplementor
+import org.utbot.framework.plugin.api.TypeReplacementMode.NoImplementors
 import org.utbot.framework.plugin.api.classId
 import org.utbot.framework.plugin.api.id
 import org.utbot.framework.plugin.api.util.executable
@@ -239,7 +242,7 @@ class Traverser(
     internal val typeResolver: TypeResolver,
     private val globalGraph: InterProceduralUnitGraph,
     private val mocker: Mocker,
-    private val applicationContext: StandardApplicationContext?,
+    private val applicationContext: ApplicationContext,
 ) : UtContextInitializer() {
 
     private val visitedStmts: MutableSet<Stmt> = mutableSetOf()
@@ -1364,7 +1367,7 @@ class Traverser(
         traverseException(current, symException)
     }
 
-    // TODO HACK violation of encapsulation
+    // TODO: HACK violation of encapsulation
     fun createObject(
         addr: UtAddrExpression,
         type: RefType,
@@ -1373,6 +1376,27 @@ class Traverser(
     ): ObjectValue {
         touchAddress(addr)
 
+        // Some types (e.g., interfaces) need to be mocked or replaced with the concrete implementor.
+        // Typically, this implementor is selected by SMT solver later.
+        // However, if we have the restriction on implementor type (it may be obtained
+        // from Spring bean definitions, for example), we can just create a symbolic object
+        // with hard constraint on the mentioned type.
+        val replacedClassId = when (applicationContext.typeReplacementMode) {
+            KnownImplementor -> applicationContext.replaceTypeIfNeeded(type)
+            AnyImplementor,
+            NoImplementors -> null
+        }
+
+        replacedClassId?.let {
+            val sootType = Scene.v().getRefType(it.canonicalName)
+            val typeStorage = typeResolver.constructTypeStorage(sootType, useConcreteType = false)
+
+            val typeHardConstraint = typeRegistry.typeConstraint(addr, typeStorage).all().asHardConstraint()
+            queuedSymbolicStateUpdates += typeHardConstraint
+
+            return ObjectValue(typeStorage, addr)
+        }
+
         val nullEqualityConstraint = mkEq(addr, nullObjectAddr)
 
         if (mockInfoGenerator != null) {
@@ -1475,48 +1499,79 @@ class Traverser(
                         "but there is no mock info generator provided to construct a mock value."
             }
 
-            val mockInfo = mockInfoGenerator.generate(addr)
-            val mockedObjectInfo = mocker.forceMock(type, mockInfoGenerator.generate(addr))
-
-            val mockedObject: ObjectValue = when (mockedObjectInfo) {
-                is NoMock -> error("Value must be mocked after the force mock")
-                is ExpectedMock -> mockedObjectInfo.value
-                is UnexpectedMock -> {
-                    // if mock occurs, but it is unexpected due to some reasons
-                    // (e.g. we do not have mock framework installed),
-                    // we can only generate a test that uses null value for mocked object
-                    queuedSymbolicStateUpdates += nullEqualityConstraint.asHardConstraint()
-
-                    mockedObjectInfo.value
-                }
+            return createMockedObject(addr, type, mockInfoGenerator)
+        }
+
+        val concreteImplementation = when (applicationContext.typeReplacementMode) {
+            AnyImplementor -> {
+                val isMockConstraint = mkEq(typeRegistry.isMock(addr), UtFalse)
+
+                queuedSymbolicStateUpdates += typeHardConstraint
+                queuedSymbolicStateUpdates += mkOr(isMockConstraint, nullEqualityConstraint).asHardConstraint()
+
+                // If we have this$0 with UtArrayList type, we have to create such instance.
+                // We should create an object with typeStorage of all possible real types and concrete implementation
+                // Otherwise we'd have either a wrong type in the resolver, or missing method like 'preconditionCheck'.
+                wrapperToClass[type]?.first()?.let { wrapper(it, addr) }?.concrete
             }
+            // In case of `KnownImplementor` mode we should have already tried to replace type using `replaceTypeIfNeeded`.
+            // However, this replacement attempt might be unsuccessful even if some possible concrete types are present.
+            // For example, we may have two concrete implementors present in Spring bean definitions, so we do not know
+            // which one to use. In such case we try to mock this type, if it is possible, or prune branch as unsatisfiable.
+            //
+            // In case of `NoImplementors` mode we should try to mock this type or prune branch as unsatisfiable.
+            // Mocking can be impossible here as there are no guaranties that `mockInfoGenerator` is instantiated.
+            KnownImplementor,
+            NoImplementors -> {
+                mockInfoGenerator?.let {
+                    return createMockedObject(addr, type, it)
+                }
 
-            if (mockedObjectInfo is UnexpectedMock) {
-                return mockedObject
+                queuedSymbolicStateUpdates += mkFalse().asHardConstraint()
+                null
             }
+        }
 
-            queuedSymbolicStateUpdates += MemoryUpdate(mockInfos = persistentListOf(MockInfoEnriched(mockInfo)))
+        return ObjectValue(typeStorage, addr, concreteImplementation)
+    }
 
-            // add typeConstraint for mocked object. It's a declared type of the object.
-            val typeConstraint = typeRegistry.typeConstraint(addr, mockedObject.typeStorage).all()
-            val isMockConstraint = mkEq(typeRegistry.isMock(mockedObject.addr), UtTrue)
+    private fun createMockedObject(
+        addr: UtAddrExpression,
+        type: RefType,
+        mockInfoGenerator: UtMockInfoGenerator,
+    ): ObjectValue {
+        val nullEqualityConstraint = mkEq(addr, nullObjectAddr)
 
-            queuedSymbolicStateUpdates += typeConstraint.asHardConstraint()
-            queuedSymbolicStateUpdates += mkOr(isMockConstraint, nullEqualityConstraint).asHardConstraint()
+        val mockInfo = mockInfoGenerator.generate(addr)
+        val mockedObjectInfo = mocker.forceMock(type, mockInfoGenerator.generate(addr))
+
+        val mockedObject: ObjectValue = when (mockedObjectInfo) {
+            is NoMock -> error("Value must be mocked after the force mock")
+            is ExpectedMock -> mockedObjectInfo.value
+            is UnexpectedMock -> {
+                // if mock occurs, but it is unexpected due to some reasons
+                // (e.g. we do not have mock framework installed),
+                // we can only generate a test that uses null value for mocked object
+                queuedSymbolicStateUpdates += nullEqualityConstraint.asHardConstraint()
 
+                mockedObjectInfo.value
+            }
+        }
+
+        if (mockedObjectInfo is UnexpectedMock) {
             return mockedObject
         }
 
-        // If we have this$0 with UtArrayList type, we have to create such instance.
-        // We should create an object with typeStorage of all possible real types and concrete implementation
-        // Otherwise we'd have either a wrong type in the resolver, or missing method like 'preconditionCheck'.
-        val concreteImplementation = wrapperToClass[type]?.first()?.let { wrapper(it, addr) }?.concrete
-        val isMockConstraint = mkEq(typeRegistry.isMock(addr), UtFalse)
+        queuedSymbolicStateUpdates += MemoryUpdate(mockInfos = persistentListOf(MockInfoEnriched(mockInfo)))
+
+        // add typeConstraint for mocked object. It's a declared type of the object.
+        val typeConstraint = typeRegistry.typeConstraint(addr, mockedObject.typeStorage).all()
+        val isMockConstraint = mkEq(typeRegistry.isMock(mockedObject.addr), UtTrue)
 
-        queuedSymbolicStateUpdates += typeHardConstraint
+        queuedSymbolicStateUpdates += typeConstraint.asHardConstraint()
         queuedSymbolicStateUpdates += mkOr(isMockConstraint, nullEqualityConstraint).asHardConstraint()
 
-        return ObjectValue(typeStorage, addr, concreteImplementation)
+        return mockedObject
     }
 
     private fun TraversalContext.resolveConstant(constant: Constant): SymbolicValue =

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

@@ -105,7 +105,7 @@ class UtBotSymbolicEngine(
     dependencyPaths: String,
     val mockStrategy: MockStrategy = NO_MOCKS,
     chosenClassesToMockAlways: Set<ClassId>,
-    applicationContext: StandardApplicationContext,
+    applicationContext: ApplicationContext,
     private val solverTimeoutInMillis: Int = checkSolverTimeoutMillis
 ) : UtContextInitializer() {
     private val graph = methodUnderTest.sootMethod.jimpleBody().apply {

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/domain/Domain.kt

@@ -711,3 +711,32 @@ enum class ParametrizedTestSource(
         override val allItems: List<ParametrizedTestSource> = values().toList()
     }
 }
+
+enum class ApplicationType {
+    /**
+     * Standard JVM application without DI frameworks.
+     */
+    PURE_JVM,
+
+    /**
+     * Spring or Spring Boot application.
+     */
+    SPRING_APPLICATION,
+}
+
+enum class TypeReplacementApproach {
+    /**
+     * Do not replace interfaces and abstract classes with concrete implementors.
+     * Use mocking instead of it.
+     */
+    DO_NOT_REPLACE,
+
+    /**
+     * Try to replace interfaces and abstract classes with concrete implementors
+     * obtained from bean definitions.
+     * If it is impossible, use mocking.
+     *
+     * Currently used in Spring applications only.
+     */
+    REPLACE_IF_POSSIBLE,
+}

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

@@ -61,7 +61,7 @@ open class TestCaseGenerator(
     val engineActions: MutableList<(UtBotSymbolicEngine) -> Unit> = mutableListOf(),
     val isCanceled: () -> Boolean = { false },
     val forceSootReload: Boolean = true,
-    val applicationContext: StandardApplicationContext = StandardApplicationContext(),
+    val applicationContext: ApplicationContext = ApplicationContext(),
 ) {
     private val logger: KLogger = KotlinLogging.logger {}
     private val timeoutLogger: KLogger = KotlinLogging.logger(logger.name + ".timeout")
@@ -257,7 +257,7 @@ open class TestCaseGenerator(
         method: ExecutableId,
         mockStrategyApi: MockStrategyApi,
         chosenClassesToMockAlways: Set<ClassId>,
-        applicationContext: StandardApplicationContext,
+        applicationContext: ApplicationContext,
         executionTimeEstimator: ExecutionTimeEstimator
     ): UtBotSymbolicEngine {
         logger.debug("Starting symbolic execution for $method  --$mockStrategyApi--")

utbot-framework/src/main/kotlin/org/utbot/framework/process/EngineProcessMain.kt

@@ -81,7 +81,7 @@ private fun EngineProcessModel.setup(kryoHelper: KryoHelper, watchdog: IdleWatch
     watchdog.measureTimeForActiveCall(createTestGenerator, "Creating Test Generator") { params ->
         AnalyticsConfigureUtil.configureML()
         Instrumenter.adapter = RdInstrumenter(realProtocol.rdInstrumenterAdapter)
-        val applicationContext: StandardApplicationContext = kryoHelper.readObject(params.applicationContext)
+        val applicationContext: ApplicationContext = kryoHelper.readObject(params.applicationContext)
 
         testGenerator = TestCaseGenerator(buildDirs = params.buildDir.map { Paths.get(it) },
             classpath = params.classpath,
@@ -99,7 +99,7 @@ private fun EngineProcessModel.setup(kryoHelper: KryoHelper, watchdog: IdleWatch
         logger.debug().measureTime({ "starting generation for ${methods.size} methods, starting with ${methods.first()}" }) {
             val generateFlow = when (testGenerator.applicationContext) {
                 is SpringApplicationContext -> defaultSpringFlow(params.generationTimeout)
-                is StandardApplicationContext -> testFlow {
+                is ApplicationContext -> testFlow {
                     generationTimeout = params.generationTimeout
                     isSymbolicEngineEnabled = params.isSymbolicEngineEnabled
                     isFuzzingEnabled = params.isFuzzingEnabled