Add contextLoads() test #2330 (#2397)

* Add and use `PhasesController.executePhaseWithoutTimeout()`

* Detect and recover from invalid sequences of interactions with `TestContextManager` and make `SpringApiProviderFacade` collect exceptions

* Move `SpringInstrumentationContext` and `SpringUtExecutionInstrumentation` into separate package

* `InstrumentedProcessModel.tryLoadingSpringContext()` and use it

* Refactor code generation

* Add `contextLoads()` test in code generation

* Make `ThrowableSerializer` try to use constructors

* Fix compilation

* Address comments from #2397

Author: IlyaMuravjov

utbot-core/src/main/kotlin/org/utbot/common/ThreadUtil.kt

@@ -36,19 +36,7 @@ class ThreadBasedExecutor {
      * [stopWatch] is used to respect specific situations (such as class loading and transforming) while invoking.
      */
     fun invokeWithTimeout(timeoutMillis: Long, stopWatch: StopWatch? = null, action:() -> Any?) : Result<Any?>? {
-        if (thread?.isAlive != true) {
-            requestQueue = ArrayBlockingQueue<() -> Any?>(1)
-            responseQueue = ArrayBlockingQueue<Result<Any?>>(1)
-
-            thread = thread(name = "executor", isDaemon = true) {
-                try {
-                    while (true) {
-                        val next = requestQueue.take()
-                        responseQueue.offer(kotlin.runCatching { next() })
-                    }
-                } catch (_: InterruptedException) {}
-            }
-        }
+        ensureThreadIsAlive()
 
         requestQueue.offer {
             try {
@@ -83,4 +71,27 @@ class ThreadBasedExecutor {
         }
         return res
     }
+
+    fun invokeWithoutTimeout(action:() -> Any?) : Result<Any?> {
+        ensureThreadIsAlive()
+
+        requestQueue.offer(action)
+        return responseQueue.take()
+    }
+
+    private fun ensureThreadIsAlive() {
+        if (thread?.isAlive != true) {
+            requestQueue = ArrayBlockingQueue<() -> Any?>(1)
+            responseQueue = ArrayBlockingQueue<Result<Any?>>(1)
+
+            thread = thread(name = "executor", isDaemon = true) {
+                try {
+                    while (true) {
+                        val next = requestQueue.take()
+                        responseQueue.offer(kotlin.runCatching { next() })
+                    }
+                } catch (_: InterruptedException) {}
+            }
+        }
+    }
 }

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

@@ -327,7 +327,7 @@ object MissingState : EnvironmentModels(
 )
 
 /**
- * Error happened in traverse.
+ * Error happened during test cases generation.
  */
 data class UtError(
     val description: String,
@@ -1328,6 +1328,7 @@ interface CodeGenerationContext
 interface SpringCodeGenerationContext : CodeGenerationContext {
     val springTestType: SpringTestType
     val springSettings: SpringSettings
+    val springContextLoadingResult: SpringContextLoadingResult?
 }
 
 /**
@@ -1389,11 +1390,15 @@ open class ApplicationContext(
         field: SootField,
         classUnderTest: ClassId,
     ): Boolean = field.isFinal || !field.isPublic
+
+    open fun preventsFurtherTestGeneration(): Boolean = false
+
+    open fun getErrors(): List<UtError> = emptyList()
 }
 
-sealed interface SpringConfiguration {
-    class JavaConfiguration(val classBinaryName: String) : SpringConfiguration
-    class XMLConfiguration(val absolutePath: String) : SpringConfiguration
+sealed class SpringConfiguration(val fullDisplayName: String) {
+    class JavaConfiguration(val classBinaryName: String) : SpringConfiguration(classBinaryName)
+    class XMLConfiguration(val absolutePath: String) : SpringConfiguration(absolutePath)
 }
 
 sealed interface SpringSettings {
@@ -1413,6 +1418,16 @@ sealed interface SpringSettings {
     ) : SpringSettings
 }
 
+/**
+ * [contextLoaded] can be `true` while [exceptions] is not empty,
+ * if we failed to use most specific SpringApi available (e.g. SpringBoot), but
+ * were able to successfully fall back to less specific SpringApi (e.g. PureSpring).
+ */
+class SpringContextLoadingResult(
+    val contextLoaded: Boolean,
+    val exceptions: List<Throwable>
+)
+
 /**
  * Data we get from Spring application context
  * to manage engine and code generator behaviour.
@@ -1438,6 +1453,8 @@ class SpringApplicationContext(
     override val springSettings: SpringSettings,
 ): ApplicationContext(mockInstalled, staticsMockingIsConfigured), SpringCodeGenerationContext {
 
+    override var springContextLoadingResult: SpringContextLoadingResult? = null
+
     companion object {
         private val logger = KotlinLogging.logger {}
     }
@@ -1509,6 +1526,17 @@ class SpringApplicationContext(
         field: SootField,
         classUnderTest: ClassId,
     ): Boolean = field.fieldId in classUnderTest.allDeclaredFieldIds && field.declaringClass.id !in springInjectedClasses
+
+    override fun preventsFurtherTestGeneration(): Boolean =
+        super.preventsFurtherTestGeneration() || springContextLoadingResult?.contextLoaded == false
+
+    override fun getErrors(): List<UtError> =
+        springContextLoadingResult?.exceptions?.map { exception ->
+            UtError(
+                "Failed to load Spring application context",
+                exception
+            )
+        }.orEmpty() + super.getErrors()
 }
 
 enum class SpringTestType(

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

@@ -0,0 +1,5 @@
+package org.utbot.framework.plugin.api.util
+
+object IndentUtil {
+    const val TAB = "    "
+}

utbot-framework-api/src/main/kotlin/org/utbot/framework/process/kryo/ThrowableSerializer.kt

@@ -57,9 +57,9 @@ class ThrowableSerializer : Serializer<Throwable>() {
 
     override fun read(kryo: Kryo, input: Input, type: Class<out Throwable>): Throwable? {
         fun ThrowableModel.toThrowable(): Throwable {
-            val throwableFromBytes = this.serializedExceptionBytes?.let { bytes ->
+            this.serializedExceptionBytes?.let { bytes ->
                 try {
-                    ByteArrayInputStream(bytes).use { byteInputStream ->
+                    return@toThrowable ByteArrayInputStream(bytes).use { byteInputStream ->
                         val objectInputStream = IgnoringUidWrappingObjectInputStream(byteInputStream, kryo.classLoader)
                         objectInputStream.readObject() as Throwable
                     }
@@ -68,14 +68,31 @@ class ThrowableSerializer : Serializer<Throwable>() {
                         logger.warn { "Failed to deserialize ${this.classId} from bytes, cause: $e" }
                         logger.warn { "Falling back to constructing throwable instance from ThrowableModel" }
                     }
-                    null
                 }
             }
-            return throwableFromBytes ?: when {
-                RuntimeException::class.java.isAssignableFrom(classId.jClass) -> RuntimeException(message, cause?.toThrowable())
-                Error::class.java.isAssignableFrom(classId.jClass) -> Error(message, cause?.toThrowable())
-                else -> Exception(message, cause?.toThrowable())
-            }.also {
+
+            val cause = cause?.toThrowable()
+
+            val messageCauseConstructor = runCatching { classId.jClass.getConstructor(String::class.java, Throwable::class.java) }.getOrNull()
+            val causeOnlyConstructor = runCatching { classId.jClass.getConstructor(Throwable::class.java) }.getOrNull()
+            val messageOnlyConstructor = runCatching { classId.jClass.getConstructor(String::class.java) }.getOrNull()
+
+            val throwableFromConstructor = runCatching {
+                when {
+                    messageCauseConstructor != null && message != null && cause != null ->
+                        messageCauseConstructor.newInstance(message, cause)
+
+                    causeOnlyConstructor != null && cause != null -> causeOnlyConstructor.newInstance(cause)
+                    messageOnlyConstructor != null && message != null -> messageOnlyConstructor.newInstance(message)
+                    else -> null
+                }
+            }.getOrNull() as Throwable?
+
+            return (throwableFromConstructor ?: when {
+                RuntimeException::class.java.isAssignableFrom(classId.jClass) -> RuntimeException(message, cause)
+                Error::class.java.isAssignableFrom(classId.jClass) -> Error(message, cause)
+                else -> Exception(message, cause)
+            }).also {
                 it.stackTrace = stackTrace
             }
         }

utbot-framework/build.gradle

@@ -15,6 +15,8 @@ dependencies {
     api project(':utbot-framework-api')
     api project(':utbot-rd')
 
+    implementation project(':utbot-spring-commons-api')
+
     implementation group: 'com.jetbrains.rd', name: 'rd-framework', version: rdVersion
     implementation group: 'com.jetbrains.rd', name: 'rd-core', version: rdVersion
 

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/domain/builtin/SpringBuiltins.kt

@@ -234,7 +234,19 @@ data class CgTestMethodCluster(
 data class CgMethodsCluster(
     override val header: String?,
     override val content: List<CgRegion<CgMethod>>
-) : CgRegion<CgRegion<CgMethod>>()
+) : CgRegion<CgRegion<CgMethod>>() {
+    companion object {
+        fun withoutDocs(methodsList: List<CgMethod>) = CgMethodsCluster(
+            header = null,
+            content = listOf(
+                CgSimpleRegion(
+                    header = null,
+                    content = methodsList
+                )
+            )
+        )
+    }
+}
 
 /**
  * Util entity is either an instance of [CgAuxiliaryClass] or [CgUtilMethod].
@@ -293,10 +305,10 @@ sealed class CgMethod(open val isStatic: Boolean) : CgElement {
 
 class CgTestMethod(
     override val name: String,
-    override val returnType: ClassId,
-    override val parameters: List<CgParameterDeclaration>,
+    override val returnType: ClassId = voidClassId,
+    override val parameters: List<CgParameterDeclaration> = emptyList(),
     override val statements: List<CgStatement>,
-    override val exceptions: Set<ClassId>,
+    override val exceptions: Set<ClassId> = emptySet(),
     override val annotations: List<CgAnnotation>,
     override val visibility: VisibilityModifier = VisibilityModifier.PUBLIC,
     val type: CgTestMethodType,

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/domain/models/CgElement.kt

@@ -24,7 +24,7 @@ import org.utbot.framework.plugin.api.SpringSettings.*
 class SpringCodeGenerator(
     val classUnderTest: ClassId,
     val projectType: ProjectType,
-    val codeGenerationContext: SpringCodeGenerationContext,
+    val springCodeGenerationContext: SpringCodeGenerationContext,
     paramNames: MutableMap<ExecutableId, List<String>> = mutableMapOf(),
     generateUtilClassFile: Boolean = false,
     testFramework: TestFramework = TestFramework.defaultItem,
@@ -61,11 +61,11 @@ class SpringCodeGenerator(
         val testClassModel = SpringTestClassModelBuilder(context).createTestClassModel(classUnderTest, testSets)
 
         logger.info { "Code generation phase started at ${now()}" }
-        val astConstructor = when (codeGenerationContext.springTestType) {
+        val astConstructor = when (springCodeGenerationContext.springTestType) {
             SpringTestType.UNIT_TEST -> CgSpringUnitTestClassConstructor(context)
             SpringTestType.INTEGRATION_TEST ->
-                when (val settings = codeGenerationContext.springSettings) {
-                    is PresentSpringSettings -> CgSpringIntegrationTestClassConstructor(context, settings)
+                when (val settings = springCodeGenerationContext.springSettings) {
+                    is PresentSpringSettings -> CgSpringIntegrationTestClassConstructor(context, springCodeGenerationContext, settings)
                     is AbsentSpringSettings -> error("No Spring settings were provided for Spring integration test generation.")
                 }
         }

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/generator/SpringCodeGenerator.kt

@@ -1,5 +1,7 @@
 package org.utbot.framework.codegen.renderer
 
+import org.utbot.framework.plugin.api.util.IndentUtil
+
 interface CgPrinter {
     fun print(text: String)
     fun println(text: String = "")
@@ -58,6 +60,6 @@ class CgPrinterImpl(
     private operator fun String.times(n: Int): String = repeat(n)
 
     companion object {
-        private const val TAB = "    "
+        private const val TAB = IndentUtil.TAB
     }
 }

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/renderer/CgPrinter.kt

@@ -17,6 +17,7 @@ import org.utbot.framework.codegen.domain.models.CgVariable
 import org.utbot.framework.codegen.domain.models.SpringTestClassModel
 import org.utbot.framework.codegen.domain.models.builders.TypedModelWrappers
 import org.utbot.framework.plugin.api.ClassId
+import org.utbot.framework.plugin.api.UtExecution
 import org.utbot.framework.plugin.api.UtSpringContextModel
 import org.utbot.framework.plugin.api.util.SpringModelUtils.getBeanNameOrNull
 import org.utbot.framework.plugin.api.util.id
@@ -36,6 +37,8 @@ abstract class CgAbstractSpringTestClassConstructor(context: CgContext):
             fields += constructClassFields(testClassModel)
             clearUnwantedVariableModels()
 
+            constructAdditionalTestMethods()?.let { methodRegions += it }
+
             for ((testSetIndex, testSet) in testClassModel.methodTestSets.withIndex()) {
                 updateCurrentExecutable(testSet.executableId)
                 withTestSetIdScope(testSetIndex) {
@@ -48,7 +51,7 @@ abstract class CgAbstractSpringTestClassConstructor(context: CgContext):
                 }
             }
 
-            methodRegions += constructAdditionalMethods()
+            constructAdditionalUtilMethods()?.let { methodRegions += it }
 
             if (currentTestClass == outerMostTestClass) {
                 val utilEntities = collectUtilEntities()
@@ -81,7 +84,13 @@ abstract class CgAbstractSpringTestClassConstructor(context: CgContext):
 
     abstract fun constructClassFields(testClassModel: SpringTestClassModel): List<CgFieldDeclaration>
 
-    abstract fun constructAdditionalMethods(): CgMethodsCluster
+    /**
+     * Here "additional" means that these tests are not obtained from
+     * [UtExecution]s generated by engine or fuzzer, but have another origin.
+     */
+    open fun constructAdditionalTestMethods(): CgMethodsCluster? = null
+
+    open fun constructAdditionalUtilMethods(): CgMethodsCluster? = null
 
     protected fun constructFieldsWithAnnotation(
         annotationClassId: ClassId,