Some awful attempts

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

@@ -0,0 +1,13 @@
+package org.utbot.contest.usvm
+
+import org.jacodb.api.JcType
+import org.jacodb.api.TypeName
+import org.utbot.framework.plugin.api.ClassId
+import org.utbot.framework.plugin.api.util.id
+import org.utbot.framework.plugin.api.util.objectClassId
+
+val JcType?.classId: ClassId
+    get() = this?.javaClass?.id ?: objectClassId
+
+val TypeName.classId: ClassId
+    get() = ClassId(this.typeName)

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

@@ -14,6 +14,7 @@ import org.usvm.instrumentation.util.enclosingClass
 import org.usvm.instrumentation.util.enclosingMethod
 import org.utbot.contest.usvm.executor.JcExecution
 import org.utbot.framework.plugin.api.Coverage
+import org.utbot.framework.plugin.api.EnvironmentModels
 import org.utbot.framework.plugin.api.Instruction
 import org.utbot.framework.plugin.api.MissingState
 import org.utbot.framework.plugin.api.UtExecution
@@ -29,51 +30,49 @@ import java.util.*
 class JcToUtExecutionConverter(
     private val instructionIdProvider: InstructionIdProvider
 ) {
-    private val valueConstructor = Descriptor2ValueConverter(utContext.classLoader)
 
-    private val utModelConstructor = UtModelConstructor(
-        objectToModelCache = IdentityHashMap(),
-        idGenerator = StateBeforeAwareIdGenerator(allPreExistingModels = emptySet()),
-        utModelWithCompositeOriginConstructorFinder = { classId ->
-            javaStdLibModelWithCompositeOriginConstructors[classId.jClass]?.invoke()
-        }
-    )
+    private val modelConverter = JcToUtModelConverter()
 
     fun convert(jcExecution: JcExecution): UtExecution? {
-        // TODO usvm-sbft: convert everything other than coverage
-        return UtUsvmExecution(
-            stateBefore = MissingState,
-            stateAfter = MissingState,
-            result = UtExecutionSuccess(UtVoidModel),
-            coverage = convertCoverage(getTrace(jcExecution.uTestExecutionResult), jcExecution.method.enclosingType.jcClass),
-            instrumentation = emptyList()
-        )
-//        val coverage = Coverage(convertCoverage())
-//        return when (jcExecution.uTestExecutionResult) {
-//            is UTestExecutionSuccessResult -> {
-//
-//                TODO("usvm-sbft")
-//            }
-//            is UTestExecutionExceptionResult -> TODO("usvm-sbft")
-//            is UTestExecutionInitFailedResult -> {
-//                val exception =
-//                    valueConstructor.buildObjectFromDescriptor(jcExecution.uTestExecutionResult.cause) as Throwable
-//                logger.error(exception) { "Concrete executor failed" }
-//                null
-//            }
-//            is UTestExecutionFailedResult -> {
-//                val exception =
-//                    valueConstructor.buildObjectFromDescriptor(jcExecution.uTestExecutionResult.cause) as Throwable
-//                if (!jcExecution.uTestExecutionResult.cause.raisedByUserCode)
-//                    logger.error(exception) { "Concrete executor failed" }
-//                // TODO usvm-sbft
-//                null
-//            }
-//            is UTestExecutionTimedOutResult -> {
-//                // TODO usvm-sbft
-//                null
-//            }
-//        }
+        val coverage = convertCoverage(getTrace(jcExecution.uTestExecutionResult), jcExecution.method.enclosingType.jcClass)
+
+        val executionResult = jcExecution.uTestExecutionResult
+        return when (executionResult) {
+            is UTestExecutionSuccessResult -> {
+                val result = UtExecutionSuccess(modelConverter.convert(executionResult.result))
+
+                UtUsvmExecution(
+                    stateBefore = MissingState,
+                    stateAfter = MissingState,
+                    result = result,
+                    coverage = coverage,
+                    instrumentation = emptyList()
+                )
+            }
+
+            is UTestExecutionExceptionResult -> TODO("usvm-sbft")
+            is UTestExecutionInitFailedResult -> {
+                val exception =
+                    valueConstructor.buildObjectFromDescriptor(jcExecution.uTestExecutionResult.cause) as Throwable
+                logger.error(exception) { "Concrete executor failed" }
+                null
+            }
+
+            is UTestExecutionFailedResult -> {
+                val exception =
+                    valueConstructor.buildObjectFromDescriptor(jcExecution.uTestExecutionResult.cause) as Throwable
+                if (!jcExecution.uTestExecutionResult.cause.raisedByUserCode)
+                    logger.error(exception) { "Concrete executor failed" }
+                // TODO usvm-sbft
+                null
+            }
+
+            is UTestExecutionTimedOutResult -> {
+                // TODO usvm-sbft
+                null
+            }
+        }
+
     }
 
     private fun getTrace(executionResult: UTestExecutionResult): List<JcInst>? = when (executionResult) {
@@ -86,13 +85,13 @@ class JcToUtExecutionConverter(
 
     private fun convertCoverage(jcCoverage: List<JcInst>?, jcClass: JcClassOrInterface) = Coverage(
         coveredInstructions = jcCoverage.orEmpty().map {
-                val methodSignature = it.enclosingMethod.jcdbSignature
-                Instruction(
-                    internalName = it.enclosingClass.name.replace('.', '/'),
-                    methodSignature = methodSignature,
-                    lineNumber = it.lineNumber,
-                    id = instructionIdProvider.provideInstructionId(methodSignature, it.location.index)
-                )
+            val methodSignature = it.enclosingMethod.jcdbSignature
+            Instruction(
+                internalName = it.enclosingClass.name.replace('.', '/'),
+                methodSignature = methodSignature,
+                lineNumber = it.lineNumber,
+                id = instructionIdProvider.provideInstructionId(methodSignature, it.location.index)
+            )
         },
         // TODO usvm-sbft: maybe add cache here
         // TODO usvm-sbft: make sure static initializers are included into instructions count

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

@@ -0,0 +1,131 @@
+package org.utbot.contest.usvm
+
+import org.jacodb.analysis.library.analyzers.thisInstance
+import org.usvm.instrumentation.classloader.WorkerClassLoader
+import org.usvm.instrumentation.testcase.api.UTestExpression
+import org.usvm.instrumentation.testcase.api.UTestMock
+import org.usvm.instrumentation.testcase.api.UTestMockObject
+import org.usvm.instrumentation.testcase.descriptor.Descriptor2ValueConverter
+import org.usvm.instrumentation.testcase.descriptor.UTestValueDescriptor
+import org.usvm.instrumentation.testcase.descriptor.Value2DescriptorConverter
+import org.usvm.instrumentation.testcase.executor.UTestExpressionExecutor
+import org.usvm.instrumentation.util.toJavaClass
+import org.usvm.instrumentation.util.toJavaField
+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.UtCompositeModel
+import org.utbot.framework.plugin.api.UtModel
+import org.utbot.framework.plugin.api.UtNullModel
+import org.utbot.framework.plugin.api.util.fieldId
+import org.utbot.framework.plugin.api.util.id
+import org.utbot.framework.plugin.api.util.jClass
+import org.utbot.framework.plugin.api.util.objectClassId
+import org.utbot.framework.plugin.api.util.utContext
+import org.utbot.instrumentation.instrumentation.execution.constructors.StateBeforeAwareIdGenerator
+import org.utbot.instrumentation.instrumentation.execution.constructors.UtModelConstructor
+import org.utbot.instrumentation.instrumentation.execution.constructors.javaStdLibModelWithCompositeOriginConstructors
+import java.util.*
+
+class JcToUtModelConverter {
+
+    private val classLoader = utContext.classLoader
+    private val toValueConverter = Descriptor2ValueConverter(classLoader)
+
+    // TODO: properly deal with test executor and related features
+    private val testExecutor = UTestExpressionExecutor()
+    private val toDescriptorConverter = Value2DescriptorConverter(WorkerClassLoader(), null)
+
+
+    private val utModelConstructor = UtModelConstructor(
+        objectToModelCache = IdentityHashMap(),
+        idGenerator = StateBeforeAwareIdGenerator(allPreExistingModels = emptySet()),
+        utModelWithCompositeOriginConstructorFinder = { classId ->
+            javaStdLibModelWithCompositeOriginConstructors[classId.jClass]?.invoke()
+        }
+    )
+
+    private val exprToModelCache = mutableMapOf<UTestMock, UtCompositeModel>()
+    private val descrToModelCache = mutableMapOf<UTestValueDescriptor, UtModel>()
+
+    fun convert(valueDescriptor: UTestValueDescriptor?): UtModel {
+        //WTF, how can it happen? but null can be passed here
+        if (valueDescriptor == null) {
+            return UtNullModel(objectClassId)
+        }
+
+        return descrToModelCache.getOrPut(valueDescriptor) {
+            val concreteValue = toValueConverter.buildObjectFromDescriptor(valueDescriptor)
+            val objectType = valueDescriptor.type.toJavaClass(classLoader).id
+
+            val mocklessModel = utModelConstructor.construct(concreteValue, objectType)
+
+            if (mocklessModel !is UtCompositeModel) {
+                return mocklessModel
+            }
+
+            val instantiatingExpr: UTestMock = // TODO: valueDescriptor.instantiatingExpr
+                UTestMockObject(valueDescriptor.type, emptyMap(), emptyMap())
+
+            restoreMockInfo(instantiatingExpr, mocklessModel)
+        }
+    }
+
+
+    private fun restoreMockInfo(
+        mockExpr: UTestMock,
+        mocklessModel: UtCompositeModel,
+    ): UtModel {
+
+        exprToModelCache[mockExpr]?.let { return it }
+
+        val fields = mutableMapOf<FieldId, UtModel>()
+        val mocks = mutableMapOf<ExecutableId, List<UtModel>>()
+
+        val finalModel = UtCompositeModel(
+            id = mocklessModel.id,
+            classId = mocklessModel.classId,
+            isMock = true,
+            fields = fields,
+            mocks = mocks,
+        )
+        exprToModelCache[mockExpr] = finalModel
+
+        fields += mockExpr.fields
+            .entries
+            .associate { (jcField, uTestExpr) ->
+                val fieldType = jcField.toJavaField(classLoader)!!.fieldId.type
+                val fieldId = FieldId(fieldType, jcField.name)
+
+                val fieldModelDescr = exprToDescriptor(uTestExpr)
+
+                val fieldModel = convert(fieldModelDescr)
+                fieldId to fieldModel
+            }
+            .toMutableMap()
+
+        mocks += mockExpr.methods
+            .entries
+            .associate { (jcMethod, uTestExprs) ->
+                val type = jcMethod.thisInstance.type.classId
+                val returnType = jcMethod.returnType.classId
+                val parameters = jcMethod.parameters.map { it.type.classId }
+                val executableId: ExecutableId = MethodId(type, jcMethod.name, returnType, parameters)
+
+                val models = uTestExprs
+                    .map { expr -> exprToDescriptor(expr) }
+                    .map { descr -> convert(descr) }
+
+                executableId to models
+            }
+            .toMutableMap()
+
+        return finalModel
+    }
+
+    private fun exprToDescriptor(expr: UTestExpression): UTestValueDescriptor =
+        toDescriptorConverter
+            .buildDescriptorFromUTestExpr(expr, testExecutor)
+            ?.getOrNull()!!
+            .valueDescriptor!!
+}