Apply fixes to mocks creation in specific implementors modes, add documentation.

Author: EgorkaKulikov

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

@@ -1157,18 +1157,20 @@ class WildcardTypeParameter : TypeParameters(emptyList())
  */
 enum class TypeReplacementMode {
     /**
-     * Any possible implementor may be used.
+     * Any possible implementor (that is preferred by solver) may be used.
      */
     AnyImplementor,
 
     /**
      * There is a known implementor to be used.
-     * For example, it is found in Spring bean definitions.
+     * 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,
 }

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

@@ -1376,14 +1376,19 @@ 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 = typeResolver.classOrDefault(it.canonicalName)
+            val sootType = Scene.v().getSootClass(it.canonicalName).type
             val typeStorage = typeResolver.constructTypeStorage(sootType, useConcreteType = false)
 
             val typeHardConstraint = typeRegistry.typeConstraint(addr, typeStorage).all().asHardConstraint()
@@ -1494,36 +1499,7 @@ 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
-                }
-            }
-
-            if (mockedObjectInfo is UnexpectedMock) {
-                return mockedObject
-            }
-
-            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 += typeConstraint.asHardConstraint()
-            queuedSymbolicStateUpdates += mkOr(isMockConstraint, nullEqualityConstraint).asHardConstraint()
-
-            return mockedObject
+            return createMockedObject(addr, type, mockInfoGenerator)
         }
 
         val concreteImplementation = when (applicationContext.typeReplacementMode) {
@@ -1538,10 +1514,19 @@ class Traverser(
                 // 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`.
+            // 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,
-            // If no implementors are allowed, we should have already generated a mock object.
             NoImplementors -> {
+                mockInfoGenerator?.let {
+                    return createMockedObject(addr, type, it)
+                }
+
                 queuedSymbolicStateUpdates += mkFalse().asHardConstraint()
                 null
             }
@@ -1550,6 +1535,45 @@ class Traverser(
         return ObjectValue(typeStorage, addr, concreteImplementation)
     }
 
+    private fun createMockedObject(
+        addr: UtAddrExpression,
+        type: RefType,
+        mockInfoGenerator: UtMockInfoGenerator,
+    ): ObjectValue {
+        val nullEqualityConstraint = mkEq(addr, nullObjectAddr)
+
+        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
+        }
+
+        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 += typeConstraint.asHardConstraint()
+        queuedSymbolicStateUpdates += mkOr(isMockConstraint, nullEqualityConstraint).asHardConstraint()
+
+        return mockedObject
+    }
+
     private fun TraversalContext.resolveConstant(constant: Constant): SymbolicValue =
         when (constant) {
             is IntConstant -> constant.value.toPrimitiveValue()

utbot-framework/src/main/kotlin/org/utbot/engine/types/TypeResolver.kt

@@ -95,7 +95,7 @@ class TypeResolver(private val typeRegistry: TypeRegistry, private val hierarchy
             .toSet()
     }
 
-    fun classOrDefault(typeName: String): RefType =
+    private fun classOrDefault(typeName: String): RefType =
         runCatching { Scene.v().getRefType(typeName) }.getOrDefault(OBJECT_TYPE)
 
     fun findFields(type: RefType) = typeRegistry.findFields(type) {