Initial implementations of the adapter from JcExecution to UtExecution

settings.gradle.kts

@@ -48,13 +48,13 @@ include("utbot-summary-tests")
 include("utbot-framework-test")
 include("utbot-testing")
 include("utbot-rd")
-include("utbot-android-studio")
+//include("utbot-android-studio")
 
-if (includeRiderInBuild.toBoolean()) {
-    include("utbot-rider")
-}
+//if (includeRiderInBuild.toBoolean()) {
+//    include("utbot-rider")
+//}
 
-include("utbot-ui-commons")
+//include("utbot-ui-commons")
 
 include("utbot-spring-framework")
 include("utbot-spring-commons-api")
@@ -63,14 +63,14 @@ include("utbot-spring-analyzer")
 include("utbot-spring-sample")
 include("utbot-spring-test")
 
-if (javaIde.split(",").contains(ideType)) {
-    include("utbot-intellij")
-}
+//if (javaIde.split(",").contains(ideType)) {
+//   include("utbot-intellij")
+//}
 
 if (pythonIde.split(",").contains(ideType)) {
     include("utbot-python")
     include("utbot-cli-python")
-    include("utbot-intellij-python")
+//    include("utbot-intellij-python")
     include("utbot-python-parser")
     include("utbot-python-types")
     include("utbot-python-executor")
@@ -80,19 +80,19 @@ if (projectType == ultimateEdition) {
     if (jsBuild == buildType || jsIde.split(",").contains(ideType)) {
         include("utbot-js")
         include("utbot-cli-js")
-        include("utbot-intellij-js")
+//        include("utbot-intellij-js")
     }
 
     if (goIde.split(",").contains(ideType)) {
         include("utbot-go")
         include("utbot-cli-go")
-        include("utbot-intellij-go")
+//        include("utbot-intellij-go")
     }
 }
 
 include("utbot-light")
 
-include("utbot-intellij-main")
+//include("utbot-intellij-main")
 
 // TODO usvm-sbft-merge: add if here if we want merge contest it into main
 includeBuild("../usvm")

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

@@ -5,13 +5,16 @@ import org.utbot.framework.plugin.api.UtDirectGetFieldModel
 import org.utbot.framework.plugin.api.UtDirectSetFieldModel
 import org.utbot.framework.plugin.api.UtExecutableCallModel
 import org.utbot.framework.plugin.api.UtExecution
+import org.utbot.framework.plugin.api.UtExecutionResult
+import org.utbot.framework.plugin.api.UtExecutionSuccess
 import org.utbot.framework.plugin.api.UtInstrumentation
 import org.utbot.framework.plugin.api.UtModel
 import org.utbot.framework.plugin.api.UtNewInstanceInstrumentation
 import org.utbot.framework.plugin.api.UtReferenceModel
 import org.utbot.framework.plugin.api.UtStatementCallModel
 import org.utbot.framework.plugin.api.UtStatementModel
 import org.utbot.framework.plugin.api.UtStaticMethodInstrumentation
+import org.utbot.framework.plugin.api.isSuccess
 
 inline fun <reified T : UtModel> T.mapPreservingType(mapper: UtModelMapper): T =
     mapper.map(this, T::class.java)
@@ -54,6 +57,14 @@ fun EnvironmentModels.mapModels(mapper: UtModelMapper) = EnvironmentModels(
     executableToCall = executableToCall,
 )
 
+fun UtExecutionResult.mapModelIfExists(mapper: UtModelMapper) = if (this.isSuccess) {
+    val successResult = this as UtExecutionSuccess
+    UtExecutionSuccess(successResult.model.map(mapper))
+} else {
+    this
+}
+
+
 fun UtInstrumentation.mapModels(mapper: UtModelMapper) = when (this) {
     is UtNewInstanceInstrumentation -> copy(instances = instances.mapModels(mapper))
     is UtStaticMethodInstrumentation -> copy(values = values.mapModels(mapper))

utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/generator/CodeGenerationController.kt

@@ -776,7 +776,6 @@ object CodeGenerationController {
         }
 
         DumbService.getInstance(model.project).runWhenSmart {
-            OptimizeImportsProcessor(project, file).run()
             codeStyleManager.reformat(file)
             when (model.codegenLanguage) {
                 CodegenLanguage.JAVA -> {

utbot-junit-contest/build.gradle

@@ -29,6 +29,7 @@ def testProjects = [
         'build/output/test/seata-core-0.5.0',
         'build/output/test/spoon',
         'build/output/test/spoon-core-7.0.0',
+        'build/output/test/samples',
 ]
 
 sourceSets {
@@ -140,6 +141,8 @@ dependencies {
     implementation group: 'org.mockito', name: 'mockito-inline', version: mockitoInlineVersion
     implementation 'junit:junit:4.13.2'
 
+    implementation "org.burningwave:core:12.62.7"
+
     implementation('org.usvm:usvm-core')
     implementation('org.usvm:usvm-jvm')
     implementation('org.usvm:usvm-jvm-instrumentation')

utbot-junit-contest/src/main/kotlin/org/utbot/contest/ContestEstimator.kt

@@ -354,6 +354,10 @@ interface Tool {
 }
 
 fun main(args: Array<String>) {
+    // See https://dzone.com/articles/how-to-export-all-modules-to-all-modules-at-runtime-in-java?preview=true
+    // `Modules` is `null` on JDK 8 (see comment to StaticComponentContainer.Modules)
+    org.burningwave.core.assembler.StaticComponentContainer.Modules?.exportAllToAll()
+
     val estimatorArgs: Array<String>
     val methodFilter: String?
     val projectFilter: List<String>?

utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt

@@ -11,6 +11,9 @@ import org.objectweb.asm.Type
 import org.usvm.UMachineOptions
 import org.usvm.instrumentation.util.toJcdbSignature
 import org.usvm.machine.JcMachine
+import org.usvm.machine.state.JcState
+import org.utbot.common.ThreadBasedExecutor
+import org.utbot.common.debug
 import org.utbot.common.info
 import org.utbot.common.measureTime
 import org.utbot.contest.*
@@ -24,14 +27,18 @@ import org.utbot.framework.codegen.domain.junitByVersion
 import org.utbot.framework.codegen.generator.CodeGenerator
 import org.utbot.framework.codegen.generator.CodeGeneratorParams
 import org.utbot.framework.codegen.services.language.CgLanguageAssistant
+import org.utbot.framework.minimization.minimizeExecutions
 import org.utbot.framework.plugin.api.*
 import org.utbot.framework.plugin.api.util.constructor
 import org.utbot.framework.plugin.api.util.jClass
 import org.utbot.framework.plugin.api.util.method
 import org.utbot.framework.plugin.services.JdkInfoService
+import org.utbot.fuzzer.ReferencePreservingIntIdGenerator
 import org.utbot.fuzzer.UtFuzzedExecution
+import org.utbot.summary.summarizeAll
 import java.io.File
 import java.net.URLClassLoader
+import java.util.*
 import kotlin.math.max
 
 private val logger = KotlinLogging.logger {}
@@ -80,6 +87,8 @@ fun runUsvmGeneration(
 
     val resolver by lazy { JcTestExecutor(jcDbContainer.cp) }
 
+    val idGenerator = ReferencePreservingIntIdGenerator()
+
     val instructionIds = mutableMapOf<Pair<String, Int>, Long>()
     val instructionIdProvider = InstructionIdProvider { methodSignature, instrIndex ->
         instructionIds.getOrPut(methodSignature to instrIndex) { instructionIds.size.toLong() }
@@ -98,6 +107,7 @@ fun runUsvmGeneration(
 
     //remaining budget
     val startTime = System.currentTimeMillis()
+    logger.debug { "STARTED COUNTING BUDGET FOR ${cut.classId.name}" }
     fun remainingBudgetMillisWithoutCodegen() =
         max(0, generationTimeoutMillisWithoutCodegen - (System.currentTimeMillis() - startTime))
 
@@ -139,14 +149,16 @@ fun runUsvmGeneration(
         val totalBudgetPerMethod = remainingBudgetMillisWithoutCodegen() / filteredMethods.size
         val concreteBudgetMsPerMethod = 500L
             .coerceIn((totalBudgetPerMethod / 10L).. (totalBudgetPerMethod / 2L))
+        val symbolicBudgetPerMethod = totalBudgetPerMethod - concreteBudgetMsPerMethod
+        logger.debug { "Symbolic budget per method: $symbolicBudgetPerMethod" }
 
         // TODO usvm-sbft: reuse same machine for different classes,
         //  right now I can't do that, because `timeoutMs` can't be changed after machine creation
         logger.info().measureTime({ "preparation: creating JcMachine" }) {
             JcMachine(
                 cp = jcDbContainer.cp,
                 // TODO usvm-sbft: we may want to tune UMachineOptions for contest
-                options = UMachineOptions(timeoutMs = totalBudgetPerMethod - concreteBudgetMsPerMethod)
+                options = UMachineOptions(timeoutMs = symbolicBudgetPerMethod)
             )
         }.use { machine ->
             val jcClass = jcDbContainer.cp.findClass(cut.fqn)
@@ -167,7 +179,17 @@ fun runUsvmGeneration(
                     logger.error { "Method [$method] not found in jcClass [$jcClass]" }
                     continue
                 }
-                val states = machine.analyze(jcTypedMethod.method)
+                val states = logger.debug().measureTime({ "machine.analyze(${method.classId}.${method.signature})" }) {
+                    ((ThreadBasedExecutor.threadLocal.invokeWithTimeout(10 * symbolicBudgetPerMethod) {
+                        machine.analyze(jcTypedMethod.method)
+                    } as? Result<List<JcState>>) ?: run {
+                        logger.error { "machine.analyze(${jcTypedMethod.method}) timed out" }
+                        Result.success(emptyList())
+                    }).getOrElse { e ->
+                        logger.error("JcMachine failed", e)
+                        emptyList()
+                    }
+                }
                 val jcExecutions = states.mapNotNull {
                     // TODO usvm-sbft: if we have less than `runner.timeout` budget we should only let resolver run
                     //  for `remainingBudgetMillisWithoutCodegen()` ms, right now last resolver call may exceed budget,
@@ -176,11 +198,13 @@ fun runUsvmGeneration(
                         // TODO usvm-sbft: right now this call fails unless you set:
                         //  - "usvm-jvm-instrumentation-jar" environment variable to something like "/home/ilya/IdeaProjects/usvm/usvm-jvm-instrumentation/build/libs/usvm-jvm-instrumentation-1.0.jar"
                         //  - "usvm-jvm-collectors-jar"  environment variable to something like "/home/ilya/IdeaProjects/usvm/usvm-jvm-instrumentation/build/libs/usvm-jvm-instrumentation-collectors.jar"
-                        runCatching {
-                            resolver.resolve(jcTypedMethod, it)
-                        }.getOrElse { e ->
-                            logger.error(e) { "Resolver failed" }
-                            null
+                        logger.debug().measureTime({ "resolver.resolve(${method.classId}.${method.signature}, ...)" }) {
+                            runCatching {
+                                resolver.resolve(jcTypedMethod, it)
+                            }.getOrElse { e ->
+                                logger.error(e) { "Resolver failed" }
+                                null
+                            }
                         }
                     else null
                 }
@@ -193,7 +217,20 @@ fun runUsvmGeneration(
                 statsForClass.statsForMethods.add(statsForMethod)
 
                 val utExecutions: List<UtExecution> = jcExecutions.mapNotNull {
-                    JcToUtExecutionConverter(instructionIdProvider).convert(it)
+                    logger.debug().measureTime({ "Convert JcExecution" }) {
+                        try {
+                            JcToUtExecutionConverter(
+                                jcExecution = it,
+                                idGenerator = idGenerator,
+                                instructionIdProvider = instructionIdProvider,
+                                utilMethodProvider = codeGenerator.context.utilMethodProvider
+                            ).convert()
+                        } catch (e: Exception) {
+                            val stackTrace = Arrays.toString(e.stackTrace);
+                            logger.error(e) { "Can't convert execution for method ${method.name}, exception is  ${e.message}. \n $stackTrace" }
+                            null
+                        }
+                    }
                 }
 
                 utExecutions.forEach { result ->
@@ -220,19 +257,20 @@ fun runUsvmGeneration(
                         logger.error(e) { "Test generation failed during stats update" }
                     }
                 }
+                logger.debug { "Finished $method" }
             }
         }
     }
 
-// TODO usvm-sbft: codegen, requires proper UtUsvmExecution creation (not just coverage)
+    val testSets = testsByMethod.map { (method, executions) ->
+        UtMethodTestSet(method, minimizeExecutions(executions), jimpleBody = null)
+    }.summarizeAll(cut.classfileDir.toPath(), sourceFile = null)
+
+    logger.info().measureTime({ "Flushing tests for [${cut.simpleName}] on disk" }) {
+        writeTestClass(cut, codeGenerator.generateAsString(testSets))
+    }
 
-//    val testSets = testsByMethod.map { (method, executions) ->
-//        UtMethodTestSet(method, minimizeExecutions(executions), jimpleBody(method))
-//    }.summarizeAll(cut.classfileDir.toPath(), sourceFile = null)
-//
-//    logger.info().measureTime({ "Flushing tests for [${cut.simpleName}] on disk" }) {
-//        writeTestClass(cut, codeGenerator.generateAsString(testSets))
-//    }
+    logger.debug { "STOPPED COUNTING BUDGET FOR ${cut.classId.name}" }
 
     statsForClass
 }

utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt

@@ -0,0 +1,48 @@
+package org.utbot.contest.usvm
+
+import org.jacodb.analysis.library.analyzers.thisInstance
+import org.jacodb.api.JcClassOrInterface
+import org.jacodb.api.JcField
+import org.jacodb.api.JcMethod
+import org.jacodb.api.JcType
+import org.jacodb.api.TypeName
+import org.usvm.instrumentation.testcase.api.UTestInst
+import org.usvm.instrumentation.testcase.descriptor.UTestObjectDescriptor
+import org.usvm.instrumentation.testcase.descriptor.UTestValueDescriptor
+import org.usvm.instrumentation.util.toJavaClass
+import org.usvm.instrumentation.util.toJavaField
+import org.utbot.framework.plugin.api.ClassId
+import org.utbot.framework.plugin.api.ConstructorId
+import org.utbot.framework.plugin.api.ExecutableId
+import org.utbot.framework.plugin.api.FieldId
+import org.utbot.framework.plugin.api.MethodId
+import org.utbot.framework.plugin.api.util.fieldId
+import org.utbot.framework.plugin.api.util.id
+import org.utbot.framework.plugin.api.util.objectClassId
+import org.utbot.framework.plugin.api.util.utContext
+
+fun JcMethod.toExecutableId(): ExecutableId {
+    val type = this.thisInstance.type.classId
+    val parameters = this.parameters.map { it.type.classId }
+
+    if (isConstructor) {
+        return ConstructorId(type, parameters)
+    }
+
+    return MethodId(type, this.name, this.returnType.classId, parameters)
+}
+
+val JcType?.classId: ClassId
+    get() = this?.toJavaClass(utContext.classLoader)?.id ?: objectClassId
+
+val JcClassOrInterface.classId: ClassId
+    get() = this.toJavaClass(utContext.classLoader).id
+
+val TypeName.classId: ClassId
+    get() = ClassId(this.typeName)
+
+val JcField.fieldId: FieldId
+    get() = toJavaField(utContext.classLoader)!!.fieldId
+
+val UTestValueDescriptor.origin: UTestInst?
+    get() = (this as? UTestObjectDescriptor)?.originUTestExpr