Fix codegen to generate tests for nested classes into nested testclasses

Author: volivan239

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

@@ -28,7 +28,6 @@ import org.utbot.framework.plugin.api.util.isPrimitive
 import org.utbot.framework.plugin.api.util.jClass
 import org.utbot.framework.plugin.api.util.longClassId
 import org.utbot.framework.plugin.api.util.method
-import org.utbot.framework.plugin.api.util.objectClassId
 import org.utbot.framework.plugin.api.util.primitiveTypeJvmNameOrNull
 import org.utbot.framework.plugin.api.util.safeJField
 import org.utbot.framework.plugin.api.util.shortClassId

utbot-framework/src/main/kotlin/org/utbot/external/api/UtBotJavaApi.kt

@@ -18,7 +18,6 @@ import org.utbot.framework.plugin.api.MockFramework
 import org.utbot.framework.plugin.api.MockStrategyApi
 import org.utbot.framework.plugin.api.TestCaseGenerator
 import org.utbot.framework.plugin.api.UtExecution
-import org.utbot.framework.plugin.api.UtExecutionCreator
 import org.utbot.framework.plugin.api.UtMethod
 import org.utbot.framework.plugin.api.UtPrimitiveModel
 import org.utbot.framework.plugin.api.UtMethodTestSet

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/Domain.kt

@@ -1,9 +1,13 @@
 package org.utbot.framework.codegen
 
+import org.junit.experimental.runners.Enclosed
 import org.utbot.framework.DEFAULT_CONCRETE_EXECUTION_TIMEOUT_IN_CHILD_PROCESS_MS
 import org.utbot.framework.codegen.model.constructor.builtin.mockitoClassId
 import org.utbot.framework.codegen.model.constructor.builtin.ongoingStubbingClassId
+import org.utbot.framework.codegen.model.constructor.util.CgStatementConstructor
+import org.utbot.framework.codegen.model.tree.CgAnnotation
 import org.utbot.framework.codegen.model.tree.CgClassId
+import org.utbot.framework.codegen.model.tree.CgGetJavaClass
 import org.utbot.framework.plugin.api.BuiltinClassId
 import org.utbot.framework.plugin.api.ClassId
 import org.utbot.framework.plugin.api.CodeGenerationSettingBox
@@ -183,6 +187,7 @@ sealed class TestFramework(
     abstract val methodSourceAnnotation: String
     abstract val methodSourceAnnotationId: ClassId
     abstract val methodSourceAnnotationFqn: String
+    abstract val nestedClassesShouldBeStatic: Boolean
 
     val assertEquals by lazy { assertionId("assertEquals", objectClassId, objectClassId) }
 
@@ -221,6 +226,10 @@ sealed class TestFramework(
     private fun arrayAssertionId(name: String, vararg params: ClassId): MethodId =
             builtinStaticMethodId(arraysAssertionsClass, name, voidClassId, *params)
 
+    abstract fun getAnnotationForNestedClasses(constructor: CgStatementConstructor): CgAnnotation?
+
+    abstract fun getAnnotationForOuterClasses(constructor: CgStatementConstructor): CgAnnotation?
+
     abstract fun getRunTestsCommand(
         executionInvoke: String,
         classPath: String,
@@ -301,6 +310,12 @@ object TestNg : TestFramework(displayName = "TestNG") {
         simpleName = "DataProvider"
     )
 
+    override val nestedClassesShouldBeStatic = true
+
+    override fun getAnnotationForNestedClasses(constructor: CgStatementConstructor) = null
+
+    override fun getAnnotationForOuterClasses(constructor: CgStatementConstructor) = null
+
     @OptIn(ExperimentalStdlibApi::class)
     override fun getRunTestsCommand(
         executionInvoke: String,
@@ -385,6 +400,17 @@ object Junit4 : TestFramework("JUnit4") {
         )
     }
 
+
+    override val nestedClassesShouldBeStatic = true
+
+    override fun getAnnotationForNestedClasses(constructor: CgStatementConstructor) = null
+
+    override fun getAnnotationForOuterClasses(constructor: CgStatementConstructor) =
+        constructor.annotation(
+            runWithAnnotationClassId,
+            CgGetJavaClass(Enclosed::class.id)
+        )
+
     @OptIn(ExperimentalStdlibApi::class)
     override fun getRunTestsCommand(
         executionInvoke: String,
@@ -440,6 +466,12 @@ object Junit5 : TestFramework("JUnit5") {
         arguments = arrayOf(longClassId)
     )
 
+    val nestedTestClassAnnotationId = BuiltinClassId(
+        name = "$JUNIT5_PACKAGE.Nested",
+        canonicalName = "$JUNIT5_PACKAGE.Nested",
+        simpleName = "Nested"
+    )
+
     override val testAnnotationId = BuiltinClassId(
         name = "$JUNIT5_PACKAGE.Test",
         canonicalName = "$JUNIT5_PACKAGE.Test",
@@ -501,9 +533,16 @@ object Junit5 : TestFramework("JUnit5") {
         )
     }
 
+    override val nestedClassesShouldBeStatic = false
+
     private const val junitVersion = "1.7.1" // TODO read it from gradle.properties
     private const val platformJarName: String = "junit-platform-console-standalone-$junitVersion.jar"
 
+    override fun getAnnotationForNestedClasses(constructor: CgStatementConstructor) =
+        constructor.annotation(nestedTestClassAnnotationId)
+
+    override fun getAnnotationForOuterClasses(constructor: CgStatementConstructor) = null
+
     @OptIn(ExperimentalStdlibApi::class)
     override fun getRunTestsCommand(
         executionInvoke: String,

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/model/CodeGenerator.kt

@@ -17,6 +17,7 @@ import org.utbot.framework.plugin.api.CodegenLanguage
 import org.utbot.framework.plugin.api.ExecutableId
 import org.utbot.framework.plugin.api.MockFramework
 import org.utbot.framework.plugin.api.UtMethodTestSet
+import org.utbot.framework.codegen.model.constructor.UtTestClass
 
 class CodeGenerator(
     private val classUnderTest: ClassId,
@@ -62,15 +63,18 @@ class CodeGenerator(
         return generateAsStringWithTestReport(cgTestSets, testClassCustomName)
     }
 
-    fun generateAsStringWithTestReport(
+    private fun generateAsStringWithTestReport(
         cgTestSets: List<CgMethodTestSet>,
         testClassCustomName: String? = null,
-    ): TestsCodeWithTestReport = withCustomContext(testClassCustomName) {
-        context.withClassScope {
-            val testClassFile = CgTestClassConstructor(context).construct(cgTestSets)
-            TestsCodeWithTestReport(renderClassFile(testClassFile), testClassFile.testsGenerationReport)
-        }
-    }
+    ): TestsCodeWithTestReport =
+            withCustomContext(testClassCustomName) {
+                context.withTestClassFileScope {
+                    val testClassFile = CgTestClassConstructor(context).construct(
+                        UtTestClass.fromTestSets(classUnderTest, cgTestSets)
+                    )
+                    TestsCodeWithTestReport(renderClassFile(testClassFile), testClassFile.testsGenerationReport)
+                }
+            }
 
     /**
      * Wrapper function that configures context as needed for utbot-online:

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

@@ -0,0 +1,20 @@
+package org.utbot.framework.codegen.model.constructor
+
+import org.utbot.framework.codegen.model.tree.CgAnnotation
+import org.utbot.framework.codegen.model.tree.CgMethod
+import org.utbot.framework.plugin.api.ClassId
+
+data class TestClassInfo(
+    val collectedTestClassInterfaces: MutableSet<ClassId> = mutableSetOf(),
+    val collectedTestClassAnnotations: MutableSet<CgAnnotation> = mutableSetOf(),
+    val cgDataProviderMethods: MutableList<CgMethod> = mutableListOf(),
+) {
+    var testClassSuperclass: ClassId? = null
+        set(value) {
+            // Assigning a value to the testClassSuperclass when it is already non-null
+            // means that we need the test class to have more than one superclass
+            // which is impossible in Java and Kotlin.
+            require(field == null) { "It is impossible for the test class to have more than one superclass" }
+            field = value
+        }
+}

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

@@ -0,0 +1,39 @@
+package org.utbot.framework.codegen.model.constructor
+
+import org.utbot.framework.plugin.api.ClassId
+import org.utbot.framework.plugin.api.util.enclosingClass
+
+// TODO: seems like this class needs to be renamed
+data class UtTestClass(
+    val classUnderTest: ClassId,
+    val methodTestSets: List<CgMethodTestSet>,
+    val nestedClasses: List<UtTestClass> = listOf()
+) {
+    companion object {
+        fun fromTestSets(classUnderTest: ClassId, testSets: List<CgMethodTestSet>): UtTestClass {
+            val class2methodTestSets = testSets.groupBy { it.executableId.classId }
+            val class2nestedClasses = testSets
+                .map { it.executableId.classId }
+                .flatMap { generateSequence(it) { it.enclosingClass }.takeWhile { it != classUnderTest } }
+                .groupBy { it.enclosingClass ?: error("All of the given to codegen methods should belong to classUnderTest") }
+                .mapValues { (_, v) -> v.distinct() }
+            return constructRecursively(classUnderTest, class2methodTestSets, class2nestedClasses)
+        }
+
+        private fun constructRecursively(
+            clazz: ClassId,
+            class2methodTestSets: Map<ClassId, List<CgMethodTestSet>>,
+            class2nestedClasses: Map<ClassId, List<ClassId>>
+        ): UtTestClass {
+            val currentNestedClasses = class2nestedClasses.getOrDefault(clazz, listOf())
+            val currentMethodTestSets = class2methodTestSets.getOrDefault(clazz, listOf())
+            return UtTestClass(
+                clazz,
+                currentMethodTestSets,
+                currentNestedClasses.map {
+                    constructRecursively(it, class2methodTestSets, class2nestedClasses)
+                }
+            )
+        }
+    }
+}

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/model/constructor/context/CgContext.kt

@@ -52,6 +52,7 @@ import kotlinx.collections.immutable.persistentListOf
 import kotlinx.collections.immutable.persistentMapOf
 import kotlinx.collections.immutable.persistentSetOf
 import org.utbot.framework.codegen.model.constructor.CgMethodTestSet
+import org.utbot.framework.codegen.model.constructor.TestClassInfo
 import org.utbot.framework.codegen.model.constructor.builtin.streamsDeepEqualsMethodId
 import org.utbot.framework.codegen.model.tree.CgParameterKind
 import org.utbot.framework.plugin.api.util.id
@@ -66,7 +67,7 @@ import org.utbot.framework.plugin.api.util.jClass
  * Although, some of the properties are declared as 'var' so that
  * they can be reassigned as well as modified
  *
- * For example, [currentTestClass] and [currentExecutable] can be reassigned
+ * For example, [currentOuterMostTestClass] and [currentExecutable] can be reassigned
  * when we start generating another method or test class
  *
  * [existingVariableNames] is a 'var' property
@@ -79,19 +80,15 @@ internal interface CgContextOwner {
     val classUnderTest: ClassId
 
     // test class currently being generated
-    val currentTestClass: ClassId
+    val currentOuterMostTestClass: ClassId
 
     // current executable under test
     var currentExecutable: ExecutableId?
 
-    // test class superclass (if needed)
-    var testClassSuperclass: ClassId?
+    // TODO: add comments (especially about the case when outerMostTestClassInfo === currentTestClassInfo)
+    var outerMostTestClassInfo: TestClassInfo
 
-    // list of interfaces that the test class must inherit
-    val collectedTestClassInterfaces: MutableSet<ClassId>
-
-    // list of annotations of the test class
-    val collectedTestClassAnnotations: MutableSet<CgAnnotation>
+    var currentTestClassInfo: TestClassInfo
 
     // exceptions that can be thrown inside of current method being built
     val collectedExceptions: MutableSet<ClassId>
@@ -262,7 +259,7 @@ internal interface CgContextOwner {
         }
     }
 
-    fun <R> withClassScope(block: () -> R): R {
+    fun <R> withTestClassFileScope(block: () -> R): R {
         clearClassScope()
         return try {
             block()
@@ -271,6 +268,16 @@ internal interface CgContextOwner {
         }
     }
 
+    fun <R> withTestClassScope(block: () -> R): R {
+        val savedCurrentTestClassInfo = currentTestClassInfo
+        currentTestClassInfo = TestClassInfo()
+        return try {
+            block()
+        } finally {
+            currentTestClassInfo = savedCurrentTestClassInfo
+        }
+    }
+
     /**
      * Set [mockFrameworkUsed] flag to true if the block is successfully executed
      */
@@ -307,6 +314,8 @@ internal interface CgContextOwner {
     }
 
     private fun clearClassScope() {
+        outerMostTestClassInfo = TestClassInfo()
+        currentTestClassInfo = outerMostTestClassInfo
         collectedImports.clear()
         importedStaticMethods.clear()
         importedClasses.clear()
@@ -321,7 +330,7 @@ internal interface CgContextOwner {
      * Check whether a method is an util method of the current class
      */
     val MethodId.isUtil: Boolean
-        get() = this in currentTestClass.possibleUtilMethodIds
+        get() = this in currentOuterMostTestClass.possibleUtilMethodIds
 
     /**
      * Checks is it our util reflection field getter method.
@@ -335,49 +344,49 @@ internal interface CgContextOwner {
     // util methods of current test class
 
     val getUnsafeInstance: MethodId
-        get() = currentTestClass.getUnsafeInstanceMethodId
+        get() = currentOuterMostTestClass.getUnsafeInstanceMethodId
 
     val createInstance: MethodId
-        get() = currentTestClass.createInstanceMethodId
+        get() = currentOuterMostTestClass.createInstanceMethodId
 
     val createArray: MethodId
-        get() = currentTestClass.createArrayMethodId
+        get() = currentOuterMostTestClass.createArrayMethodId
 
     val setField: MethodId
-        get() = currentTestClass.setFieldMethodId
+        get() = currentOuterMostTestClass.setFieldMethodId
 
     val setStaticField: MethodId
-        get() = currentTestClass.setStaticFieldMethodId
+        get() = currentOuterMostTestClass.setStaticFieldMethodId
 
     val getFieldValue: MethodId
-        get() = currentTestClass.getFieldValueMethodId
+        get() = currentOuterMostTestClass.getFieldValueMethodId
 
     val getStaticFieldValue: MethodId
-        get() = currentTestClass.getStaticFieldValueMethodId
+        get() = currentOuterMostTestClass.getStaticFieldValueMethodId
 
     val getEnumConstantByName: MethodId
-        get() = currentTestClass.getEnumConstantByNameMethodId
+        get() = currentOuterMostTestClass.getEnumConstantByNameMethodId
 
     val deepEquals: MethodId
-        get() = currentTestClass.deepEqualsMethodId
+        get() = currentOuterMostTestClass.deepEqualsMethodId
 
     val arraysDeepEquals: MethodId
-        get() = currentTestClass.arraysDeepEqualsMethodId
+        get() = currentOuterMostTestClass.arraysDeepEqualsMethodId
 
     val iterablesDeepEquals: MethodId
-        get() = currentTestClass.iterablesDeepEqualsMethodId
+        get() = currentOuterMostTestClass.iterablesDeepEqualsMethodId
 
     val streamsDeepEquals: MethodId
-        get() = currentTestClass.streamsDeepEqualsMethodId
+        get() = currentOuterMostTestClass.streamsDeepEqualsMethodId
 
     val mapsDeepEquals: MethodId
-        get() = currentTestClass.mapsDeepEqualsMethodId
+        get() = currentOuterMostTestClass.mapsDeepEqualsMethodId
 
     val hasCustomEquals: MethodId
-        get() = currentTestClass.hasCustomEqualsMethodId
+        get() = currentOuterMostTestClass.hasCustomEqualsMethodId
 
     val getArrayLength: MethodId
-        get() = currentTestClass.getArrayLengthMethodId
+        get() = currentOuterMostTestClass.getArrayLengthMethodId
 }
 
 /**
@@ -386,8 +395,8 @@ internal interface CgContextOwner {
 internal data class CgContext(
     override val classUnderTest: ClassId,
     override var currentExecutable: ExecutableId? = null,
-    override val collectedTestClassInterfaces: MutableSet<ClassId> = mutableSetOf(),
-    override val collectedTestClassAnnotations: MutableSet<CgAnnotation> = mutableSetOf(),
+    override var outerMostTestClassInfo: TestClassInfo = TestClassInfo(),
+    override var currentTestClassInfo: TestClassInfo = outerMostTestClassInfo,
     override val collectedExceptions: MutableSet<ClassId> = mutableSetOf(),
     override val collectedMethodAnnotations: MutableSet<CgAnnotation> = mutableSetOf(),
     override val collectedImports: MutableSet<Import> = mutableSetOf(),
@@ -425,7 +434,7 @@ internal data class CgContext(
     override lateinit var statesCache: EnvironmentFieldStateCache
     override lateinit var actual: CgVariable
 
-    override val currentTestClass: ClassId by lazy {
+    override val currentOuterMostTestClass: ClassId by lazy {
         val packagePrefix = if (testClassPackageName.isNotEmpty()) "$testClassPackageName." else ""
         val simpleName = testClassCustomName ?: "${createTestClassName(classUnderTest.name)}Test"
         val name = "$packagePrefix$simpleName"
@@ -436,20 +445,11 @@ internal data class CgContext(
         )
     }
 
-    override var testClassSuperclass: ClassId? = null
-        set(value) {
-            // Assigning a value to the testClassSuperclass when it is already non-null
-            // means that we need the test class to have more than one superclass
-            // which is impossible in Java and Kotlin.
-            require(field == null) { "It is impossible for the test class to have more than one superclass" }
-            field = value
-        }
-
     override var valueByModel: IdentityHashMap<UtModel, CgValue> = IdentityHashMap()
 
     override var valueByModelId: MutableMap<Int?, CgValue> = mutableMapOf()
 
     override val currentMethodParameters: MutableMap<CgParameterKind, CgVariable> = mutableMapOf()
 
-    override val testClassThisInstance: CgThisInstance = CgThisInstance(currentTestClass)
+    override val testClassThisInstance: CgThisInstance = CgThisInstance(currentOuterMostTestClass)
 }