Generate parametrized tests when there is no force mocking

Author: sofurihafe

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

@@ -180,6 +180,8 @@ class UtBotSymbolicEngine(
 
     fun attachMockListener(mockListener: MockListener) = mocker.mockListenerController?.attach(mockListener)
 
+    fun detachMockListener(mockListener: MockListener) = mocker.mockListenerController?.detach(mockListener)
+
     private val statesForConcreteExecution: MutableList<ExecutionState> = mutableListOf()
 
     private val traverser = Traverser(

utbot-framework/src/main/kotlin/org/utbot/engine/util/mockListeners/ForceMockListener.kt

@@ -2,6 +2,7 @@ package org.utbot.engine.util.mockListeners
 import org.utbot.engine.EngineController
 import org.utbot.engine.MockStrategy
 import org.utbot.engine.UtMockInfo
+import org.utbot.framework.plugin.api.TestCaseGenerator
 import org.utbot.framework.util.Conflict
 import org.utbot.framework.util.ConflictTriggers
 
@@ -18,4 +19,13 @@ class ForceMockListener(triggers: ConflictTriggers): MockListener(triggers) {
 
         triggers[Conflict.ForceMockHappened] = true
     }
+
+    companion object {
+        fun create(testCaseGenerator: TestCaseGenerator, conflictTriggers: ConflictTriggers) : ForceMockListener {
+            val listener = ForceMockListener(conflictTriggers)
+            testCaseGenerator.engineActions.add { engine -> engine.attachMockListener(listener) }
+
+            return listener
+        }
+    }
 }

utbot-framework/src/main/kotlin/org/utbot/engine/util/mockListeners/ForceStaticMockListener.kt

@@ -6,6 +6,7 @@ import org.utbot.engine.UtMockInfo
 import org.utbot.engine.UtNewInstanceMockInfo
 import org.utbot.engine.UtStaticMethodMockInfo
 import org.utbot.engine.UtStaticObjectMockInfo
+import org.utbot.framework.plugin.api.TestCaseGenerator
 import org.utbot.framework.util.Conflict
 import org.utbot.framework.util.ConflictTriggers
 
@@ -26,4 +27,13 @@ class ForceStaticMockListener(triggers: ConflictTriggers): MockListener(triggers
             triggers[Conflict.ForceStaticMockHappened] = true
         }
     }
+
+    companion object {
+        fun create(testCaseGenerator: TestCaseGenerator, conflictTriggers: ConflictTriggers) : ForceStaticMockListener {
+            val listener = ForceStaticMockListener(conflictTriggers)
+            testCaseGenerator.engineActions.add { engine -> engine.attachMockListener(listener) }
+
+            return listener
+        }
+    }
 }

utbot-framework/src/main/kotlin/org/utbot/engine/util/mockListeners/MockListener.kt

@@ -3,6 +3,7 @@ package org.utbot.engine.util.mockListeners
 import org.utbot.engine.EngineController
 import org.utbot.engine.MockStrategy
 import org.utbot.engine.UtMockInfo
+import org.utbot.framework.plugin.api.TestCaseGenerator
 import org.utbot.framework.util.ConflictTriggers
 
 /**
@@ -12,4 +13,8 @@ abstract class MockListener(
     val triggers: ConflictTriggers
 ) {
     abstract fun onShouldMock(controller: EngineController, strategy: MockStrategy, mockInfo: UtMockInfo)
+
+    fun detach(testCaseGenerator: TestCaseGenerator, listener: MockListener) {
+        testCaseGenerator.engineActions.add { engine -> engine.detachMockListener(listener) }
+    }
 }

utbot-framework/src/main/kotlin/org/utbot/engine/util/mockListeners/MockListenerController.kt

@@ -14,6 +14,10 @@ class MockListenerController(private val controller: EngineController) {
         listeners += listener
     }
 
+    fun detach(listener: MockListener) {
+        listeners -= listener
+    }
+
     fun onShouldMock(strategy: MockStrategy, mockInfo: UtMockInfo) {
         listeners.map { it.onShouldMock(controller, strategy, mockInfo) }
     }

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/model/constructor/tree/CgMethodConstructor.kt

@@ -1217,11 +1217,7 @@ internal class CgMethodConstructor(val context: CgContext) : CgContextOwner by c
     private val expectedResultVarName = "expectedResult"
     private val expectedErrorVarName = "expectedError"
 
-    fun createParameterizedTestMethod(testSet: UtMethodTestSet, dataProviderMethodName: String): CgTestMethod? {
-        if (testSet.executions.isEmpty()) {
-            return null
-        }
-
+    fun createParameterizedTestMethod(testSet: UtMethodTestSet, dataProviderMethodName: String): CgTestMethod {
         //TODO: orientation on generic execution may be misleading, but what is the alternative?
         //may be a heuristic to select a model with minimal number of internal nulls should be used
         val genericExecution = testSet.executions

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/model/constructor/tree/CgTestClassConstructor.kt

@@ -52,7 +52,7 @@ internal class CgTestClassConstructor(val context: CgContext) :
                     cgDataProviderMethods.clear()
                     for (testSet in testSets) {
                         updateCurrentExecutable(testSet.method)
-                        val currentMethodUnderTestRegions = construct(testSet)
+                        val currentMethodUnderTestRegions = construct(testSet) ?: continue
                         val executableUnderTestCluster = CgExecutableUnderTestCluster(
                             "Test suites for executable $currentExecutable",
                             currentMethodUnderTestRegions
@@ -76,7 +76,11 @@ internal class CgTestClassConstructor(val context: CgContext) :
         }
     }
 
-    private fun construct(testSet: UtMethodTestSet): List<CgRegion<CgMethod>> {
+    private fun construct(testSet: UtMethodTestSet): List<CgRegion<CgMethod>>? {
+        if (testSet.executions.isEmpty()) {
+            return null
+        }
+
         val (methodUnderTest, executions, _, _, clustersInfo) = testSet
         val regions = mutableListOf<CgRegion<CgMethod>>()
         val requiredFields = mutableListOf<CgParameterDeclaration>()
@@ -107,17 +111,15 @@ internal class CgTestClassConstructor(val context: CgContext) :
                     val parameterizedTestMethod =
                         methodConstructor.createParameterizedTestMethod(testSet, dataProviderMethodName)
 
-                    if (parameterizedTestMethod != null) {
-                        requiredFields += parameterizedTestMethod.requiredFields
+                    requiredFields += parameterizedTestMethod.requiredFields
 
-                        cgDataProviderMethods +=
-                            methodConstructor.createParameterizedTestDataProvider(testSet, dataProviderMethodName)
+                    cgDataProviderMethods +=
+                        methodConstructor.createParameterizedTestDataProvider(testSet, dataProviderMethodName)
 
-                        regions += CgSimpleRegion(
-                            "Parameterized test for method ${methodUnderTest.displayName}",
-                            listOf(parameterizedTestMethod),
-                        )
-                    }
+                    regions += CgSimpleRegion(
+                        "Parameterized test for method ${methodUnderTest.displayName}",
+                        listOf(parameterizedTestMethod),
+                    )
                 }.onFailure { error -> processFailure(testSet, error) }
             }
         }

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

@@ -117,6 +117,8 @@ open class TestCaseGenerator(
         executionTimeEstimator: ExecutionTimeEstimator = ExecutionTimeEstimator(utBotGenerationTimeoutInMillis, 1)
     ): Flow<UtResult> {
         val engine = createSymbolicEngine(controller, method, mockStrategy, chosenClassesToMockAlways, executionTimeEstimator)
+        engineActions.map { engine.apply(it) }
+        engineActions.clear()
         return defaultTestFlow(engine, executionTimeEstimator.userTimeout)
     }
 

utbot-framework/src/test/kotlin/org/utbot/examples/TestSpecificTestCaseGenerator.kt

@@ -7,6 +7,8 @@ import org.utbot.common.runIgnoringCancellationException
 import org.utbot.engine.EngineController
 import org.utbot.engine.Mocker
 import org.utbot.engine.UtBotSymbolicEngine
+import org.utbot.engine.util.mockListeners.ForceMockListener
+import org.utbot.engine.util.mockListeners.ForceStaticMockListener
 import org.utbot.framework.UtSettings
 import org.utbot.framework.plugin.api.MockStrategyApi
 import org.utbot.framework.plugin.api.TestCaseGenerator
@@ -45,6 +47,10 @@ class TestSpecificTestCaseGenerator(
         val mockAlwaysDefaults = Mocker.javaDefaultClasses.mapTo(mutableSetOf()) { it.id }
         val defaultTimeEstimator = ExecutionTimeEstimator(UtSettings.utBotGenerationTimeoutInMillis, 1)
 
+        val conflictTriggers = TestFrameworkConfiguration.conflictTriggers
+        val forceMockListener = ForceMockListener.create(this, conflictTriggers)
+        val forceStaticMockListener = ForceStaticMockListener.create(this, conflictTriggers)
+
         runIgnoringCancellationException {
             runBlockingWithCancellationPredicate(isCanceled) {
                 super
@@ -58,6 +64,9 @@ class TestSpecificTestCaseGenerator(
             }
         }
 
+        forceMockListener.detach(this, forceMockListener)
+        forceStaticMockListener.detach(this, forceStaticMockListener)
+
         val minimizedExecutions = super.minimizeExecutions(executions)
         return UtMethodTestSet(method, minimizedExecutions, jimpleBody(method), errors)
     }

utbot-framework/src/test/kotlin/org/utbot/examples/TestUtil.kt

@@ -14,6 +14,8 @@ import org.utbot.framework.plugin.api.MockFramework
 import org.utbot.framework.plugin.api.MockStrategyApi
 import org.utbot.framework.plugin.api.MockStrategyApi.NO_MOCKS
 import org.utbot.framework.plugin.api.MockStrategyApi.OTHER_CLASSES
+import org.utbot.framework.util.Conflict
+import org.utbot.framework.util.ConflictTriggers
 
 
 data class TestFrameworkConfiguration(
@@ -28,6 +30,11 @@ data class TestFrameworkConfiguration(
     val runtimeExceptionTestsBehaviour: RuntimeExceptionTestsBehaviour = RuntimeExceptionTestsBehaviour.PASS,
     val enableTestsTimeout: Boolean = false // our tests should not fail due to timeout
 ) {
+    val isParametrizedAndMocked: Boolean
+        get() = parametrizedTestSource == ParametrizedTestSource.PARAMETRIZE &&
+                (mockStrategy != NO_MOCKS ||
+                        conflictTriggers[Conflict.ForceMockHappened] ?: false || conflictTriggers[Conflict.ForceStaticMockHappened] ?: false)
+
     val isDisabled: Boolean
         get() = run {
             // TODO Any? JIRA:1366
@@ -42,9 +49,6 @@ data class TestFrameworkConfiguration(
             // because otherwise the code generator will not create mocks even for mandatory to mock classes
             if (forceStaticMocking == ForceStaticMocking.FORCE && staticsMocking == NoStaticMocking) return true
 
-            // TODO find if mocks are used during the analysis JIRA:1418
-            if (parametrizedTestSource == ParametrizedTestSource.PARAMETRIZE) return true
-
             // junit4 doesn't support parametrized tests
             if (testFramework == Junit4 && parametrizedTestSource == ParametrizedTestSource.PARAMETRIZE) return true
 
@@ -53,6 +57,10 @@ data class TestFrameworkConfiguration(
 
             return false
         }
+
+    companion object Triggers {
+        val conflictTriggers: ConflictTriggers = ConflictTriggers()
+    }
 }
 
 val allTestFrameworkConfigurations: List<TestFrameworkConfiguration> = run {