diff --git a/settings.gradle.kts b/settings.gradle.kts index cbeca8b19d..cad5a70f52 100644 --- a/settings.gradle.kts +++ b/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") \ No newline at end of file diff --git a/utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/mapper/Utils.kt b/utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/mapper/Utils.kt index 30bbbe01d7..9c8ed80a8a 100644 --- a/utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/mapper/Utils.kt +++ b/utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/mapper/Utils.kt @@ -5,6 +5,8 @@ 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 @@ -12,6 +14,7 @@ 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 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)) diff --git a/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/generator/CodeGenerationController.kt b/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/generator/CodeGenerationController.kt index 550c366084..02601bc67c 100644 --- a/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/generator/CodeGenerationController.kt +++ b/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 -> { diff --git a/utbot-junit-contest/build.gradle b/utbot-junit-contest/build.gradle index afea753424..27bd4c8c1d 100644 --- a/utbot-junit-contest/build.gradle +++ b/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') diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/ContestEstimator.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/ContestEstimator.kt index 0894c45f05..40abcdcdac 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/ContestEstimator.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/ContestEstimator.kt @@ -354,6 +354,10 @@ interface Tool { } fun main(args: Array) { + // 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 val methodFilter: String? val projectFilter: List? diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt index 8780e74b9a..97b073b2f0 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt +++ b/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, 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,6 +149,8 @@ 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 @@ -146,7 +158,7 @@ fun runUsvmGeneration( 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>) ?: 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,21 @@ fun runUsvmGeneration( statsForClass.statsForMethods.add(statsForMethod) val utExecutions: List = 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) { + logger.error(e) { + "Can't convert execution for method ${method.name}, exception is ${e.message}" + } + null + } + } } utExecutions.forEach { result -> @@ -220,19 +258,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 } \ No newline at end of file diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt new file mode 100644 index 0000000000..70c2551142 --- /dev/null +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt @@ -0,0 +1,50 @@ +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 + ?: error("Can not construct classId for $this") + +val JcClassOrInterface.classId: ClassId + get() = this.toJavaClass(utContext.classLoader).id + +//TODO usvm-sbft: incorrectly converts types of com.google.common.util.concurrent.AtomicDoubleArray. parameters +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 \ No newline at end of file diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt index dee5b56ae7..0f76278ec5 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt @@ -1,81 +1,111 @@ package org.utbot.contest.usvm +import mu.KotlinLogging import org.jacodb.api.JcClassOrInterface +import org.jacodb.api.JcTypedMethod import org.jacodb.api.cfg.JcInst import org.jacodb.api.ext.jcdbSignature import org.usvm.instrumentation.testcase.api.UTestExecutionExceptionResult import org.usvm.instrumentation.testcase.api.UTestExecutionFailedResult import org.usvm.instrumentation.testcase.api.UTestExecutionInitFailedResult import org.usvm.instrumentation.testcase.api.UTestExecutionResult +import org.usvm.instrumentation.testcase.api.UTestExecutionState import org.usvm.instrumentation.testcase.api.UTestExecutionSuccessResult import org.usvm.instrumentation.testcase.api.UTestExecutionTimedOutResult import org.usvm.instrumentation.testcase.descriptor.Descriptor2ValueConverter +import org.usvm.instrumentation.testcase.descriptor.UTestExceptionDescriptor import org.usvm.instrumentation.util.enclosingClass import org.usvm.instrumentation.util.enclosingMethod import org.utbot.contest.usvm.executor.JcExecution +import org.utbot.framework.codegen.domain.builtin.UtilMethodProvider import org.utbot.framework.plugin.api.Coverage +import org.utbot.framework.plugin.api.EnvironmentModels +import org.utbot.framework.plugin.api.ExecutableId import org.utbot.framework.plugin.api.Instruction -import org.utbot.framework.plugin.api.MissingState import org.utbot.framework.plugin.api.UtExecution +import org.utbot.framework.plugin.api.UtExecutionFailure import org.utbot.framework.plugin.api.UtExecutionSuccess +import org.utbot.framework.plugin.api.UtExplicitlyThrownException +import org.utbot.framework.plugin.api.UtImplicitlyThrownException +import org.utbot.framework.plugin.api.UtInstrumentation import org.utbot.framework.plugin.api.UtVoidModel -import org.utbot.framework.plugin.api.util.jClass 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.* +import org.utbot.fuzzer.IdGenerator + +private val logger = KotlinLogging.logger {} class JcToUtExecutionConverter( - private val instructionIdProvider: InstructionIdProvider + private val jcExecution: JcExecution, + private val idGenerator: IdGenerator, + private val instructionIdProvider: InstructionIdProvider, + utilMethodProvider: UtilMethodProvider, ) { - private val valueConstructor = Descriptor2ValueConverter(utContext.classLoader) + private val toValueConverter = Descriptor2ValueConverter(utContext.classLoader) - private val utModelConstructor = UtModelConstructor( - objectToModelCache = IdentityHashMap(), - idGenerator = StateBeforeAwareIdGenerator(allPreExistingModels = emptySet()), - utModelWithCompositeOriginConstructorFinder = { classId -> - javaStdLibModelWithCompositeOriginConstructors[classId.jClass]?.invoke() - } - ) + private var jcToUtModelConverter: 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 -// } -// } + init { + val instToModelConverter = UTestInst2UtModelConverter(idGenerator, utilMethodProvider) + + instToModelConverter.processUTest(jcExecution.uTest) + jcToUtModelConverter = JcToUtModelConverter(idGenerator, instToModelConverter) } + fun convert(): UtExecution? { + val coverage = convertCoverage(getTrace(jcExecution.uTestExecutionResult), jcExecution.method.enclosingType.jcClass) + // TODO usvm-sbft: fill up instrumentation with data from UTest + val instrumentation = emptyList() + + val utUsvmExecution: UtUsvmExecution = when (val executionResult = jcExecution.uTestExecutionResult) { + is UTestExecutionSuccessResult -> UtUsvmExecution( + stateBefore = convertState(executionResult.initialState, jcExecution.method, jcToUtModelConverter), + stateAfter = convertState(executionResult.resultState, jcExecution.method, jcToUtModelConverter), + // TODO usvm-sbft: ask why `UTestExecutionSuccessResult.result` is nullable + result = UtExecutionSuccess(executionResult.result?.let { jcToUtModelConverter.convert(it) } ?: UtVoidModel), + coverage = coverage, + instrumentation = instrumentation, + ) + is UTestExecutionExceptionResult -> { + UtUsvmExecution( + stateBefore = convertState(executionResult.initialState, jcExecution.method, jcToUtModelConverter), + stateAfter = convertState(executionResult.resultState, jcExecution.method, jcToUtModelConverter), + result = createExecutionFailureResult( + executionResult.cause, + jcExecution.method, + ), + coverage = coverage, + instrumentation = instrumentation, + ) + } + + is UTestExecutionInitFailedResult -> { + logger.warn(convertException(executionResult.cause)) { + "Execution failed before method under test call" + } + null + } + + is UTestExecutionFailedResult -> { + logger.error(convertException(executionResult.cause)) { + "Concrete execution failed" + } + null + } + + is UTestExecutionTimedOutResult -> { + // TODO usvm-sbft + null + } + } ?: return null + + return utUsvmExecution + } + + private fun convertException(exceptionDescriptor: UTestExceptionDescriptor): Throwable = + toValueConverter.buildObjectFromDescriptor(exceptionDescriptor.dropStaticFields( + cache = mutableMapOf() + )) as Throwable + private fun getTrace(executionResult: UTestExecutionResult): List? = when (executionResult) { is UTestExecutionExceptionResult -> executionResult.trace is UTestExecutionInitFailedResult -> executionResult.trace @@ -84,15 +114,50 @@ class JcToUtExecutionConverter( is UTestExecutionTimedOutResult -> emptyList() } + private fun convertState( + state: UTestExecutionState, + method: JcTypedMethod, + modelConverter: JcToUtModelConverter, + ): EnvironmentModels { + val thisInstance = + if (method.isStatic) null + else if (method.method.isConstructor) null + else modelConverter.convert(state.instanceDescriptor ?: error("Unexpected null instanceDescriptor")) + val parameters = state.argsDescriptors.map { modelConverter.convert(it ?: error("Unexpected null argDescriptor")) } + val statics = state.statics + .entries + .associate { (jcField, uTestDescr) -> + jcField.fieldId to modelConverter.convert(uTestDescr) + } + val executableId: ExecutableId = method.method.toExecutableId() + return EnvironmentModels(thisInstance, parameters, statics, executableId) + } + + private fun createExecutionFailureResult( + exceptionDescriptor: UTestExceptionDescriptor, + jcTypedMethod: JcTypedMethod, + ): UtExecutionFailure { + val exception = convertException(exceptionDescriptor) + val fromNestedMethod = exception.stackTrace.firstOrNull()?.let { stackTraceElement -> + stackTraceElement.className != jcTypedMethod.enclosingType.jcClass.name || + stackTraceElement.methodName != jcTypedMethod.name + } ?: false + return if (exceptionDescriptor.raisedByUserCode) { + UtExplicitlyThrownException(exception, fromNestedMethod) + } else { + UtImplicitlyThrownException(exception, fromNestedMethod) + } + } + private fun convertCoverage(jcCoverage: List?, 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 diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt new file mode 100644 index 0000000000..ef3f5285b0 --- /dev/null +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt @@ -0,0 +1,157 @@ +package org.utbot.contest.usvm + +import org.usvm.instrumentation.testcase.api.UTestExpression +import org.usvm.instrumentation.testcase.descriptor.UTestArrayDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestClassDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestConstantDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestCyclicReferenceDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestEnumValueDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestExceptionDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestObjectDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestRefDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestValueDescriptor +import org.utbot.framework.plugin.api.FieldId +import org.utbot.framework.plugin.api.UtArrayModel +import org.utbot.framework.plugin.api.UtClassRefModel +import org.utbot.framework.plugin.api.UtCompositeModel +import org.utbot.framework.plugin.api.UtEnumConstantModel +import org.utbot.framework.plugin.api.UtModel +import org.utbot.framework.plugin.api.UtNullModel +import org.utbot.framework.plugin.api.UtPrimitiveModel +import org.utbot.framework.plugin.api.util.classClassId +import org.utbot.framework.plugin.api.util.id +import org.utbot.framework.plugin.api.util.jClass +import org.utbot.framework.plugin.api.util.stringClassId +import org.utbot.fuzzer.IdGenerator +import java.lang.Throwable + +class JcToUtModelConverter( + private val idGenerator: IdGenerator, + private val instToUtModelConverter: UTestInst2UtModelConverter, +) { + private val descriptorToModelCache = mutableMapOf() + private val refIdToDescriptorCache = mutableMapOf() + + fun convert(valueDescriptor: UTestValueDescriptor): UtModel = descriptorToModelCache.getOrPut(valueDescriptor) { + valueDescriptor.origin?.let { originExpr -> + return instToUtModelConverter.findModelByInst(originExpr as UTestExpression) + } + + if (valueDescriptor is UTestRefDescriptor) + refIdToDescriptorCache[valueDescriptor.refId] = valueDescriptor + + return when (valueDescriptor) { + is UTestObjectDescriptor -> { + val fields = mutableMapOf() + + val model = UtCompositeModel( + id = idGenerator.createId(), + classId = valueDescriptor.type.classId, + isMock = false, + mocks = mutableMapOf(), + fields = fields, + ) + + descriptorToModelCache[valueDescriptor] = model + + fields += valueDescriptor.fields + .entries + .associate { (jcField, fieldDescr) -> + val fieldId = FieldId(jcField.type.classId, jcField.name) + val fieldModel = convert(fieldDescr) + fieldId to fieldModel + } + + model + } + + is UTestArrayDescriptor.Array -> { + val stores = mutableMapOf() + + val model = UtArrayModel( + id = idGenerator.createId(), + classId = valueDescriptor.type.classId, + length = valueDescriptor.length, + constModel = UtNullModel(valueDescriptor.elementType.classId), + stores = stores, + ) + + descriptorToModelCache[valueDescriptor] = model + + valueDescriptor.value + .map { elemDescr -> convert(elemDescr) } + .forEachIndexed { index, elemModel -> stores += index to elemModel } + + model + } + + is UTestArrayDescriptor.BooleanArray -> constructPrimitiveArray(valueDescriptor, valueDescriptor.value.toList()) + is UTestArrayDescriptor.ByteArray -> constructPrimitiveArray(valueDescriptor, valueDescriptor.value.toList()) + is UTestArrayDescriptor.CharArray -> constructPrimitiveArray(valueDescriptor, valueDescriptor.value.toList()) + is UTestArrayDescriptor.DoubleArray -> constructPrimitiveArray(valueDescriptor, valueDescriptor.value.toList()) + is UTestArrayDescriptor.FloatArray -> constructPrimitiveArray(valueDescriptor, valueDescriptor.value.toList()) + is UTestArrayDescriptor.IntArray -> constructPrimitiveArray(valueDescriptor, valueDescriptor.value.toList()) + is UTestArrayDescriptor.LongArray -> constructPrimitiveArray(valueDescriptor, valueDescriptor.value.toList()) + is UTestArrayDescriptor.ShortArray -> constructPrimitiveArray(valueDescriptor, valueDescriptor.value.toList()) + + is UTestClassDescriptor -> UtClassRefModel( + id = idGenerator.createId(), + classId = classClassId, + value = valueDescriptor.classType.classId, + ) + + is UTestConstantDescriptor.Null -> UtNullModel(valueDescriptor.type.classId) + + is UTestConstantDescriptor.Boolean -> UtPrimitiveModel(valueDescriptor.value) + is UTestConstantDescriptor.Byte -> UtPrimitiveModel(valueDescriptor.value) + is UTestConstantDescriptor.Char -> UtPrimitiveModel(valueDescriptor.value) + is UTestConstantDescriptor.Double -> UtPrimitiveModel(valueDescriptor.value) + is UTestConstantDescriptor.Float -> UtPrimitiveModel(valueDescriptor.value) + is UTestConstantDescriptor.Int -> UtPrimitiveModel(valueDescriptor.value) + is UTestConstantDescriptor.Long -> UtPrimitiveModel(valueDescriptor.value) + is UTestConstantDescriptor.Short -> UtPrimitiveModel(valueDescriptor.value) + is UTestConstantDescriptor.String -> UtPrimitiveModel(valueDescriptor.value) + + is UTestCyclicReferenceDescriptor -> descriptorToModelCache.getValue( + refIdToDescriptorCache.getValue(valueDescriptor.refId) + ) + is UTestEnumValueDescriptor -> UtEnumConstantModel( + id = idGenerator.createId(), + classId = valueDescriptor.type.classId, + value = valueDescriptor.type.classId.jClass.enumConstants.find { + (it as Enum<*>).name == valueDescriptor.enumValueName + } as Enum<*> + ) + is UTestExceptionDescriptor -> UtCompositeModel( + id = idGenerator.createId(), + classId = valueDescriptor.type.classId, + isMock = false, + fields = mutableMapOf( + // TODO usvm-sbft: ask why `UTestExceptionDescriptor.message` is not nullable, support it here + FieldId(Throwable::class.java.id, "detailMessage") to UtPrimitiveModel(valueDescriptor.message) + ) + ) + } + } + + private fun constructPrimitiveArray(valueDescriptor: UTestArrayDescriptor<*>, arrayContent: List): UtArrayModel { + val stores = mutableMapOf() + + val model = UtArrayModel( + id = idGenerator.createId(), + classId = valueDescriptor.type.classId, + length = valueDescriptor.length, + constModel = UtNullModel(valueDescriptor.elementType.classId), + stores = stores, + ) + + descriptorToModelCache[valueDescriptor] = model + + arrayContent + .map { elemValue -> UtPrimitiveModel(elemValue) } + .forEachIndexed { index, elemModel -> stores += index to elemModel } + + return model + } + +} \ No newline at end of file diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt new file mode 100644 index 0000000000..0ceab1c6aa --- /dev/null +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt @@ -0,0 +1,321 @@ +package org.utbot.contest.usvm + +import org.usvm.instrumentation.testcase.UTest +import org.usvm.instrumentation.testcase.api.UTestAllocateMemoryCall +import org.usvm.instrumentation.testcase.api.UTestArithmeticExpression +import org.usvm.instrumentation.testcase.api.UTestArrayGetExpression +import org.usvm.instrumentation.testcase.api.UTestArrayLengthExpression +import org.usvm.instrumentation.testcase.api.UTestArraySetStatement +import org.usvm.instrumentation.testcase.api.UTestBinaryConditionExpression +import org.usvm.instrumentation.testcase.api.UTestBinaryConditionStatement +import org.usvm.instrumentation.testcase.api.UTestBooleanExpression +import org.usvm.instrumentation.testcase.api.UTestByteExpression +import org.usvm.instrumentation.testcase.api.UTestCastExpression +import org.usvm.instrumentation.testcase.api.UTestCharExpression +import org.usvm.instrumentation.testcase.api.UTestClassExpression +import org.usvm.instrumentation.testcase.api.UTestConstructorCall +import org.usvm.instrumentation.testcase.api.UTestCreateArrayExpression +import org.usvm.instrumentation.testcase.api.UTestDoubleExpression +import org.usvm.instrumentation.testcase.api.UTestExpression +import org.usvm.instrumentation.testcase.api.UTestFloatExpression +import org.usvm.instrumentation.testcase.api.UTestGetFieldExpression +import org.usvm.instrumentation.testcase.api.UTestGetStaticFieldExpression +import org.usvm.instrumentation.testcase.api.UTestGlobalMock +import org.usvm.instrumentation.testcase.api.UTestInst +import org.usvm.instrumentation.testcase.api.UTestIntExpression +import org.usvm.instrumentation.testcase.api.UTestLongExpression +import org.usvm.instrumentation.testcase.api.UTestMethodCall +import org.usvm.instrumentation.testcase.api.UTestMockObject +import org.usvm.instrumentation.testcase.api.UTestNullExpression +import org.usvm.instrumentation.testcase.api.UTestSetFieldStatement +import org.usvm.instrumentation.testcase.api.UTestSetStaticFieldStatement +import org.usvm.instrumentation.testcase.api.UTestShortExpression +import org.usvm.instrumentation.testcase.api.UTestStaticMethodCall +import org.usvm.instrumentation.testcase.api.UTestStringExpression +import org.utbot.framework.codegen.domain.builtin.UtilMethodProvider +import org.utbot.framework.plugin.api.ExecutableId +import org.utbot.framework.plugin.api.FieldId +import org.utbot.framework.plugin.api.UtArrayModel +import org.utbot.framework.plugin.api.UtAssembleModel +import org.utbot.framework.plugin.api.UtClassRefModel +import org.utbot.framework.plugin.api.UtCompositeModel +import org.utbot.framework.plugin.api.UtExecutableCallModel +import org.utbot.framework.plugin.api.UtInstrumentation +import org.utbot.framework.plugin.api.UtModel +import org.utbot.framework.plugin.api.UtNullModel +import org.utbot.framework.plugin.api.UtPrimitiveModel +import org.utbot.framework.plugin.api.util.classClassId +import org.utbot.framework.plugin.api.util.objectClassId +import org.utbot.fuzzer.IdGenerator + +class UTestInst2UtModelConverter( + private val idGenerator: IdGenerator, + private val utilMethodProvider: UtilMethodProvider, +) { + private val exprToModelCache = mutableMapOf() + private val instrumentations = mutableListOf() + + fun processUTest(uTest: UTest) { + exprToModelCache.clear() + instrumentations.clear() + + uTest.initStatements.forEach { uInst -> processInst(uInst) } + removeInstantiationCallFromThisInstanceModificationChain(processExpr(uTest.callMethodExpression)) + } + + fun findModelByInst(expr: UTestExpression): UtModel { + val alreadyCreatedModel = exprToModelCache.getValue(expr) + removeInstantiationCallFromThisInstanceModificationChain(alreadyCreatedModel) + return alreadyCreatedModel + } + + private fun removeInstantiationCallFromThisInstanceModificationChain(model: UtModel) { + if (model is UtAssembleModel) { + val instantiationCall = model.instantiationCall + if (instantiationCall is UtExecutableCallModel) { + val instanceModel = instantiationCall.instance as? UtAssembleModel + instanceModel?.let { + (it.modificationsChain as MutableList).remove(instantiationCall) + } + } + } + } + + private fun processInst(uTestInst: UTestInst) { + when (uTestInst) { + is UTestExpression -> processExpr(uTestInst) + + is UTestArraySetStatement -> { + val arrayModel = processExpr(uTestInst.arrayInstance) + require(arrayModel is UtArrayModel) + + val storeIndex = uTestInst.index as UTestIntExpression + val elementModel = processExpr(uTestInst.setValueExpression) + + arrayModel.stores[storeIndex.value] = elementModel + } + + is UTestSetFieldStatement -> { + val instanceExpr = uTestInst.instance + + val instanceModel = processExpr(instanceExpr) + require(instanceModel is UtAssembleModel) + + val fieldType = uTestInst.field.type.classId + val fieldName = uTestInst.field.name + val setValueModel = processExpr(uTestInst.value) + + val methodCall = UtExecutableCallModel( + instance = null, + executable = utilMethodProvider.setFieldMethodId, + params = listOf( + instanceModel, + UtPrimitiveModel(fieldType.name), + UtPrimitiveModel(fieldName), + setValueModel, + ), + ) + + instanceModel?.let { + (it.modificationsChain as MutableList).add(methodCall) + } + } + + is UTestSetStaticFieldStatement -> processExpr(uTestInst.value) + + is UTestBinaryConditionStatement -> error("This expression type is not supported") + } + } + + private fun processExpr(uTestExpr: UTestExpression): UtModel = exprToModelCache.getOrPut(uTestExpr) { + when (uTestExpr) { + is UTestAllocateMemoryCall -> { + val createInstanceCall = UtExecutableCallModel( + instance = null, + executable = utilMethodProvider.createInstanceMethodId, + params = listOf(UtPrimitiveModel(uTestExpr.clazz.classId.name)), + ) + + UtAssembleModel( + id = idGenerator.createId(), + classId = uTestExpr.clazz.classId, + modelName = "", + instantiationCall = createInstanceCall, + ) + } + + is UTestConstructorCall -> { + val constructorCall = UtExecutableCallModel( + instance = null, + executable = uTestExpr.method.toExecutableId(), + params = uTestExpr.args.map { arg -> + processExpr(arg) + }, + ) + + UtAssembleModel( + id = idGenerator.createId(), + classId = uTestExpr.type.classId, + modelName = "", + instantiationCall = constructorCall, + ) + } + + is UTestMethodCall -> { + val instanceModel = processExpr(uTestExpr.instance) + require(instanceModel is UtAssembleModel) + + val methodCall = UtExecutableCallModel( + instance = instanceModel, + executable = uTestExpr.method.toExecutableId(), + params = uTestExpr.args.map { arg -> processExpr(arg) }, + ) + + (instanceModel.modificationsChain as MutableList).add(methodCall) + + UtAssembleModel( + id = idGenerator.createId(), + classId = uTestExpr.type.classId, + modelName = "", + instantiationCall = methodCall, + ) + } + + is UTestStaticMethodCall -> { + UtAssembleModel( + id = idGenerator.createId(), + classId = uTestExpr.type.classId, + modelName = "", + instantiationCall = UtExecutableCallModel( + instance = null, + executable = uTestExpr.method.toExecutableId(), + params = uTestExpr.args.map { arg -> processExpr(arg) }, + ), + ) + } + + is UTestClassExpression -> UtClassRefModel( + id = idGenerator.createId(), + classId = classClassId, + value = uTestExpr.type.classId, + ) + + + is UTestBooleanExpression -> UtPrimitiveModel(uTestExpr.value) + is UTestByteExpression -> UtPrimitiveModel(uTestExpr.value) + is UTestCharExpression -> UtPrimitiveModel(uTestExpr.value) + is UTestDoubleExpression -> UtPrimitiveModel(uTestExpr.value) + is UTestFloatExpression -> UtPrimitiveModel(uTestExpr.value) + is UTestIntExpression -> UtPrimitiveModel(uTestExpr.value) + is UTestLongExpression -> UtPrimitiveModel(uTestExpr.value) + is UTestShortExpression -> UtPrimitiveModel(uTestExpr.value) + is UTestStringExpression -> UtPrimitiveModel(uTestExpr.value) + + is UTestNullExpression -> UtNullModel(uTestExpr.type.classId) + + is UTestCreateArrayExpression -> { + require(uTestExpr.size is UTestIntExpression) + val arrayLength = uTestExpr.size as UTestIntExpression + + UtArrayModel( + id = idGenerator.createId(), + classId = uTestExpr.type.classId, + length = arrayLength.value, + constModel = UtNullModel(objectClassId), + stores = mutableMapOf(), + ) + } + + is UTestGetFieldExpression -> { + val instanceModel = processExpr(uTestExpr.instance) + + val getFieldCall = UtExecutableCallModel( + instance = null, + executable = utilMethodProvider.getFieldValueMethodId, + params = listOf( + instanceModel, + UtPrimitiveModel(uTestExpr.field.type.classId.name), + UtPrimitiveModel(uTestExpr.field.name), + ), + ) + + UtAssembleModel( + id = idGenerator.createId(), + classId = uTestExpr.type.classId, + modelName = "", + instantiationCall = getFieldCall, + ) + } + + is UTestGetStaticFieldExpression -> { + val getStaticFieldCall = UtExecutableCallModel( + instance = null, + executable = utilMethodProvider.getStaticFieldValueMethodId, + params = listOf( + UtPrimitiveModel(uTestExpr.field.type.classId.name), + UtPrimitiveModel(uTestExpr.field.name), + ), + ) + + UtAssembleModel( + id = idGenerator.createId(), + classId = uTestExpr.type.classId, + modelName = "", + instantiationCall = getStaticFieldCall, + ) + } + + is UTestMockObject -> { + val fields = mutableMapOf() + val mocks = mutableMapOf>() + + val newModel = UtCompositeModel( + id = idGenerator.createId(), + classId = uTestExpr.type.classId, + isMock = true, + fields = fields, + mocks = mocks, + ) + exprToModelCache[uTestExpr] = newModel + + fields += uTestExpr.fields + .entries + .associate { (jcField, uTestExpr) -> + jcField.fieldId to processExpr(uTestExpr) + } + + mocks += uTestExpr.methods + .entries + .associate { (jcMethod, uTestExprs) -> + val executableId: ExecutableId = jcMethod.toExecutableId() + val models = uTestExprs.map { expr -> + processExpr(expr) + } + + executableId to models + } + + newModel + } + + is UTestGlobalMock -> { + // TODO usvm-sbft: collect instrumentations here + // UtClassRefModel is returned here for consistency with [Descriptor2ValueConverter] + // which returns Class<*> instance for [UTestGlobalMock] descriptors. + UtClassRefModel( + id = idGenerator.createId(), + classId = classClassId, + value = uTestExpr.type.classId + ) + } + + is UTestArithmeticExpression -> error("This expression type is not supported") + is UTestBinaryConditionExpression -> error("This expression type is not supported") + + is UTestCastExpression -> error("This expression type is not supported") + + is UTestArrayGetExpression -> error("This expression type is not supported") + is UTestArrayLengthExpression -> error("This expression type is not supported") + } + } +} \ No newline at end of file diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestValueDescriptorUtils.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestValueDescriptorUtils.kt new file mode 100644 index 0000000000..ba7dc42ee7 --- /dev/null +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestValueDescriptorUtils.kt @@ -0,0 +1,48 @@ +package org.utbot.contest.usvm + +import org.usvm.instrumentation.testcase.descriptor.UTestArrayDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestClassDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestConstantDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestCyclicReferenceDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestEnumValueDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestExceptionDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestObjectDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestValueDescriptor + +fun UTestValueDescriptor.dropStaticFields( + cache: MutableMap +): UTestValueDescriptor = cache.getOrPut(this) { + when (this) { + is UTestArrayDescriptor.Array -> UTestArrayDescriptor.Array( + elementType = elementType, + length = length, + value = value.map { it.dropStaticFields(cache) }, + refId = refId + ) + + is UTestArrayDescriptor<*> -> this + is UTestClassDescriptor -> this + is UTestConstantDescriptor -> this + is UTestCyclicReferenceDescriptor -> this + is UTestEnumValueDescriptor -> UTestEnumValueDescriptor( + type = type, + enumValueName = enumValueName, + fields = emptyMap(), + refId = refId + ) + + is UTestExceptionDescriptor -> UTestExceptionDescriptor( + type = type, + message = message, + stackTrace = stackTrace.map { it.dropStaticFields(cache) }, + raisedByUserCode = raisedByUserCode + ) + + is UTestObjectDescriptor -> UTestObjectDescriptor( + type = type, + fields = fields.entries.filter { !it.key.isStatic }.associate { it.key to it.value.dropStaticFields(cache) }, + originUTestExpr = originUTestExpr, + refId = refId + ) + } +} \ No newline at end of file diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UtUsvmExecution.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UtUsvmExecution.kt index a7f469ab4d..0964c0c29b 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UtUsvmExecution.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UtUsvmExecution.kt @@ -42,6 +42,26 @@ class UtUsvmExecution( summary, testMethodName, displayName, - instrumentation + instrumentation, + ) + + fun copy( + stateBefore: EnvironmentModels = this.stateBefore, + stateAfter: EnvironmentModels = this.stateAfter, + result: UtExecutionResult = this.result, + coverage: Coverage? = this.coverage, + summary: List? = this.summary, + testMethodName: String? = this.testMethodName, + displayName: String? = this.displayName, + instrumentation: List = this.instrumentation, + ) = UtUsvmExecution( + stateBefore, + stateAfter, + result, + coverage, + summary, + testMethodName, + displayName, + instrumentation, ) } \ No newline at end of file diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/Utils.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/Utils.kt new file mode 100644 index 0000000000..f58c682e26 --- /dev/null +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/Utils.kt @@ -0,0 +1,16 @@ +package org.utbot.contest.usvm + +import org.utbot.framework.plugin.api.mapper.UtModelMapper +import org.utbot.framework.plugin.api.mapper.mapModelIfExists +import org.utbot.framework.plugin.api.mapper.mapModels + +fun UtUsvmExecution.mapModels(mapper: UtModelMapper) = copy( + stateBefore = stateBefore.mapModels(mapper), + stateAfter = stateAfter.mapModels(mapper), + result = result.mapModelIfExists(mapper), + coverage = this.coverage, + summary = this.summary, + testMethodName = this.testMethodName, + displayName = this.displayName, + instrumentation = instrumentation.map { it.mapModels(mapper) }, +) \ No newline at end of file diff --git a/utbot-junit-contest/src/main/resources/classes/samples/list b/utbot-junit-contest/src/main/resources/classes/samples/list new file mode 100644 index 0000000000..df9d9e4e48 --- /dev/null +++ b/utbot-junit-contest/src/main/resources/classes/samples/list @@ -0,0 +1,23 @@ +org.utbot.examples.primitives.IntExamples +org.utbot.examples.primitives.ByteExamples +org.utbot.examples.primitives.CharExamples +org.utbot.examples.primitives.FloatExamples +org.utbot.examples.primitives.DoubleExamples +org.utbot.examples.controlflow.Conditions +org.utbot.examples.controlflow.CycleDependedCondition +org.utbot.examples.controlflow.Cycles +org.utbot.examples.controlflow.Switch +org.utbot.examples.recursion.Recursion +org.utbot.examples.math.BitOperators +org.utbot.examples.math.DivRemExamples +org.utbot.examples.math.DoubleFunctions +org.utbot.examples.wrappers.ShortWrapper +org.utbot.examples.wrappers.LongWrapper +org.utbot.examples.wrappers.IntegerWrapper +org.utbot.examples.wrappers.FloatWrapper +org.utbot.examples.wrappers.DoubleWrapper +org.utbot.examples.wrappers.CharacterWrapper +org.utbot.examples.wrappers.ByteWrapper +org.utbot.examples.wrappers.BooleanWrapper + + diff --git a/utbot-junit-contest/src/main/resources/projects/samples/utbot-sample-2023.11-SNAPSHOT.jar b/utbot-junit-contest/src/main/resources/projects/samples/utbot-sample-2023.11-SNAPSHOT.jar new file mode 100644 index 0000000000..ab0e73badf Binary files /dev/null and b/utbot-junit-contest/src/main/resources/projects/samples/utbot-sample-2023.11-SNAPSHOT.jar differ