Fix review comments

Author: EgorkaKulikov

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

@@ -3,19 +3,21 @@ 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 testMockInterfaceWithoutImplementorsWithNoMocksStrategy() {
         checkMocks(
             CommonMocksExample::mockInterfaceWithoutImplementors,
             eq(1),
             { v, mocks, _ -> v == null && mocks.isEmpty() },
-            coverage = DoNotCalculate,
             mockStrategy = MockStrategyApi.NO_MOCKS,
+            coverage = atLeast(75),
         )
     }
 
@@ -26,8 +28,8 @@ internal class CommonMocksExampleTest: UtValueTestCaseChecker(testClass = Common
             eq(2),
             { v, mocks, _ -> v == null && mocks.isEmpty() },
             { _, mocks, _ -> mocks.singleOrNull() != null },
-            coverage = DoNotCalculate,
             mockStrategy = MockStrategyApi.OTHER_CLASSES,
+            coverage = atLeast(75),
         )
     }
 
@@ -40,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)
         )
     }
 
@@ -55,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)
         )
     }
 
@@ -66,7 +68,7 @@ internal class CommonMocksExampleTest: UtValueTestCaseChecker(testClass = Common
             eq(1),
             { r -> r == -420 },
             mockStrategy = MockStrategyApi.OTHER_CLASSES,
-            coverage = DoNotCalculate
+            coverage = atLeast(70),
         )
     }
 
@@ -76,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

@@ -130,7 +130,7 @@ data class UtStaticMethodMockInfo(
 ) : UtMockInfo(methodId.classId, addr)
 
 /**
- * A wrapper for [ObjectValue] to store additional onfo.
+ * A wrapper for [ObjectValue] to store additional info.
  */
 sealed class MockedObjectInfo {
     abstract val value: ObjectValue?
@@ -142,16 +142,18 @@ object NoMock: MockedObjectInfo() {
 
 /**
  * Represents a mock that occurs when mock strategy allows it
- * or when an object type is in a set that requires force mocking.
+ * 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 recommended
+ * Represents a mock that occurs when it is not allowed.
  * E.g. mock framework is not installed or
- * mock startegy is DO_NOT_MOCK and class is not in mockAlways set.
+ * mock strategy is [MockStrategy.NO_MOCKS] and class is not in [Mocker.mockAlways] set.
  */
 class UnexpectedMock(objectValue: ObjectValue): MockedObjectInfo() {
     override val value: ObjectValue = objectValue
@@ -170,31 +172,6 @@ class Mocker(
 ) {
     private val mocksAreDesired: Boolean = strategy != MockStrategy.NO_MOCKS
 
-    /**
-     * Constructs [MockedObjectInfo]: enriches given value with
-     * an information if this mock is expected or not.
-     */
-    fun construct(value: ObjectValue?, mockInfo: UtMockInfo): MockedObjectInfo {
-        if (value == null) {
-            return 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)
-        }
-    }
-
     /**
      * Creates mocked instance (if it should be mocked by the mocker) of the [type] using [mockInfo]
      * otherwise returns [NoMock].
@@ -207,8 +184,7 @@ class Mocker(
     }
 
     /**
-     * Creates mocked instance of the [type] using [mockInfo]
-     * 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): MockedObjectInfo {
         mockListenerController?.onShouldMock(strategy, mockInfo)
@@ -241,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

@@ -1382,14 +1382,15 @@ class Traverser(
 
             val mockedObjectInfo = mocker.mock(type, mockInfo)
 
-            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()
+                return mockedObjectInfo.value
             }
 
+            val mockedObject = mockedObjectInfo.value
             if (mockedObject != null) {
                 queuedSymbolicStateUpdates += MemoryUpdate(mockInfos = persistentListOf(MockInfoEnriched(mockInfo)))
 
@@ -1478,7 +1479,7 @@ class Traverser(
             val mockedObjectInfo = mocker.forceMock(type, mockInfoGenerator.generate(addr))
 
             val mockedObject: ObjectValue = when (mockedObjectInfo) {
-                is NoMock -> error("Value must be mocked after the fore mock")
+                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
@@ -1490,6 +1491,10 @@ class Traverser(
                 }
             }
 
+            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.
@@ -2728,6 +2733,15 @@ class Traverser(
                         // 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")
                 }
             }