Apply fixes under review

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

@@ -1157,7 +1157,13 @@ class WildcardTypeParameter : TypeParameters(emptyList())
 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

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

@@ -132,21 +132,30 @@ data class UtStaticMethodMockInfo(
 /**
  * A wrapper for [ObjectValue] to store additional onfo.
  */
-sealed class MockedObjectInfo(val value: ObjectValue?)
+sealed class MockedObjectInfo {
+ abstract val value: ObjectValue?
+}
 
-object NoMock: MockedObjectInfo(value = null)
+object NoMock: MockedObjectInfo() {
+ override val value: ObjectValue? = null
+}
 
 /**
  * Represents a mock that occurs when mock strategy allows it
  * or when an object type is in a set that requires force mocking.
  */
-class ExpectedMock(value: ObjectValue): MockedObjectInfo(value)
+class ExpectedMock(objectValue: ObjectValue): MockedObjectInfo() {
+ override val value: ObjectValue = objectValue
+}
 
 /**
  * Represents a mock that occurs when it is not recommended
- * E.g. mock strategy recommends do not mock
+ * E.g. mock framework is not installed or
+ * mock startegy is DO_NOT_MOCK and class is not in mockAlways set.
  */
-class UnexpectedMock(value: ObjectValue): MockedObjectInfo(value)
+class UnexpectedMock(objectValue: ObjectValue): MockedObjectInfo() {
+ override val value: ObjectValue = objectValue
+}
 
 /**
  * Service to mock things. Knows mock strategy, class under test and class hierarchy.
@@ -166,24 +175,24 @@ class Mocker(
  * an information if this mock is expected or not.
  */
  fun construct(value: ObjectValue?, mockInfo: UtMockInfo): MockedObjectInfo {
- return value
- ?.let {
- val mockingIsPossible = when (mockInfo) {
- is UtFieldMockInfo,
- is UtObjectMockInfo -> applicationContext.mockFrameworkInstalled
- is UtNewInstanceMockInfo,
- is UtStaticMethodMockInfo,
- is UtStaticObjectMockInfo -> applicationContext.staticsMockingIsConfigured
- }
- val mockingIsForcedAndPossible = mockAlways(it.type) && mockingIsPossible
+ if (value == null) {
+ return NoMock
+ }
 
- if (mocksAreDesired || mockingIsForcedAndPossible) {
- ExpectedMock(it)
- } else {
- UnexpectedMock(it)
- }
- }
- ?: NoMock
+ val mockingIsPossible = when (mockInfo) {
+ is UtFieldMockInfo,
+ is UtObjectMockInfo -> applicationContext.mockFrameworkInstalled
+ is UtNewInstanceMockInfo,
+ is UtStaticMethodMockInfo,
+ is UtStaticObjectMockInfo -> applicationContext.staticsMockingIsConfigured
+ }
+ val mockingIsForcedAndPossible = mockAlways(value.type) && mockingIsPossible
+
+ return if (mocksAreDesired || mockingIsForcedAndPossible) {
+ ExpectedMock(value)
+ } else {
+ UnexpectedMock(value)
+ }
  }
 
  /**

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

@@ -1384,6 +1384,9 @@ class Traverser(
 
  val mockedObject = mockedObjectInfo.value
  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()
  }
 
@@ -1474,10 +1477,17 @@ class Traverser(
  val mockInfo = mockInfoGenerator.generate(addr)
  val mockedObjectInfo = mocker.forceMock(type, mockInfoGenerator.generate(addr))
 
- val mockedObject = mockedObjectInfo.value ?: error("Mocked value cannot be null after force mock")
- if (mockedObjectInfo is UnexpectedMock) {
- queuedSymbolicStateUpdates += nullEqualityConstraint.asHardConstraint()
- return mockedObject
+ val mockedObject: ObjectValue = when (mockedObjectInfo) {
+ is NoMock -> error("Value must be mocked after the fore 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
+ }
  }
 
  queuedSymbolicStateUpdates += MemoryUpdate(mockInfos = persistentListOf(MockInfoEnriched(mockInfo)))
@@ -2680,7 +2690,7 @@ class Traverser(
  } ?: findMethodInvocationTargets(types, methodSubSignature)
 
  return methodInvocationTargets
- .mapNotNull { (method, implementationClass, possibleTypes) ->
+ .map { (method, implementationClass, possibleTypes) ->
  val typeStorage = typeResolver.constructTypeStorage(implementationClass, possibleTypes)
  val mockInfo = memory.mockInfoByAddr(instance.addr)
  val mockedObjectInfo = mockInfo?.let {
@@ -2710,7 +2720,7 @@ class Traverser(
  InvocationTarget(wrapperOrInstance, method, constraints)
  }
  is ExpectedMock -> {
- val mockedObject = mockedObjectInfo.value!!
+ val mockedObject = mockedObjectInfo.value
  val typeConstraint = typeRegistry.typeConstraint(mockedObject.addr, mockedObject.typeStorage)
  val constraints = setOf(typeConstraint.isOrNullConstraint())