Add constructorId support in parametrized test generation & refactor name generator (#637)

Author: sofurihafe

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/model/constructor/name/CgNameGenerator.kt

@@ -86,10 +86,8 @@ internal class CgNameGeneratorImpl(private val context: CgContext)
     }
 
     override fun testMethodNameFor(executableId: ExecutableId, customName: String?): String {
-        val executableName = when (executableId) {
-            is ConstructorId -> executableId.classId.prettifiedName // TODO: maybe we need some suffix e.g. "Ctor"?
-            is MethodId -> executableId.name
-        }
+        val executableName = createExecutableName(executableId)
+
         // no index suffix allowed only when there's a vacant custom name
         val name = if (customName != null && customName !in existingMethodNames) {
             customName
@@ -107,17 +105,15 @@ internal class CgNameGeneratorImpl(private val context: CgContext)
         dataProviderMethodName.replace(dataProviderMethodPrefix, "parameterizedTestsFor")
 
     override fun dataProviderMethodNameFor(executableId: ExecutableId): String {
-        val indexedName = nextIndexedMethodName(executableId.name.capitalize(), skipOne = true)
+        val executableName = createExecutableName(executableId)
+        val indexedName = nextIndexedMethodName(executableName.capitalize(), skipOne = true)
 
         existingMethodNames += indexedName
         return "$dataProviderMethodPrefix$indexedName"
     }
 
     override fun errorMethodNameFor(executableId: ExecutableId): String {
-        val executableName = when (executableId) {
-            is ConstructorId -> executableId.classId.prettifiedName
-            is MethodId -> executableId.name
-        }
+        val executableName = createExecutableName(executableId)
         val newName = when (val base = "test${executableName.capitalize()}_errors") {
             !in existingMethodNames -> base
             else -> nextIndexedMethodName(base)
@@ -151,6 +147,13 @@ internal class CgNameGeneratorImpl(private val context: CgContext)
             if (baseName !in existingVariableNames) "`$baseName`" else nextIndexedVarName(baseName)
         }
     }
+
+    private fun createExecutableName(executableId: ExecutableId): String {
+        return when (executableId) {
+            is ConstructorId -> executableId.classId.prettifiedName // TODO: maybe we need some suffix e.g. "Ctor"?
+            is MethodId -> executableId.name
+        }
+    }
 }
 
 /**

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

@@ -284,30 +284,7 @@ internal class CgMethodConstructor(val context: CgContext) : CgContextOwner by c
      */
     private fun generateResultAssertions() {
         when (currentExecutable) {
-            is ConstructorId -> {
-                // we cannot generate any assertions for constructor testing
-                // but we need to generate a constructor call
-                val constructorCall = currentExecutable as ConstructorId
-                val currentExecution = currentExecution!!
-                currentExecution.result
-                    .onSuccess {
-                        methodType = SUCCESSFUL
-
-                        // TODO engine returns UtCompositeModel sometimes (concrete execution?)
-
-                        // TODO support inner classes constructors testing JIRA:1461
-                        require(!constructorCall.classId.isInner) {
-                            "Inner class ${constructorCall.classId} constructor testing is not supported yet"
-                        }
-
-                        actual = newVar(constructorCall.classId, "actual") {
-                            constructorCall(*methodArguments.toTypedArray())
-                        }
-                    }
-                    .onFailure { exception ->
-                        processExecutionFailure(currentExecution, exception)
-                    }
-            }
+            is ConstructorId -> generateConstructorCall(currentExecutable!!, currentExecution!!)
             is BuiltinMethodId -> error("Unexpected BuiltinMethodId $currentExecutable while generating result assertions")
             is MethodId -> {
                 emptyLineIfNeeded()
@@ -434,24 +411,30 @@ internal class CgMethodConstructor(val context: CgContext) : CgContextOwner by c
      */
     private fun generateAssertionsForParameterizedTest() {
         emptyLineIfNeeded()
-        val method = currentExecutable as MethodId
-        currentExecution!!.result
-            .onSuccess { result ->
-                if (result.isUnit()) {
-                    +thisInstance[method](*methodArguments.toTypedArray())
-                } else {
-                    //"generic" expected variable is represented with a wrapper if
-                    //actual result is primitive to support cases with exceptions.
-                    resultModel = if (result is UtPrimitiveModel) assemble(result) else result
 
-                    val expectedVariable = currentMethodParameters[CgParameterKind.ExpectedResult]!!
-                    val expectedExpression = CgNotNullAssertion(expectedVariable)
+        when (currentExecutable) {
+            is ConstructorId -> generateConstructorCall(currentExecutable!!, currentExecution!!)
+            is MethodId -> {
+                val method = currentExecutable as MethodId
+                currentExecution!!.result
+                    .onSuccess { result ->
+                        if (result.isUnit()) {
+                            +thisInstance[method](*methodArguments.toTypedArray())
+                        } else {
+                            //"generic" expected variable is represented with a wrapper if
+                            //actual result is primitive to support cases with exceptions.
+                            resultModel = if (result is UtPrimitiveModel) assemble(result) else result
 
-                    assertEquality(expectedExpression, actual)
-                    println()
-                }
+                            val expectedVariable = currentMethodParameters[CgParameterKind.ExpectedResult]!!
+                            val expectedExpression = CgNotNullAssertion(expectedVariable)
+
+                            assertEquality(expectedExpression, actual)
+                            println()
+                        }
+                    }
+                    .onFailure { thisInstance[method](*methodArguments.toTypedArray()).intercepted() }
             }
-            .onFailure { thisInstance[method](*methodArguments.toTypedArray()).intercepted() }
+        }
     }
 
     /**
@@ -1024,6 +1007,27 @@ internal class CgMethodConstructor(val context: CgContext) : CgContextOwner by c
         generateDeepEqualsOrNullAssertion(expected.expression, actual)
     }
 
+    private fun generateConstructorCall(currentExecutableId: ExecutableId, currentExecution: UtExecution) {
+        // we cannot generate any assertions for constructor testing
+        // but we need to generate a constructor call
+        val constructorCall = currentExecutableId as ConstructorId
+        currentExecution.result
+            .onSuccess {
+                methodType = SUCCESSFUL
+
+                require(!constructorCall.classId.isInner) {
+                    "Inner class ${constructorCall.classId} constructor testing is not supported yet"
+                }
+
+                actual = newVar(constructorCall.classId, "actual") {
+                    constructorCall(*methodArguments.toTypedArray())
+                }
+            }
+            .onFailure { exception ->
+                processExecutionFailure(currentExecution, exception)
+            }
+    }
+
     /**
      * We can't use standard deepEquals method in parametrized tests
      * because nullable objects require different asserts.
@@ -1264,9 +1268,7 @@ internal class CgMethodConstructor(val context: CgContext) : CgContextOwner by c
                 currentMethodParameters[CgParameterKind.Argument(index)] = argument.parameter
             }
 
-            val method = currentExecutable as MethodId
-            val containsFailureExecution = containsFailureExecution(testSet)
-
+            val method = currentExecutable!!
             val expectedResultClassId = wrapTypeIfRequired(method.returnType)
 
             if (expectedResultClassId != voidClassId) {
@@ -1284,6 +1286,7 @@ internal class CgMethodConstructor(val context: CgContext) : CgContextOwner by c
                 currentMethodParameters[CgParameterKind.ExpectedResult] = expectedResult.parameter
             }
 
+            val containsFailureExecution = containsFailureExecution(testSet)
             if (containsFailureExecution) {
                 val classClassId = Class::class.id
                 val expectedException = CgParameterDeclaration(
@@ -1349,7 +1352,7 @@ internal class CgMethodConstructor(val context: CgContext) : CgContextOwner by c
             arguments += variableConstructor.getOrCreateVariable(paramModel, argumentName)
         }
 
-        val method = currentExecutable as MethodId
+        val method = currentExecutable!!
         val needsReturnValue = method.returnType != voidClassId
         val containsFailureExecution = containsFailureExecution(testSet)
         execution.result