Try to apply fixes after review

Author: EgorkaKulikov

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

@@ -56,6 +56,7 @@ 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
@@ -1151,6 +1152,27 @@ 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 may be used.
+     */
+    AnyImplementor,
+
+    /**
+     * There is a known implementor to be used.
+     * For example, it is found in Spring bean definitions.
+     */
+    KnownImplementor,
+
+    /**
+     * Using implementors is not allowed.
+     */
+    NoImplementors,
+}
+
 /**
  * A context to use when no specific data is required.
  *
@@ -1181,8 +1203,13 @@ open class ApplicationContext(
     }
 
     /**
-     * Finds a type to replace the original during symbolic
-     * analysis if it is guided with some additional information.
+     * 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
 }
@@ -1197,8 +1224,8 @@ open class ApplicationContext(
 class SpringApplicationContext(
     mockInstalled: Boolean,
     staticsMockingIsConfigured: Boolean,
-    val beanQualifiedNames: List<String> = emptyList(),
-    val shouldUseImplementors: Boolean,
+    private val beanQualifiedNames: List<String> = emptyList(),
+    private val shouldUseImplementors: Boolean,
 ): ApplicationContext(mockInstalled, staticsMockingIsConfigured) {
 
     private val springInjectedClasses: List<ClassId> by lazy {
@@ -1208,13 +1235,15 @@ class SpringApplicationContext(
             .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 (shouldUseImplementors &&
-            (type.sootClass.isInterface || type.sootClass.isAbstract)) {
+        if (type.sootClass.isInterface || type.sootClass.isAbstract) {
             springInjectedClasses.singleOrNull { it.isSubtypeOf(type.id) }
         } else {
             null

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

@@ -121,7 +121,9 @@ 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.SpringApplicationContext
+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
@@ -1365,7 +1367,7 @@ class Traverser(
         traverseException(current, symException)
     }
 
-    // TODO HACK violation of encapsulation
+    // TODO: HACK violation of encapsulation
     fun createObject(
         addr: UtAddrExpression,
         type: RefType,
@@ -1374,8 +1376,13 @@ class Traverser(
     ): ObjectValue {
         touchAddress(addr)
 
-        val concreteClassId = applicationContext.replaceTypeIfNeeded(type)
-        concreteClassId?.let {
+        val replacedClassId = when (applicationContext.typeReplacementMode) {
+            KnownImplementor -> applicationContext.replaceTypeIfNeeded(type)
+            AnyImplementor,
+            NoImplementors -> null
+        }
+
+        replacedClassId?.let {
             val sootType = typeResolver.classOrDefault(it.canonicalName)
             val typeStorage = typeResolver.constructTypeStorage(sootType, useConcreteType = false)
 
@@ -1481,58 +1488,66 @@ class Traverser(
             return it
         }
 
-        // In Spring application we may rely on concrete types obtained from bean definitions only,
-        // and this potential replacement has already been suggested in the beginning of the method
-        val useConcreteTypes = applicationContext !is SpringApplicationContext
-
-        if (useConcreteTypes && typeStorage.possibleConcreteTypes.any()) {
-            // 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 += typeHardConstraint
-            queuedSymbolicStateUpdates += mkOr(isMockConstraint, nullEqualityConstraint).asHardConstraint()
+        if (typeStorage.possibleConcreteTypes.isEmpty()) {
+            requireNotNull(mockInfoGenerator) {
+                "An object with $addr and $type doesn't have concrete possible types," +
+                        "but there is no mock info generator provided to construct a mock value."
+            }
 
-            return ObjectValue(typeStorage, addr, concreteImplementation)
-        }
+            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
+                }
+            }
 
-        requireNotNull(mockInfoGenerator) {
-            "An object with $addr and $type doesn't have concrete possible types," +
-                    "but there is no mock info generator provided to construct a mock value."
-        }
+            if (mockedObjectInfo is UnexpectedMock) {
+                return mockedObject
+            }
 
-        val mockInfo = mockInfoGenerator.generate(addr)
-        val mockedObjectInfo = mocker.forceMock(type, mockInfoGenerator.generate(addr))
+            queuedSymbolicStateUpdates += MemoryUpdate(mockInfos = persistentListOf(MockInfoEnriched(mockInfo)))
 
-        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()
+            // 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)
 
-                mockedObjectInfo.value
-            }
-        }
+            queuedSymbolicStateUpdates += typeConstraint.asHardConstraint()
+            queuedSymbolicStateUpdates += mkOr(isMockConstraint, nullEqualityConstraint).asHardConstraint()
 
-        if (mockedObjectInfo is UnexpectedMock) {
             return mockedObject
         }
 
-        queuedSymbolicStateUpdates += MemoryUpdate(mockInfos = persistentListOf(MockInfoEnriched(mockInfo)))
+        val concreteImplementation = when (applicationContext.typeReplacementMode) {
+            AnyImplementor -> {
+                val isMockConstraint = mkEq(typeRegistry.isMock(addr), UtFalse)
 
-        // 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 += mkOr(isMockConstraint, nullEqualityConstraint).asHardConstraint()
 
-        queuedSymbolicStateUpdates += typeConstraint.asHardConstraint()
-        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 known implementor we should have already tried to replace type using `replaceTypeIfNeeded`.
+            KnownImplementor,
+            // If no implementors are allowed, we should have already generated a mock object.
+            NoImplementors -> {
+                queuedSymbolicStateUpdates += mkFalse().asHardConstraint()
+                null
+            }
+        }
 
-        return mockedObject
+        return ObjectValue(typeStorage, addr, concreteImplementation)
     }