Prune branches with unexpected mocks

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

@@ -1149,24 +1149,33 @@ open class TypeParameters(val parameters: List<ClassId> = emptyList())
 class WildcardTypeParameter : TypeParameters(emptyList())
 
 /**
- * Additional data describing user project.
- */
-interface ApplicationContext
-
-/**
- * A context to use when no additional data is required.
+ * 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
  */
-object EmptyApplicationContext: ApplicationContext
+open class StandardApplicationContext(
+ val mockFrameworkInstalled: Boolean = true,
+ val staticsMockingIsConfigured: Boolean = true,
+) {
+ init {
+ if (!mockFrameworkInstalled) {
+ require(!staticsMockingIsConfigured) { "Static mocking cannot be used without mock framework" }
+ }
+ }
+}
 
 /**
  * Data we get from Spring application context
  * to manage engine and code generator behaviour.
  *
  * @param beanQualifiedNames describes fqn of injected classes
  */
-data class SpringApplicationContext(
+class SpringApplicationContext(
+ mockInstalled: Boolean,
+ staticsMockingIsConfigured: Boolean,
  val beanQualifiedNames: List<String> = emptyList(),
-): ApplicationContext {
+): StandardApplicationContext(mockInstalled, staticsMockingIsConfigured) {
  private val springInjectedClasses: List<ClassId> by lazy {
  beanQualifiedNames.map { fqn -> utContext.classLoader.loadClass(fqn).id }
  }

utbot-framework-test/src/test/kotlin/org/utbot/examples/mock/CommonMocksExampleTest.kt

@@ -3,18 +3,33 @@ package org.utbot.examples.mock
 import org.utbot.framework.plugin.api.MockStrategyApi
 import org.junit.jupiter.api.Test
 import org.utbot.testcheckers.eq
-import org.utbot.testing.DoNotCalculate
 import org.utbot.testing.UtValueTestCaseChecker
+import org.utbot.testing.atLeast
 
 internal class CommonMocksExampleTest: UtValueTestCaseChecker(testClass = CommonMocksExample::class) {
+
+ //TODO: coverage values here require further investigation by experts
+
  @Test
- fun testMockInterfaceWithoutImplementors() {
+ fun testMockInterfaceWithoutImplementorsWithNoMocksStrategy() {
+ checkMocks(
+ CommonMocksExample::mockInterfaceWithoutImplementors,
+ eq(1),
+ { v, mocks, _ -> v == null && mocks.isEmpty() },
+ mockStrategy = MockStrategyApi.NO_MOCKS,
+ coverage = atLeast(75),
+ )
+ }
+
+ @Test
+ fun testMockInterfaceWithoutImplementorsWithMockingStrategy() {
  checkMocks(
  CommonMocksExample::mockInterfaceWithoutImplementors,
  eq(2),
  { v, mocks, _ -> v == null && mocks.isEmpty() },
  { _, mocks, _ -> mocks.singleOrNull() != null },
- coverage = DoNotCalculate
+ mockStrategy = MockStrategyApi.OTHER_CLASSES,
+ coverage = atLeast(75),
  )
  }
 
@@ -27,7 +42,7 @@ internal class CommonMocksExampleTest: UtValueTestCaseChecker(testClass = Common
  { fst, _, mocks, _ -> fst == null && mocks.isEmpty() },
  { _, _, mocks, _ -> mocks.isEmpty() }, // should be changed to not null fst when 1449 will be finished
  mockStrategy = MockStrategyApi.OTHER_PACKAGES,
- coverage = DoNotCalculate
+ coverage = atLeast(75)
  )
  }
 
@@ -42,7 +57,7 @@ internal class CommonMocksExampleTest: UtValueTestCaseChecker(testClass = Common
  // node == node.next
  // node.next.value == node.value + 1
  mockStrategy = MockStrategyApi.OTHER_CLASSES,
- coverage = DoNotCalculate
+ coverage = atLeast(13)
  )
  }
 
@@ -53,7 +68,7 @@ internal class CommonMocksExampleTest: UtValueTestCaseChecker(testClass = Common
  eq(1),
  { r -> r == -420 },
  mockStrategy = MockStrategyApi.OTHER_CLASSES,
- coverage = DoNotCalculate
+ coverage = atLeast(70),
  )
  }
 
@@ -63,7 +78,7 @@ internal class CommonMocksExampleTest: UtValueTestCaseChecker(testClass = Common
  CommonMocksExample::mocksForNullOfDifferentTypes,
  eq(1),
  mockStrategy = MockStrategyApi.OTHER_PACKAGES,
- coverage = DoNotCalculate
+ coverage = atLeast(75)
  )
  }
 }

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

@@ -19,6 +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.util.isInaccessibleViaReflection
 import soot.BooleanType
 import soot.RefType
@@ -128,6 +129,36 @@ data class UtStaticMethodMockInfo(
  val methodId: MethodId
 ) : UtMockInfo(methodId.classId, addr)
 
+/**
+ * A wrapper for [ObjectValue] to store additional info.
+ */
+sealed class MockedObjectInfo {
+ abstract val value: ObjectValue?
+}
+
+object NoMock: MockedObjectInfo() {
+ override val value: ObjectValue? = null
+}
+
+/**
+ * Represents a mock that occurs when mock strategy allows it
+ * or when an object type requires always requires mocking.
+ *
+ * See [Mocker.mockAlways] for more details.
+ */
+class ExpectedMock(objectValue: ObjectValue): MockedObjectInfo() {
+ override val value: ObjectValue = objectValue
+}
+
+/**
+ * Represents a mock that occurs when it is not allowed.
+ * E.g. mock framework is not installed or
+ * mock strategy is [MockStrategy.NO_MOCKS] and class is not in [Mocker.mockAlways] set.
+ */
+class UnexpectedMock(objectValue: ObjectValue): MockedObjectInfo() {
+ override val value: ObjectValue = objectValue
+}
+
 /**
  * Service to mock things. Knows mock strategy, class under test and class hierarchy.
  */
@@ -137,21 +168,30 @@ class Mocker(
  private val hierarchy: Hierarchy,
  chosenClassesToMockAlways: Set<ClassId>,
  internal val mockListenerController: MockListenerController? = null,
+ private val applicationContext: StandardApplicationContext,
 ) {
+ private val mocksAreDesired: Boolean = strategy != MockStrategy.NO_MOCKS
+
  /**
- * Creates mocked instance of the [type] using mock info if it should be mocked by the mocker,
- * otherwise returns null.
+ * Creates mocked instance (if it should be mocked by the mocker) of the [type] using [mockInfo]
+ * otherwise returns [NoMock].
  *
  * @see shouldMock
  */
- fun mock(type: RefType, mockInfo: UtMockInfo): ObjectValue? =
- if (shouldMock(type, mockInfo)) createMockObject(type, mockInfo) else null
+ fun mock(type: RefType, mockInfo: UtMockInfo): MockedObjectInfo {
+ val objectValue = if (shouldMock(type, mockInfo)) createMockObject(type, mockInfo) else null
+ return construct(objectValue, mockInfo)
+ }
 
  /**
- * Creates mocked instance of the [type] using mock info. Unlike to [mock], it does not
- * check anything and always returns the constructed mock.
+ * Unlike to [mock], unconditionally creates a mocked instance of the [type] using [mockInfo].
  */
- fun forceMock(type: RefType, mockInfo: UtMockInfo): ObjectValue = createMockObject(type, mockInfo)
+ fun forceMock(type: RefType, mockInfo: UtMockInfo): MockedObjectInfo {
+ mockListenerController?.onShouldMock(strategy, mockInfo)
+
+ val objectValue = createMockObject(type, mockInfo)
+ return construct(objectValue, mockInfo)
+ }
 
  /**
  * Checks if Engine should mock objects of particular type with current mock strategy and mock type.
@@ -177,6 +217,30 @@ class Mocker(
  }
  }
 
+ /**
+ * Constructs [MockedObjectInfo]: enriches given [mockedValue] with an information if mocking is expected or not.
+ */
+ private fun construct(mockedValue: ObjectValue?, mockInfo: UtMockInfo): MockedObjectInfo {
+ if (mockedValue == null) {
+ return NoMock
+ }
+
+ val mockingIsPossible = when (mockInfo) {
+ is UtFieldMockInfo,
+ is UtObjectMockInfo -> applicationContext.mockFrameworkInstalled
+ is UtNewInstanceMockInfo,
+ is UtStaticMethodMockInfo,
+ is UtStaticObjectMockInfo -> applicationContext.staticsMockingIsConfigured
+ }
+ val mockingIsForcedAndPossible = mockAlways(mockedValue.type) && mockingIsPossible
+
+ return if (mocksAreDesired || mockingIsForcedAndPossible) {
+ ExpectedMock(mockedValue)
+ } else {
+ UnexpectedMock(mockedValue)
+ }
+ }
+
  private fun checkIfShouldMock(
  type: RefType,
  mockInfo: UtMockInfo

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

@@ -116,12 +116,11 @@ 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.ApplicationContext
+import org.utbot.framework.plugin.api.StandardApplicationContext
 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.classId
 import org.utbot.framework.plugin.api.id
 import org.utbot.framework.plugin.api.util.executable
@@ -240,7 +239,7 @@ class Traverser(
  internal val typeResolver: TypeResolver,
  private val globalGraph: InterProceduralUnitGraph,
  private val mocker: Mocker,
- private val applicationContext: ApplicationContext?,
+ private val applicationContext: StandardApplicationContext?,
 ) : UtContextInitializer() {
 
  private val visitedStmts: MutableSet<Stmt> = mutableSetOf()
@@ -277,8 +276,6 @@ class Traverser(
 
  internal val objectCounter = ObjectCounter(TypeRegistry.objectCounterInitialValue)
 
-
-
  private fun findNewAddr(insideStaticInitializer: Boolean): UtAddrExpression {
  val newAddr = objectCounter.createNewAddr()
  // return negative address for objects created inside static initializer
@@ -1383,8 +1380,17 @@ class Traverser(
 
  queuedSymbolicStateUpdates += MemoryUpdate(addrToMockInfo = persistentHashMapOf(addr to mockInfo))
 
- val mockedObject = mocker.mock(type, mockInfo)
+ val mockedObjectInfo = mocker.mock(type, mockInfo)
+
+ if (mockedObjectInfo 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()
+ return mockedObjectInfo.value
+ }
 
+ val mockedObject = mockedObjectInfo.value
  if (mockedObject != null) {
  queuedSymbolicStateUpdates += MemoryUpdate(mockInfos = persistentListOf(MockInfoEnriched(mockInfo)))
 
@@ -1470,7 +1476,24 @@ class Traverser(
  }
 
  val mockInfo = mockInfoGenerator.generate(addr)
- val mockedObject = mocker.forceMock(type, 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)))
 
@@ -2675,7 +2698,7 @@ class Traverser(
  .map { (method, implementationClass, possibleTypes) ->
  val typeStorage = typeResolver.constructTypeStorage(implementationClass, possibleTypes)
  val mockInfo = memory.mockInfoByAddr(instance.addr)
- val mockedObject = mockInfo?.let {
+ val mockedObjectInfo = mockInfo?.let {
  // TODO rewrite to fix JIRA:1611
  val type = Scene.v().getSootClass(mockInfo.classId.name).type
  val ancestorTypes = typeResolver.findOrConstructAncestorsIncludingTypes(type)
@@ -2684,28 +2707,42 @@ class Traverser(
  } else {
  it.copyWithClassId(classId = implementationClass.id)
  }
- mocker.mock(implementationClass, updatedMockInfo)
- }
-
- if (mockedObject == null) {
- // Above we might get implementationClass that has to be substituted.
- // For example, for a call "Collection.size()" such classes will be produced.
- val wrapperOrInstance = wrapper(implementationClass, instance.addr)
- ?: instance.copy(typeStorage = typeStorage)
 
- val typeConstraint = typeRegistry.typeConstraint(instance.addr, wrapperOrInstance.typeStorage)
-  val constraints = setOf(typeConstraint.isOrNullConstraint())
+ mocker.mock(implementationClass, updatedMockInfo)
+ } ?: NoMock
 
- // TODO add memory updated for types JIRA:1523
+ when (mockedObjectInfo) {
+ is NoMock -> {
+ // Above we might get implementationClass that has to be substituted.
+ // For example, for a call "Collection.size()" such classes will be produced.
+ val wrapperOrInstance = wrapper(implementationClass, instance.addr)
+ ?: instance.copy(typeStorage = typeStorage)
 
- InvocationTarget(wrapperOrInstance, method, constraints)
- } else {
- val typeConstraint = typeRegistry.typeConstraint(mockedObject.addr, mockedObject.typeStorage)
- val constraints = setOf(typeConstraint.isOrNullConstraint())
+ val typeConstraint = typeRegistry.typeConstraint(instance.addr, wrapperOrInstance.typeStorage)
+ val constraints = setOf(typeConstraint.isOrNullConstraint())
 
- // TODO add memory updated for types JIRA:1523
- // TODO isMock????
- InvocationTarget(mockedObject, method, constraints)
+ // TODO add memory updated for types JIRA:1523
+ InvocationTarget(wrapperOrInstance, method, constraints)
+ }
+ is ExpectedMock -> {
+ val mockedObject = mockedObjectInfo.value
+ val typeConstraint = typeRegistry.typeConstraint(mockedObject.addr, mockedObject.typeStorage)
+ val constraints = setOf(typeConstraint.isOrNullConstraint())
+
+ // TODO add memory updated for types JIRA:1523
+ // TODO isMock????
+ InvocationTarget(mockedObject, method, constraints)
+ }
+ /*
+ Currently, it is unclear how this could happen.
+ Perhaps, the answer is somewhere in the following situation:
+ you have an interface with an abstract method `foo`, and it has an abstract inheritor with the implementation of the method,
+ but this inheritor doesn't have any concrete inheritors. It looks like in this case we would mock this instance
+ (because it doesn't have any possible concrete type), but it is impossible since either this class cannot present
+ in possible types of the object on which we call `foo` (since they contain only concrete types),
+ or this class would be already mocked (since it doesn't contain any concrete implementors).
+ */
+ is UnexpectedMock -> unreachableBranch("If it ever happens, it should be investigated")
  }
  }
  }

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: ApplicationContext?,
+ applicationContext: StandardApplicationContext,
  private val solverTimeoutInMillis: Int = checkSolverTimeoutMillis
 ) : UtContextInitializer() {
  private val graph = methodUnderTest.sootMethod.jimpleBody().apply {
@@ -129,7 +129,8 @@ class UtBotSymbolicEngine(
  classUnderTest,
  hierarchy,
  chosenClassesToMockAlways,
- MockListenerController(controller)
+ MockListenerController(controller),
+ applicationContext = applicationContext,
  )
 
  fun attachMockListener(mockListener: MockListener) = mocker.mockListenerController?.attach(mockListener)