From fc570eae3eaffed12671d0199f0629729266239b Mon Sep 17 00:00:00 2001 From: IlyaMuravjov <71839386+IlyaMuravjov@users.noreply.github.com> Date: Fri, 27 Oct 2023 18:18:22 +0300 Subject: [PATCH 001/121] Introduce `Tool.USVM` in `ContestEstimator`, implement `runUsvmGeneration` (#2666) * Add `Tool.USVM` in `ContestEstimator`, implement `runUsvmGeneration` * Remove redundant TODO * Bump UtBot dependencies version to match USVM dependencies * Use `UTestExecutionResult.trace` instead of `JcCoverage` --- gradle.properties | 14 +- settings.gradle.kts | 4 + .../org/utbot/framework/plugin/api/Api.kt | 8 +- utbot-framework-test/build.gradle | 5 +- utbot-framework/build.gradle | 5 +- .../codegen/tree/CgMethodConstructor.kt | 4 +- .../org/utbot/fuzzer/UtFuzzedExecution.kt | 4 +- utbot-junit-contest/build.gradle | 13 + .../main/kotlin/org/utbot/contest/Contest.kt | 6 +- .../org/utbot/contest/ContestEstimator.kt | 100 +++++- .../org/utbot/contest/usvm/ContestUsvm.kt | 238 +++++++++++++ .../contest/usvm/InstructionIdProvider.kt | 8 + .../org/utbot/contest/usvm/JacoDBContainer.kt | 42 +++ .../contest/usvm/JcToUtExecutionConverter.kt | 102 ++++++ .../org/utbot/contest/usvm/UtUsvmExecution.kt | 47 +++ .../contest/usvm/executor/JcExecution.kt | 13 + .../contest/usvm/executor/JcTestExecutor.kt | 313 ++++++++++++++++++ .../contest/usvm/executor/UTestRunner.kt | 24 ++ utbot-testing/build.gradle | 5 +- 19 files changed, 921 insertions(+), 34 deletions(-) create mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt create mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/InstructionIdProvider.kt create mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JacoDBContainer.kt create mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt create mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UtUsvmExecution.kt create mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/executor/JcExecution.kt create mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/executor/JcTestExecutor.kt create mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/executor/UTestRunner.kt diff --git a/gradle.properties b/gradle.properties index d67d7f007d..b3a4e98f68 100644 --- a/gradle.properties +++ b/gradle.properties @@ -41,12 +41,15 @@ junit4PlatformVersion=1.9.0 # NOTE: Mockito versions 5+ are not compatible with Java 8: https://www.davidvlijmincx.com/posts/upgrade-to-mockito-5 mockitoVersion=4.11.0 mockitoInlineVersion=4.11.0 -ksmtVersion=0.4.3 +# TODO usvm-sbft-merge: UtBot engine uses ksmt 0.4.3, while USVM uses ksmt 0.5.7 +ksmtVersion=0.5.7 sootVersion=4.4.0-FORK-2 kotlinVersion=1.8.0 log4j2Version=2.13.3 -coroutinesVersion=1.6.3 -collectionsVersion=0.3.4 +# TODO usvm-sbft-merge: UtBot uses kotlinx.coroutines 1.6.3, while USVM uses kotlinx.coroutines 1.6.4 +coroutinesVersion=1.6.4 +# TODO usvm-sbft-merge: UtBot uses kotlinx.collections 0.3.4, while USVM uses kotlinx.collections 0.3.5 +collectionsVersion=0.3.5 # after updating plugin version you should manually bump corresponding versions in plugin # as they cannot be set from properties # utbot-intellij/build.gradle.kts @@ -56,7 +59,8 @@ intellijPluginVersion=1.13.1 # every time you bump rd version: # 1. regenerate all models # 2. check if rider plugin works -rdVersion=2023.1.2 +# TODO usvm-sbft-merge: UtBot engine uses RD 2023.1.2, while USVM uses RD 2023.2.0 +rdVersion=2023.2.0 # to enable - add -PincludeRiderInBuild=true in build CLI includeRiderInBuild=false jacocoVersion=0.8.8 @@ -77,6 +81,7 @@ testNgVersion=7.6.0 kamlVersion=0.51.0 jacksonVersion=2.12.3 kotlinxSerializationVersion=1.5.0 +# TODO usvm-sbft: USVM uses slf4j 1.6.1 slf4jVersion=1.7.36 eclipseAetherVersion=1.1.0 mavenWagonVersion=3.5.1 @@ -96,6 +101,7 @@ commonsLoggingVersion=1.2 commonsIOVersion=2.11.0 javaxVersion=2.2 jakartaVersion=3.1.0 +jacoDbVersion=1.3.0 # use latest Java 8 compaitable Spring and Spring Boot versions springVersion=5.3.28 diff --git a/settings.gradle.kts b/settings.gradle.kts index 38c5173f3b..cbeca8b19d 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -91,4 +91,8 @@ if (projectType == ultimateEdition) { } include("utbot-light") + 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/Api.kt b/utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/Api.kt index 80a8639b5c..ffb15e7344 100644 --- a/utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/Api.kt +++ b/utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/Api.kt @@ -148,6 +148,10 @@ abstract class UtExecution( val executableToCall get() = stateBefore.executableToCall } +interface UtExecutionWithInstrumentation { + val instrumentation: List +} + /** * Symbolic execution. * @@ -163,7 +167,7 @@ class UtSymbolicExecution( stateBefore: EnvironmentModels, stateAfter: EnvironmentModels, result: UtExecutionResult, - val instrumentation: List, + override val instrumentation: List, val path: MutableList, val fullPath: List, coverage: Coverage? = null, @@ -171,7 +175,7 @@ class UtSymbolicExecution( testMethodName: String? = null, displayName: String? = null, /** Convenient view of the full symbolic path */ val symbolicSteps: List = listOf(), -) : UtExecution(stateBefore, stateAfter, result, coverage, summary, testMethodName, displayName) { +) : UtExecution(stateBefore, stateAfter, result, coverage, summary, testMethodName, displayName), UtExecutionWithInstrumentation { /** * By design the 'before' and 'after' states contain info about the same fields. * It means that it is not possible for a field to be present at 'before' and to be absent at 'after'. diff --git a/utbot-framework-test/build.gradle b/utbot-framework-test/build.gradle index eea8967eb1..5c4bc02926 100644 --- a/utbot-framework-test/build.gradle +++ b/utbot-framework-test/build.gradle @@ -42,8 +42,9 @@ dependencies { testImplementation group: 'org.mockito', name: 'mockito-inline', version: mockitoInlineVersion testImplementation group: 'org.apache.logging.log4j', name: 'log4j-core', version: log4j2Version - implementation group: 'com.github.UnitTestBot.ksmt', name: 'ksmt-core', version: ksmtVersion - implementation group: 'com.github.UnitTestBot.ksmt', name: 'ksmt-z3', version: ksmtVersion + // TODO sbft-usvm-merge: UtBot engine expects `com.github.UnitTestBot.ksmt` here + implementation group: 'io.ksmt', name: 'ksmt-core', version: ksmtVersion + implementation group: 'io.ksmt', name: 'ksmt-z3', version: ksmtVersion } // This is required to avoid conflict between SpringBoot standard logger and the logger of our project. diff --git a/utbot-framework/build.gradle b/utbot-framework/build.gradle index b56b4bfb88..c471f88cef 100644 --- a/utbot-framework/build.gradle +++ b/utbot-framework/build.gradle @@ -42,8 +42,9 @@ dependencies { implementation group: 'org.junit.jupiter', name: 'junit-jupiter-params', version: '5.8.1' implementation group: 'org.junit.jupiter', name: 'junit-jupiter-engine', version: '5.8.1' - implementation group: 'com.github.UnitTestBot.ksmt', name: 'ksmt-core', version: ksmtVersion - implementation group: 'com.github.UnitTestBot.ksmt', name: 'ksmt-z3', version: ksmtVersion + // TODO sbft-usvm-merge: UtBot engine expects `com.github.UnitTestBot.ksmt` here + implementation group: 'io.ksmt', name: 'ksmt-core', version: ksmtVersion + implementation group: 'io.ksmt', name: 'ksmt-z3', version: ksmtVersion fetchInstrumentationJar project(path: ':utbot-instrumentation', configuration: 'instrumentationArchive') } diff --git a/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/tree/CgMethodConstructor.kt b/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/tree/CgMethodConstructor.kt index cc709f84ea..5fbb965f1b 100644 --- a/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/tree/CgMethodConstructor.kt +++ b/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/tree/CgMethodConstructor.kt @@ -99,6 +99,7 @@ import org.utbot.framework.plugin.api.UtExecution import org.utbot.framework.plugin.api.UtExecutionFailure import org.utbot.framework.plugin.api.UtExecutionResult import org.utbot.framework.plugin.api.UtExecutionSuccess +import org.utbot.framework.plugin.api.UtExecutionWithInstrumentation import org.utbot.framework.plugin.api.UtExplicitlyThrownException import org.utbot.framework.plugin.api.UtLambdaModel import org.utbot.framework.plugin.api.UtModel @@ -201,8 +202,7 @@ open class CgMethodConstructor(val context: CgContext) : CgContextOwner by conte protected fun setupInstrumentation() { val instrumentation = when (val execution = currentExecution) { - is UtSymbolicExecution -> execution.instrumentation - is UtFuzzedExecution -> execution.instrumentation + is UtExecutionWithInstrumentation -> execution.instrumentation else -> return } if (instrumentation.isEmpty()) return diff --git a/utbot-java-fuzzing/src/main/kotlin/org/utbot/fuzzer/UtFuzzedExecution.kt b/utbot-java-fuzzing/src/main/kotlin/org/utbot/fuzzer/UtFuzzedExecution.kt index 8ea8b2a459..806f3126ec 100644 --- a/utbot-java-fuzzing/src/main/kotlin/org/utbot/fuzzer/UtFuzzedExecution.kt +++ b/utbot-java-fuzzing/src/main/kotlin/org/utbot/fuzzer/UtFuzzedExecution.kt @@ -22,8 +22,8 @@ class UtFuzzedExecution( displayName: String? = null, val fuzzingValues: List? = null, val fuzzedMethodDescription: FuzzedMethodDescription? = null, - val instrumentation: List = emptyList(), -) : UtExecution(stateBefore, stateAfter, result, coverage, summary, testMethodName, displayName) { + override val instrumentation: List = emptyList(), +) : UtExecution(stateBefore, stateAfter, result, coverage, summary, testMethodName, displayName), UtExecutionWithInstrumentation { /** * By design the 'before' and 'after' states contain info about the same fields. * It means that it is not possible for a field to be present at 'before' and to be absent at 'after'. diff --git a/utbot-junit-contest/build.gradle b/utbot-junit-contest/build.gradle index 52254278f2..afea753424 100644 --- a/utbot-junit-contest/build.gradle +++ b/utbot-junit-contest/build.gradle @@ -139,6 +139,19 @@ dependencies { implementation group: 'org.mockito', name: 'mockito-core', version: mockitoVersion implementation group: 'org.mockito', name: 'mockito-inline', version: mockitoInlineVersion implementation 'junit:junit:4.13.2' + + implementation('org.usvm:usvm-core') + implementation('org.usvm:usvm-jvm') + implementation('org.usvm:usvm-jvm-instrumentation') + + implementation group: "org.jacodb", name: "jacodb-core", version: jacoDbVersion + implementation group: "org.jacodb", name: "jacodb-analysis", version: jacoDbVersion + implementation group: "org.jacodb", name: "jacodb-approximations", version: jacoDbVersion + + // TODO uvms-sbft-hack: UtBot has `fastutil:8.3.0` on the classpath that overrides classes from + // `fastutil-core:8.5.11` that USVM adds. Solution: bump `fastutil` version to `8.5.11` + runtimeOnly("it.unimi.dsi:fastutil:8.5.11") + testImplementation fileTree(dir: 'src/main/resources/projects/', include: '*/*.jar') testImplementation files('src/main/resources/evosuite/evosuite-1.2.0.jar') testImplementation files('src/main/resources/evosuite/evosuite-standalone-runtime-1.2.0.jar') diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/Contest.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/Contest.kt index 896cd35002..3a20f61596 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/Contest.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/Contest.kt @@ -417,7 +417,7 @@ fun runGeneration( statsForClass } -private fun prepareClass(javaClazz: Class<*>, methodNameFilter: String?): List { +fun prepareClass(javaClazz: Class<*>, methodNameFilter: String?): List { //1. all methods from cut val methods = javaClazz.declaredMethods .filterNot { it.isAbstract } @@ -491,11 +491,13 @@ internal fun File.toUrl(): URL = toURI().toURL() internal fun testMethodName(name: String, num: Int): String = "test${name.capitalize()}$num" +// TODO usvm-sbft: does SBFT allow to generate tests for private methods and constructors +// If no, add more filtering here internal val Method.isVisibleFromGeneratedTest: Boolean get() = (this.modifiers and Modifier.ABSTRACT) == 0 && (this.modifiers and Modifier.NATIVE) == 0 -private fun StatsForClass.updateCoverage(newCoverage: Coverage, isNewClass: Boolean, fromFuzzing: Boolean) { +fun StatsForClass.updateCoverage(newCoverage: Coverage, isNewClass: Boolean, fromFuzzing: Boolean) { coverage.update(newCoverage, isNewClass) // other coverage type updates by empty coverage to respect new class val emptyCoverage = newCoverage.copy( 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 d1271f70c2..0894c45f05 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 @@ -26,6 +26,7 @@ import org.utbot.contest.Paths.evosuiteReportFile import org.utbot.contest.Paths.jarsDir import org.utbot.contest.Paths.moduleTestDir import org.utbot.contest.Paths.outputDir +import org.utbot.contest.usvm.runUsvmGeneration import org.utbot.features.FeatureExtractorFactoryImpl import org.utbot.features.FeatureProcessorWithStatesRepetitionFactory import org.utbot.framework.PathSelectorType @@ -125,10 +126,20 @@ object Paths { } @Suppress("unused") -enum class Tool { - UtBot { - @OptIn(ObsoleteCoroutinesApi::class) - @Suppress("EXPERIMENTAL_API_USAGE") +interface Tool { + abstract class UtBotBasedTool : Tool { + abstract fun runGeneration( + project: ProjectToEstimate, + cut: ClassUnderTest, + timeLimit: Long, + fuzzingRatio: Double, + methodNameFilter: String?, + statsForProject: StatsForProject, + compiledTestDir: File, + classFqn: String, + expectedExceptions: ExpectedExceptionsForClass + ) : StatsForClass + override fun run( project: ProjectToEstimate, cut: ClassUnderTest, @@ -142,19 +153,21 @@ enum class Tool { ) = withUtContext(ContextManager.createNewContext(project.classloader)) { val classStats: StatsForClass = try { runGeneration( - project.name, + project, cut, timeLimit, fuzzingRatio, - project.sootClasspathString, - runFromEstimator = true, - expectedExceptions, - methodNameFilter + methodNameFilter, + statsForProject, + compiledTestDir, + classFqn, + expectedExceptions ) } catch (e: CancellationException) { logger.info { "[$classFqn] finished with CancellationException" } return } catch (e: Throwable) { + logger.error(e) { "ISOLATION: $e" } logger.info { "ISOLATION: $e" } logger.info { "continue without compilation" } return @@ -198,8 +211,61 @@ enum class Tool { override fun moveProducedFilesIfNeeded() { // don't do anything } - }, - EvoSuite { + } + + object UtBot : UtBotBasedTool() { + @OptIn(ObsoleteCoroutinesApi::class) + @Suppress("EXPERIMENTAL_API_USAGE") + override fun runGeneration( + project: ProjectToEstimate, + cut: ClassUnderTest, + timeLimit: Long, + fuzzingRatio: Double, + methodNameFilter: String?, + statsForProject: StatsForProject, + compiledTestDir: File, + classFqn: String, + expectedExceptions: ExpectedExceptionsForClass + ): StatsForClass { + return runGeneration( + project.name, + cut, + timeLimit, + fuzzingRatio, + project.sootClasspathString, + runFromEstimator = true, + expectedExceptions, + methodNameFilter + ) + } + } + + object USVM : UtBotBasedTool() { + @OptIn(ObsoleteCoroutinesApi::class) + @Suppress("EXPERIMENTAL_API_USAGE") + override fun runGeneration( + project: ProjectToEstimate, + cut: ClassUnderTest, + timeLimit: Long, + fuzzingRatio: Double, + methodNameFilter: String?, + statsForProject: StatsForProject, + compiledTestDir: File, + classFqn: String, + expectedExceptions: ExpectedExceptionsForClass + ): StatsForClass = runUsvmGeneration( + project.name, + cut, + timeLimit, + fuzzingRatio, + project.sootClasspathString, + runFromEstimator = true, + expectedExceptions, + methodNameFilter + ) + } + + object EvoSuite : Tool { override fun run( project: ProjectToEstimate, cut: ClassUnderTest, @@ -272,7 +338,7 @@ enum class Tool { } }; - abstract fun run( + fun run( project: ProjectToEstimate, cut: ClassUnderTest, timeLimit: Long, @@ -284,7 +350,7 @@ enum class Tool { expectedExceptions: ExpectedExceptionsForClass ) - abstract fun moveProducedFilesIfNeeded() + fun moveProducedFilesIfNeeded() } fun main(args: Array) { @@ -295,7 +361,7 @@ fun main(args: Array) { val tools: List // very special case when you run your project directly from IntellijIDEA omitting command line arguments - if (args.isEmpty() && System.getProperty("os.name")?.run { contains("win", ignoreCase = true) } == true) { + if (args.isEmpty()) { processedClassesThreshold = 9999 //change to change number of classes to run val timeLimit = 20 // increase if you want to debug something val fuzzingRatio = 0.1 // sets fuzzing ratio to total test generation @@ -319,7 +385,8 @@ fun main(args: Array) { // config for SBST 2022 methodFilter = null projectFilter = listOf("fastjson-1.2.50", "guava-26.0", "seata-core-0.5.0", "spoon-core-7.0.0") - tools = listOf(Tool.UtBot) + // TODO usvm-sbft-merge: add if here if we want merge contest it into main + tools = listOf(Tool.USVM) estimatorArgs = arrayOf( classesLists, @@ -339,7 +406,8 @@ fun main(args: Array) { processedClassesThreshold = 9999 methodFilter = null projectFilter = null - tools = listOf(Tool.UtBot) + // TODO usvm-sbft-merge: add if here if we want merge contest it into main + tools = listOf(Tool.USVM) } JdkInfoService.jdkInfoProvider = ContestEstimatorJdkInfoProvider(javaHome) 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 new file mode 100644 index 0000000000..8780e74b9a --- /dev/null +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt @@ -0,0 +1,238 @@ +package org.utbot.contest.usvm + +import kotlinx.coroutines.* +import mu.KotlinLogging +import org.jacodb.api.ext.findClass +import org.jacodb.api.ext.jcdbSignature +import org.jacodb.api.ext.toType +import org.jacodb.approximation.Approximations +import org.jacodb.impl.features.InMemoryHierarchy +import org.objectweb.asm.Type +import org.usvm.UMachineOptions +import org.usvm.instrumentation.util.toJcdbSignature +import org.usvm.machine.JcMachine +import org.utbot.common.info +import org.utbot.common.measureTime +import org.utbot.contest.* +import org.utbot.contest.junitVersion +import org.utbot.contest.testMethodName +import org.utbot.contest.usvm.executor.JcTestExecutor +import org.utbot.contest.usvm.executor.UTestRunner +import org.utbot.framework.codegen.domain.ProjectType +import org.utbot.framework.codegen.domain.RuntimeExceptionTestsBehaviour +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.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.UtFuzzedExecution +import java.io.File +import java.net.URLClassLoader +import kotlin.math.max + +private val logger = KotlinLogging.logger {} + +@ObsoleteCoroutinesApi +@SuppressWarnings +fun runUsvmGeneration( + project: String, + cut: ClassUnderTest, + timeLimitSec: Long, + fuzzingRatio: Double, + classpathString: String, + runFromEstimator: Boolean, + expectedExceptions: ExpectedExceptionsForClass, + methodNameFilter: String? = null // For debug purposes you can specify method name +): StatsForClass = runBlocking { + val testsByMethod: MutableMap> = mutableMapOf() + + val timeBudgetMs = timeLimitSec * 1000 + val generationTimeoutMillisWithoutCodegen: Long = timeBudgetMs - timeBudgetMs * 15 / 100 // 15% to terminate all activities and finalize code in file + + logger.debug { "-----------------------------------------------------------------------------" } + logger.info( + "Contest.runGeneration: Time budget: $timeBudgetMs ms, Generation timeout=$generationTimeoutMillisWithoutCodegen ms, " + + "classpath=$classpathString, methodNameFilter=$methodNameFilter" + ) + + val classpathFiles = classpathString.split(File.pathSeparator).map { File(it) } + + val jcDbContainer by lazy { + JacoDBContainer( + key = classpathString, + classpath = classpathFiles, + ) { + // TODO usvm-sbft: we may want to tune these JcSettings for contest + useJavaRuntime(JdkInfoService.provide().path.toFile()) + installFeatures(InMemoryHierarchy, Approximations) + loadByteCode(classpathFiles) + } + } + + val runner by lazy { + UTestRunner.initRunner(classpathFiles.map { it.absolutePath }, jcDbContainer.cp) + UTestRunner.runner + } + + val resolver by lazy { JcTestExecutor(jcDbContainer.cp) } + + val instructionIds = mutableMapOf, Long>() + val instructionIdProvider = InstructionIdProvider { methodSignature, instrIndex -> + instructionIds.getOrPut(methodSignature to instrIndex) { instructionIds.size.toLong() } + } + + if (runFromEstimator) { + setOptions() + //will not be executed in real contest + logger.info().measureTime({ "warmup: 1st optional JacoDB initialization (not to be counted in time budget)" }) { + jcDbContainer // force init lazy property + } + logger.info().measureTime({ "warmup: 1st optional executor start (not to be counted in time budget)" }) { + runner.ensureRunnerAlive() + } + } + + //remaining budget + val startTime = System.currentTimeMillis() + fun remainingBudgetMillisWithoutCodegen() = + max(0, generationTimeoutMillisWithoutCodegen - (System.currentTimeMillis() - startTime)) + + logger.info("$cut") + + if (cut.classLoader.javaClass != URLClassLoader::class.java) { + logger.error("Seems like classloader for cut not valid (maybe it was backported to system): ${cut.classLoader}") + } + + val statsForClass = StatsForClass(project, cut.fqn) + + val codeGenerator = CodeGenerator( + CodeGeneratorParams( + cut.classId, + projectType = ProjectType.PureJvm, + testFramework = junitByVersion(junitVersion), + staticsMocking = staticsMocking, + forceStaticMocking = forceStaticMocking, + generateWarningsForStaticMocking = false, + cgLanguageAssistant = CgLanguageAssistant.getByCodegenLanguage(CodegenLanguage.defaultItem), + runtimeExceptionTestsBehaviour = RuntimeExceptionTestsBehaviour.PASS, + ) + ) + + logger.info().measureTime({ "class ${cut.fqn}" }, { statsForClass }) { + // TODO usvm-sbft: is it still needed for USVM? + val filteredMethods = logger.info().measureTime({ "preparation class ${cut.clazz}: kotlin reflection :: run" }) { + prepareClass(cut.clazz, methodNameFilter) + } + + logger.info().measureTime({ "preparation: ensure JacoDB is initialized (counted in time budget)" }) { + jcDbContainer // force init lazy property + } + logger.info().measureTime({ "preparation: ensure executor is started (counted in time budget)" }) { + runner.ensureRunnerAlive() + } + + // TODO usvm-sbft: better budget management + val totalBudgetPerMethod = remainingBudgetMillisWithoutCodegen() / filteredMethods.size + val concreteBudgetMsPerMethod = 500L + .coerceIn((totalBudgetPerMethod / 10L).. (totalBudgetPerMethod / 2L)) + + // 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) + ) + }.use { machine -> + val jcClass = jcDbContainer.cp.findClass(cut.fqn) + + statsForClass.methodsCount = filteredMethods.size + + // nothing to process further + if (filteredMethods.isEmpty()) return@runBlocking statsForClass + + for (method in filteredMethods) { + val jcTypedMethod = jcClass.toType().declaredMethods.firstOrNull { + it.name == method.name && it.method.jcdbSignature == when (method) { + is ConstructorId -> method.constructor.toJcdbSignature() + is MethodId -> method.method.toJcdbSignature() + } + } + if (jcTypedMethod == null) { + logger.error { "Method [$method] not found in jcClass [$jcClass]" } + continue + } + val states = machine.analyze(jcTypedMethod.method) + 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, + // essentially stealing some time from codegen + if (remainingBudgetMillisWithoutCodegen() > 0) + // 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 + } + else null + } + + var testsCounter = 0 + val statsForMethod = StatsForMethod( + "${method.classId.simpleName}#${method.name}", + expectedExceptions.getForMethod(method.name).exceptionNames + ) + statsForClass.statsForMethods.add(statsForMethod) + + val utExecutions: List = jcExecutions.mapNotNull { + JcToUtExecutionConverter(instructionIdProvider).convert(it) + } + + utExecutions.forEach { result -> + try { + val testMethodName = testMethodName(method.toString(), ++testsCounter) + val className = Type.getInternalName(method.classId.jClass) + logger.debug { "--new testCase collected, to generate: $testMethodName" } + statsForMethod.testsGeneratedCount++ + result.result.exceptionOrNull()?.let { exception -> + statsForMethod.detectedExceptionFqns += exception::class.java.name + } + result.coverage?.let { + statsForClass.updateCoverage( + newCoverage = it, + isNewClass = !statsForClass.testedClassNames.contains(className), + fromFuzzing = result is UtFuzzedExecution + ) + } + statsForClass.testedClassNames.add(className) + + testsByMethod.getOrPut(method) { mutableListOf() } += result + } catch (e: Throwable) { + //Here we need isolation + logger.error(e) { "Test generation failed during stats update" } + } + } + } + } + } + +// TODO usvm-sbft: codegen, requires proper UtUsvmExecution creation (not just coverage) + +// 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)) +// } + + statsForClass +} \ No newline at end of file diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/InstructionIdProvider.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/InstructionIdProvider.kt new file mode 100644 index 0000000000..252d08f566 --- /dev/null +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/InstructionIdProvider.kt @@ -0,0 +1,8 @@ +package org.utbot.contest.usvm + +fun interface InstructionIdProvider { + fun provideInstructionId( + methodSignature: String, + index: Int, + ): Long +} \ No newline at end of file diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JacoDBContainer.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JacoDBContainer.kt new file mode 100644 index 0000000000..876dc95af4 --- /dev/null +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JacoDBContainer.kt @@ -0,0 +1,42 @@ +package org.utbot.contest.usvm + +import kotlinx.coroutines.runBlocking +import org.jacodb.api.JcClasspath +import org.jacodb.api.JcDatabase +import org.jacodb.impl.JcSettings +import org.jacodb.impl.jacodb +import java.io.File + +// TODO usvm-sbft-refactoring: copied from `usvm/usvm-jvm/test`, extract this class back to USVM project +class JacoDBContainer( + classpath: List, + builder: JcSettings.() -> Unit, +) { + val db: JcDatabase + val cp: JcClasspath + + init { + val (db, cp) = runBlocking { + val db = jacodb(builder) + // TODO usvm-sbft: do we need `db.classpath(classpath)` or `db.classpathWithApproximations(classpath)` for contest? + val cp = db.classpath(classpath) + db to cp + } + this.db = db + this.cp = cp + runBlocking { + db.awaitBackgroundJobs() + } + } + + companion object { + private val keyToJacoDBContainer = HashMap() + + operator fun invoke( + key: Any?, + classpath: List, + builder: JcSettings.() -> Unit, + ): JacoDBContainer = + keyToJacoDBContainer.getOrPut(key) { JacoDBContainer(classpath, builder) } + } +} 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 new file mode 100644 index 0000000000..dee5b56ae7 --- /dev/null +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt @@ -0,0 +1,102 @@ +package org.utbot.contest.usvm + +import org.jacodb.api.JcClassOrInterface +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.UTestExecutionSuccessResult +import org.usvm.instrumentation.testcase.api.UTestExecutionTimedOutResult +import org.usvm.instrumentation.testcase.descriptor.Descriptor2ValueConverter +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.Instruction +import org.utbot.framework.plugin.api.MissingState +import org.utbot.framework.plugin.api.UtExecution +import org.utbot.framework.plugin.api.UtExecutionSuccess +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.* + +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() + } + ) + + 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 +// } +// } + } + + private fun getTrace(executionResult: UTestExecutionResult): List? = when (executionResult) { + is UTestExecutionExceptionResult -> executionResult.trace + is UTestExecutionInitFailedResult -> executionResult.trace + is UTestExecutionSuccessResult -> executionResult.trace + is UTestExecutionFailedResult -> emptyList() + is UTestExecutionTimedOutResult -> emptyList() + } + + 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) + ) + }, + // TODO usvm-sbft: maybe add cache here + // TODO usvm-sbft: make sure static initializers are included into instructions count + // I assume they are counted as part of `` method + instructionsCount = jcClass.declaredMethods.sumOf { it.instList.size.toLong() } + ) +} \ 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 new file mode 100644 index 0000000000..a7f469ab4d --- /dev/null +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UtUsvmExecution.kt @@ -0,0 +1,47 @@ +package org.utbot.contest.usvm + +import org.utbot.framework.plugin.api.Coverage +import org.utbot.framework.plugin.api.DocStatement +import org.utbot.framework.plugin.api.EnvironmentModels +import org.utbot.framework.plugin.api.UtExecution +import org.utbot.framework.plugin.api.UtExecutionResult +import org.utbot.framework.plugin.api.UtExecutionWithInstrumentation +import org.utbot.framework.plugin.api.UtInstrumentation + +class UtUsvmExecution( + stateBefore: EnvironmentModels, + stateAfter: EnvironmentModels, + result: UtExecutionResult, + coverage: Coverage?, + summary: List? = emptyList(), + testMethodName: String? = null, + displayName: String? = null, + override val instrumentation: List +) : UtExecution( + stateBefore, + stateAfter, + result, + coverage, + summary, + testMethodName, + displayName +), UtExecutionWithInstrumentation { + override fun copy( + stateBefore: EnvironmentModels, + stateAfter: EnvironmentModels, + result: UtExecutionResult, + coverage: Coverage?, + summary: List?, + testMethodName: String?, + displayName: String? + ): UtExecution = 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/executor/JcExecution.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/executor/JcExecution.kt new file mode 100644 index 0000000000..2e940c991f --- /dev/null +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/executor/JcExecution.kt @@ -0,0 +1,13 @@ +package org.utbot.contest.usvm.executor + +import org.jacodb.api.JcTypedMethod +import org.usvm.api.JcCoverage +import org.usvm.instrumentation.testcase.UTest +import org.usvm.instrumentation.testcase.api.UTestExecutionResult + +data class JcExecution( + val method: JcTypedMethod, + val uTest: UTest, + val uTestExecutionResult: UTestExecutionResult, + val coverage: JcCoverage +) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/executor/JcTestExecutor.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/executor/JcTestExecutor.kt new file mode 100644 index 0000000000..af7291687e --- /dev/null +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/executor/JcTestExecutor.kt @@ -0,0 +1,313 @@ +package org.utbot.contest.usvm.executor + +import io.ksmt.utils.asExpr +import kotlinx.coroutines.runBlocking +import org.jacodb.api.* +import org.jacodb.api.ext.* +import org.jacodb.impl.fs.BuildFolderLocation +import org.jacodb.impl.fs.JarLocation +import org.usvm.* +import org.usvm.api.JcCoverage +import org.usvm.api.JcTest +import org.usvm.api.typeStreamOf +import org.usvm.collection.array.UArrayIndexLValue +import org.usvm.collection.array.length.UArrayLengthLValue +import org.usvm.collection.field.UFieldLValue +import org.usvm.instrumentation.executor.UTestConcreteExecutor +import org.usvm.instrumentation.testcase.UTest +import org.usvm.instrumentation.testcase.api.* +import org.usvm.machine.JcContext +import org.usvm.machine.extractBool +import org.usvm.machine.extractByte +import org.usvm.machine.extractChar +import org.usvm.machine.extractDouble +import org.usvm.machine.extractFloat +import org.usvm.machine.extractInt +import org.usvm.machine.extractLong +import org.usvm.machine.extractShort +import org.usvm.machine.state.JcState +import org.usvm.machine.state.localIdx +import org.usvm.memory.ULValue +import org.usvm.memory.UReadOnlyMemory +import org.usvm.memory.URegisterStackLValue +import org.usvm.model.UModelBase +import org.usvm.types.first +import org.usvm.types.firstOrNull + +/** + * A class, responsible for resolving a single [JcExecution] for a specific method from a symbolic state. + * + * Uses reflection to resolve objects. + */ +// TODO usvm-sbft-refactoring: copied from `usvm/usvm-jvm/test`, extract this class back to USVM project +class JcTestExecutor( + val classpath: JcClasspath, +) { + + private val runner: UTestConcreteExecutor + get() { + if (!UTestRunner.isInitialized()) { + val pathToJars = + classpath.locations + .filter { it is BuildFolderLocation || (it is JarLocation && it.type == LocationType.APP) } + .map { it.path } + UTestRunner.initRunner(pathToJars, classpath) + } + return UTestRunner.runner + } + + /** + * Resolves a [JcTest] from a [method] from a [state]. + */ + fun resolve(method: JcTypedMethod, state: JcState): JcExecution { + val model = state.models.first() + + val ctx = state.ctx + + val memoryScope = MemoryScope(ctx, model, model, method) + + val uTest = memoryScope.createUTest() + + val execResult = runBlocking { + runner.executeAsync(uTest) + } + + val coverage = resolveCoverage(method, state) + + return JcExecution(method, uTest, execResult, coverage) + } + + @Suppress("UNUSED_PARAMETER") + private fun resolveCoverage(method: JcTypedMethod, state: JcState): JcCoverage { + // TODO: extract coverage + return JcCoverage(emptyMap()) + } + + /** + * An actual class for resolving objects from [UExpr]s. + * + * @param model a model to which compose expressions. + * @param memory a read-only memory to read [ULValue]s from. + */ + private class MemoryScope( + private val ctx: JcContext, + private val model: UModelBase, + private val memory: UReadOnlyMemory, + private val method: JcTypedMethod, + ) { + + private val resolvedCache = mutableMapOf>>() + + fun createUTest(): UTest { + val thisInstance = if (!method.isStatic) { + val ref = URegisterStackLValue(ctx.addressSort, idx = 0) + resolveLValue(ref, method.enclosingType) + } else { + UTestNullExpression(ctx.cp.objectType) to listOf() + } + + val parameters = method.parameters.mapIndexed { idx, param -> + val registerIdx = method.method.localIdx(idx) + val ref = URegisterStackLValue(ctx.typeToSort(param.type), registerIdx) + resolveLValue(ref, param.type) + } + + val initStmts = thisInstance.second + parameters.flatMap { it.second } + val callExpr = if (method.isStatic) { + UTestStaticMethodCall(method.method, parameters.map { it.first }) + } else { + UTestMethodCall(thisInstance.first, method.method, parameters.map { it.first }) + } + return UTest(initStmts, callExpr) + } + + + fun resolveLValue(lvalue: ULValue<*, *>, type: JcType): Pair> = + resolveExpr(memory.read(lvalue), type) + + + fun resolveExpr(expr: UExpr, type: JcType): Pair> = + when (type) { + is JcPrimitiveType -> resolvePrimitive(expr, type) + is JcRefType -> resolveReference(expr.asExpr(ctx.addressSort), type) + else -> error("Unexpected type: $type") + } + + fun resolvePrimitive( + expr: UExpr, type: JcPrimitiveType + ): Pair> { + val exprInModel = evaluateInModel(expr) + return when (type) { + ctx.cp.boolean -> UTestBooleanExpression(extractBool(exprInModel) ?: false, ctx.cp.boolean) + ctx.cp.short -> UTestShortExpression(extractShort(exprInModel) ?: 0, ctx.cp.short) + ctx.cp.int -> UTestIntExpression(extractInt(exprInModel) ?: 0, ctx.cp.int) + ctx.cp.long -> UTestLongExpression(extractLong(exprInModel) ?: 0L, ctx.cp.long) + ctx.cp.float -> UTestFloatExpression(extractFloat(exprInModel) ?: 0.0f, ctx.cp.float) + ctx.cp.double -> UTestDoubleExpression(extractDouble(exprInModel) ?: 0.0, ctx.cp.double) + ctx.cp.byte -> UTestByteExpression(extractByte(exprInModel) ?: 0, ctx.cp.byte) + ctx.cp.char -> UTestCharExpression(extractChar(exprInModel) ?: '\u0000', ctx.cp.char) + ctx.cp.void -> UTestNullExpression(ctx.cp.void) + else -> error("Unexpected type: ${type.typeName}") + }.let { it to listOf() } + } + + fun resolveReference(heapRef: UHeapRef, type: JcRefType): Pair> { + val ref = evaluateInModel(heapRef) as UConcreteHeapRef + if (ref.address == NULL_ADDRESS) { + return UTestNullExpression(type) to listOf() + } + // to find a type, we need to understand the source of the object + val typeStream = if (ref.address <= INITIAL_INPUT_ADDRESS) { + // input object + model.typeStreamOf(ref) + } else { + // allocated object + memory.typeStreamOf(ref) + }.filterBySupertype(type) + + // We filter allocated object type stream, because it could be stored in the input array, + // which resolved to a wrong type, since we do not build connections between element types + // and array types right now. + // In such cases, we need to resolve this element to null. + + val evaluatedType = typeStream.firstOrNull() ?: return UTestNullExpression(type) to listOf() + + // We check for the type stream emptiness firsly and only then for the resolved cache, + // because even if the object is already resolved, it could be incompatible with the [type], if it + // is an element of an array of the wrong type. + + return resolvedCache.getOrElse(ref.address) { + when (evaluatedType) { + is JcArrayType -> resolveArray(ref, heapRef, evaluatedType) + is JcClassType -> resolveObject(ref, heapRef, evaluatedType) + else -> error("Unexpected type: $type") + } + } + } + + private fun resolveArray( + ref: UConcreteHeapRef, heapRef: UHeapRef, type: JcArrayType + ): Pair> { + val arrayDescriptor = ctx.arrayDescriptorOf(type) + val lengthRef = UArrayLengthLValue(heapRef, arrayDescriptor, ctx.sizeSort) + val resolvedLength = resolveLValue(lengthRef, ctx.cp.int).first as UTestIntExpression + // TODO hack + val length = + if (resolvedLength.value in 0..10_000) { + resolvedLength + } else { + UTestIntExpression(0, ctx.cp.int) + } + + val cellSort = ctx.typeToSort(type.elementType) + + fun resolveElement(idx: Int): Pair> { + val elemRef = UArrayIndexLValue(cellSort, heapRef, ctx.mkBv(idx), arrayDescriptor) + return resolveLValue(elemRef, type.elementType) + } + + //val arrLength = UTestIntExpression(length, ctx.cp.int) + val arrayInstance = UTestCreateArrayExpression(type.elementType, length) + + val arraySetters = buildList { + for (i in 0 until length.value) { + with(resolveElement(i)) { + add(UTestArraySetStatement(arrayInstance, UTestIntExpression(i, ctx.cp.int), first)) + addAll(second) + } + } + } + + resolvedCache[ref.address] = arrayInstance to arraySetters + return arrayInstance to arraySetters + } + + private fun resolveObject( + ref: UConcreteHeapRef, heapRef: UHeapRef, type: JcRefType + ): Pair> { + + if (type.jcClass == ctx.classType.jcClass && ref.address <= INITIAL_STATIC_ADDRESS) { + // Note that non-negative addresses are possible only for the result value. + return resolveAllocatedClass(ref) + } + + if (type.jcClass == ctx.stringType.jcClass && ref.address <= INITIAL_STATIC_ADDRESS) { + // Note that non-negative addresses are possible only for the result value. + return resolveAllocatedString(ref) + } + + val anyEnumAncestor = type.getEnumAncestorOrNull() + if (anyEnumAncestor != null) { + return resolveEnumValue(heapRef, anyEnumAncestor) + } + + + val exprs = mutableListOf() + val instance = UTestAllocateMemoryCall(type.jcClass) + + val fieldSetters = mutableListOf() + resolvedCache[ref.address] = instance to fieldSetters + + exprs.add(instance) + + val fields = + generateSequence(type.jcClass) { it.superClass } + .map { it.toType() } + .flatMap { it.declaredFields } + .filter { !it.isStatic } + + for (field in fields) { + val lvalue = UFieldLValue(ctx.typeToSort(field.fieldType), heapRef, field.field) + val fieldValue = resolveLValue(lvalue, field.fieldType) + val uTestSetFieldStmt = UTestSetFieldStatement(instance, field.field, fieldValue.first) + fieldSetters.addAll(fieldValue.second) + fieldSetters.add(uTestSetFieldStmt) + } + return instance to fieldSetters + } + + private fun resolveEnumValue( + heapRef: UHeapRef, + enumAncestor: JcClassOrInterface + ): Pair> { + with(ctx) { + val ordinalLValue = UFieldLValue(sizeSort, heapRef, enumOrdinalField) + val ordinalFieldValue = resolveLValue(ordinalLValue, cp.int).first as UTestIntExpression + val enumField = enumAncestor.enumValues?.get(ordinalFieldValue.value) + ?: error("Cant find enum field with index ${ordinalFieldValue.value}") + + return UTestGetStaticFieldExpression(enumField) to listOf() + } + } + + private fun resolveAllocatedClass(ref: UConcreteHeapRef): Pair> { + val classTypeField = ctx.classTypeSyntheticField + val classTypeLValue = UFieldLValue(ctx.addressSort, ref, classTypeField) + val classTypeRef = memory.read(classTypeLValue) as? UConcreteHeapRef + ?: error("No type for allocated class") + + val classType = memory.typeStreamOf(classTypeRef).first() + return UTestClassExpression(classType) to listOf() + } + + private fun resolveAllocatedString(ref: UConcreteHeapRef): Pair> { + val valueField = ctx.stringValueField + val strValueLValue = UFieldLValue(ctx.typeToSort(valueField.fieldType), ref, valueField.field) + return resolveLValue(strValueLValue, valueField.fieldType) + } + + /** + * If we resolve state after, [expr] is read from a state memory, so it requires concretization via [model]. + * + * @return a concretized expression. + */ + private fun evaluateInModel(expr: UExpr): UExpr { + return model.eval(expr) + } + + // TODO simple org.jacodb.api.ext.JcClasses.isEnum does not work with enums with abstract methods + private fun JcRefType.getEnumAncestorOrNull(): JcClassOrInterface? = + (sequenceOf(jcClass) + jcClass.allSuperHierarchySequence).firstOrNull { it.isEnum } + } + +} \ No newline at end of file diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/executor/UTestRunner.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/executor/UTestRunner.kt new file mode 100644 index 0000000000..8428cc757a --- /dev/null +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/executor/UTestRunner.kt @@ -0,0 +1,24 @@ +package org.utbot.contest.usvm.executor + +import org.jacodb.api.JcClasspath +import org.usvm.instrumentation.executor.UTestConcreteExecutor +import org.usvm.instrumentation.instrumentation.JcRuntimeTraceInstrumenterFactory +import org.usvm.instrumentation.util.InstrumentationModuleConstants + +// TODO usvm-sbft-refactoring: copied from `usvm/usvm-jvm/test`, extract this class back to USVM project +object UTestRunner { + + lateinit var runner: UTestConcreteExecutor + + fun isInitialized() = this::runner.isInitialized + + fun initRunner(pathToJars: List, classpath: JcClasspath) { + runner = + UTestConcreteExecutor( + JcRuntimeTraceInstrumenterFactory::class, + pathToJars, + classpath, + InstrumentationModuleConstants.testExecutionTimeout + ) + } +} \ No newline at end of file diff --git a/utbot-testing/build.gradle b/utbot-testing/build.gradle index 716fcb0cd1..a66c022c29 100644 --- a/utbot-testing/build.gradle +++ b/utbot-testing/build.gradle @@ -57,6 +57,7 @@ dependencies { testImplementation group: 'org.mockito', name: 'mockito-inline', version: mockitoInlineVersion testImplementation group: 'org.apache.logging.log4j', name: 'log4j-core', version: log4j2Version - implementation group: 'com.github.UnitTestBot.ksmt', name: 'ksmt-core', version: ksmtVersion - implementation group: 'com.github.UnitTestBot.ksmt', name: 'ksmt-z3', version: ksmtVersion + // TODO sbft-usvm-merge: UtBot engine expects `com.github.UnitTestBot.ksmt` here + implementation group: 'io.ksmt', name: 'ksmt-core', version: ksmtVersion + implementation group: 'io.ksmt', name: 'ksmt-z3', version: ksmtVersion } \ No newline at end of file From 79cf54b682c3dbf9c127b11d5b5876025720eb31 Mon Sep 17 00:00:00 2001 From: IlyaMuravjov Date: Fri, 3 Nov 2023 16:09:36 +0300 Subject: [PATCH 002/121] Bump ksmt version to `0.5.13` --- gradle.properties | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/gradle.properties b/gradle.properties index b3a4e98f68..7595561782 100644 --- a/gradle.properties +++ b/gradle.properties @@ -41,8 +41,8 @@ junit4PlatformVersion=1.9.0 # NOTE: Mockito versions 5+ are not compatible with Java 8: https://www.davidvlijmincx.com/posts/upgrade-to-mockito-5 mockitoVersion=4.11.0 mockitoInlineVersion=4.11.0 -# TODO usvm-sbft-merge: UtBot engine uses ksmt 0.4.3, while USVM uses ksmt 0.5.7 -ksmtVersion=0.5.7 +# TODO usvm-sbft-merge: UtBot engine uses ksmt 0.4.3, while USVM uses ksmt 0.5.13 +ksmtVersion=0.5.13 sootVersion=4.4.0-FORK-2 kotlinVersion=1.8.0 log4j2Version=2.13.3 From d5cdd8af8b4fecf8a7255059f1999a290ad8a342 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Tue, 7 Nov 2023 13:56:40 +0300 Subject: [PATCH 003/121] Hacks similar to contest 2023 ones (#2676) --- .../utbot/framework/codegen/domain/Domain.kt | 2 +- .../codegen/renderer/CgAbstractRenderer.kt | 17 ++++++----------- .../framework/codegen/utils/StringUtils.kt | 6 +++++- 3 files changed, 12 insertions(+), 13 deletions(-) diff --git a/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/domain/Domain.kt b/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/domain/Domain.kt index 622c3eb534..dd88865448 100644 --- a/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/domain/Domain.kt +++ b/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/domain/Domain.kt @@ -612,7 +612,7 @@ enum class RuntimeExceptionTestsBehaviour( // Get is mandatory because of the initialization order of the inheritors. // Otherwise, in some cases we could get an incorrect value companion object : CodeGenerationSettingBox { - override val defaultItem: RuntimeExceptionTestsBehaviour get() = FAIL + override val defaultItem: RuntimeExceptionTestsBehaviour get() = PASS override val allItems: List = values().toList() } } diff --git a/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/renderer/CgAbstractRenderer.kt b/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/renderer/CgAbstractRenderer.kt index 1b19e575dd..bb6863e063 100644 --- a/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/renderer/CgAbstractRenderer.kt +++ b/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/renderer/CgAbstractRenderer.kt @@ -408,19 +408,14 @@ abstract class CgAbstractRenderer( val isBlockTooLarge = workaround(LONG_CODE_FRAGMENTS) { block.size > LARGE_CODE_BLOCK_SIZE } - if (isBlockTooLarge) { - print("/*") - println(" This block of code is ${block.size} lines long and could lead to compilation error") - } - - withIndent { - for (statement in block) { - statement.accept(this) + if (!isBlockTooLarge) { + withIndent { + for (statement in block) { + statement.accept(this) + } } } - if (isBlockTooLarge) println("*/") - print("}") if (printNextLine) println() @@ -982,6 +977,6 @@ abstract class CgAbstractRenderer( /** * @see [LONG_CODE_FRAGMENTS] */ - private const val LARGE_CODE_BLOCK_SIZE: Int = 1000 + private const val LARGE_CODE_BLOCK_SIZE: Int = 150 } } diff --git a/utbot-python/src/main/kotlin/org/utbot/python/framework/codegen/utils/StringUtils.kt b/utbot-python/src/main/kotlin/org/utbot/python/framework/codegen/utils/StringUtils.kt index 409b7acc85..40f3b5b831 100644 --- a/utbot-python/src/main/kotlin/org/utbot/python/framework/codegen/utils/StringUtils.kt +++ b/utbot-python/src/main/kotlin/org/utbot/python/framework/codegen/utils/StringUtils.kt @@ -4,5 +4,9 @@ import java.nio.file.FileSystems fun String.toRelativeRawPath(): String { - return "os.path.dirname(__file__) + r'${FileSystems.getDefault().separator}${this}'" + val dirname = "os.path.dirname(__file__)" + if (this.isEmpty()) { + return dirname + } + return "$dirname + r'${FileSystems.getDefault().separator}${this}'" } \ No newline at end of file From 092a27a58b2dae30d8debd5a750450dd04c2512d Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Thu, 9 Nov 2023 12:01:21 +0300 Subject: [PATCH 004/121] Initial implementations of the adapter from JcExecution to UtExecution (#2677) * Some awful attempts * Initially implemented a converter of UTestInst to UtModel * Refactor JcToUtModelConverter basing on UTestInst2UtModel converter * Some steps to implement JcToUtExecutionConverter * Implement minimalistic jc to ut execution conversion, enable codegen * Some improvements * DeepMapper for models is used * Corrections * Some improvements to JcToUtModelConverter * Further improvements to JcToUtModelConverter * Another converter little improvement * Improve `UtExecutionFailure` creation * Finish implementing `JcToUtModelConverter` * Refactor nullability in `JcToUtModelConverter` and `JcToUtExecutionConverter` * First version of JC to UT converters without overusing `Descriptor2ValueConverter` * Processed forgotten call method expression * Make conversion more class-friendly (do not fail if one method cause failure) * Make it possible to use samples in ContestEstimator * Tested on all primitives * contrflow tests added * More test classes added * Add `build/output/test/samples` to `utbot-junit-contest` test projects * Steps to avoid duplicating statements * Make it working correct on IntExamples.max * Remove OptimizeImportsProcessor (seems it was not called, but a source of bugs) * Process UTestStaticMethodCall * Comment out includes for IDE related projects in `settings.gradle.kts` * Avoid using burningwave to export modules on Java 8 * Fix review comments * Fix review comments --------- Co-authored-by: IlyaMuravjov --- settings.gradle.kts | 24 +- .../framework/plugin/api/mapper/Utils.kt | 11 + .../generator/CodeGenerationController.kt | 1 - utbot-junit-contest/build.gradle | 3 + .../org/utbot/contest/ContestEstimator.kt | 4 + .../org/utbot/contest/usvm/ContestUsvm.kt | 71 +++- .../org/utbot/contest/usvm/ConverterUtils.kt | 50 +++ .../contest/usvm/JcToUtExecutionConverter.kt | 179 ++++++---- .../contest/usvm/JcToUtModelConverter.kt | 157 +++++++++ .../usvm/UTestInst2UtModelConverter.kt | 321 ++++++++++++++++++ .../contest/usvm/UTestValueDescriptorUtils.kt | 48 +++ .../org/utbot/contest/usvm/UtUsvmExecution.kt | 22 +- .../kotlin/org/utbot/contest/usvm/Utils.kt | 16 + .../src/main/resources/classes/samples/list | 23 ++ .../samples/utbot-sample-2023.11-SNAPSHOT.jar | Bin 0 -> 323735 bytes 15 files changed, 843 insertions(+), 87 deletions(-) create mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt create mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt create mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt create mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestValueDescriptorUtils.kt create mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/Utils.kt create mode 100644 utbot-junit-contest/src/main/resources/classes/samples/list create mode 100644 utbot-junit-contest/src/main/resources/projects/samples/utbot-sample-2023.11-SNAPSHOT.jar 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 0000000000000000000000000000000000000000..ab0e73badfaaa4de36d25688844a0642556b6ea3 GIT binary patch literal 323735 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%0Asbe^^1DNTblU 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 literal 0 HcmV?d00001 From 31dd74d4d9b921dc8b985c6334bbdb10394f860c Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Fri, 10 Nov 2023 14:18:20 +0300 Subject: [PATCH 005/121] Supporting arrays classId in Contests (#2680) * Try to get classId from arrays with JacoDb * Fix a bug * Add primitive arrays to a list --- .../kotlin/org/utbot/contest/usvm/ContestUsvm.kt | 1 + .../org/utbot/contest/usvm/ConverterUtils.kt | 16 ++++++++++------ .../contest/usvm/JcToUtExecutionConverter.kt | 8 +++++--- .../utbot/contest/usvm/JcToUtModelConverter.kt | 4 +++- .../contest/usvm/UTestInst2UtModelConverter.kt | 16 +++++++++------- .../src/main/resources/classes/samples/list | 1 + 6 files changed, 29 insertions(+), 17 deletions(-) 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 97b073b2f0..5b57c784ac 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 @@ -221,6 +221,7 @@ fun runUsvmGeneration( try { JcToUtExecutionConverter( jcExecution = it, + jcClasspath = jcDbContainer.cp, idGenerator = idGenerator, instructionIdProvider = instructionIdProvider, utilMethodProvider = codeGenerator.context.utilMethodProvider 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 index 70c2551142..b1377418d7 100644 --- 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 @@ -2,10 +2,12 @@ package org.utbot.contest.usvm import org.jacodb.analysis.library.analyzers.thisInstance import org.jacodb.api.JcClassOrInterface +import org.jacodb.api.JcClasspath import org.jacodb.api.JcField import org.jacodb.api.JcMethod import org.jacodb.api.JcType import org.jacodb.api.TypeName +import org.jacodb.api.ext.findClassOrNull import org.usvm.instrumentation.testcase.api.UTestInst import org.usvm.instrumentation.testcase.descriptor.UTestObjectDescriptor import org.usvm.instrumentation.testcase.descriptor.UTestValueDescriptor @@ -21,15 +23,17 @@ 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 { +fun JcMethod.toExecutableId(classpath: JcClasspath): ExecutableId { val type = this.thisInstance.type.classId - val parameters = this.parameters.map { it.type.classId } + val parameters = this.parameters.map { it.type.findClassId(classpath) } if (isConstructor) { return ConstructorId(type, parameters) } - return MethodId(type, this.name, this.returnType.classId, parameters) + val returnClassId = this.returnType.findClassId(classpath) + + return MethodId(type, this.name, returnClassId, parameters) } val JcType?.classId: ClassId @@ -39,9 +43,9 @@ val JcType?.classId: ClassId 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) +fun TypeName.findClassId(classpath: JcClasspath): ClassId = + classpath.findTypeOrNull(this.typeName)?.classId + ?: error("Can not construct classId for $this") val JcField.fieldId: FieldId get() = toJavaField(utContext.classLoader)!!.fieldId 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 0f76278ec5..d5b874e06c 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 @@ -2,6 +2,7 @@ package org.utbot.contest.usvm import mu.KotlinLogging import org.jacodb.api.JcClassOrInterface +import org.jacodb.api.JcClasspath import org.jacodb.api.JcTypedMethod import org.jacodb.api.cfg.JcInst import org.jacodb.api.ext.jcdbSignature @@ -36,6 +37,7 @@ private val logger = KotlinLogging.logger {} class JcToUtExecutionConverter( private val jcExecution: JcExecution, + private val jcClasspath: JcClasspath, private val idGenerator: IdGenerator, private val instructionIdProvider: InstructionIdProvider, utilMethodProvider: UtilMethodProvider, @@ -45,10 +47,10 @@ class JcToUtExecutionConverter( private var jcToUtModelConverter: JcToUtModelConverter init { - val instToModelConverter = UTestInst2UtModelConverter(idGenerator, utilMethodProvider) + val instToModelConverter = UTestInst2UtModelConverter(idGenerator, jcClasspath, utilMethodProvider) instToModelConverter.processUTest(jcExecution.uTest) - jcToUtModelConverter = JcToUtModelConverter(idGenerator, instToModelConverter) + jcToUtModelConverter = JcToUtModelConverter(idGenerator, jcClasspath, instToModelConverter) } fun convert(): UtExecution? { @@ -129,7 +131,7 @@ class JcToUtExecutionConverter( .associate { (jcField, uTestDescr) -> jcField.fieldId to modelConverter.convert(uTestDescr) } - val executableId: ExecutableId = method.method.toExecutableId() + val executableId: ExecutableId = method.method.toExecutableId(jcClasspath) return EnvironmentModels(thisInstance, parameters, statics, executableId) } 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 index ef3f5285b0..3f0763f7c6 100644 --- 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 @@ -1,5 +1,6 @@ package org.utbot.contest.usvm +import org.jacodb.api.JcClasspath import org.usvm.instrumentation.testcase.api.UTestExpression import org.usvm.instrumentation.testcase.descriptor.UTestArrayDescriptor import org.usvm.instrumentation.testcase.descriptor.UTestClassDescriptor @@ -27,6 +28,7 @@ import java.lang.Throwable class JcToUtModelConverter( private val idGenerator: IdGenerator, + private val jcClasspath: JcClasspath, private val instToUtModelConverter: UTestInst2UtModelConverter, ) { private val descriptorToModelCache = mutableMapOf() @@ -57,7 +59,7 @@ class JcToUtModelConverter( fields += valueDescriptor.fields .entries .associate { (jcField, fieldDescr) -> - val fieldId = FieldId(jcField.type.classId, jcField.name) + val fieldId = FieldId(jcField.type.findClassId(jcClasspath), jcField.name) val fieldModel = convert(fieldDescr) fieldId to fieldModel } 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 index 0ceab1c6aa..4f842ce304 100644 --- 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 @@ -1,5 +1,6 @@ package org.utbot.contest.usvm +import org.jacodb.api.JcClasspath import org.usvm.instrumentation.testcase.UTest import org.usvm.instrumentation.testcase.api.UTestAllocateMemoryCall import org.usvm.instrumentation.testcase.api.UTestArithmeticExpression @@ -50,6 +51,7 @@ import org.utbot.fuzzer.IdGenerator class UTestInst2UtModelConverter( private val idGenerator: IdGenerator, + private val jcClasspath: JcClasspath, private val utilMethodProvider: UtilMethodProvider, ) { private val exprToModelCache = mutableMapOf() @@ -101,7 +103,7 @@ class UTestInst2UtModelConverter( val instanceModel = processExpr(instanceExpr) require(instanceModel is UtAssembleModel) - val fieldType = uTestInst.field.type.classId + val fieldType = uTestInst.field.type.findClassId(jcClasspath) val fieldName = uTestInst.field.name val setValueModel = processExpr(uTestInst.value) @@ -147,7 +149,7 @@ class UTestInst2UtModelConverter( is UTestConstructorCall -> { val constructorCall = UtExecutableCallModel( instance = null, - executable = uTestExpr.method.toExecutableId(), + executable = uTestExpr.method.toExecutableId(jcClasspath), params = uTestExpr.args.map { arg -> processExpr(arg) }, @@ -167,7 +169,7 @@ class UTestInst2UtModelConverter( val methodCall = UtExecutableCallModel( instance = instanceModel, - executable = uTestExpr.method.toExecutableId(), + executable = uTestExpr.method.toExecutableId(jcClasspath), params = uTestExpr.args.map { arg -> processExpr(arg) }, ) @@ -188,7 +190,7 @@ class UTestInst2UtModelConverter( modelName = "", instantiationCall = UtExecutableCallModel( instance = null, - executable = uTestExpr.method.toExecutableId(), + executable = uTestExpr.method.toExecutableId(jcClasspath), params = uTestExpr.args.map { arg -> processExpr(arg) }, ), ) @@ -234,7 +236,7 @@ class UTestInst2UtModelConverter( executable = utilMethodProvider.getFieldValueMethodId, params = listOf( instanceModel, - UtPrimitiveModel(uTestExpr.field.type.classId.name), + UtPrimitiveModel(uTestExpr.field.type), UtPrimitiveModel(uTestExpr.field.name), ), ) @@ -252,7 +254,7 @@ class UTestInst2UtModelConverter( instance = null, executable = utilMethodProvider.getStaticFieldValueMethodId, params = listOf( - UtPrimitiveModel(uTestExpr.field.type.classId.name), + UtPrimitiveModel(uTestExpr.field.type), UtPrimitiveModel(uTestExpr.field.name), ), ) @@ -287,7 +289,7 @@ class UTestInst2UtModelConverter( mocks += uTestExpr.methods .entries .associate { (jcMethod, uTestExprs) -> - val executableId: ExecutableId = jcMethod.toExecutableId() + val executableId: ExecutableId = jcMethod.toExecutableId(jcClasspath) val models = uTestExprs.map { expr -> processExpr(expr) } diff --git a/utbot-junit-contest/src/main/resources/classes/samples/list b/utbot-junit-contest/src/main/resources/classes/samples/list index df9d9e4e48..b7c98f8862 100644 --- a/utbot-junit-contest/src/main/resources/classes/samples/list +++ b/utbot-junit-contest/src/main/resources/classes/samples/list @@ -19,5 +19,6 @@ org.utbot.examples.wrappers.DoubleWrapper org.utbot.examples.wrappers.CharacterWrapper org.utbot.examples.wrappers.ByteWrapper org.utbot.examples.wrappers.BooleanWrapper +org.utbot.examples.arrays.PrimitiveArrays From b2cb044d4281d649b53b0766b1984a3ae2b2a1c7 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Sat, 11 Nov 2023 00:02:23 +0300 Subject: [PATCH 006/121] Very simple UtAssembleModel improver (#2678) * Very simple UtAssembleModel improver * Use `IdentityHashMap`-based cache when mapping `UtModel`s * Improve checks for `UtAssembleModel`s created with `createInstance` method --------- Co-authored-by: IlyaMuravjov --- .../UtModelSafeCastingCachingShallowMapper.kt | 3 +- .../contest/usvm/JcToUtExecutionConverter.kt | 46 ++++++++++++++++++- 2 files changed, 46 insertions(+), 3 deletions(-) diff --git a/utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/mapper/UtModelSafeCastingCachingShallowMapper.kt b/utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/mapper/UtModelSafeCastingCachingShallowMapper.kt index 1f2164fad4..e511450550 100644 --- a/utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/mapper/UtModelSafeCastingCachingShallowMapper.kt +++ b/utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/mapper/UtModelSafeCastingCachingShallowMapper.kt @@ -1,11 +1,12 @@ package org.utbot.framework.plugin.api.mapper import org.utbot.framework.plugin.api.UtModel +import java.util.IdentityHashMap class UtModelSafeCastingCachingShallowMapper( val mapper: (UtModel) -> UtModel ) : UtModelMapper { - private val cache = mutableMapOf() + private val cache = IdentityHashMap() override fun map(model: T, clazz: Class): T { val mapped = cache.getOrPut(model) { mapper(model) } 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 d5b874e06c..2e200e36d3 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 @@ -17,19 +17,27 @@ 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.common.isPublic import org.utbot.contest.usvm.executor.JcExecution import org.utbot.framework.codegen.domain.builtin.UtilMethodProvider +import org.utbot.framework.plugin.api.ClassId 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.UtAssembleModel +import org.utbot.framework.plugin.api.UtExecutableCallModel 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.UtPrimitiveModel import org.utbot.framework.plugin.api.UtVoidModel +import org.utbot.framework.plugin.api.mapper.UtModelDeepMapper +import org.utbot.framework.plugin.api.util.executableId +import org.utbot.framework.plugin.api.util.jClass import org.utbot.framework.plugin.api.util.utContext import org.utbot.fuzzer.IdGenerator @@ -40,7 +48,7 @@ class JcToUtExecutionConverter( private val jcClasspath: JcClasspath, private val idGenerator: IdGenerator, private val instructionIdProvider: InstructionIdProvider, - utilMethodProvider: UtilMethodProvider, + private val utilMethodProvider: UtilMethodProvider, ) { private val toValueConverter = Descriptor2ValueConverter(utContext.classLoader) @@ -100,7 +108,41 @@ class JcToUtExecutionConverter( } } ?: return null - return utUsvmExecution + return utUsvmExecution.mapModels(constructAssemblingMapper()) + } + + private fun constructAssemblingMapper(): UtModelDeepMapper = UtModelDeepMapper { model -> + // TODO usvm-sbft: support constructors with parameters here if it is really required + // Unfortunately, it is not possible to use [AssembleModelGeneral] as it requires soot being initialized. + if (model !is UtAssembleModel + || utilMethodProvider.createInstanceMethodId != model.instantiationCall.statement + || model.modificationsChain.isNotEmpty()) { + return@UtModelDeepMapper model + } + + val instantiatingClassName = (model + .instantiationCall + .params + .single() as UtPrimitiveModel).value.toString() + + val defaultConstructor = ClassId(instantiatingClassName) + .jClass + .constructors + .firstOrNull { it.isPublic && it.parameters.isEmpty() } + + + defaultConstructor?.let { ctor -> + UtAssembleModel( + id = idGenerator.createId(), + classId = model.classId, + modelName = "", + instantiationCall = UtExecutableCallModel( + instance = null, + executable = ctor.executableId, + params = emptyList(), + ) + ) + } ?: model } private fun convertException(exceptionDescriptor: UTestExceptionDescriptor): Throwable = From 3400a965afeb17a272cdd7579eb79a85a63f8164 Mon Sep 17 00:00:00 2001 From: Kirill Shishin <73890886+tepa46@users.noreply.github.com> Date: Mon, 13 Nov 2023 13:39:26 +0300 Subject: [PATCH 007/121] Fix class name argument in the setField method (#2681) Fix setField class name argument --- .../kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 index 4f842ce304..0615e41f36 100644 --- 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 @@ -103,7 +103,7 @@ class UTestInst2UtModelConverter( val instanceModel = processExpr(instanceExpr) require(instanceModel is UtAssembleModel) - val fieldType = uTestInst.field.type.findClassId(jcClasspath) + val fieldType = uTestInst.field.enclosingClass.classId val fieldName = uTestInst.field.name val setValueModel = processExpr(uTestInst.value) From a11c3e998e2884b403028fbcc52285805bbf27a4 Mon Sep 17 00:00:00 2001 From: IlyaMuravjov <71839386+IlyaMuravjov@users.noreply.github.com> Date: Mon, 13 Nov 2023 14:06:18 +0300 Subject: [PATCH 008/121] Fix test generation for nested classes (#2684) --- .../src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) 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 5b57c784ac..c44cbb1698 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 @@ -161,14 +161,14 @@ fun runUsvmGeneration( options = UMachineOptions(timeoutMs = symbolicBudgetPerMethod) ) }.use { machine -> - val jcClass = jcDbContainer.cp.findClass(cut.fqn) - statsForClass.methodsCount = filteredMethods.size // nothing to process further if (filteredMethods.isEmpty()) return@runBlocking statsForClass for (method in filteredMethods) { + val jcClass = jcDbContainer.cp.findClass(method.classId.name) + val jcTypedMethod = jcClass.toType().declaredMethods.firstOrNull { it.name == method.name && it.method.jcdbSignature == when (method) { is ConstructorId -> method.constructor.toJcdbSignature() From 27886303236f774891da9e72206eb5186c1e818f Mon Sep 17 00:00:00 2001 From: IlyaMuravjov <71839386+IlyaMuravjov@users.noreply.github.com> Date: Mon, 13 Nov 2023 14:11:17 +0300 Subject: [PATCH 009/121] Improver `UTestRunner` initialization and shutdown (#2683) --- .../org/utbot/contest/ContestEstimator.kt | 98 +++++++++++-------- .../org/utbot/contest/usvm/ContestUsvm.kt | 3 +- 2 files changed, 57 insertions(+), 44 deletions(-) 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 40abcdcdac..f955a7bdc8 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 @@ -26,6 +26,7 @@ import org.utbot.contest.Paths.evosuiteReportFile import org.utbot.contest.Paths.jarsDir import org.utbot.contest.Paths.moduleTestDir import org.utbot.contest.Paths.outputDir +import org.utbot.contest.usvm.executor.UTestRunner import org.utbot.contest.usvm.runUsvmGeneration import org.utbot.features.FeatureExtractorFactoryImpl import org.utbot.features.FeatureProcessorWithStatesRepetitionFactory @@ -263,6 +264,11 @@ interface Tool { expectedExceptions, methodNameFilter ) + + override fun close() { + if (UTestRunner.isInitialized()) + UTestRunner.runner.close() + } } object EvoSuite : Tool { @@ -351,6 +357,8 @@ interface Tool { ) fun moveProducedFilesIfNeeded() + + fun close() {} } fun main(args: Array) { @@ -508,52 +516,56 @@ fun runEstimator( try { tools.forEach { tool -> - var classIndex = 0 - - outer@ for (project in projects) { - if (projectFilter != null && project.name !in projectFilter) continue - - val statsForProject = StatsForProject(project.name) - globalStats.projectStats.add(statsForProject) - - logger.info { "------------- project [${project.name}] ---- " } - - // take all the classes from the corresponding jar if a list of the specified classes is empty - val extendedClassFqn = project.classFQNs.ifEmpty { project.classNames } - - for (classFqn in extendedClassFqn.filter { classFqnFilter?.equals(it) ?: true }) { - classIndex++ - if (classIndex > processedClassesThreshold) { - logger.info { "Reached limit of $processedClassesThreshold classes" } - break@outer - } - - try { - val cut = - ClassUnderTest( - project.classloader.loadClass(classFqn).id, - project.outputTestSrcFolder, - project.unzippedDir + try { + var classIndex = 0 + + outer@ for (project in projects) { + if (projectFilter != null && project.name !in projectFilter) continue + + val statsForProject = StatsForProject(project.name) + globalStats.projectStats.add(statsForProject) + + logger.info { "------------- project [${project.name}] ---- " } + + // take all the classes from the corresponding jar if a list of the specified classes is empty + val extendedClassFqn = project.classFQNs.ifEmpty { project.classNames } + + for (classFqn in extendedClassFqn.filter { classFqnFilter?.equals(it) ?: true }) { + classIndex++ + if (classIndex > processedClassesThreshold) { + logger.info { "Reached limit of $processedClassesThreshold classes" } + break@outer + } + + try { + val cut = + ClassUnderTest( + project.classloader.loadClass(classFqn).id, + project.outputTestSrcFolder, + project.unzippedDir + ) + + logger.info { "------------- [${project.name}] ---->--- [$classIndex:$classFqn] ---------------------" } + + tool.run( + project, + cut, + timeLimit, + fuzzingRatio, + methodNameFilter, + statsForProject, + compiledTestDir, + classFqn, + project.expectedExceptions.getForClass(classFqn) ) - - logger.info { "------------- [${project.name}] ---->--- [$classIndex:$classFqn] ---------------------" } - - tool.run( - project, - cut, - timeLimit, - fuzzingRatio, - methodNameFilter, - statsForProject, - compiledTestDir, - classFqn, - project.expectedExceptions.getForClass(classFqn) - ) - } - catch (e: Throwable) { - logger.warn(e) { "===================== ERROR IN [${project.name}] FOR [$classIndex:$classFqn] ============" } + } + catch (e: Throwable) { + logger.warn(e) { "===================== ERROR IN [${project.name}] FOR [$classIndex:$classFqn] ============" } + } } } + } finally { + tool.close() } } } finally { 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 c44cbb1698..6a8e8f0e3d 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 @@ -81,7 +81,8 @@ fun runUsvmGeneration( } val runner by lazy { - UTestRunner.initRunner(classpathFiles.map { it.absolutePath }, jcDbContainer.cp) + if (!UTestRunner.isInitialized()) + UTestRunner.initRunner(classpathFiles.map { it.absolutePath }, jcDbContainer.cp) UTestRunner.runner } From 62aa5b076cbb0f88aafc650bba991ed1ce27a748 Mon Sep 17 00:00:00 2001 From: Kirill Shishin <73890886+tepa46@users.noreply.github.com> Date: Mon, 13 Nov 2023 15:54:51 +0300 Subject: [PATCH 010/121] Add summarization for usvm-sbft (#2682) * Add summarization for usvm-sbft * Add summary setting to the setOption method and do small refactoring --- .../main/kotlin/org/utbot/contest/Contest.kt | 3 + .../org/utbot/contest/usvm/ContestUsvm.kt | 4 +- .../kotlin/org/utbot/summary/Summarization.kt | 18 +++-- .../fuzzer/names/MethodBasedNameSuggester.kt | 4 +- .../org/utbot/summary/usvm/USummarization.kt | 77 +++++++++++++++++++ 5 files changed, 98 insertions(+), 8 deletions(-) create mode 100644 utbot-summary/src/main/kotlin/org/utbot/summary/usvm/USummarization.kt diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/Contest.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/Contest.kt index 3a20f61596..94d9b4da7c 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/Contest.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/Contest.kt @@ -161,6 +161,9 @@ fun setOptions() { // We need to use assemble model generator to increase readability UtSettings.useAssembleModelGenerator = true UtSettings.summaryGenerationType = SummariesGenerationType.LIGHT + UtSettings.enableTestNamesGeneration = true + UtSettings.enableDisplayNameGeneration = false + UtSettings.enableJavaDocGeneration = true UtSettings.preferredCexOption = false UtSettings.warmupConcreteExecution = true UtSettings.testMinimizationStrategyType = TestSelectionStrategyType.COVERAGE_STRATEGY 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 6a8e8f0e3d..1d255a92a4 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 @@ -35,7 +35,7 @@ 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 org.utbot.summary.usvm.summarizeAll import java.io.File import java.net.URLClassLoader import java.util.* @@ -267,7 +267,7 @@ fun runUsvmGeneration( val testSets = testsByMethod.map { (method, executions) -> UtMethodTestSet(method, minimizeExecutions(executions), jimpleBody = null) - }.summarizeAll(cut.classfileDir.toPath(), sourceFile = null) + }.summarizeAll() logger.info().measureTime({ "Flushing tests for [${cut.simpleName}] on disk" }) { writeTestClass(cut, codeGenerator.generateAsString(testSets)) diff --git a/utbot-summary/src/main/kotlin/org/utbot/summary/Summarization.kt b/utbot-summary/src/main/kotlin/org/utbot/summary/Summarization.kt index db03adf89b..1583cf2664 100644 --- a/utbot-summary/src/main/kotlin/org/utbot/summary/Summarization.kt +++ b/utbot-summary/src/main/kotlin/org/utbot/summary/Summarization.kt @@ -83,7 +83,7 @@ private fun UtMethodTestSet.summarizeOne(searchDirectory: Path, sourceFile: File ) // TODO: looks weird and don't create the real copy } -class Summarization(val sourceFile: File?, val invokeDescriptions: List) { +open class Summarization(val sourceFile: File?, val invokeDescriptions: List) { private val tagGenerator = TagGenerator() private val jimpleBodyAnalysis = ExecutionStructureAnalysis() @@ -239,10 +239,7 @@ class Summarization(val sourceFile: File?, val invokeDescriptions: List { val clustersToReturn: MutableList = mutableListOf() - val methodTestSet = when (descriptionSource) { - MethodDescriptionSource.FUZZER -> prepareTestSetWithFuzzedExecutions(testSet) - MethodDescriptionSource.SYMBOLIC -> prepareTestSetForByteCodeAnalysis(testSet) - } + val methodTestSet = prepareMethodTestSet(testSet, descriptionSource) if (methodTestSet.executions.isNotEmpty()) { methodTestSet.executions.forEach { utExecution -> @@ -263,7 +260,11 @@ class Summarization(val sourceFile: File?, val invokeDescriptions: List { val executableId = testSet.method val description = FuzzedMethodDescription(executableId).apply { + packageName = executableId.classId.packageName + className = executableId.classId.simpleName compilableName = if (!executableId.isConstructor) executableId.name else null + canonicalName = executableId.classId.canonicalName + isNested = executableId.classId.isNested } it.suggest( description, @@ -309,6 +310,13 @@ class Summarization(val sourceFile: File?, val invokeDescriptions: List prepareTestSetWithFuzzedExecutions(testSet) + MethodDescriptionSource.SYMBOLIC -> prepareTestSetForByteCodeAnalysis(testSet) + } + } + /** Filter and copies executions with non-empty paths. */ private fun prepareTestSetForByteCodeAnalysis(testSet: UtMethodTestSet): UtMethodTestSet { val executions = diff --git a/utbot-summary/src/main/kotlin/org/utbot/summary/fuzzer/names/MethodBasedNameSuggester.kt b/utbot-summary/src/main/kotlin/org/utbot/summary/fuzzer/names/MethodBasedNameSuggester.kt index a1ba9a7254..e38f566657 100644 --- a/utbot-summary/src/main/kotlin/org/utbot/summary/fuzzer/names/MethodBasedNameSuggester.kt +++ b/utbot-summary/src/main/kotlin/org/utbot/summary/fuzzer/names/MethodBasedNameSuggester.kt @@ -4,6 +4,7 @@ import org.utbot.framework.plugin.api.UtExecutionResult import org.utbot.fuzzer.FuzzedMethodDescription import org.utbot.fuzzer.FuzzedValue import org.utbot.summary.MethodDescriptionSource +import java.util.* class MethodBasedNameSuggester(private val source: MethodDescriptionSource = MethodDescriptionSource.FUZZER) : NameSuggester { override fun suggest( @@ -11,7 +12,8 @@ class MethodBasedNameSuggester(private val source: MethodDescriptionSource = Met values: List, result: UtExecutionResult? ): Sequence { - val compilableName = description.compilableName?.capitalize() ?: "Created" + val compilableName = description.compilableName?.replaceFirstChar { if (it.isLowerCase()) it.titlecase(Locale.getDefault()) else it.toString() } + ?: "Created" // See [Summarization.generateSummariesForTests]. val suffix = if (source == MethodDescriptionSource.FUZZER) "ByFuzzer" else "" return sequenceOf(TestSuggestedInfo("test${compilableName}${suffix}")) diff --git a/utbot-summary/src/main/kotlin/org/utbot/summary/usvm/USummarization.kt b/utbot-summary/src/main/kotlin/org/utbot/summary/usvm/USummarization.kt new file mode 100644 index 0000000000..d4aab53e33 --- /dev/null +++ b/utbot-summary/src/main/kotlin/org/utbot/summary/usvm/USummarization.kt @@ -0,0 +1,77 @@ +package org.utbot.summary.usvm + +import org.utbot.framework.plugin.api.UtMethodTestSet +import mu.KotlinLogging +import org.utbot.common.measureTime +import org.utbot.common.info +import org.utbot.framework.SummariesGenerationType.* +import org.utbot.framework.UtSettings.enableDisplayNameGeneration +import org.utbot.framework.UtSettings.enableJavaDocGeneration +import org.utbot.framework.UtSettings.enableTestNamesGeneration +import org.utbot.framework.UtSettings.summaryGenerationType +import org.utbot.summary.InvokeDescription +import org.utbot.summary.MethodDescriptionSource +import org.utbot.summary.Summarization +import java.io.File + +private val logger = KotlinLogging.logger {} + +/** +USummarization is used to generate summaries for *usvm-sbft*. + +To generate summary, use the following settings: +- *SummariesGenerationType == LIGHT* +- *enableTestNamesGeneration = true* +- *enableDisplayNameGeneration = false* +- *enableJavaDocGeneration = true* + */ + +fun Collection.summarizeAll(): List = + logger.info().measureTime({ + "----------------------------------------------------------------------------------------\n" + + "-------------------Summarization started for ${this.size} test cases--------------------\n" + + "----------------------------------------------------------------------------------------" + }) { + this.map { + it.summarizeOne() + } + } + +private fun UtMethodTestSet.summarizeOne(): UtMethodTestSet = + logger.info().measureTime({ "Summarization for ${this.method}" }) { + + if (summaryGenerationType != LIGHT || !enableTestNamesGeneration || enableDisplayNameGeneration || !enableJavaDocGeneration) { + logger.info { + "Incorrect settings are used to generate Summaries for usvm-sbft" + } + return this + } + + USummarization(sourceFile = null, invokeDescriptions = emptyList()).fillSummaries(this) + return this + } + +class USummarization(sourceFile: File?, invokeDescriptions: List) : + Summarization(sourceFile, invokeDescriptions) { + + /* + * Used to prepare methodTestSet for further generation of summaries. + * In the case of generating tests using USVM, we only need to work with Symbolic tests. + */ + override fun prepareMethodTestSet( + testSet: UtMethodTestSet, + descriptionSource: MethodDescriptionSource + ): UtMethodTestSet { + return when (descriptionSource) { + MethodDescriptionSource.FUZZER -> UtMethodTestSet( + method = testSet.method, + executions = emptyList(), + jimpleBody = testSet.jimpleBody, + errors = testSet.errors, + clustersInfo = testSet.clustersInfo + ) + + MethodDescriptionSource.SYMBOLIC -> testSet + } + } +} From 0a9003dbdece31e2ac4abce357bcbc7df0b5046c Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Mon, 13 Nov 2023 18:29:56 +0300 Subject: [PATCH 011/121] Use usvm samples instead of UtBot ones (#2685) --- .../src/main/resources/classes/samples/list | 46 +++++++++--------- .../projects/samples/usvm-jvm-test.jar | Bin 0 -> 341145 bytes .../samples/utbot-sample-2023.11-SNAPSHOT.jar | Bin 323735 -> 0 bytes 3 files changed, 23 insertions(+), 23 deletions(-) create mode 100644 utbot-junit-contest/src/main/resources/projects/samples/usvm-jvm-test.jar delete mode 100644 utbot-junit-contest/src/main/resources/projects/samples/utbot-sample-2023.11-SNAPSHOT.jar diff --git a/utbot-junit-contest/src/main/resources/classes/samples/list b/utbot-junit-contest/src/main/resources/classes/samples/list index b7c98f8862..f342ff5c31 100644 --- a/utbot-junit-contest/src/main/resources/classes/samples/list +++ b/utbot-junit-contest/src/main/resources/classes/samples/list @@ -1,24 +1,24 @@ -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 -org.utbot.examples.arrays.PrimitiveArrays - +org.usvm.samples.primitives.IntExamples +org.usvm.samples.primitives.ByteExamples +org.usvm.samples.primitives.CharExamples +org.usvm.samples.primitives.FloatExamples +org.usvm.samples.primitives.DoubleExamples +org.usvm.samples.controlflow.Conditions +org.usvm.samples.controlflow.CycleDependedCondition +org.usvm.samples.controlflow.Cycles +org.usvm.samples.controlflow.Switch +org.usvm.samples.recursion.Recursion +org.usvm.samples.math.BitOperators +org.usvm.samples.math.DivRemExamples +org.usvm.samples.math.DoubleFunctions +org.usvm.samples.wrappers.ShortWrapper +org.usvm.samples.wrappers.LongWrapper +org.usvm.samples.wrappers.IntegerWrapper +org.usvm.samples.wrappers.FloatWrapper +org.usvm.samples.wrappers.DoubleWrapper +org.usvm.samples.wrappers.CharacterWrapper +org.usvm.samples.wrappers.ByteWrapper +org.usvm.samples.wrappers.BooleanWrapper +org.usvm.samples.arrays.PrimitiveArrays +org.usvm.samples.arrays.IntArrayBasics diff --git a/utbot-junit-contest/src/main/resources/projects/samples/usvm-jvm-test.jar b/utbot-junit-contest/src/main/resources/projects/samples/usvm-jvm-test.jar new file mode 100644 index 0000000000000000000000000000000000000000..5f3f33107f73f9214f6db2f659beb8f4a50ed625 GIT binary patch literal 341145 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

^CC1KpPm_Ln6YZkQ;%z$SGIXq`fr4=pJUbO(Lk z;F6!Uqn@>0`jPpS*w+vY#v;zV;dp=>X&=&ue8Mfku?#(JYUoe>FgLl(RV>#rC6XPuj7m6H07u(nG zhML}sypzY!CmY>Rd}$0V^hzK9gKjX7Ym8W30EE73W?ivrx`Xg-KcIf<_K_TNSl0KI zd3R=FYl7Ym>u14`dA#xb)@)GwqJhrnay4;pLp0H&-#-5np_Tkdo=-P1&_wg0qY?(1 zZmz^>q1=mw68AHaYvqhn1ux!NfMCxO=>eU*b%&(Df_E(((HD9J(8`@o=R=?Ld97TL zFNlRy75rK-49FAAb@y9UU8f6^*X&IqujsJe!F?}0bdWw>zR#l7&nOa?+43y!em`I4 zjMnv=FBq~NQzn*1-NSWBJqy8su0_=ZjqC6nd8P1cjNM@KJWVWLO5fd?DR@V;8Eshk z%ec=C1>MG;t*je53E6x^Pw<<*zM?$8Z=e>u6A-a8dapS1m^ph|2|HWWR6&G@6R7zn z55|5>Vs?DFSaD;^DQ-V>Aq)7<_7&rSba@muh-Uya!85c}{VP$EJxg^=JQkAKEhy@y z4hx44OLH4yF^yc{{b1XtEzRyws!#H8o_R zBn`2{>Nn6BHRMO}ffzMKa)-1h(TnpqJM5#MI{967>u?^_BDn>-K9om-qJxaUYxLUj zo2(S$xyCuuYysOkb>V1lLe}yjc8wIti_`p+Ur>JBM7Fzd*!0jTUb3lP1xZ>{>OcQ{ zx7ON|_$Yp`48=IYv2JQtsP1N}wZRmn#=t(>MF(*Lw8-;;3pA-+Z>h1TF%o9qw-J=g z;Kh7<12H>i0_k06P%djU`yKe7DIh-pZ{{$L_-g^6G*tzNl!*R&4)tG>r(W{fmMHRw zJn>a)m6|9E7S=eHCkJcRCmlc0uet>Y5zEz}Zm-DHw`tSYs#__as!*3vX?}vd$ZxNv z7YKxVH91beI*wzRc)veB!gS%Bau$EH$l1@00?%EtM1JS<;ambAdd%cth2i{s6;ANQ1#N1=C~lNh;o=7_$6S@ zhfP$tFz)I(HB3}~|65>bB$^E>HlI^Xm?*b@hD@H3&>~9v$!wHQo>HlEU0+Mm;-Br@TEp2kWfsyYk#-%jN}seZd=6cUcBgFdSy5id9@8M_jIK$GaJH*BP3YDKhXfYjN#M9Jt z)Xv-oKmBSAz4YGFyTK?HKLw-JP1L;fvUKbo<_y$yPx*164XSD_X-pDqf`FUjFp1%q z%TEf(nJr0q4P;BP9f5qtuPGv*TZM$hsVYJoU%-)BNq3c*T`lYLOL|DCvnRD>c(3+vf2b#}0p;6C0S;m!!QEuFUwtqq8Zp z70e|EIExF#34JV+D$m=}2t8W(=&kIY#Jw_vUgWMS|P1XwWgEB4^ZEsLM`B>r9` zTAeOemUtvvEtLO&7!C%x^g=_#u|tMai_e#dlN7FfLb!5f=7AOFkgM_A3mb(Mc315U z=vU=I=a#AalC|yvsopcUpl0)$_=wl!)!=euJ@}yNtVP=okYyBBH=oM%WUFP9I)NU; z{6UKs3xDRq_AZ(Tf?)c}`%!F^xI;1k|P~isUpJv0CR7H?Cbg@`Wz^ooR66M%S z$g3#F60NZFlkpLI*vLK@>W9`h7$z*=>R52$`%63CZvKJ5;Hc-H6t)DiHjCk)Dd-`| zNV#}K`{CI(z9m~$*x4sE2BU_>V7?^-49>nKFo2{?vJ)`-yW2k@AW88*!w*|rF~d5

V^}r(KS- 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

c^Oh5i32ratras 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%0Du>=mWq4=tIC`#uwhT@Lpn8u% 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%0DupH@kbRS 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%0Asbe^^1DNTblU zH1uv}d&|hYATCN(G`7mCr<**H8^Ql$A9B>F&^Mvjq;yfONr}#(t;c$mjI}lEWPt_I zPRZ|Jn5HG@;L^F$%Gi^(BYh41+}f?K9ju^@S*(VVR#WwM!cij_&haZ|MXw;fZtB1= z?AUb2UBqu2gKdw+$+T7{VeFJdLa9wwW`Tu!wepr-<8|q&pjr;k z)kCU<_rb#=EZ}8>P>AQFGpopn&1*xd+z@!C?zzLq~F#1WC&k--4z(Gzg;ekuW(7-kaG2zWA^^>89<8~FuNAFcLWwrzI zZ~tlpmw?&eP3mqtJ|LjFCVh-Nwf*4dz^_Auz1sM4uL3Gv`iW(jPiy5K+dT;WMr!6d z3fdaQ>K>vD?z$Yr5e`4vkC0s@p8ZqdT`zWOk)`ak>H~Bw!1uD#d+y|{6vVoeqgtVZ zgX92ur>x^LuKg?qQ<>n6aAfFAgsU@TzeijDEeJLAtjYFSGwNz9^*PgUngK1N&o+Gs zTq4G^G13}p>-stJ&11;3Q(w|!=-_FBY>2(W1!rxXU2*Tj zf8P^S`gUMsC%>EW{2I!c^V8dE*E^&q3$G6iKg+PN>iR0Vh3(VR1$ay0eU9s^e#*Nx z(mPy#;Y&T!yKEfiVkKOKL5=2wFwD!YuIOxi^votPcBRW7pUxw8lJ?`7c=@)3uPR z9Y(jOnt_o(!a14)z^vY<8#djbmRrzgT}@j>O72`iu~yJk&p-&YX0z=fklA*KQ`>#* z^?b5xX(mXDYmm+R{$@eY5SEcrvv^%+NsumClG?B1jrI9ksG5H4&T!!s#5YzP9qG~q zDHwOb2(8(or2AvwWAzFwQ6j35`lVs8s8K3W!YVdh+(J7_42Lp3@a>}0S7a|GN8_!o z&?f1D7h-qREC1Ecf1Ac-aXn$zbPis|LJc2YyM{V&(T{z%$C@)FzS=RGfw)S#Uqvcv*2~Su)O7Oyj1%s7|K8GWvwU$sJr8i2su=ns?Ty+2k4K zJ*EvWNuNx}7qf|D>Z|Q*yL{msMP{1KjL2Zkudn(^8-f2rxydN2=e!hdLh%-m^m6uu zN8rf=c2;~qnIHSn74i6OcSeGUcf9)RE4}|0z2PA(B0M9rVKGxGx3I2_8(Bo)F3~iV z6p>vnZR)w&FMcEhC-T@3bXr7CQo(s>SIn?xdx*489%?Lm6%aUw*4#SL6)uj|P2DOT zYP4EDT4}K2X0e*Yh82>W^pIs0eqa!|vtp|JNYb-kd3v1Q2sLyuyY20;wAC@PjPvvu zmerzbc%zHh8Mps7Iw_f5chdgG#P+|3$vZKsCz#d)bO;R zL_~s#Bui1Co(e3o3+oFh2eS%@5nw)lc*oy3?&J$GtvqdBPNt=7e7w7T{jl-H0u+~F zD0Vf7He80ui(!-m(bWqv=5oCkvdUh18Kir_f9X?Q9(WAqnGQFs?{48I!Xe`sV6P=EPMGfmbH}V%Q+jEg8 z{!~wI9JjL%9`cfdTH`j&!=`znD#~>9Y41ck67e}26(5bgI`_S%`=J=rinIhHst~`8 zmw4S&{Wd}kFn^)lI>81PpWU$_*92Y+P|IAU^A~lA38T}ifZWJ93O0zTa&xV0=v(Vl z!OLYQ6N2gJ1n3Dio{;1ch&q(_`tt=d#vdsZ#n1g3nAh@(MkEmRa^fJCt)`MivXJ?v z5=4@5r4eT|fVo($ag}GHZTAWcS~Li2m<1Hb8bv3gG)RCG5}!`vLl0q3!`N zu)(jR#z(_SicCWXdisJ01uc&Ae^6+qG+zV0lk8>mibXJ-cxJj!O1`~3eE!@UrTnr1VLvPpT> zrclFX*1duKlunX`6rpqe4CQ{ORIvcgK0RJO5e+e~5T7Gc`K}d!x1pHB467`aAG=5} z1Q*WK77wWW0@Q}wqXLaaXGt2cWY=;9$sH2$LM>yN*_}TXDrK;z0(2wez+1z+$-%O| zYV?f|daVExFD!15VXYvi5xzL9Lp=Z_E#JOuvMg3i6p^0N?E$E$R-8fM1)3;S8M>lC zNP7!}fcX%Qc#O)D;VLyf1%7)x5 z4OWI@sx2%+a7TXXs`mfnra^^6^cTRl$lb3;4#UT`f%*ME4JP@4z%pa#)U%04Y#?kjWkXQ=NjF=;Bb!DN-w3UxEe^ zI}>n$y^t^2c1RqwW}h&DPP2w3!fbfyeU4^#J00H;T%1mlTlgfy1Qau(K6HtwUGQyINctb{2*1HjR=eDtatXKCv!)l_XH4dNC5W zk{MH_a&^W^{-oD1sNXvK7HejsX}S%IMka&C#}hM)eD5qj2!h;ar{I5b-TH8kGpB!^ z?BBQsb(4Ke#O_OP^&Q)%dxdQO`T*C+TcEUrc#+nvILgZLC|>}q-2d52y`$&7xf&()IL6%T$%-; z$5^VPYWohCr2oV_duBlMWQvHe!x#K1%O)X#(?!hC5r)5@R;WdM2;|_X^zz=XD_5s* zzko@&6}FAVR03_NXiJUymVpM(**PR%{1T#eqn&&gd&ljDwe$GkMGhZ!7EkV=yPYm{ zNi+Xxhqa%N)kgKfduw3m4VA55kJUy{zO}hEDh80^Lf@fDo0liCbo4j7zh;8(;Qx>3h1mZ|CUDU={F`6i|Nh2stBi-r>pRK& z0{!Qb=Kud|!GHeAZ{cYFEfM^Fj`Yu7+&{W-{}8au5jdT)S&Gi_nZNEQAe)Tp0}6_e zAd-?$!bgxf_UOe*z&Ax=vFc-sdjZxQgF5sD;*!m9Zgn@|UN#TXf;sjq-?g?rrMq9Q zUvYPN0ovd^L51TM{I?^Kv1F zdzMKN($v0YFOc;MdM2*%=uv#_Y7}dR1#zNciwTeoYJg@ino0>#B2w3ISkV@9=5P|B z3(FyZe6O2=2z6X-=#qMdddp=DL_$MG#x?Ln&k?MK+;h#+y7Cf@L`Q8XJS42S|9bn~ zK)Eo zDsACwv2~=|A{8lcy>dUI&vG-YJ0kyaz*`}I_Y%y{Jh5euhQi+r+->bnu%d6HD0cu* zcu}MPMFb0DKhDK93I66!rbIoY?WLRV7VMNoLia4IYZW;GnX2!qN(4i)nSol>Y=r>3 zd{sTuk2irJIE_3-$Oux6q6H57ZfHbP<5J^cao{du7~obTPadaQQ`RA+SFl6ydrxzp z8F_Mh|8?;3kN4*vaSj)lLB*lEzUW#v`KCAp)|eo8Y4c>PdKq9T#*@>(jU3eqMr`QE zi5XKdhAKp2r0$&3m-$x}iyMtR2j_3JYYXAG)u1W`w?+FOP;V6dRY-ImAt}y&4@ywavpo_zl^5U&cixXtBXcu8hMzGuUR9ZQpHpnoPqKi{6a5@8w!+Vrf zc3dcXx@@~zNcenR$od4>hWA49gYkm)rFn%#47NOrdXNxoYNQ*(SQDCo1M|{RE3}vF z=4SL%=I`ouSu36{SGb&)7^6MMU>D50OlB147tyKh8(f~nx~qw4u=I2u@Gx^w2?Qou zO%zueSyr`T8%u+1C{#3a3B(hCU4Vtu2eb8+nAjX;$cRXdqjkDB>(FChv9-iNyIO{J zme1}|VG4z*O9$j)iF_BGvl}-fu9fwr#~LO>GLjuxRi7x;WzE#&mYROi z4a5t_B~6h450^Mt9a6?zt8c87+DZuVAP=`q8OZK+C|aaBSn1B43WHLiIj(k?au_W$Ywb6+>XIV;X0YCDhZzR@azl&q7ZJBOv} z-HN)3PE-%H%+EqK-C(NBKX`rWZT2fW7wFJpE|2XFX!1LA>qLJyfj_18hq;Lfv_OSa zA%MI9blo7WqeqXj5M~;FI60%cghqQR>_$b|Jk~_tgwO|XQspXITtyU-!0OS~h79_` z!9%Pr-;qM)?k3hG#E%M`M0`U>>MItfX;Rm$Lmy1t=QMM)-;8nx;K!ajDV;GnR=3F3 zC2;kqQPT6wW1XXem^cm8tvba(s_eICM82-HO1s_Agkmv_OFHOS|8nh8Nz<1js7-9$ z1K>ls_H6A3?{|x}bO4AR+BYUu$pxU8F%?Q8WHX z2ED)xYmTl~!g!HuI~Ttn*|`{Q4-X)9H~KtpiQyN$W$96QN7*N9bDp*m^!%HcYyF76 z82RHle#&O-2X}82E5tjH?bG!ZTsE`~*Ta#F7ZVam0RT**vAk!2LKY@q0qYChlMeOO z+SpL%?h&{9X*X$piH}`+w-5SO5AEgfH2pjwI4(~Z&1+1yV5)hMDQ!=JDAX()pKKJF z%ToLWs#ho|kasE$7KVq^Y*r+`vAmg*+)I}8Tr@pknuI~v9oRbzg9#)$2r}a!9ErQ= zr`jieG!uP^Clp-}Jh%2GsdcQdWQ3fy+Osg8p`|~2-a7ka2Ex6IoNk7!>WilT(EPWG z7azM4tdUdWozX6?IoLFr9EMXu*+nQ5qLJny-cn-#-BQ)X>rbV2*89Zvt12;oX@ZDn zNRKkAY81}a&^w{PI??>HYR6NHa|%1k$O7S|mXgnGJ=*Q7_^k(+WqX^Evs#D3f!GB9GjnE4C$YTe z!AlBlZu`?Xid$q%FTJ+tM5HFT4F?(v?$giDAVeuvBF%I=iQ1(&>`hiDIGY5eyZW(P zD~jn`bXzZxH;OlF-$m8UYG5UsnX_KJCP+e@I4$frE9{?#YDeQmbm#$J=4=NriNV=w zG_0Rm(!iKh3>L>wZK&82ZnhUdmn(xoqjG&Wh+X}wPModS{k3p z#Kh2wYsEphtFr2w)SE-jFNZF=-e*pmA{1=gLO;u|Ra1<213Ejpu_HiK;**JC_DUZv z$t|(66MxYegzqv6yr3KLt^(hZ+Fp~>vI5cX`rXib%;o+5rS0q+NJt-b(;wiHb|MZx zdmGx-D>!?5@qB>tYz2VR-rs=I{0V?_xBHbNEW*To&wX+76&YUiu12-@+w1V%T>#(RVl=wsO8L-3)lPt;Y-g?`UQRacIx@% zWk$~>M;Qvo^AD;~9YGk;ix`NhJggs#L`D#fLBqh*`~tWP*dGEq+pm80tQsvgV8W_335+{m z`yJZLr0YkNXXfb<*T>Hf`bJLrHc0?I^E8f>u@w7F`$=|VquVo_DX*V4&{2;0)46z- ze?1Xhq14(d?AwTKsjVR_kIuOWyjb0l3`~3SoFBY{l@;?TtoeXHqS= zgZzDlE=70G=x`})Wun}_9!Xf5bJ2okAZi~8<=}uztj{trok7je6WDo?SV*A6%x?_a zVl?oJ;?5W2S~8{wE%33LVz(qx>)!O3`5JjL#tG19afg@ZCQ-meUFFx4pzS8IRLst) z?PjV#=dwdEsC=}sTaYqBvR_J9sr&gS0*k?*=#ORJMX#=EYGS_(4JGa{!==L9Uvfm4ewp7 zEJSe7SM=#-!6@s|P##!IH#xphGy~B!8#Wp2F)~O^xJg`0HV93q^{Mey7IgRXcjke3 z&nI07vbToTjJ2a?;-`W|x`{h{ag>J2yHe@an&Qa&=@i4Rfpy=*J*CHvq4Y)S7keQR-`IE?& z>N~?Hd4e5MD%m@DeJ3DNo&j=-m8oGz<$dHBf?N&;x+bx^c*+z0TTy#8=6VHW9#n8= z)Ac)Bvv_XwhM`UiVIJb+Yjj_idGV4WsI9+^IH;lcvXqkqR31ZljWI&mfS4HLq2hTx zelc;ZT1~7W8}T0SBYVWD=Nw(pr57_yd6`d=(uQKK?^wmG!ys{3vzJPBxM6in+E_M` zeQxQU-)30~YiVX2MAn%F>5+w523Ee)f~F6b9zP>i`cm7Hhn2QZMX{GUWKlF%UN1~g z6uT7<2W^lSeA!}Axc2p&Os32u$rNm7|BiLJ2>E+6Qk!>i&&(8(n}w^zla3MILA+H-g*!(~f7)wK!-xA7ryY(l|#mBL? zy$D{HnzmS%=lAxMXf)9Q_3=~jsR zBnAq4_+y2Y5Hynd7BFBcmq!HA;|ET_GCgT@F^QG65sp3c-`lR3pj;Ho*y%qoY``}_ zZwPuN_Uo?Q5=IRR9HeZh6)Q{0{Wi{qC@pdidSI#pd}!teD9XzOlyfvf2I%4l|2&wW zZE{2%(s{kCoU)AuyTTI6VUn>ir2`s+*{puozdAe*(46?ztgvM=?TX z!(6LoZME6%p)d;QiXx0D;26+8^7@WHz$+t|L1@7MgEhuOQu#+mEt(`fw>oUy1N-3VnNRt|0XTuc^gYg!EU4b>_99e!s6I>^6HmD z#>7^4fD(7CHB~msO<;E`Reyp#xk~!r^pGPL&=XnbZ(}qYQK6;MDr@#Q>z8BNuU0vX zu)>KN-aJmp7YSxefYhSl=#}W2JJ%MOFuKhoTQmCW46%mUQE(?VeIc@Y>AdSgPD5=( z@;$_eZ>DUU%(xhnM~mhqY|P!R201P{Mvioup>AR?)|D)GR2i%Gf$%nmE;Z?JnrGX8 zrMIW|w}IgNEY*kFILx#l*~ER)c;X;|dKeF(eY*f6tjBAXVYW=kY%zq3X(J;xOYWYx z4QdHVmfvP>POYp~Y@Rjc<~?VB5Tf7eVGTxOk&C8giLe(O!nqG3Z(Fme0HXOV zuH_T*O$;ZslM$xDh>l#JLX#a^t(lV4xEc!x!>1V*l;abF9*?X<>T)a^HqLLe!QC5M zx{(d0(`}*tGC{iPyyjOtGVn_7Ff~**0qMF0M?WsiOHkZ?@=|LO8)mtUZ7N#lC!~T< z)4>l^MZSnJ5d_nl@1*1ppvsXRh+-qK# z4I46i5N;X#RNmj^d8!qKY+W?X)`Ir)rg57!QY{}}h)6VrCDmcHg}MEfK4pVaH`LJJ zo5NsKqDz_3BG8Tv(^W&Kedt%9sc6Hcq8fu#=3culU7FbmiM#jcet9B{`6XskhtP?+ zVC|N}q!9}d>3Z!tV~V=n*|iXQvtegO7@@Dx(Ki9(SMhOPz;M^;yZ7i`CRm>a)~jIQ zylkfZ4_-)KgpeiP0HV^U&O>sdYJvSSdp#pnUZ}$-u!pIcXv=)Z6X3*q3WiZcMS|?8 zX`iEaOM_H;#bYisTK7%7FRYmay?k-1fqYvINuN5;G8DLW4jkzgrLB=X-0z6G(4>sv z;GwhqE?xRmdTKB$u#NLZKrpAs<0B&IuE=Gik73kq$dn}HQ^4$2TP|H2` zJs@Qfl%O8aZeYD@o?JtdA>GXzUk^lSV}ePtg3e=Mw35Rvuu}7!Yr!m@8tmk`yuULk z66Dz>(yKT8?J0U_Xm69m(SJb9X-rte<>OBiT&{#$(NS z%gkA*mL8%{z6iuNzDHYm&37dstksXZ)K9YZE*qR{$tnq^XMb$OW)^YbF}p{F8&F0jh5Rk@jCC zO!V(}@$X?oc#NhM!Y{E1HI#bycxnpI(lWBzy_}De55_)Q{g|MRy=5z! z)h$eiR@?nhdb(jeojjWrRac|pWMYUteWPi~F8gUN8_C}mHoSnGy~VL02{2}nvV-Vb z?c2mWP{LM!(Cok1nnHD0eu=m|*4zT?Hn&~53pKi_N&-zdNux#&P`&KB4xK>%yqubA zOjPOL7$67<(AB(!^6WcdaU%J-e#jpNJp8b1Te_KqFHZr>WX^cH#=Dkmk=c@f2yW$o z4#O^B6Aq7vqpGsqd-G7x{!^_qS}mX(X318P{$k8${aL|jKj{rppDdAOMgfPeP-+1Q zI=Ox?=={`{sI|dee@49iETV~PGlTeGL`aFf|I#$)rGeUtjwp|hRJt(oI$nJb1$YN~ zm;+rl-2M4IfqB=>VjIo-`3we{Fe2J4?6~0hBd*u!<&nHq_QiN>m9ySZaC?3k$qhrU zy1f0&emku@46*BoRGQ9W(;m$AZArtSFQaDSdkTTSI)YQDbz-(&%1FFm-V<`^HOz8i zRFjBD7#dy#*3Tv{r1PDRaKcm8nOpcc)ON1{A>iRkJ0jV3`i1#fpWQ@+XPL5X6~|K2 zW&=Vast*qrX5Xl~fn^R;j;yKh5F-K?v#?!)A>)DM@dCP+2FKtt4QV4$1_?yS9Q)cTIk&!P7@d{d>++vZ{#<(qiYiZ`hSBqD!)vW~wc!Y&e#Eo9 z;6zs|zZjV`9VSaiPq}O@l=rgU)jS3D^!PEA#i!!X4`EnG54qcEUQ`MJ97_h*uS7cV zW`h`gJgIcTM~Ar4m{$8m zJ;&WX?9$xw^1usX_r?rS{Q6xD?oMR;b0&exG_8-;;UJ<)o!U#zy4(yQT7CB{C%jOx zyh)HZ43f+Fv6%Pl?vnJ?u&&H$jYh?f1AVs?3mS-g`kwhiD7w%ucYZENphE|xqBXRw z0xi0{Z}u%OKs!gMIi$=rgN(9S^Uv2G#XYFCqjgNZAPkfXD%12Uw3&xU+o6R@KW_YU z%?$IO4$;xd46v~C_a!HYW;FaDfb;(~@BI&n4HL^hf6Aw8XK$;cXa8^YzJK+q$IEg_ z^a5I0n41LkZeJ+O&u&9Bpg4r!_`pG^rKhdtf37kv#gFY@TB$*x{Ay%*U{MdzX6zY# z-fa7`vB;+lnlebf_lvM7T0M#`xijHt+QuvtF_(aCe)!!1^wgGIyl%XX=~~)-dwoWU z(G)jx@y;^U8R3=CnhR+ztX6MiM_3r4>(zJ|PGh_ma~rz13n+uwj$>_rPAw>OW?zX&*Aqy77VNLel; zd;}os1^E8)R{e=8zmA>3A8M9=-Kxkg@m@N>t*Wh?Yd$H5TIUKX3~F*#;A|wILgFHG zlQC;H9Ak;e4~5<9i{0!3yUgkpqbA6Z)P5V~c??L7oM>?RFo2c^4o4E?s>(M?mlm40 zsjkTAnLc5#g|@ArMDElNcYY>=SjupU#<3GV625aSMuk&X+Ekpd?|u7q*0xkglTlF5 zjuagfAm zMxPwxj3hp`9?75cnnMQ@qU<;_vX%;M{;*Fh+3B-Zm)5eaIKAbVLo@HiGq6c!oDQ(> zXYSKYJoh(&JFn<2*e~WaW4{3@yltZZ1_03)@cqLI+JBj+pn;)|gSq{`)v5l9CT0GV z15KUJ?Kd@>+xS6%0cRD0%JT#6l#kkZH8-}Ic?~92>WBvs>GnJlfm9Bz^$V2M1}Bb{ zAvgE8^$%&<9N$SRIbxyE_vB@A+%%PibV_rE3h^k@8Jg}GfX--?H=!Pk#3`L< zCYM)m!4AQ(&^W>=646knG+?uXyU&kio5_3>2D`9s0+= z^#Jxo<6>$fJ3x4v9Ws>LIYCFFPrCR!I}4wrHwD57cT9QQqP1+`+*U0SL1Qe;|JJbv zE?=E`0pN)M0IL6>Gyi{4wKZ`BcqG3hdH=G|D863;tNt6c^iyaSFwXaQ#>k_6soPyB zeBfGf>!e4@Dl?_#EL|OYVwan+mm#h!qhOKuuQ!jMHnB{?aGv0OKrq1} z0{giQ%P7M}W-)2CDChK>&qqTKnORN0+RVUpOK1WbrVnu=^Wj+_M9eyatD6-VCxn9_ z3d|x8R+Z1|9f!x86#cZ#4GDa|E*zI@A`Np}%LT{o=kJ;hD+3mlGFr>1BSc(#fi~my z-sjilHBU)+zFU2-F*-*B3(6($PM8(G&ZVBRSYnX7NOS+bZg7Mjjqb|W7cr{uf2zBA zmDREQ{96(B&giYDzxHC-w(z{wHvSQUhn1qD5#?Q>vBxA|14<9|_t{j)iZ1(oYnI&h5r=w7E=n7b+i0*uKRCz2&nNgwUqD2Y-Y1lXIXkjD&BuG1O!u^7CcyEc0^WJ zTDs-88QkWqL$^m!zKO|*82!aOEgB{&zgw+myRcjKc)+S<=Z2bY+C zr`&1NDf6Fz?0gQ&KdMXr{bc^~s{b_VI#msGEEV)OBO|N&fdyxemGB*+ym}`VN6f(6 znAvbd-Rf{!leA_SF^x#4fjgoTO-7EB-nK~){*gLa^<4R45)eT@q$tWdP2-YVZ!jXV z?TlgY6P?^sLc5fyPd0{8Hwh|9g~9+wKAG6dA4CAT_7MH!nL(KQn?zae{N_}a9I3-c z-K9aK&Rpx4Bw@@VjV$&2Vgvosz{*@-4|9*p7BtaF;Z(rhScjrdN&RV#5C|S8eWG_V zj7gYGPiSj}vc~K7!es`rm>CjF1#&zZ5W0JVMOdlR%;J+QPB()1v2tYV4VGB~Oog&F z1IcOwX{;7Mq4|Bitrm=fzDP40-kjbKFfR{zf}xI%#+cL;X)rg3TdEW?n(bpVa#^xN zHQlx))Zh{FW%ZoYcRD1yH3&P=9p8N!8RyX3uTCz)GjuzjHHKZ8iDp%3GJiTwy)&(i z1pWe*;4#NlR{JeSF5eZ;g8D*JhY^fPd|LC;QHR`ujo7LtNGK+Zd{(LcWQ%{k3PlQb z6Oh{_K|jtq35Caj2xLylCWNeO&SHs?!evSKNyo0T(EBts=>!d78)lV0f2h?A>xrVV z^qIySCt~;6dDcTbN6-Fi7KX3IVxk6+B(+Arm+lBK2A3#fAv_HN!6Y^OhZOY&pp(!3 zCTMowXkb!VBGlCEvMbrlmPNwUlyTJiZOI84Ef!IpsYza~aRr0Dn0(0?TcTb;-wct9 zCp63rnT&EewWZTXaz+au%`r|2t^g}uWWER=?>1HuJsjJ9b=!Jyz~s#m9cF>2FTWB# zTh0D{Xn)487O>W`O@d@zslONz?_*uRSk|gs?U^xV{7R2!6*VbE^DDl#F^_%p+T9#;d2W9IhOA#`Jc3I*cJe*2`X4d!Y1-ub3hh_RA}}6pZ=A ze=@NFJKqbZPH$wTs46@W%(V$;

qK5MpGYM+}50w#?vepk1LB1;ZDm6^7%Q0Vy#K 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Π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 From b40f0f3d8a587f98e070db15aff90ad61c9a3c82 Mon Sep 17 00:00:00 2001 From: Kirill Shishin <73890886+tepa46@users.noreply.github.com> Date: Mon, 13 Nov 2023 21:29:05 +0300 Subject: [PATCH 012/121] Fix fieldId creation for UtCompositeModel (#2686) --- .../main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 index 3f0763f7c6..b0ccdb6fb1 100644 --- 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 @@ -59,7 +59,7 @@ class JcToUtModelConverter( fields += valueDescriptor.fields .entries .associate { (jcField, fieldDescr) -> - val fieldId = FieldId(jcField.type.findClassId(jcClasspath), jcField.name) + val fieldId = FieldId(jcField.enclosingClass.classId, jcField.name) val fieldModel = convert(fieldDescr) fieldId to fieldModel } From 629983c6314b83c02d238fb0e2621006c12b7c47 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Mon, 13 Nov 2023 22:19:11 +0300 Subject: [PATCH 013/121] A tempopary hack for void TypeName processing --- .../kotlin/org/utbot/contest/usvm/ConverterUtils.kt | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) 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 index b1377418d7..4186435ed3 100644 --- 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 @@ -22,6 +22,7 @@ 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 +import org.utbot.framework.plugin.api.util.voidClassId fun JcMethod.toExecutableId(classpath: JcClasspath): ExecutableId { val type = this.thisInstance.type.classId @@ -43,9 +44,15 @@ val JcType?.classId: ClassId val JcClassOrInterface.classId: ClassId get() = this.toJavaClass(utContext.classLoader).id -fun TypeName.findClassId(classpath: JcClasspath): ClassId = - classpath.findTypeOrNull(this.typeName)?.classId +fun TypeName.findClassId(classpath: JcClasspath): ClassId { + // TODO usvm-sbft: fix it properly with Alexey Volkov + if (this.typeName == "void") { + return voidClassId + } + + return classpath.findTypeOrNull(this.typeName)?.classId ?: error("Can not construct classId for $this") +} val JcField.fieldId: FieldId get() = toJavaField(utContext.classLoader)!!.fieldId From 1d974f7e3a389852f71d90e6ed7b8ae76fc83346 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Tue, 14 Nov 2023 11:06:38 +0300 Subject: [PATCH 014/121] A proper solution for void TypeName processing --- .../org/utbot/contest/usvm/ConverterUtils.kt | 50 +++++++++++++++---- 1 file changed, 40 insertions(+), 10 deletions(-) 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 index 4186435ed3..130108a0b1 100644 --- 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 @@ -5,9 +5,19 @@ import org.jacodb.api.JcClassOrInterface import org.jacodb.api.JcClasspath import org.jacodb.api.JcField import org.jacodb.api.JcMethod +import org.jacodb.api.JcPrimitiveType import org.jacodb.api.JcType import org.jacodb.api.TypeName +import org.jacodb.api.ext.boolean +import org.jacodb.api.ext.byte +import org.jacodb.api.ext.char +import org.jacodb.api.ext.double import org.jacodb.api.ext.findClassOrNull +import org.jacodb.api.ext.float +import org.jacodb.api.ext.int +import org.jacodb.api.ext.long +import org.jacodb.api.ext.short +import org.jacodb.api.ext.void import org.usvm.instrumentation.testcase.api.UTestInst import org.usvm.instrumentation.testcase.descriptor.UTestObjectDescriptor import org.usvm.instrumentation.testcase.descriptor.UTestValueDescriptor @@ -18,9 +28,17 @@ 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.booleanClassId +import org.utbot.framework.plugin.api.util.byteClassId +import org.utbot.framework.plugin.api.util.charClassId +import org.utbot.framework.plugin.api.util.doubleClassId import org.utbot.framework.plugin.api.util.fieldId +import org.utbot.framework.plugin.api.util.floatClassId import org.utbot.framework.plugin.api.util.id +import org.utbot.framework.plugin.api.util.intClassId +import org.utbot.framework.plugin.api.util.longClassId import org.utbot.framework.plugin.api.util.objectClassId +import org.utbot.framework.plugin.api.util.shortClassId import org.utbot.framework.plugin.api.util.utContext import org.utbot.framework.plugin.api.util.voidClassId @@ -38,21 +56,33 @@ fun JcMethod.toExecutableId(classpath: JcClasspath): ExecutableId { } val JcType?.classId: ClassId - get() = this?.toJavaClass(utContext.classLoader)?.id - ?: error("Can not construct classId for $this") + get() { + if (this !is JcPrimitiveType) { + return this?.toJavaClass(utContext.classLoader)?.id + ?: error("Can not construct classId for $this") + } + + val cp = this.classpath + return when (this) { + cp.boolean -> booleanClassId + cp.byte -> byteClassId + cp.short -> shortClassId + cp.int -> intClassId + cp.long -> longClassId + cp.float -> floatClassId + cp.double -> doubleClassId + cp.char -> charClassId + cp.void -> voidClassId + else -> error("$this is not a primitive type") + } + } val JcClassOrInterface.classId: ClassId get() = this.toJavaClass(utContext.classLoader).id -fun TypeName.findClassId(classpath: JcClasspath): ClassId { - // TODO usvm-sbft: fix it properly with Alexey Volkov - if (this.typeName == "void") { - return voidClassId - } - - return classpath.findTypeOrNull(this.typeName)?.classId +fun TypeName.findClassId(classpath: JcClasspath): ClassId = + classpath.findTypeOrNull(this.typeName)?.classId ?: error("Can not construct classId for $this") -} val JcField.fieldId: FieldId get() = toJavaField(utContext.classLoader)!!.fieldId From 2b6ff8967f9dae8e9a72a2aa9aad153f3d36494c Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Tue, 14 Nov 2023 12:15:31 +0300 Subject: [PATCH 015/121] Add all arrays as test classes for converters --- .../src/main/resources/classes/samples/list | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/utbot-junit-contest/src/main/resources/classes/samples/list b/utbot-junit-contest/src/main/resources/classes/samples/list index f342ff5c31..9a70fde39a 100644 --- a/utbot-junit-contest/src/main/resources/classes/samples/list +++ b/utbot-junit-contest/src/main/resources/classes/samples/list @@ -21,4 +21,13 @@ org.usvm.samples.wrappers.ByteWrapper org.usvm.samples.wrappers.BooleanWrapper org.usvm.samples.arrays.PrimitiveArrays org.usvm.samples.arrays.IntArrayBasics +org.usvm.samples.arrays.ArraysOfArrays +org.usvm.samples.arrays.ArrayOfObjects +org.usvm.samples.arrays.ArraysOverwriteValue +org.usvm.samples.arrays.ArrayStoreExceptionExamples +org.usvm.samples.arrays.CopyOfExample +org.usvm.samples.arrays.FinalStaticFieldArray +org.usvm.samples.arrays.MultiDimensional +org.usvm.samples.arrays.OneDimensional + From 5b0e8dd7695a69c3d1a4cff5d4ce8d8caca9519d Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Wed, 15 Nov 2023 11:19:11 +0300 Subject: [PATCH 016/121] Add samples from types --- utbot-junit-contest/src/main/resources/classes/samples/list | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/utbot-junit-contest/src/main/resources/classes/samples/list b/utbot-junit-contest/src/main/resources/classes/samples/list index 9a70fde39a..e0982d3bf1 100644 --- a/utbot-junit-contest/src/main/resources/classes/samples/list +++ b/utbot-junit-contest/src/main/resources/classes/samples/list @@ -29,5 +29,11 @@ org.usvm.samples.arrays.CopyOfExample org.usvm.samples.arrays.FinalStaticFieldArray org.usvm.samples.arrays.MultiDimensional org.usvm.samples.arrays.OneDimensional +org.usvm.samples.types.CastExamples +org.usvm.samples.types.Generics +org.usvm.samples.types.PathDependentGenericsExample +org.usvm.samples.types.TypeBorders +org.usvm.samples.types.TypeMatches + From f38dae074c2c3636290d5b356ba3de29560fa37d Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Wed, 15 Nov 2023 11:32:35 +0300 Subject: [PATCH 017/121] Add samples from ternary --- utbot-junit-contest/src/main/resources/classes/samples/list | 1 + 1 file changed, 1 insertion(+) diff --git a/utbot-junit-contest/src/main/resources/classes/samples/list b/utbot-junit-contest/src/main/resources/classes/samples/list index e0982d3bf1..d61769b3ed 100644 --- a/utbot-junit-contest/src/main/resources/classes/samples/list +++ b/utbot-junit-contest/src/main/resources/classes/samples/list @@ -34,6 +34,7 @@ org.usvm.samples.types.Generics org.usvm.samples.types.PathDependentGenericsExample org.usvm.samples.types.TypeBorders org.usvm.samples.types.TypeMatches +org.usvm.samples.ternary.Ternary From 3080413aee4d2cd0c416dbbffa12da9e9c9b957e Mon Sep 17 00:00:00 2001 From: Kirill Shishin <73890886+tepa46@users.noreply.github.com> Date: Wed, 15 Nov 2023 11:48:17 +0300 Subject: [PATCH 018/121] Add processing of usvmExistingButNullString (#2689) add processing of existingButNullString --- .../org/utbot/contest/usvm/JcToUtModelConverter.kt | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) 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 index b0ccdb6fb1..14d235b729 100644 --- 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 @@ -11,6 +11,7 @@ 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.usvm.instrumentation.util.InstrumentationModuleConstants.nameForExistingButNullString import org.utbot.framework.plugin.api.FieldId import org.utbot.framework.plugin.api.UtArrayModel import org.utbot.framework.plugin.api.UtClassRefModel @@ -112,7 +113,7 @@ class JcToUtModelConverter( 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 UTestConstantDescriptor.String -> constructString(valueDescriptor.value) is UTestCyclicReferenceDescriptor -> descriptorToModelCache.getValue( refIdToDescriptorCache.getValue(valueDescriptor.refId) @@ -156,4 +157,11 @@ class JcToUtModelConverter( return model } + private fun constructString(valueDescriptorValue: String): UtModel { + if(valueDescriptorValue == nameForExistingButNullString){ + return UtNullModel(stringClassId) + } + return UtPrimitiveModel(valueDescriptorValue) + } + } \ No newline at end of file From 26d9901a3d1610b71ab9b9814229fc01f700082c Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Wed, 15 Nov 2023 13:31:31 +0300 Subject: [PATCH 019/121] Fix classloader problem and correct class lists (exclude missing classes & classes compiled with Java 17) --- .../main/kotlin/org/utbot/contest/ContestEstimator.kt | 2 +- .../src/main/resources/classes/codeforces/list | 11 ----------- .../src/main/resources/classes/fastjson-1.2.50/list | 1 - .../src/main/resources/classes/samples/list | 7 ++----- 4 files changed, 3 insertions(+), 18 deletions(-) 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 f955a7bdc8..dc6aa019d1 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 @@ -629,7 +629,7 @@ class ProjectToEstimate( ) { val outputTestSrcFolder = File(testCandidatesDir, name).apply { mkdirs() } val unzippedDir = File(unzippedJars, name) - val classloader = URLClassLoader(jars.map { it.toUrl() }.toTypedArray(), null) + val classloader = URLClassLoader(jars.map { it.toUrl() }.toTypedArray(), ClassLoader.getSystemClassLoader().parent) val sootClasspathString get() = jars.joinToString(classPathSeparator) val compileClasspathString get() = arrayOf(outputTestSrcFolder.absolutePath, sootClasspathString, dependenciesJars) diff --git a/utbot-junit-contest/src/main/resources/classes/codeforces/list b/utbot-junit-contest/src/main/resources/classes/codeforces/list index 2fa0b1a6a1..e69de29bb2 100644 --- a/utbot-junit-contest/src/main/resources/classes/codeforces/list +++ b/utbot-junit-contest/src/main/resources/classes/codeforces/list @@ -1,11 +0,0 @@ -org.utbot.examples.codeforces.error.stackof.Task_70A -org.utbot.examples.codeforces.exception.aiobe.Task_70A -org.utbot.examples.codeforces.exception.aiobe.Task_71B -org.utbot.examples.codeforces.exception.aiobe.Task_1712C -org.utbot.examples.codeforces.exception.aiobe.Task_1749C -org.utbot.examples.codeforces.exception.arithmetic.Task_1715B -org.utbot.examples.codeforces.exception.error.Task_1718A2 -org.utbot.examples.codeforces.exception.iobe.Task_1740C -org.utbot.examples.codeforces.exception.npe.Task_1703D -org.utbot.examples.codeforces.exception.siobe.Task_75A -org.utbot.examples.codeforces.exception.siobe.Task_1702B \ No newline at end of file diff --git a/utbot-junit-contest/src/main/resources/classes/fastjson-1.2.50/list b/utbot-junit-contest/src/main/resources/classes/fastjson-1.2.50/list index 3932a0c176..fbadea5765 100644 --- a/utbot-junit-contest/src/main/resources/classes/fastjson-1.2.50/list +++ b/utbot-junit-contest/src/main/resources/classes/fastjson-1.2.50/list @@ -15,5 +15,4 @@ com.alibaba.fastjson.serializer.ClobSeriliazer com.alibaba.fastjson.serializer.JSONSerializer com.alibaba.fastjson.serializer.StringCodec com.alibaba.fastjson.support.hsf.HSFJSONUtils -com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter com.alibaba.fastjson.util.IOUtils \ 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 index d61769b3ed..268f2a9201 100644 --- a/utbot-junit-contest/src/main/resources/classes/samples/list +++ b/utbot-junit-contest/src/main/resources/classes/samples/list @@ -21,7 +21,7 @@ org.usvm.samples.wrappers.ByteWrapper org.usvm.samples.wrappers.BooleanWrapper org.usvm.samples.arrays.PrimitiveArrays org.usvm.samples.arrays.IntArrayBasics -org.usvm.samples.arrays.ArraysOfArrays +org.usvm.samples.arrays.ArrayOfArrays org.usvm.samples.arrays.ArrayOfObjects org.usvm.samples.arrays.ArraysOverwriteValue org.usvm.samples.arrays.ArrayStoreExceptionExamples @@ -34,7 +34,4 @@ org.usvm.samples.types.Generics org.usvm.samples.types.PathDependentGenericsExample org.usvm.samples.types.TypeBorders org.usvm.samples.types.TypeMatches -org.usvm.samples.ternary.Ternary - - - +org.usvm.samples.ternary.Ternary \ No newline at end of file From 89045853892b6f287a15de124d697b75184a15ea Mon Sep 17 00:00:00 2001 From: IlyaMuravjov <71839386+IlyaMuravjov@users.noreply.github.com> Date: Wed, 15 Nov 2023 16:09:23 +0300 Subject: [PATCH 020/121] Include usvm via GitHub packages (#2687) * Include usvm via GitHub packages * Improve gradle script for utbot-junit-contest --- gradle.properties | 7 +++ settings.gradle.kts | 3 -- utbot-analytics/build.gradle | 38 +++++++++----- utbot-junit-contest/build.gradle | 87 ++++++++++++++++++++++++++++++-- 4 files changed, 113 insertions(+), 22 deletions(-) diff --git a/gradle.properties b/gradle.properties index 7595561782..c08e7fda4a 100644 --- a/gradle.properties +++ b/gradle.properties @@ -102,12 +102,19 @@ commonsIOVersion=2.11.0 javaxVersion=2.2 jakartaVersion=3.1.0 jacoDbVersion=1.3.0 +usvmVersion=1.0.0-competition # use latest Java 8 compaitable Spring and Spring Boot versions springVersion=5.3.28 springBootVersion=2.7.13 springSecurityVersion=5.8.5 +# Put your GitHub username here to use utbot-junit-contest with usvm +githubActor= +# Use your GitHub token generated here -- https://github.com/settings/tokens/new?description=USVM&scopes=read:packages +# Keep `read:packages` checkbox selected +githubToken= + # configuration for build server # # the following options are passed to gradle command explicitly (see appropriate workflow): diff --git a/settings.gradle.kts b/settings.gradle.kts index cad5a70f52..8318313222 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -93,6 +93,3 @@ if (projectType == ultimateEdition) { include("utbot-light") //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-analytics/build.gradle b/utbot-analytics/build.gradle index 9952de6e7e..5838ac7591 100644 --- a/utbot-analytics/build.gradle +++ b/utbot-analytics/build.gradle @@ -45,17 +45,27 @@ processResources { } } -jar { - dependsOn classes - manifest { - attributes 'Main-Class': 'org.utbot.QualityAnalysisKt' - } - - dependsOn configurations.runtimeClasspath - from { - configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) } - } - - duplicatesStrategy = DuplicatesStrategy.EXCLUDE - zip64 = true -} \ No newline at end of file +// TODO if you need utbot-analytics fat jar, use shadow jar to create a SEPARATE task for a fat jar. +// Do not use main jar for a fat jar, because it breaks Gradle conflict resolution, here's how: +// 1. utbot-analytics depends on library A version 1.0 (and adds it to own main jar) +// 2. utbot-junit-contest depends on utbot-analytics and library A version 1.1 +// 3. Both library A version 1.0 and version 1.1 end up on the classpath and it's a matter of chance which one is earlier +// If utbot-analytics were to only declare its dependency on library A version 1.0 and not force it by adding it to a +// main jar, then Gradle would be able to recognize the conflict of library A version 1.0 and version 1.1 and resolve +// it according to a conflict resolution strategy, which by default picks the latest version, which works in most cases. +// But if you put library A version 1.0 into some fat jar, Gradle will no longer be able to exclude it from the fat jar +// in favor of a newer version when it needs to resolve dependency conflicts. +//jar { +// dependsOn classes +// manifest { +// attributes 'Main-Class': 'org.utbot.QualityAnalysisKt' +// } +// +// dependsOn configurations.runtimeClasspath +// from { +// configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) } +// } +// +// duplicatesStrategy = DuplicatesStrategy.EXCLUDE +// zip64 = true +//} \ No newline at end of file diff --git a/utbot-junit-contest/build.gradle b/utbot-junit-contest/build.gradle index 27bd4c8c1d..8fd6aa5e2b 100644 --- a/utbot-junit-contest/build.gradle +++ b/utbot-junit-contest/build.gradle @@ -3,10 +3,29 @@ plugins { } apply plugin: 'jacoco' +repositories { + mavenCentral() + maven { url 'https://jitpack.io' } + maven { + url = uri('https://maven.pkg.github.com/UnitTestBot/usvm') + credentials { + username = project.githubActor // System.getenv("GITHUB_ACTOR") + password = project.githubToken // System.getenv("GITHUB_TOKEN") + } + } +} + configurations { fetchInstrumentationJar + approximations + usvmApproximationsApi + usvmInstrumentationCollector + usvmInstrumentationRunner } +def approximationsRepo = "com.github.UnitTestBot.java-stdlib-approximations" +def approximationsVersion = "53ceeb23ea" + compileJava { options.compilerArgs << '-XDignore.symbol.file' } @@ -44,7 +63,10 @@ sourceSets { test { useJUnit() - jvmArgs =[ + if (JavaVersion.current() < JavaVersion.VERSION_1_9) { + jvmArgs = [] + } else { + jvmArgs = [ "--add-opens", "java.base/java.util.concurrent.atomic=ALL-UNNAMED", "--add-opens", "java.base/java.lang.invoke=ALL-UNNAMED", "--add-opens", "java.base/java.util.concurrent=ALL-UNNAMED", @@ -95,7 +117,8 @@ test { "--add-opens", "java.base/jdk.internal.util.xml.impl=ALL-UNNAMED", "--add-opens", "java.base/jdk.internal.vm=ALL-UNNAMED", "--add-opens", "java.base/jdk.internal.vm.annotation=ALL-UNNAMED" - ] + ] + } finalizedBy jacocoTestReport } @@ -136,6 +159,7 @@ dependencies { implementation group: 'io.github.microutils', name: 'kotlin-logging', version: kotlinLoggingVersion implementation group: 'org.jsoup', name: 'jsoup', version: '1.6.2' implementation 'org.jetbrains.kotlinx:kotlinx-serialization-json:1.4.1' + implementation group: 'com.google.guava', name: 'guava', version: guavaVersion // need for tests implementation group: 'org.mockito', name: 'mockito-core', version: mockitoVersion implementation group: 'org.mockito', name: 'mockito-inline', version: mockitoInlineVersion @@ -143,9 +167,11 @@ dependencies { implementation "org.burningwave:core:12.62.7" - implementation('org.usvm:usvm-core') - implementation('org.usvm:usvm-jvm') - implementation('org.usvm:usvm-jvm-instrumentation') + implementation group: "org.usvm", name: "usvm-core", version: usvmVersion + implementation group: "org.usvm", name: "usvm-jvm", version: usvmVersion + implementation group: "org.usvm", name: "usvm-jvm-api", version: usvmVersion + implementation group: "org.usvm", name: "usvm-jvm-instrumentation", version: usvmVersion + implementation group: "org.usvm", name: "usvm-jvm-instrumentation-collectors", version: usvmVersion implementation group: "org.jacodb", name: "jacodb-core", version: jacoDbVersion implementation group: "org.jacodb", name: "jacodb-analysis", version: jacoDbVersion @@ -160,6 +186,12 @@ dependencies { testImplementation files('src/main/resources/evosuite/evosuite-standalone-runtime-1.2.0.jar') fetchInstrumentationJar project(path: ':utbot-instrumentation', configuration: 'instrumentationArchive') + + approximations "$approximationsRepo:approximations:$approximationsVersion" + usvmApproximationsApi "org.usvm:usvm-jvm-api:$usvmVersion" + usvmInstrumentationCollector "org.usvm:usvm-jvm-instrumentation-collectors:$usvmVersion" + usvmInstrumentationRunner "org.usvm:usvm-jvm-instrumentation:$usvmVersion" + usvmInstrumentationRunner "org.usvm:usvm-jvm-instrumentation-collectors:$usvmVersion" } processResources { @@ -214,3 +246,48 @@ task monitoringJar(type: Jar) { duplicatesStrategy = DuplicatesStrategy.EXCLUDE } + +// TODO usvm-sbft-saloed: replace with runner from usvm (unavailable due to huge jar size) +task usvmInstrumentationRunnerJar(type: Jar) { + archiveBaseName = "usvm-instrumentation-runner" + duplicatesStrategy = DuplicatesStrategy.EXCLUDE + manifest { + attributes( + "Main-Class": "org.usvm.instrumentation.rd.InstrumentedProcessKt", + "Premain-Class": "org.usvm.instrumentation.agent.Agent", + "Can-Retransform-Classes": "true", + "Can-Redefine-Classes": "true" + ) + } + + from { + configurations.usvmInstrumentationRunner.collect { + it.isDirectory() ? it : zipTree(it) + } + } +} + +task run(type: JavaExec) { + mainClass.set("org.utbot.contest.ContestEstimatorKt") + classpath = sourceSets.main.runtimeClasspath + workingDir = project.rootProject.projectDir + + def usvmApproximationJarPath = configurations.approximations.resolvedConfiguration.files.find() + def usvmApproximationApiJarPath = configurations.usvmApproximationsApi.resolvedConfiguration.files.find() + environment "usvm.jvm.api.jar.path", usvmApproximationApiJarPath.absolutePath + environment "usvm.jvm.approximations.jar.path", usvmApproximationJarPath.absolutePath + + def usvmInstrumentationCollectorJarPath = configurations.usvmInstrumentationCollector.resolvedConfiguration.files.find() + environment "usvm-jvm-collectors-jar", usvmInstrumentationCollectorJarPath.absolutePath + + dependsOn(usvmInstrumentationRunnerJar) + environment "usvm-jvm-instrumentation-jar", usvmInstrumentationRunnerJar.outputs.files.singleFile + + // "JAVA_HOME" specifies Java path for instrumented process and JacoDB, + // while `System.getProperty('java.home')` is Java used by this process. + // We want both of them to be the same and we also need JDK (not JRE), since we use `javac` to compile tests. + def javaHome = System.getProperty('java.home') + def jreSuffix = "${File.separatorChar}jre" + if (javaHome.endsWith(jreSuffix)) javaHome = javaHome.dropRight(jreSuffix.length()) + environment "JAVA_HOME", javaHome +} From 9869eb08bb9bf66009227f1bbd6761e0c326e218 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Wed, 15 Nov 2023 17:19:39 +0300 Subject: [PATCH 021/121] Upgrade usvm version --- gradle.properties | 2 +- .../src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/gradle.properties b/gradle.properties index c08e7fda4a..0263097807 100644 --- a/gradle.properties +++ b/gradle.properties @@ -102,7 +102,7 @@ commonsIOVersion=2.11.0 javaxVersion=2.2 jakartaVersion=3.1.0 jacoDbVersion=1.3.0 -usvmVersion=1.0.0-competition +usvmVersion=comp-231115-1620 # use latest Java 8 compaitable Spring and Spring Boot versions springVersion=5.3.28 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 1d255a92a4..303e780dd8 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 @@ -9,7 +9,7 @@ import org.jacodb.approximation.Approximations import org.jacodb.impl.features.InMemoryHierarchy import org.objectweb.asm.Type import org.usvm.UMachineOptions -import org.usvm.instrumentation.util.toJcdbSignature +import org.usvm.instrumentation.util.jcdbSignature import org.usvm.machine.JcMachine import org.usvm.machine.state.JcState import org.utbot.common.ThreadBasedExecutor @@ -172,8 +172,8 @@ fun runUsvmGeneration( val jcTypedMethod = jcClass.toType().declaredMethods.firstOrNull { it.name == method.name && it.method.jcdbSignature == when (method) { - is ConstructorId -> method.constructor.toJcdbSignature() - is MethodId -> method.method.toJcdbSignature() + is ConstructorId -> method.constructor.jcdbSignature + is MethodId -> method.method.jcdbSignature } } if (jcTypedMethod == null) { From 1362ac7869afb2a2ae80ce2c6ac570d345ca769b Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Wed, 15 Nov 2023 23:13:20 +0300 Subject: [PATCH 022/121] Add invokes into samples --- .../src/main/resources/classes/samples/list | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/utbot-junit-contest/src/main/resources/classes/samples/list b/utbot-junit-contest/src/main/resources/classes/samples/list index 268f2a9201..563869aaa7 100644 --- a/utbot-junit-contest/src/main/resources/classes/samples/list +++ b/utbot-junit-contest/src/main/resources/classes/samples/list @@ -34,4 +34,10 @@ org.usvm.samples.types.Generics org.usvm.samples.types.PathDependentGenericsExample org.usvm.samples.types.TypeBorders org.usvm.samples.types.TypeMatches -org.usvm.samples.ternary.Ternary \ No newline at end of file +org.usvm.samples.ternary.Ternary +org.usvm.samples.invokes.InvokeExample +org.usvm.samples.invokes.NativeExample +org.usvm.samples.invokes.SimpleInterfaceExample +org.usvm.samples.invokes.StaticInvokeExample +org.usvm.samples.invokes.VirtualInvokeExample +org.usvm.samples.invokes.VirtualInvokeNestedIteExample \ No newline at end of file From c365a7acf03a815449e25f36c24e289e53cd1bca Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Thu, 16 Nov 2023 12:27:51 +0300 Subject: [PATCH 023/121] Add several new classes to samples - Yuri said that it is enough --- utbot-junit-contest/src/main/resources/classes/samples/list | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/utbot-junit-contest/src/main/resources/classes/samples/list b/utbot-junit-contest/src/main/resources/classes/samples/list index 563869aaa7..4dcd38eca0 100644 --- a/utbot-junit-contest/src/main/resources/classes/samples/list +++ b/utbot-junit-contest/src/main/resources/classes/samples/list @@ -40,4 +40,7 @@ org.usvm.samples.invokes.NativeExample org.usvm.samples.invokes.SimpleInterfaceExample org.usvm.samples.invokes.StaticInvokeExample org.usvm.samples.invokes.VirtualInvokeExample -org.usvm.samples.invokes.VirtualInvokeNestedIteExample \ No newline at end of file +org.usvm.samples.invokes.VirtualInvokeNestedIteExample +org.usvm.samples.loops.While +org.usvm.samples.enums.SimpleEnumExample +org.usvm.samples.enums.ComplexEnumExamples \ No newline at end of file From 7429dc9216294bd79c116027953ab0728d47d0b2 Mon Sep 17 00:00:00 2001 From: Kirill Shishin Date: Thu, 16 Nov 2023 16:38:41 +0300 Subject: [PATCH 024/121] Fix enum converter and add sample from enums --- .../main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt | 3 ++- utbot-junit-contest/src/main/resources/classes/samples/list | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) 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 index 14d235b729..70f46029f8 100644 --- 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 @@ -122,7 +122,8 @@ class JcToUtModelConverter( id = idGenerator.createId(), classId = valueDescriptor.type.classId, value = valueDescriptor.type.classId.jClass.enumConstants.find { - (it as Enum<*>).name == valueDescriptor.enumValueName + // [valueDescriptor.enumValueName] is the enum value to which toString() was applied + (it as Enum<*>).toString() == valueDescriptor.enumValueName } as Enum<*> ) is UTestExceptionDescriptor -> UtCompositeModel( diff --git a/utbot-junit-contest/src/main/resources/classes/samples/list b/utbot-junit-contest/src/main/resources/classes/samples/list index 4dcd38eca0..ed388667ac 100644 --- a/utbot-junit-contest/src/main/resources/classes/samples/list +++ b/utbot-junit-contest/src/main/resources/classes/samples/list @@ -43,4 +43,5 @@ org.usvm.samples.invokes.VirtualInvokeExample org.usvm.samples.invokes.VirtualInvokeNestedIteExample org.usvm.samples.loops.While org.usvm.samples.enums.SimpleEnumExample -org.usvm.samples.enums.ComplexEnumExamples \ No newline at end of file +org.usvm.samples.enums.ComplexEnumExamples +org.usvm.samples.enums.ClassWithEnum \ No newline at end of file From 9bb144aca8a48fcb7843dd94b7db3dc855107f42 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Thu, 16 Nov 2023 16:57:51 +0300 Subject: [PATCH 025/121] Remove non-relevant TODO --- .../src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt | 3 --- 1 file changed, 3 deletions(-) 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 303e780dd8..e3aa6853c7 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 @@ -196,9 +196,6 @@ fun runUsvmGeneration( // for `remainingBudgetMillisWithoutCodegen()` ms, right now last resolver call may exceed budget, // essentially stealing some time from codegen if (remainingBudgetMillisWithoutCodegen() > 0) - // 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" logger.debug().measureTime({ "resolver.resolve(${method.classId}.${method.signature}, ...)" }) { runCatching { resolver.resolve(jcTypedMethod, it) From 6e6c378f0b556389abbd71c7445a2b22b987f7aa Mon Sep 17 00:00:00 2001 From: IlyaMuravjov <71839386+IlyaMuravjov@users.noreply.github.com> Date: Sat, 18 Nov 2023 16:08:23 +0300 Subject: [PATCH 026/121] Improve `UTestValueDescriptor` to `UtModel` conversion and state change asserts generation (#2691) * Fix compilation after USVM update (jvm-instrumentation-persistent-descriptors) * Make `JcToUtModelConverter` construct `UtCompositeModel.origin` and assign same id to `stateBefore` and `stateAfter` models that describe same object * Adapt `ExecutionStateAnalyzer` to deal with absence of `refId` in USVM descriptors for classes, enums, and throwables * Adapt `ExecutionStateAnalyzer` to deal with `UtAssembleModel`s with `origin` * Replace `UtAssembleModel`s that only use reflection with `UtCompositeModel`s, improve `constModel` for `UtArrayModel` --- .../plugin/api/mapper/UtModelDeepMapper.kt | 3 +- .../fields/ExecutionStateAnalyzer.kt | 45 +++---- .../contest/usvm/EnvironmentStateKind.kt | 5 + .../contest/usvm/JcToUtExecutionConverter.kt | 57 +++++++-- .../contest/usvm/JcToUtModelConverter.kt | 113 ++++++++++-------- .../contest/usvm/UTestValueDescriptorUtils.kt | 3 +- 6 files changed, 141 insertions(+), 85 deletions(-) create mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/EnvironmentStateKind.kt diff --git a/utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/mapper/UtModelDeepMapper.kt b/utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/mapper/UtModelDeepMapper.kt index 85e590aaf8..1d207f118d 100644 --- a/utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/mapper/UtModelDeepMapper.kt +++ b/utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/mapper/UtModelDeepMapper.kt @@ -12,6 +12,7 @@ import org.utbot.framework.plugin.api.UtNullModel import org.utbot.framework.plugin.api.UtPrimitiveModel import org.utbot.framework.plugin.api.UtReferenceModel import org.utbot.framework.plugin.api.UtVoidModel +import java.util.IdentityHashMap /** * Performs deep mapping of [UtModel]s. @@ -30,7 +31,7 @@ class UtModelDeepMapper private constructor( * Values are models that have been deeply mapped by this [UtModelDeepMapper]. * Models are only associated with models of the same type (i.e. the cache type is actually `MutableMap`) */ - private val cache = mutableMapOf() + private val cache = IdentityHashMap() private val allInputtedModels get() = cache.keys private val allOutputtedModels get() = cache.values diff --git a/utbot-framework/src/main/kotlin/org/utbot/framework/fields/ExecutionStateAnalyzer.kt b/utbot-framework/src/main/kotlin/org/utbot/framework/fields/ExecutionStateAnalyzer.kt index 46466eb945..a8731dc14d 100644 --- a/utbot-framework/src/main/kotlin/org/utbot/framework/fields/ExecutionStateAnalyzer.kt +++ b/utbot-framework/src/main/kotlin/org/utbot/framework/fields/ExecutionStateAnalyzer.kt @@ -21,6 +21,8 @@ import org.utbot.framework.plugin.api.UtPrimitiveModel import org.utbot.framework.plugin.api.UtReferenceModel import org.utbot.framework.plugin.api.UtSymbolicExecution import org.utbot.framework.plugin.api.UtVoidModel +import org.utbot.framework.plugin.api.util.id +import org.utbot.framework.plugin.api.util.isSubtypeOf import org.utbot.framework.util.UtModelVisitor import org.utbot.framework.util.hasThisInstance import org.utbot.fuzzer.UtFuzzedExecution @@ -104,31 +106,23 @@ class ExecutionStateAnalyzer(val execution: UtExecution) { initialPath: FieldPath = FieldPath() ): FieldStatesInfo { var modelBefore = before + var modelAfter = after if (before::class != after::class) { - if (before is UtModelWithCompositeOrigin && after is UtModelWithCompositeOrigin && before.origin != null) { - modelBefore = before.origin ?: unreachableBranch("We have already checked the origin for a null value") - } else { - doNotRun { - // it is ok because we might have modelBefore with some absent fields (i.e. statics), but - // modelAfter (constructed by concrete executor) will consist all these fields, - // therefore, AssembleModelGenerator won't be able to transform the given composite model - - val reason = if (before is UtModelWithCompositeOrigin && after is UtCompositeModel) { - "ModelBefore is an UtModelWithOrigin and ModelAfter " + - "is a CompositeModel, but modelBefore doesn't have an origin model." - } else { - "The model before and the model after have different types: " + - "model before is ${before::class}, but model after is ${after::class}." - } + if (before is UtModelWithCompositeOrigin) + modelBefore = before.origin ?: before + if (after is UtModelWithCompositeOrigin) + modelAfter = after.origin ?: after + } - error("Cannot analyze fields modification. $reason") - } + if (modelBefore::class != modelAfter::class) { + doNotRun { + error("Cannot analyze model fields modification, before: [$before], after: [$after]") + } - // remove it when we will fix assemble models in the resolver JIRA:1464 - workaround(WorkaroundReason.IGNORE_MODEL_TYPES_INEQUALITY) { - return FieldStatesInfo(fieldsBefore = emptyMap(), fieldsAfter = emptyMap()) - } + // remove it when we will fix assemble models in the resolver JIRA:1464 + workaround(WorkaroundReason.IGNORE_MODEL_TYPES_INEQUALITY) { + return FieldStatesInfo(fieldsBefore = emptyMap(), fieldsAfter = emptyMap()) } } @@ -139,7 +133,7 @@ class ExecutionStateAnalyzer(val execution: UtExecution) { modelBefore.accept(FieldStateVisitor(), dataBefore) val dataAfter = FieldData(FieldsVisitorMode.AFTER, fieldsAfter, initialPath, previousFields = fieldsBefore) - after.accept(FieldStateVisitor(), dataAfter) + modelAfter.accept(FieldStateVisitor(), dataAfter) return FieldStatesInfo(fieldsBefore, fieldsAfter) } @@ -260,6 +254,13 @@ private class FieldStateVisitor : UtModelVisitor() { // sometimes we don't have initial state of the field, e.g. if it is static and we didn't `touch` it // during the analysis, but the concrete executor included it in the modelAfter val initial = previousFields[path] ?: return false + + // TODO usvm-sbft: In USVM descriptors for classes, enums, and throwables don't implement `UTestRefDescriptor` + // and don't have `refId`, which causes `UtReferenceModel.id` to diverge in `stateBefore` and `stateAfter` + if (initial is UtClassRefModel) return initial.value != ((model as? UtClassRefModel)?.value) + if (initial is UtEnumConstantModel) return initial.value != ((model as? UtEnumConstantModel)?.value) + if (initial.classId isSubtypeOf java.lang.Throwable::class.id) return initial.classId != model.classId + return initial != model } } diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/EnvironmentStateKind.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/EnvironmentStateKind.kt new file mode 100644 index 0000000000..0c275c4152 --- /dev/null +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/EnvironmentStateKind.kt @@ -0,0 +1,5 @@ +package org.utbot.contest.usvm + +enum class EnvironmentStateKind { + INITIAL, FINAL +} \ 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 2e200e36d3..88d872f41e 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 @@ -25,6 +25,7 @@ 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.UtArrayModel import org.utbot.framework.plugin.api.UtAssembleModel import org.utbot.framework.plugin.api.UtExecutableCallModel import org.utbot.framework.plugin.api.UtExecution @@ -34,12 +35,14 @@ 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.UtPrimitiveModel +import org.utbot.framework.plugin.api.UtStatementCallModel import org.utbot.framework.plugin.api.UtVoidModel import org.utbot.framework.plugin.api.mapper.UtModelDeepMapper import org.utbot.framework.plugin.api.util.executableId import org.utbot.framework.plugin.api.util.jClass import org.utbot.framework.plugin.api.util.utContext import org.utbot.fuzzer.IdGenerator +import java.util.IdentityHashMap private val logger = KotlinLogging.logger {} @@ -68,17 +71,19 @@ class JcToUtExecutionConverter( 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), + stateBefore = convertState(executionResult.initialState, EnvironmentStateKind.INITIAL, jcExecution.method), + stateAfter = convertState(executionResult.resultState, EnvironmentStateKind.FINAL, jcExecution.method), // TODO usvm-sbft: ask why `UTestExecutionSuccessResult.result` is nullable - result = UtExecutionSuccess(executionResult.result?.let { jcToUtModelConverter.convert(it) } ?: UtVoidModel), + result = UtExecutionSuccess(executionResult.result?.let { + jcToUtModelConverter.convert(it, EnvironmentStateKind.FINAL) + } ?: UtVoidModel), coverage = coverage, instrumentation = instrumentation, ) is UTestExecutionExceptionResult -> { UtUsvmExecution( - stateBefore = convertState(executionResult.initialState, jcExecution.method, jcToUtModelConverter), - stateAfter = convertState(executionResult.resultState, jcExecution.method, jcToUtModelConverter), + stateBefore = convertState(executionResult.initialState, EnvironmentStateKind.INITIAL, jcExecution.method), + stateAfter = convertState(executionResult.resultState, EnvironmentStateKind.FINAL, jcExecution.method), result = createExecutionFailureResult( executionResult.cause, jcExecution.method, @@ -108,7 +113,10 @@ class JcToUtExecutionConverter( } } ?: return null - return utUsvmExecution.mapModels(constructAssemblingMapper()) + return utUsvmExecution + .mapModels(constructAssemblingMapper()) + .mapModels(constructAssembleToCompositeModelMapper()) + .mapModels(constructConstArrayModelMapper()) } private fun constructAssemblingMapper(): UtModelDeepMapper = UtModelDeepMapper { model -> @@ -145,6 +153,31 @@ class JcToUtExecutionConverter( } ?: model } + private fun constructConstArrayModelMapper(): UtModelDeepMapper = UtModelDeepMapper { model -> + if (model is UtArrayModel) { + val storeGroups = model.stores.entries.groupByTo(IdentityHashMap()) { it.value } + val mostCommonStore = storeGroups.maxBy { it.value.size } + if (mostCommonStore.value.size > 1) { + model.constModel = mostCommonStore.key + mostCommonStore.value.forEach { (index, _) -> model.stores.remove(index) } + } + } + model + } + + private fun constructAssembleToCompositeModelMapper(): UtModelDeepMapper = UtModelDeepMapper { model -> + if (model is UtAssembleModel + && utilMethodProvider.createInstanceMethodId == model.instantiationCall.statement + && model.modificationsChain.all { + utilMethodProvider.setFieldMethodId == (it as? UtStatementCallModel)?.statement + } + ) { + model.origin ?: model + } else { + model + } + } + private fun convertException(exceptionDescriptor: UTestExceptionDescriptor): Throwable = toValueConverter.buildObjectFromDescriptor(exceptionDescriptor.dropStaticFields( cache = mutableMapOf() @@ -160,18 +193,20 @@ class JcToUtExecutionConverter( private fun convertState( state: UTestExecutionState, + stateKind: EnvironmentStateKind, method: JcTypedMethod, - modelConverter: JcToUtModelConverter, - ): EnvironmentModels { + ): 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")) } + else jcToUtModelConverter.convert(state.instanceDescriptor ?: error("Unexpected null instanceDescriptor"), stateKind) + val parameters = state.argsDescriptors.map { + jcToUtModelConverter.convert(it ?: error("Unexpected null argDescriptor"), stateKind) + } val statics = state.statics .entries .associate { (jcField, uTestDescr) -> - jcField.fieldId to modelConverter.convert(uTestDescr) + jcField.fieldId to jcToUtModelConverter.convert(uTestDescr, stateKind) } val executableId: ExecutableId = method.method.toExecutableId(jcClasspath) return EnvironmentModels(thisInstance, parameters, statics, executableId) 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 index 70f46029f8..9f79379732 100644 --- 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 @@ -2,6 +2,7 @@ package org.utbot.contest.usvm import org.jacodb.api.JcClasspath import org.usvm.instrumentation.testcase.api.UTestExpression +import org.usvm.instrumentation.testcase.api.UTestMock import org.usvm.instrumentation.testcase.descriptor.UTestArrayDescriptor import org.usvm.instrumentation.testcase.descriptor.UTestClassDescriptor import org.usvm.instrumentation.testcase.descriptor.UTestConstantDescriptor @@ -14,18 +15,19 @@ import org.usvm.instrumentation.testcase.descriptor.UTestValueDescriptor import org.usvm.instrumentation.util.InstrumentationModuleConstants.nameForExistingButNullString 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.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.UtReferenceModel 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, @@ -33,22 +35,57 @@ class JcToUtModelConverter( private val instToUtModelConverter: UTestInst2UtModelConverter, ) { private val descriptorToModelCache = mutableMapOf() - private val refIdToDescriptorCache = mutableMapOf() + private val refIdAndStateKindToDescriptorCache = + mutableMapOf, UTestValueDescriptor>() + + fun convert( + valueDescriptor: UTestValueDescriptor, + stateKind: EnvironmentStateKind, + ): UtModel = descriptorToModelCache.getOrPut(valueDescriptor) { + if (stateKind == EnvironmentStateKind.INITIAL || valueDescriptor.origin is UTestMock) + valueDescriptor.origin?.let { originExpr -> + val model = instToUtModelConverter.findModelByInst(originExpr as UTestExpression) + if (model is UtAssembleModel && model.origin == null) { + val compositeOrigin = convertIgnoringOriginExprForThisModel( + valueDescriptor = valueDescriptor, + stateKind = stateKind, + curModelId = model.id ?: idGenerator.createId(), + ) + if (compositeOrigin is UtCompositeModel) + return@getOrPut model.copy(origin = compositeOrigin) + } + return@getOrPut model + } - fun convert(valueDescriptor: UTestValueDescriptor): UtModel = descriptorToModelCache.getOrPut(valueDescriptor) { - valueDescriptor.origin?.let { originExpr -> - return instToUtModelConverter.findModelByInst(originExpr as UTestExpression) - } + val previousStateModel = + if (stateKind == EnvironmentStateKind.FINAL && valueDescriptor is UTestRefDescriptor) { + (getModelByRefIdAndStateKind(valueDescriptor.refId, EnvironmentStateKind.INITIAL) as? UtReferenceModel) + } else { + null + } + + return@getOrPut convertIgnoringOriginExprForThisModel( + valueDescriptor, + stateKind, + curModelId = previousStateModel?.id ?: idGenerator.createId() + ) + } - if (valueDescriptor is UTestRefDescriptor) - refIdToDescriptorCache[valueDescriptor.refId] = valueDescriptor + private fun convertIgnoringOriginExprForThisModel( + valueDescriptor: UTestValueDescriptor, + stateKind: EnvironmentStateKind, + curModelId: Int, + ): UtModel = descriptorToModelCache.getOrPut(valueDescriptor) { + if (valueDescriptor is UTestRefDescriptor) { + refIdAndStateKindToDescriptorCache[valueDescriptor.refId to stateKind] = valueDescriptor + } return when (valueDescriptor) { is UTestObjectDescriptor -> { val fields = mutableMapOf() val model = UtCompositeModel( - id = idGenerator.createId(), + id = curModelId, classId = valueDescriptor.type.classId, isMock = false, mocks = mutableMapOf(), @@ -61,18 +98,18 @@ class JcToUtModelConverter( .entries .associate { (jcField, fieldDescr) -> val fieldId = FieldId(jcField.enclosingClass.classId, jcField.name) - val fieldModel = convert(fieldDescr) + val fieldModel = convert(fieldDescr, stateKind) fieldId to fieldModel } model } - is UTestArrayDescriptor.Array -> { + is UTestArrayDescriptor -> { val stores = mutableMapOf() val model = UtArrayModel( - id = idGenerator.createId(), + id = curModelId, classId = valueDescriptor.type.classId, length = valueDescriptor.length, constModel = UtNullModel(valueDescriptor.elementType.classId), @@ -82,26 +119,17 @@ class JcToUtModelConverter( descriptorToModelCache[valueDescriptor] = model valueDescriptor.value - .map { elemDescr -> convert(elemDescr) } + .map { elemDescr -> convert(elemDescr, stateKind) } .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(), + id = curModelId, classId = classClassId, value = valueDescriptor.classType.classId, - ) + ) is UTestConstantDescriptor.Null -> UtNullModel(valueDescriptor.type.classId) @@ -115,11 +143,11 @@ class JcToUtModelConverter( is UTestConstantDescriptor.Short -> UtPrimitiveModel(valueDescriptor.value) is UTestConstantDescriptor.String -> constructString(valueDescriptor.value) - is UTestCyclicReferenceDescriptor -> descriptorToModelCache.getValue( - refIdToDescriptorCache.getValue(valueDescriptor.refId) - ) + is UTestCyclicReferenceDescriptor -> getModelByRefIdAndStateKind(valueDescriptor.refId, stateKind) + ?: error("Invalid UTestCyclicReferenceDescriptor: $valueDescriptor") + is UTestEnumValueDescriptor -> UtEnumConstantModel( - id = idGenerator.createId(), + id = curModelId, classId = valueDescriptor.type.classId, value = valueDescriptor.type.classId.jClass.enumConstants.find { // [valueDescriptor.enumValueName] is the enum value to which toString() was applied @@ -127,7 +155,7 @@ class JcToUtModelConverter( } as Enum<*> ) is UTestExceptionDescriptor -> UtCompositeModel( - id = idGenerator.createId(), + id = curModelId, classId = valueDescriptor.type.classId, isMock = false, fields = mutableMapOf( @@ -138,26 +166,6 @@ class JcToUtModelConverter( } } - 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 - } - private fun constructString(valueDescriptorValue: String): UtModel { if(valueDescriptorValue == nameForExistingButNullString){ return UtNullModel(stringClassId) @@ -165,4 +173,11 @@ class JcToUtModelConverter( return UtPrimitiveModel(valueDescriptorValue) } + private fun getModelByRefIdAndStateKind( + refId: Int, + stateKind: EnvironmentStateKind + ): UtModel? = + refIdAndStateKindToDescriptorCache[refId to stateKind]?.let { + descriptorToModelCache[it] + } } \ 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 index ba7dc42ee7..cd96782def 100644 --- 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 @@ -13,14 +13,13 @@ fun UTestValueDescriptor.dropStaticFields( cache: MutableMap ): UTestValueDescriptor = cache.getOrPut(this) { when (this) { - is UTestArrayDescriptor.Array -> UTestArrayDescriptor.Array( + is UTestArrayDescriptor -> UTestArrayDescriptor( elementType = elementType, length = length, value = value.map { it.dropStaticFields(cache) }, refId = refId ) - is UTestArrayDescriptor<*> -> this is UTestClassDescriptor -> this is UTestConstantDescriptor -> this is UTestCyclicReferenceDescriptor -> this From 5084e02d4df9d91d296bb1a90da069a772bc13bf Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Sat, 18 Nov 2023 16:37:43 +0300 Subject: [PATCH 027/121] Update usvm version --- gradle.properties | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gradle.properties b/gradle.properties index 0263097807..9223130aba 100644 --- a/gradle.properties +++ b/gradle.properties @@ -102,7 +102,7 @@ commonsIOVersion=2.11.0 javaxVersion=2.2 jakartaVersion=3.1.0 jacoDbVersion=1.3.0 -usvmVersion=comp-231115-1620 +usvmVersion=comp-231118-1620 # use latest Java 8 compaitable Spring and Spring Boot versions springVersion=5.3.28 From ae1cdcf187f4800d4200acbe64db7c12b82ebf32 Mon Sep 17 00:00:00 2001 From: IlyaMuravjov Date: Sat, 18 Nov 2023 21:42:43 +0300 Subject: [PATCH 028/121] Fix `constructConstArrayModelMapper` for empty arrays --- .../kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 88d872f41e..6643853d45 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 @@ -156,7 +156,7 @@ class JcToUtExecutionConverter( private fun constructConstArrayModelMapper(): UtModelDeepMapper = UtModelDeepMapper { model -> if (model is UtArrayModel) { val storeGroups = model.stores.entries.groupByTo(IdentityHashMap()) { it.value } - val mostCommonStore = storeGroups.maxBy { it.value.size } + val mostCommonStore = storeGroups.maxByOrNull { it.value.size } ?: return@UtModelDeepMapper model if (mostCommonStore.value.size > 1) { model.constModel = mostCommonStore.key mostCommonStore.value.forEach { (index, _) -> model.stores.remove(index) } From b74f3c84917b2648c2ecd9326566b3982d7216c7 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Mon, 20 Nov 2023 12:09:07 +0300 Subject: [PATCH 029/121] Remove non-relevant TODO --- .../src/main/kotlin/org/utbot/contest/Contest.kt | 2 -- 1 file changed, 2 deletions(-) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/Contest.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/Contest.kt index 94d9b4da7c..92a2700820 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/Contest.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/Contest.kt @@ -494,8 +494,6 @@ internal fun File.toUrl(): URL = toURI().toURL() internal fun testMethodName(name: String, num: Int): String = "test${name.capitalize()}$num" -// TODO usvm-sbft: does SBFT allow to generate tests for private methods and constructors -// If no, add more filtering here internal val Method.isVisibleFromGeneratedTest: Boolean get() = (this.modifiers and Modifier.ABSTRACT) == 0 && (this.modifiers and Modifier.NATIVE) == 0 From 5429647d0fb0a09783518033b80db8b56efb5500 Mon Sep 17 00:00:00 2001 From: IlyaMuravjov Date: Mon, 20 Nov 2023 15:05:36 +0300 Subject: [PATCH 030/121] Use jacodb with `classpathWithApproximations` --- .../src/main/kotlin/org/utbot/contest/usvm/JacoDBContainer.kt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JacoDBContainer.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JacoDBContainer.kt index 876dc95af4..baa2676374 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JacoDBContainer.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JacoDBContainer.kt @@ -5,6 +5,7 @@ import org.jacodb.api.JcClasspath import org.jacodb.api.JcDatabase import org.jacodb.impl.JcSettings import org.jacodb.impl.jacodb +import org.usvm.util.classpathWithApproximations import java.io.File // TODO usvm-sbft-refactoring: copied from `usvm/usvm-jvm/test`, extract this class back to USVM project @@ -18,8 +19,7 @@ class JacoDBContainer( init { val (db, cp) = runBlocking { val db = jacodb(builder) - // TODO usvm-sbft: do we need `db.classpath(classpath)` or `db.classpathWithApproximations(classpath)` for contest? - val cp = db.classpath(classpath) + val cp = db.classpathWithApproximations(classpath) db to cp } this.db = db From 96993d9f17eef6309e29a757f2468d6fb50f0322 Mon Sep 17 00:00:00 2001 From: IlyaMuravjov Date: Mon, 20 Nov 2023 15:11:06 +0300 Subject: [PATCH 031/121] Reduce concrete execution timeout to 1 second --- .../src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt | 5 +---- .../kotlin/org/utbot/contest/usvm/executor/UTestRunner.kt | 5 +++-- 2 files changed, 4 insertions(+), 6 deletions(-) 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 e3aa6853c7..639e123d06 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 @@ -192,10 +192,7 @@ fun runUsvmGeneration( } } 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, - // essentially stealing some time from codegen - if (remainingBudgetMillisWithoutCodegen() > 0) + if (remainingBudgetMillisWithoutCodegen() > UTestRunner.CONTEST_TEST_EXECUTION_TIMEOUT.inWholeMilliseconds) logger.debug().measureTime({ "resolver.resolve(${method.classId}.${method.signature}, ...)" }) { runCatching { resolver.resolve(jcTypedMethod, it) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/executor/UTestRunner.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/executor/UTestRunner.kt index 8428cc757a..7923305df2 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/executor/UTestRunner.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/executor/UTestRunner.kt @@ -3,10 +3,11 @@ package org.utbot.contest.usvm.executor import org.jacodb.api.JcClasspath import org.usvm.instrumentation.executor.UTestConcreteExecutor import org.usvm.instrumentation.instrumentation.JcRuntimeTraceInstrumenterFactory -import org.usvm.instrumentation.util.InstrumentationModuleConstants +import kotlin.time.Duration.Companion.seconds // TODO usvm-sbft-refactoring: copied from `usvm/usvm-jvm/test`, extract this class back to USVM project object UTestRunner { + val CONTEST_TEST_EXECUTION_TIMEOUT = 1.seconds lateinit var runner: UTestConcreteExecutor @@ -18,7 +19,7 @@ object UTestRunner { JcRuntimeTraceInstrumenterFactory::class, pathToJars, classpath, - InstrumentationModuleConstants.testExecutionTimeout + CONTEST_TEST_EXECUTION_TIMEOUT ) } } \ No newline at end of file From e8a30d7d336999cb6a32c07d8bf6a708f1d20a73 Mon Sep 17 00:00:00 2001 From: IlyaMuravjov Date: Mon, 20 Nov 2023 15:13:03 +0300 Subject: [PATCH 032/121] Remove redundant TODO --- .../src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt | 1 - 1 file changed, 1 deletion(-) 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 639e123d06..53805bcdf3 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 @@ -134,7 +134,6 @@ fun runUsvmGeneration( ) logger.info().measureTime({ "class ${cut.fqn}" }, { statsForClass }) { - // TODO usvm-sbft: is it still needed for USVM? val filteredMethods = logger.info().measureTime({ "preparation class ${cut.clazz}: kotlin reflection :: run" }) { prepareClass(cut.clazz, methodNameFilter) } From ab0a529a94708a78da429aa856d5bb26cb9ae7de Mon Sep 17 00:00:00 2001 From: IlyaMuravjov Date: Mon, 20 Nov 2023 15:23:48 +0300 Subject: [PATCH 033/121] Replace generics with bounds when converting to ut models --- .../org/utbot/contest/usvm/ConverterUtils.kt | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) 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 index 130108a0b1..3bce88c6c9 100644 --- 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 @@ -1,23 +1,25 @@ package org.utbot.contest.usvm import org.jacodb.analysis.library.analyzers.thisInstance +import org.jacodb.api.JcArrayType import org.jacodb.api.JcClassOrInterface import org.jacodb.api.JcClasspath import org.jacodb.api.JcField import org.jacodb.api.JcMethod import org.jacodb.api.JcPrimitiveType +import org.jacodb.api.JcRefType import org.jacodb.api.JcType import org.jacodb.api.TypeName import org.jacodb.api.ext.boolean import org.jacodb.api.ext.byte import org.jacodb.api.ext.char import org.jacodb.api.ext.double -import org.jacodb.api.ext.findClassOrNull import org.jacodb.api.ext.float import org.jacodb.api.ext.int import org.jacodb.api.ext.long import org.jacodb.api.ext.short import org.jacodb.api.ext.void +import org.jacodb.api.ext.toType import org.usvm.instrumentation.testcase.api.UTestInst import org.usvm.instrumentation.testcase.descriptor.UTestObjectDescriptor import org.usvm.instrumentation.testcase.descriptor.UTestValueDescriptor @@ -37,7 +39,6 @@ import org.utbot.framework.plugin.api.util.floatClassId import org.utbot.framework.plugin.api.util.id import org.utbot.framework.plugin.api.util.intClassId import org.utbot.framework.plugin.api.util.longClassId -import org.utbot.framework.plugin.api.util.objectClassId import org.utbot.framework.plugin.api.util.shortClassId import org.utbot.framework.plugin.api.util.utContext import org.utbot.framework.plugin.api.util.voidClassId @@ -55,10 +56,18 @@ fun JcMethod.toExecutableId(classpath: JcClasspath): ExecutableId { return MethodId(type, this.name, returnClassId, parameters) } +private fun JcType.replaceToBoundIfGeneric(): JcType { + return when (this) { + is JcArrayType -> this.classpath.arrayTypeOf(elementType.replaceToBoundIfGeneric()) + is JcRefType -> this.jcClass.toType() + else -> this + } +} + val JcType?.classId: ClassId get() { if (this !is JcPrimitiveType) { - return this?.toJavaClass(utContext.classLoader)?.id + return this?.replaceToBoundIfGeneric()?.toJavaClass(utContext.classLoader)?.id ?: error("Can not construct classId for $this") } From 75cd001adef7008e067f6ab7b0ccd2cbe4e8ec65 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Mon, 20 Nov 2023 16:47:30 +0300 Subject: [PATCH 034/121] Correct JacoDb classpath --- .../src/main/kotlin/org/utbot/contest/usvm/JacoDBContainer.kt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JacoDBContainer.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JacoDBContainer.kt index baa2676374..6a45f7e3a2 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JacoDBContainer.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JacoDBContainer.kt @@ -4,6 +4,7 @@ import kotlinx.coroutines.runBlocking import org.jacodb.api.JcClasspath import org.jacodb.api.JcDatabase import org.jacodb.impl.JcSettings +import org.jacodb.impl.features.classpaths.UnknownClasses import org.jacodb.impl.jacodb import org.usvm.util.classpathWithApproximations import java.io.File @@ -19,7 +20,7 @@ class JacoDBContainer( init { val (db, cp) = runBlocking { val db = jacodb(builder) - val cp = db.classpathWithApproximations(classpath) + val cp = db.classpath(classpath, listOf(UnknownClasses)) db to cp } this.db = db From eaf85e98dcf6d6f9818beea084e1c4a83c652ec2 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Mon, 20 Nov 2023 16:48:58 +0300 Subject: [PATCH 035/121] Correct JacoDb classpath --- .../src/main/kotlin/org/utbot/contest/usvm/JacoDBContainer.kt | 1 + 1 file changed, 1 insertion(+) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JacoDBContainer.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JacoDBContainer.kt index 6a45f7e3a2..e4ae8bbb61 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JacoDBContainer.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JacoDBContainer.kt @@ -20,6 +20,7 @@ class JacoDBContainer( init { val (db, cp) = runBlocking { val db = jacodb(builder) + // TODO usvm-sbft: use classpathWithApproximations here val cp = db.classpath(classpath, listOf(UnknownClasses)) db to cp } From 273335e303a40afe428edacb9a84d7d65d878c3f Mon Sep 17 00:00:00 2001 From: Yury Kamenev Date: Mon, 20 Nov 2023 19:44:50 +0300 Subject: [PATCH 036/121] Update jacodb (#2694) --- gradle.properties | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gradle.properties b/gradle.properties index 9223130aba..370b601ff4 100644 --- a/gradle.properties +++ b/gradle.properties @@ -101,7 +101,7 @@ commonsLoggingVersion=1.2 commonsIOVersion=2.11.0 javaxVersion=2.2 jakartaVersion=3.1.0 -jacoDbVersion=1.3.0 +jacoDbVersion=1.4.1 usvmVersion=comp-231118-1620 # use latest Java 8 compaitable Spring and Spring Boot versions From 22e577b2275b1ebed85d7ed5e75a5f1759a46660 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Tue, 21 Nov 2023 18:07:39 +0300 Subject: [PATCH 037/121] Update approximations version --- utbot-junit-contest/build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/utbot-junit-contest/build.gradle b/utbot-junit-contest/build.gradle index 8fd6aa5e2b..48daa00033 100644 --- a/utbot-junit-contest/build.gradle +++ b/utbot-junit-contest/build.gradle @@ -24,7 +24,7 @@ configurations { } def approximationsRepo = "com.github.UnitTestBot.java-stdlib-approximations" -def approximationsVersion = "53ceeb23ea" +def approximationsVersion = "034c49fb78" compileJava { options.compilerArgs << '-XDignore.symbol.file' From 9bbb24c12fde6aa4ea207033fb17387e9e18a6fc Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Tue, 21 Nov 2023 18:21:54 +0300 Subject: [PATCH 038/121] Update usvm version --- gradle.properties | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gradle.properties b/gradle.properties index 370b601ff4..f335e5ca8e 100644 --- a/gradle.properties +++ b/gradle.properties @@ -102,7 +102,7 @@ commonsIOVersion=2.11.0 javaxVersion=2.2 jakartaVersion=3.1.0 jacoDbVersion=1.4.1 -usvmVersion=comp-231118-1620 +usvmVersion=comp-231121-1810 # use latest Java 8 compaitable Spring and Spring Boot versions springVersion=5.3.28 From 623a94fd4f3fc3bb802f10269e30631b0c44ce37 Mon Sep 17 00:00:00 2001 From: IlyaMuravjov <71839386+IlyaMuravjov@users.noreply.github.com> Date: Tue, 21 Nov 2023 19:29:27 +0300 Subject: [PATCH 039/121] Make JcMachine's budget distributing strategy and refactor (#2695) --- .../org/utbot/contest/ContestEstimator.kt | 5 +- .../org/utbot/contest/usvm/ContestUsvm.kt | 267 +++++++++--------- .../contest/usvm/EnvironmentStateKind.kt | 5 - .../contest/usvm/InstructionIdProvider.kt | 8 - .../org/utbot/contest/usvm/JacoDBContainer.kt | 44 --- .../kotlin/org/utbot/contest/usvm/Utils.kt | 16 -- .../usvm/{ => converter}/ConverterUtils.kt | 2 +- .../usvm/converter/InstructionIdProvider.kt | 12 + .../JcToUtExecutionConverter.kt | 6 +- .../{ => converter}/JcToUtModelConverter.kt | 8 +- .../UTestInstToUtModelConverter.kt} | 4 +- .../UTestValueDescriptorUtils.kt | 2 +- .../usvm/{ => converter}/UtUsvmExecution.kt | 18 +- .../contest/usvm/executor/UTestRunner.kt | 25 -- .../org/utbot/contest/usvm/jc/JcContainer.kt | 82 ++++++ .../usvm/{executor => jc}/JcExecution.kt | 2 +- .../usvm/{executor => jc}/JcTestExecutor.kt | 72 +++-- 17 files changed, 298 insertions(+), 280 deletions(-) delete mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/EnvironmentStateKind.kt delete mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/InstructionIdProvider.kt delete mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JacoDBContainer.kt delete mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/Utils.kt rename utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/{ => converter}/ConverterUtils.kt (98%) create mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/InstructionIdProvider.kt rename utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/{ => converter}/JcToUtExecutionConverter.kt (98%) rename utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/{ => converter}/JcToUtModelConverter.kt (98%) rename utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/{UTestInst2UtModelConverter.kt => converter/UTestInstToUtModelConverter.kt} (99%) rename utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/{ => converter}/UTestValueDescriptorUtils.kt (97%) rename utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/{ => converter}/UtUsvmExecution.kt (76%) delete mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/executor/UTestRunner.kt create mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcContainer.kt rename utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/{executor => jc}/JcExecution.kt (89%) rename utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/{executor => jc}/JcTestExecutor.kt (86%) 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 dc6aa019d1..1b94267218 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 @@ -26,7 +26,7 @@ import org.utbot.contest.Paths.evosuiteReportFile import org.utbot.contest.Paths.jarsDir import org.utbot.contest.Paths.moduleTestDir import org.utbot.contest.Paths.outputDir -import org.utbot.contest.usvm.executor.UTestRunner +import org.utbot.contest.usvm.jc.JcContainer import org.utbot.contest.usvm.runUsvmGeneration import org.utbot.features.FeatureExtractorFactoryImpl import org.utbot.features.FeatureProcessorWithStatesRepetitionFactory @@ -266,8 +266,7 @@ interface Tool { ) override fun close() { - if (UTestRunner.isInitialized()) - UTestRunner.runner.close() + JcContainer.close() } } 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 53805bcdf3..8364cfaac3 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 @@ -2,6 +2,9 @@ package org.utbot.contest.usvm import kotlinx.coroutines.* import mu.KotlinLogging +import org.jacodb.api.JcClasspath +import org.jacodb.api.JcMethod +import org.jacodb.api.JcTypedMethod import org.jacodb.api.ext.findClass import org.jacodb.api.ext.jcdbSignature import org.jacodb.api.ext.toType @@ -10,17 +13,18 @@ import org.jacodb.impl.features.InMemoryHierarchy import org.objectweb.asm.Type import org.usvm.UMachineOptions import org.usvm.instrumentation.util.jcdbSignature -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.* import org.utbot.contest.junitVersion -import org.utbot.contest.testMethodName -import org.utbot.contest.usvm.executor.JcTestExecutor -import org.utbot.contest.usvm.executor.UTestRunner +import org.utbot.contest.usvm.converter.JcToUtExecutionConverter +import org.utbot.contest.usvm.converter.SimpleInstructionIdProvider +import org.utbot.contest.usvm.converter.toExecutableId +import org.utbot.contest.usvm.jc.JcContainer +import org.utbot.contest.usvm.jc.JcContainer.Companion.CONTEST_TEST_EXECUTION_TIMEOUT +import org.utbot.contest.usvm.jc.JcTestExecutor import org.utbot.framework.codegen.domain.ProjectType import org.utbot.framework.codegen.domain.RuntimeExceptionTestsBehaviour import org.utbot.framework.codegen.domain.junitByVersion @@ -38,8 +42,8 @@ import org.utbot.fuzzer.UtFuzzedExecution import org.utbot.summary.usvm.summarizeAll import java.io.File import java.net.URLClassLoader -import java.util.* import kotlin.math.max +import kotlin.time.Duration.Companion.milliseconds private val logger = KotlinLogging.logger {} @@ -58,20 +62,25 @@ fun runUsvmGeneration( val testsByMethod: MutableMap> = mutableMapOf() val timeBudgetMs = timeLimitSec * 1000 - val generationTimeoutMillisWithoutCodegen: Long = timeBudgetMs - timeBudgetMs * 15 / 100 // 15% to terminate all activities and finalize code in file + + // 15% to terminate all activities and finalize code in file + val generationTimeoutMillisWithoutCodegen: Long = timeBudgetMs - timeBudgetMs * 15 / 100 + // 15% for instrumentation + // TODO usvm-sbft: when `jcMachine.analyzeAsync(): Flow` is added run `analyze` and `execute` under common timeout + val jcMachineTimeoutMillis: Long = generationTimeoutMillisWithoutCodegen - timeBudgetMs * 15 / 100 logger.debug { "-----------------------------------------------------------------------------" } logger.info( - "Contest.runGeneration: Time budget: $timeBudgetMs ms, Generation timeout=$generationTimeoutMillisWithoutCodegen ms, " + + "Contest.runGeneration: Time budget: $timeBudgetMs ms, jcMachine timeout=$jcMachineTimeoutMillis ms, " + "classpath=$classpathString, methodNameFilter=$methodNameFilter" ) val classpathFiles = classpathString.split(File.pathSeparator).map { File(it) } - val jcDbContainer by lazy { - JacoDBContainer( - key = classpathString, + val jcContainer by lazy { + JcContainer( classpath = classpathFiles, + machineOptions = UMachineOptions(timeout = jcMachineTimeoutMillis.milliseconds) ) { // TODO usvm-sbft: we may want to tune these JcSettings for contest useJavaRuntime(JdkInfoService.provide().path.toFile()) @@ -80,40 +89,28 @@ fun runUsvmGeneration( } } - val runner by lazy { - if (!UTestRunner.isInitialized()) - UTestRunner.initRunner(classpathFiles.map { it.absolutePath }, jcDbContainer.cp) - UTestRunner.runner - } - - val resolver by lazy { JcTestExecutor(jcDbContainer.cp) } + val executor by lazy { JcTestExecutor(jcContainer.cp, jcContainer.runner) } - val idGenerator = ReferencePreservingIntIdGenerator() - - val instructionIds = mutableMapOf, Long>() - val instructionIdProvider = InstructionIdProvider { methodSignature, instrIndex -> - instructionIds.getOrPut(methodSignature to instrIndex) { instructionIds.size.toLong() } - } + val utModelIdGenerator = ReferencePreservingIntIdGenerator() + val instructionIdGenerator = SimpleInstructionIdProvider() if (runFromEstimator) { - setOptions() - //will not be executed in real contest + setOptions() // UtBot options (aka UtSettings) + // will not be executed in real contest (see ContestKt.main() for more details) logger.info().measureTime({ "warmup: 1st optional JacoDB initialization (not to be counted in time budget)" }) { - jcDbContainer // force init lazy property + jcContainer // force init lazy property } logger.info().measureTime({ "warmup: 1st optional executor start (not to be counted in time budget)" }) { - runner.ensureRunnerAlive() + jcContainer.runner.ensureRunnerAlive() } } - //remaining budget + logger.info { "STARTED COUNTING BUDGET FOR ${cut.classId.name}" } + val startTime = System.currentTimeMillis() - logger.debug { "STARTED COUNTING BUDGET FOR ${cut.classId.name}" } fun remainingBudgetMillisWithoutCodegen() = max(0, generationTimeoutMillisWithoutCodegen - (System.currentTimeMillis() - startTime)) - logger.info("$cut") - if (cut.classLoader.javaClass != URLClassLoader::class.java) { logger.error("Seems like classloader for cut not valid (maybe it was backported to system): ${cut.classLoader}") } @@ -139,134 +136,128 @@ fun runUsvmGeneration( } logger.info().measureTime({ "preparation: ensure JacoDB is initialized (counted in time budget)" }) { - jcDbContainer // force init lazy property + jcContainer // force init lazy property } logger.info().measureTime({ "preparation: ensure executor is started (counted in time budget)" }) { - runner.ensureRunnerAlive() + jcContainer.runner.ensureRunnerAlive() } - // TODO usvm-sbft: better budget management - 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 = symbolicBudgetPerMethod) + statsForClass.methodsCount = filteredMethods.size + val methodToStats = filteredMethods.associateWith { method -> + StatsForMethod( + "${method.classId.simpleName}#${method.name}", + expectedExceptions.getForMethod(method.name).exceptionNames ) - }.use { machine -> - statsForClass.methodsCount = filteredMethods.size + }.onEach { (_, statsForMethod) -> statsForClass.statsForMethods.add(statsForMethod) } - // nothing to process further - if (filteredMethods.isEmpty()) return@runBlocking statsForClass + val jcMethods = filteredMethods.mapNotNull { methodId -> + jcContainer.cp.findMethodOrNull(methodId).also { + if (it == null) logger.error { "Method [$methodId] not found in jcClasspath [${jcContainer.cp}]" } + } + } - for (method in filteredMethods) { - val jcClass = jcDbContainer.cp.findClass(method.classId.name) + // nothing to process further + if (jcMethods.isEmpty()) return@runBlocking statsForClass + + val states = logger.info().measureTime({ "machine.analyze(${cut.classId.name})" }) { + ((ThreadBasedExecutor.threadLocal.invokeWithTimeout(jcMachineTimeoutMillis * 11 / 10) { + // TODO usvm-sbft: sometimes `machine.analyze` hangs forever, completely ignoring timeout specified for it + jcContainer.machine.analyze(jcMethods, targets = emptyList()) + } as? Result>) ?: run { + logger.error { "machine.analyze(${cut.classId.name}) timed out" } + Result.success(emptyList()) + }).getOrElse { e -> + logger.error(e) { "machine.analyze(${cut.classId.name}) failed" } + emptyList() + } + } - val jcTypedMethod = jcClass.toType().declaredMethods.firstOrNull { - it.name == method.name && it.method.jcdbSignature == when (method) { - is ConstructorId -> method.constructor.jcdbSignature - is MethodId -> method.method.jcdbSignature - } - } - if (jcTypedMethod == null) { - logger.error { "Method [$method] not found in jcClass [$jcClass]" } - continue - } - 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 = logger.info().measureTime({ "executor.execute(${cut.classId.name})" }) { + states.mapNotNull { state -> + // TODO usvm-sbft: if we have less than CONTEST_TEST_EXECUTION_TIMEOUT time left, we should + // try executing with smaller timeout, but instrumentation currently doesn't allow to change timeout + if (remainingBudgetMillisWithoutCodegen() > CONTEST_TEST_EXECUTION_TIMEOUT.inWholeMilliseconds) { + runCatching { + executor.execute(state.entrypoint.typedMethod, state) + }.getOrElse { e -> + logger.error(e) { "executor.execute(${state.entrypoint}) failed" } + null } + } else { + logger.warn { "executor.execute(${cut.classId.name}) run out of time" } + null } - val jcExecutions = states.mapNotNull { - if (remainingBudgetMillisWithoutCodegen() > UTestRunner.CONTEST_TEST_EXECUTION_TIMEOUT.inWholeMilliseconds) - logger.debug().measureTime({ "resolver.resolve(${method.classId}.${method.signature}, ...)" }) { - runCatching { - resolver.resolve(jcTypedMethod, it) - }.getOrElse { e -> - logger.error(e) { "Resolver failed" } - null - } - } - else null - } + } + } - var testsCounter = 0 - val statsForMethod = StatsForMethod( - "${method.classId.simpleName}#${method.name}", - expectedExceptions.getForMethod(method.name).exceptionNames - ) - statsForClass.statsForMethods.add(statsForMethod) - - val utExecutions: List = jcExecutions.mapNotNull { - logger.debug().measureTime({ "Convert JcExecution" }) { - try { - JcToUtExecutionConverter( - jcExecution = it, - jcClasspath = jcDbContainer.cp, - 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 - } - } + val utExecutions = logger.info().measureTime({"JcToUtExecutionConverter.convert(${cut.classId.name})"}) { + jcExecutions.mapNotNull { jcExecution -> + try { + val methodId = jcExecution.method.method.toExecutableId(jcContainer.cp) + JcToUtExecutionConverter( + jcExecution = jcExecution, + jcClasspath = jcContainer.cp, + idGenerator = utModelIdGenerator, + instructionIdProvider = instructionIdGenerator, + utilMethodProvider = codeGenerator.context.utilMethodProvider + ).convert()?.let { it to methodId } + } catch (e: Exception) { + logger.error(e) { "JcToUtExecutionConverter.convert(${jcExecution.method.method}) failed" } + null } + } + } - utExecutions.forEach { result -> - try { - val testMethodName = testMethodName(method.toString(), ++testsCounter) - val className = Type.getInternalName(method.classId.jClass) - logger.debug { "--new testCase collected, to generate: $testMethodName" } - statsForMethod.testsGeneratedCount++ - result.result.exceptionOrNull()?.let { exception -> - statsForMethod.detectedExceptionFqns += exception::class.java.name - } - result.coverage?.let { - statsForClass.updateCoverage( - newCoverage = it, - isNewClass = !statsForClass.testedClassNames.contains(className), - fromFuzzing = result is UtFuzzedExecution - ) - } - statsForClass.testedClassNames.add(className) - - testsByMethod.getOrPut(method) { mutableListOf() } += result - } catch (e: Throwable) { - //Here we need isolation - logger.error(e) { "Test generation failed during stats update" } + logger.info().measureTime({"Collect stats for ${cut.classId.name}"}) { + utExecutions.forEach { (utExecution, methodId) -> + try { + val className = Type.getInternalName(methodId.classId.jClass) + val statsForMethod = methodToStats.getValue(methodId) + statsForMethod.testsGeneratedCount++ + utExecution.result.exceptionOrNull()?.let { exception -> + statsForMethod.detectedExceptionFqns += exception::class.java.name } + utExecution.coverage?.let { + statsForClass.updateCoverage( + newCoverage = it, + isNewClass = !statsForClass.testedClassNames.contains(className), + fromFuzzing = utExecution is UtFuzzedExecution + ) + } + statsForClass.testedClassNames.add(className) + testsByMethod.getOrPut(methodId) { mutableListOf() } += utExecution + } catch (e: Throwable) { + logger.error(e) { "Test generation failed during stats update for $methodId" } } - logger.debug { "Finished $method" } } } } - val testSets = testsByMethod.map { (method, executions) -> - UtMethodTestSet(method, minimizeExecutions(executions), jimpleBody = null) - }.summarizeAll() + val testSets = logger.info().measureTime({ "Code generation for ${cut.classId.name}" }) { + testsByMethod.map { (method, executions) -> + UtMethodTestSet(method, minimizeExecutions(executions), jimpleBody = null) + }.summarizeAll() + } - logger.info().measureTime({ "Flushing tests for [${cut.simpleName}] on disk" }) { + logger.info().measureTime({ "Flushing tests for [${cut.classId.name}] on disk" }) { writeTestClass(cut, codeGenerator.generateAsString(testSets)) } - logger.debug { "STOPPED COUNTING BUDGET FOR ${cut.classId.name}" } + logger.info { "STOPPED COUNTING BUDGET FOR ${cut.classId.name}" } statsForClass -} \ No newline at end of file +} + +fun JcClasspath.findMethodOrNull(method: ExecutableId): JcMethod? = + findClass(method.classId.name).declaredMethods.firstOrNull { + it.name == method.name && it.jcdbSignature == method.jcdbSignature + } + +val JcMethod.typedMethod: JcTypedMethod get() = enclosingClass.toType().declaredMethods.first { + it.name == name && it.method.jcdbSignature == jcdbSignature +} + +val ExecutableId.jcdbSignature: String get() = when (this) { + is ConstructorId -> constructor.jcdbSignature + is MethodId -> method.jcdbSignature +} diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/EnvironmentStateKind.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/EnvironmentStateKind.kt deleted file mode 100644 index 0c275c4152..0000000000 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/EnvironmentStateKind.kt +++ /dev/null @@ -1,5 +0,0 @@ -package org.utbot.contest.usvm - -enum class EnvironmentStateKind { - INITIAL, FINAL -} \ No newline at end of file diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/InstructionIdProvider.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/InstructionIdProvider.kt deleted file mode 100644 index 252d08f566..0000000000 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/InstructionIdProvider.kt +++ /dev/null @@ -1,8 +0,0 @@ -package org.utbot.contest.usvm - -fun interface InstructionIdProvider { - fun provideInstructionId( - methodSignature: String, - index: Int, - ): Long -} \ No newline at end of file diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JacoDBContainer.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JacoDBContainer.kt deleted file mode 100644 index e4ae8bbb61..0000000000 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JacoDBContainer.kt +++ /dev/null @@ -1,44 +0,0 @@ -package org.utbot.contest.usvm - -import kotlinx.coroutines.runBlocking -import org.jacodb.api.JcClasspath -import org.jacodb.api.JcDatabase -import org.jacodb.impl.JcSettings -import org.jacodb.impl.features.classpaths.UnknownClasses -import org.jacodb.impl.jacodb -import org.usvm.util.classpathWithApproximations -import java.io.File - -// TODO usvm-sbft-refactoring: copied from `usvm/usvm-jvm/test`, extract this class back to USVM project -class JacoDBContainer( - classpath: List, - builder: JcSettings.() -> Unit, -) { - val db: JcDatabase - val cp: JcClasspath - - init { - val (db, cp) = runBlocking { - val db = jacodb(builder) - // TODO usvm-sbft: use classpathWithApproximations here - val cp = db.classpath(classpath, listOf(UnknownClasses)) - db to cp - } - this.db = db - this.cp = cp - runBlocking { - db.awaitBackgroundJobs() - } - } - - companion object { - private val keyToJacoDBContainer = HashMap() - - operator fun invoke( - key: Any?, - classpath: List, - builder: JcSettings.() -> Unit, - ): JacoDBContainer = - keyToJacoDBContainer.getOrPut(key) { JacoDBContainer(classpath, builder) } - } -} 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 deleted file mode 100644 index f58c682e26..0000000000 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/Utils.kt +++ /dev/null @@ -1,16 +0,0 @@ -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/kotlin/org/utbot/contest/usvm/ConverterUtils.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/ConverterUtils.kt similarity index 98% rename from utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt rename to utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/ConverterUtils.kt index 3bce88c6c9..ffb884ad03 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/ConverterUtils.kt @@ -1,4 +1,4 @@ -package org.utbot.contest.usvm +package org.utbot.contest.usvm.converter import org.jacodb.analysis.library.analyzers.thisInstance import org.jacodb.api.JcArrayType diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/InstructionIdProvider.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/InstructionIdProvider.kt new file mode 100644 index 0000000000..898ba718eb --- /dev/null +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/InstructionIdProvider.kt @@ -0,0 +1,12 @@ +package org.utbot.contest.usvm.converter + +fun interface InstructionIdProvider { + fun provideInstructionId(methodSignature: String, instIndex: Int): Long +} + +class SimpleInstructionIdProvider : InstructionIdProvider { + private val instructionIds = mutableMapOf, Long>() + + override fun provideInstructionId(methodSignature: String, instIndex: Int): Long = + instructionIds.getOrPut(methodSignature to instIndex) { instructionIds.size.toLong() } +} \ 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/converter/JcToUtExecutionConverter.kt similarity index 98% rename from utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt rename to utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtExecutionConverter.kt index 6643853d45..7d97a082cd 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/converter/JcToUtExecutionConverter.kt @@ -1,4 +1,4 @@ -package org.utbot.contest.usvm +package org.utbot.contest.usvm.converter import mu.KotlinLogging import org.jacodb.api.JcClassOrInterface @@ -18,7 +18,7 @@ import org.usvm.instrumentation.testcase.descriptor.UTestExceptionDescriptor import org.usvm.instrumentation.util.enclosingClass import org.usvm.instrumentation.util.enclosingMethod import org.utbot.common.isPublic -import org.utbot.contest.usvm.executor.JcExecution +import org.utbot.contest.usvm.jc.JcExecution import org.utbot.framework.codegen.domain.builtin.UtilMethodProvider import org.utbot.framework.plugin.api.ClassId import org.utbot.framework.plugin.api.Coverage @@ -58,7 +58,7 @@ class JcToUtExecutionConverter( private var jcToUtModelConverter: JcToUtModelConverter init { - val instToModelConverter = UTestInst2UtModelConverter(idGenerator, jcClasspath, utilMethodProvider) + val instToModelConverter = UTestInstToUtModelConverter(idGenerator, jcClasspath, utilMethodProvider) instToModelConverter.processUTest(jcExecution.uTest) jcToUtModelConverter = JcToUtModelConverter(idGenerator, jcClasspath, instToModelConverter) 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/converter/JcToUtModelConverter.kt similarity index 98% rename from utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt rename to utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtModelConverter.kt index 9f79379732..67b955af2f 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtModelConverter.kt @@ -1,4 +1,4 @@ -package org.utbot.contest.usvm +package org.utbot.contest.usvm.converter import org.jacodb.api.JcClasspath import org.usvm.instrumentation.testcase.api.UTestExpression @@ -29,10 +29,14 @@ import org.utbot.framework.plugin.api.util.jClass import org.utbot.framework.plugin.api.util.stringClassId import org.utbot.fuzzer.IdGenerator +enum class EnvironmentStateKind { + INITIAL, FINAL +} + class JcToUtModelConverter( private val idGenerator: IdGenerator, private val jcClasspath: JcClasspath, - private val instToUtModelConverter: UTestInst2UtModelConverter, + private val instToUtModelConverter: UTestInstToUtModelConverter, ) { private val descriptorToModelCache = mutableMapOf() private val refIdAndStateKindToDescriptorCache = 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/converter/UTestInstToUtModelConverter.kt similarity index 99% rename from utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt rename to utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/UTestInstToUtModelConverter.kt index 0615e41f36..42634d0ff3 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/UTestInstToUtModelConverter.kt @@ -1,4 +1,4 @@ -package org.utbot.contest.usvm +package org.utbot.contest.usvm.converter import org.jacodb.api.JcClasspath import org.usvm.instrumentation.testcase.UTest @@ -49,7 +49,7 @@ import org.utbot.framework.plugin.api.util.classClassId import org.utbot.framework.plugin.api.util.objectClassId import org.utbot.fuzzer.IdGenerator -class UTestInst2UtModelConverter( +class UTestInstToUtModelConverter( private val idGenerator: IdGenerator, private val jcClasspath: JcClasspath, private val utilMethodProvider: UtilMethodProvider, 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/converter/UTestValueDescriptorUtils.kt similarity index 97% rename from utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestValueDescriptorUtils.kt rename to utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/UTestValueDescriptorUtils.kt index cd96782def..659a086f34 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestValueDescriptorUtils.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/UTestValueDescriptorUtils.kt @@ -1,4 +1,4 @@ -package org.utbot.contest.usvm +package org.utbot.contest.usvm.converter import org.usvm.instrumentation.testcase.descriptor.UTestArrayDescriptor import org.usvm.instrumentation.testcase.descriptor.UTestClassDescriptor 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/converter/UtUsvmExecution.kt similarity index 76% rename from utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UtUsvmExecution.kt rename to utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/UtUsvmExecution.kt index 0964c0c29b..2bed13737b 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/converter/UtUsvmExecution.kt @@ -1,4 +1,4 @@ -package org.utbot.contest.usvm +package org.utbot.contest.usvm.converter import org.utbot.framework.plugin.api.Coverage import org.utbot.framework.plugin.api.DocStatement @@ -7,6 +7,9 @@ import org.utbot.framework.plugin.api.UtExecution import org.utbot.framework.plugin.api.UtExecutionResult import org.utbot.framework.plugin.api.UtExecutionWithInstrumentation import org.utbot.framework.plugin.api.UtInstrumentation +import org.utbot.framework.plugin.api.mapper.UtModelMapper +import org.utbot.framework.plugin.api.mapper.mapModelIfExists +import org.utbot.framework.plugin.api.mapper.mapModels class UtUsvmExecution( stateBefore: EnvironmentModels, @@ -64,4 +67,15 @@ class UtUsvmExecution( displayName, instrumentation, ) -} \ No newline at end of file +} + +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/kotlin/org/utbot/contest/usvm/executor/UTestRunner.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/executor/UTestRunner.kt deleted file mode 100644 index 7923305df2..0000000000 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/executor/UTestRunner.kt +++ /dev/null @@ -1,25 +0,0 @@ -package org.utbot.contest.usvm.executor - -import org.jacodb.api.JcClasspath -import org.usvm.instrumentation.executor.UTestConcreteExecutor -import org.usvm.instrumentation.instrumentation.JcRuntimeTraceInstrumenterFactory -import kotlin.time.Duration.Companion.seconds - -// TODO usvm-sbft-refactoring: copied from `usvm/usvm-jvm/test`, extract this class back to USVM project -object UTestRunner { - val CONTEST_TEST_EXECUTION_TIMEOUT = 1.seconds - - lateinit var runner: UTestConcreteExecutor - - fun isInitialized() = this::runner.isInitialized - - fun initRunner(pathToJars: List, classpath: JcClasspath) { - runner = - UTestConcreteExecutor( - JcRuntimeTraceInstrumenterFactory::class, - pathToJars, - classpath, - CONTEST_TEST_EXECUTION_TIMEOUT - ) - } -} \ No newline at end of file diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcContainer.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcContainer.kt new file mode 100644 index 0000000000..a5e02bf520 --- /dev/null +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcContainer.kt @@ -0,0 +1,82 @@ +package org.utbot.contest.usvm.jc + +import kotlinx.coroutines.runBlocking +import mu.KotlinLogging +import org.jacodb.api.JcClasspath +import org.jacodb.api.JcDatabase +import org.jacodb.impl.JcSettings +import org.jacodb.impl.features.classpaths.UnknownClasses +import org.jacodb.impl.jacodb +import org.usvm.UMachineOptions +import org.usvm.instrumentation.executor.UTestConcreteExecutor +import org.usvm.instrumentation.instrumentation.JcRuntimeTraceInstrumenterFactory +import org.usvm.machine.JcMachine +import java.io.File +import kotlin.time.Duration.Companion.seconds + +private val logger = KotlinLogging.logger {} + +// TODO usvm-sbft-refactoring: copied from `usvm/usvm-jvm/test`, extract this class back to USVM project +class JcContainer private constructor( + classpath: List, + machineOptions: UMachineOptions, + builder: JcSettings.() -> Unit, +) : AutoCloseable { + val db: JcDatabase + val cp: JcClasspath + val machine: JcMachine + val runner: UTestConcreteExecutor + + init { + val (db, cp) = runBlocking { + val db = jacodb(builder) + // TODO usvm-sbft: use classpathWithApproximations here when approximation decoders are finished + val cp = db.classpath(classpath, listOf(UnknownClasses)) + db to cp + } + this.db = db + this.cp = cp + this.machine = JcMachine(cp, machineOptions) + this.runner = UTestConcreteExecutor( + JcRuntimeTraceInstrumenterFactory::class, + classpath.map { it.absolutePath }, + cp, + CONTEST_TEST_EXECUTION_TIMEOUT + ) + runBlocking { + db.awaitBackgroundJobs() + } + } + + override fun close() { + cp.close() + db.close() + machine.close() + runner.close() + } + + companion object : AutoCloseable { + val CONTEST_TEST_EXECUTION_TIMEOUT = 1.seconds + + private val cache = HashMap, UMachineOptions>, JcContainer>() + + operator fun invoke( + classpath: List, + machineOptions: UMachineOptions, + builder: JcSettings.() -> Unit, + ): JcContainer { + val cacheKey = classpath to machineOptions + return cache[cacheKey] ?: run { + // TODO usvm-sbft: right now max cache size is 1, do we need to increase it? + logger.info { "JcContainer cache miss" } + close() + JcContainer(classpath, machineOptions, builder).also { cache[cacheKey] = it } + } + } + + override fun close() { + cache.values.forEach { it.close() } + cache.clear() + } + } +} diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/executor/JcExecution.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcExecution.kt similarity index 89% rename from utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/executor/JcExecution.kt rename to utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcExecution.kt index 2e940c991f..92812f9d7d 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/executor/JcExecution.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcExecution.kt @@ -1,4 +1,4 @@ -package org.utbot.contest.usvm.executor +package org.utbot.contest.usvm.jc import org.jacodb.api.JcTypedMethod import org.usvm.api.JcCoverage diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/executor/JcTestExecutor.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcTestExecutor.kt similarity index 86% rename from utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/executor/JcTestExecutor.kt rename to utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcTestExecutor.kt index af7291687e..c646747066 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/executor/JcTestExecutor.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcTestExecutor.kt @@ -1,11 +1,9 @@ -package org.utbot.contest.usvm.executor +package org.utbot.contest.usvm.jc import io.ksmt.utils.asExpr import kotlinx.coroutines.runBlocking import org.jacodb.api.* import org.jacodb.api.ext.* -import org.jacodb.impl.fs.BuildFolderLocation -import org.jacodb.impl.fs.JarLocation import org.usvm.* import org.usvm.api.JcCoverage import org.usvm.api.JcTest @@ -37,29 +35,17 @@ import org.usvm.types.firstOrNull /** * A class, responsible for resolving a single [JcExecution] for a specific method from a symbolic state. * - * Uses reflection to resolve objects. + * Uses concrete execution */ // TODO usvm-sbft-refactoring: copied from `usvm/usvm-jvm/test`, extract this class back to USVM project class JcTestExecutor( val classpath: JcClasspath, -) { - private val runner: UTestConcreteExecutor - get() { - if (!UTestRunner.isInitialized()) { - val pathToJars = - classpath.locations - .filter { it is BuildFolderLocation || (it is JarLocation && it.type == LocationType.APP) } - .map { it.path } - UTestRunner.initRunner(pathToJars, classpath) - } - return UTestRunner.runner - } - +) { /** * Resolves a [JcTest] from a [method] from a [state]. */ - fun resolve(method: JcTypedMethod, state: JcState): JcExecution { + fun execute(method: JcTypedMethod, state: JcState): JcExecution { val model = state.models.first() val ctx = state.ctx @@ -138,15 +124,41 @@ class JcTestExecutor( ): Pair> { val exprInModel = evaluateInModel(expr) return when (type) { - ctx.cp.boolean -> UTestBooleanExpression(extractBool(exprInModel) ?: false, ctx.cp.boolean) - ctx.cp.short -> UTestShortExpression(extractShort(exprInModel) ?: 0, ctx.cp.short) - ctx.cp.int -> UTestIntExpression(extractInt(exprInModel) ?: 0, ctx.cp.int) - ctx.cp.long -> UTestLongExpression(extractLong(exprInModel) ?: 0L, ctx.cp.long) - ctx.cp.float -> UTestFloatExpression(extractFloat(exprInModel) ?: 0.0f, ctx.cp.float) - ctx.cp.double -> UTestDoubleExpression(extractDouble(exprInModel) ?: 0.0, ctx.cp.double) - ctx.cp.byte -> UTestByteExpression(extractByte(exprInModel) ?: 0, ctx.cp.byte) - ctx.cp.char -> UTestCharExpression(extractChar(exprInModel) ?: '\u0000', ctx.cp.char) - ctx.cp.void -> UTestNullExpression(ctx.cp.void) + ctx.cp.boolean -> UTestBooleanExpression( + value = extractBool(exprInModel) ?: false, + type = ctx.cp.boolean + ) + ctx.cp.short -> UTestShortExpression( + value = extractShort(exprInModel) ?: 0, + type = ctx.cp.short + ) + ctx.cp.int -> UTestIntExpression( + value = extractInt(exprInModel) ?: 0, + type = ctx.cp.int + ) + ctx.cp.long -> UTestLongExpression( + value = extractLong(exprInModel) ?: 0L, + type = ctx.cp.long + ) + ctx.cp.float -> UTestFloatExpression( + value = extractFloat(exprInModel) ?: 0.0f, + type = ctx.cp.float + ) + ctx.cp.double -> UTestDoubleExpression( + value = extractDouble(exprInModel) ?: 0.0, + type = ctx.cp.double + ) + ctx.cp.byte -> UTestByteExpression( + value = extractByte(exprInModel) ?: 0, + type = ctx.cp.byte + ) + ctx.cp.char -> UTestCharExpression( + value = extractChar(exprInModel) ?: '\u0000', + type = ctx.cp.char + ) + ctx.cp.void -> UTestNullExpression( + type = ctx.cp.void + ) else -> error("Unexpected type: ${type.typeName}") }.let { it to listOf() } } @@ -206,7 +218,6 @@ class JcTestExecutor( return resolveLValue(elemRef, type.elementType) } - //val arrLength = UTestIntExpression(length, ctx.cp.int) val arrayInstance = UTestCreateArrayExpression(type.elementType, length) val arraySetters = buildList { @@ -307,7 +318,10 @@ class JcTestExecutor( // TODO simple org.jacodb.api.ext.JcClasses.isEnum does not work with enums with abstract methods private fun JcRefType.getEnumAncestorOrNull(): JcClassOrInterface? = - (sequenceOf(jcClass) + jcClass.allSuperHierarchySequence).firstOrNull { it.isEnum } + jcClass.getAllSuperHierarchyIncludingThis().firstOrNull { it.isEnum } + + private fun JcClassOrInterface.getAllSuperHierarchyIncludingThis() = + (sequenceOf(this) + allSuperHierarchySequence) } } \ No newline at end of file From 65dd727daab9243821f3a5436fc3e145c08299a1 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Wed, 22 Nov 2023 12:09:55 +0300 Subject: [PATCH 040/121] SBFT'24 An attempt to support UTestGlobalMock in converters (#2690) * An attempt to support UTestGlobalMock in converters * Apply review fixes * Corrected valueModels for global constructors mocks --- .../converter/JcToUtExecutionConverter.kt | 13 ++--- .../converter/UTestInstToUtModelConverter.kt | 58 ++++++++++++++++--- 2 files changed, 57 insertions(+), 14 deletions(-) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtExecutionConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtExecutionConverter.kt index 7d97a082cd..adab60cc8f 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtExecutionConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtExecutionConverter.kt @@ -56,18 +56,17 @@ class JcToUtExecutionConverter( private val toValueConverter = Descriptor2ValueConverter(utContext.classLoader) private var jcToUtModelConverter: JcToUtModelConverter + private var uTestProcessResult: UTestAnalysisResult init { - val instToModelConverter = UTestInstToUtModelConverter(idGenerator, jcClasspath, utilMethodProvider) - - instToModelConverter.processUTest(jcExecution.uTest) + val instToModelConverter = UTestInstToUtModelConverter(jcExecution.uTest, jcClasspath, idGenerator, utilMethodProvider) jcToUtModelConverter = JcToUtModelConverter(idGenerator, jcClasspath, instToModelConverter) + + uTestProcessResult = instToModelConverter.processUTest() } 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( @@ -78,7 +77,7 @@ class JcToUtExecutionConverter( jcToUtModelConverter.convert(it, EnvironmentStateKind.FINAL) } ?: UtVoidModel), coverage = coverage, - instrumentation = instrumentation, + instrumentation = uTestProcessResult.instrumentation, ) is UTestExecutionExceptionResult -> { UtUsvmExecution( @@ -89,7 +88,7 @@ class JcToUtExecutionConverter( jcExecution.method, ), coverage = coverage, - instrumentation = instrumentation, + instrumentation = uTestProcessResult.instrumentation, ) } diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/UTestInstToUtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/UTestInstToUtModelConverter.kt index 42634d0ff3..be2d579ed5 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/UTestInstToUtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/UTestInstToUtModelConverter.kt @@ -36,6 +36,7 @@ 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.MethodId import org.utbot.framework.plugin.api.UtArrayModel import org.utbot.framework.plugin.api.UtAssembleModel import org.utbot.framework.plugin.api.UtClassRefModel @@ -43,26 +44,29 @@ 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.UtNewInstanceInstrumentation import org.utbot.framework.plugin.api.UtNullModel import org.utbot.framework.plugin.api.UtPrimitiveModel +import org.utbot.framework.plugin.api.UtStaticMethodInstrumentation import org.utbot.framework.plugin.api.util.classClassId import org.utbot.framework.plugin.api.util.objectClassId +import org.utbot.framework.plugin.api.util.voidClassId import org.utbot.fuzzer.IdGenerator class UTestInstToUtModelConverter( - private val idGenerator: IdGenerator, + private val uTest: UTest, private val jcClasspath: JcClasspath, + private val idGenerator: IdGenerator, private val utilMethodProvider: UtilMethodProvider, ) { private val exprToModelCache = mutableMapOf() private val instrumentations = mutableListOf() - fun processUTest(uTest: UTest) { - exprToModelCache.clear() - instrumentations.clear() - + fun processUTest(): UTestAnalysisResult { uTest.initStatements.forEach { uInst -> processInst(uInst) } removeInstantiationCallFromThisInstanceModificationChain(processExpr(uTest.callMethodExpression)) + + return UTestAnalysisResult(instrumentations) } fun findModelByInst(expr: UTestExpression): UtModel { @@ -301,7 +305,43 @@ class UTestInstToUtModelConverter( } is UTestGlobalMock -> { - // TODO usvm-sbft: collect instrumentations here + val methodsToExprs = uTestExpr.methods.entries + val initMethodExprs = methodsToExprs.filter { it.key.isConstructor } + val otherMethodsExprs = methodsToExprs.minus(initMethodExprs.toSet()) + + otherMethodsExprs + .forEach { (jcMethod, uTestExprs) -> + val methodId = jcMethod.toExecutableId(jcClasspath) as MethodId + val valueModels = uTestExprs.map { expr -> processExpr(expr) } + val methodInstrumentation = UtStaticMethodInstrumentation( + methodId = methodId, + values = valueModels, + ) + + instrumentations += methodInstrumentation + } + + initMethodExprs + .forEach { (jcMethod, uTestExprs) -> + // TODO usvm-sbft-merge: it can be .map { expr -> processExpr(expr) } here + // However, there's no special treatment for cases when method occurs in a global mock + val valueModels = uTestExprs.map { _ -> UtCompositeModel( + id=idGenerator.createId(), + classId = voidClassId, + isMock = true, + ) + } + val methodInstrumentation = UtNewInstanceInstrumentation( + classId = jcMethod.enclosingClass.classId, + instances = valueModels, + // [UTestGlobalMock] does not have an equivalent of [callSites], + // but it is used only in UtBot instrumentation. We use USVM one, so it is not a problem. + callSites = emptySet(), + ) + + instrumentations += methodInstrumentation + } + // UtClassRefModel is returned here for consistency with [Descriptor2ValueConverter] // which returns Class<*> instance for [UTestGlobalMock] descriptors. UtClassRefModel( @@ -320,4 +360,8 @@ class UTestInstToUtModelConverter( is UTestArrayLengthExpression -> error("This expression type is not supported") } } -} \ No newline at end of file +} + +data class UTestAnalysisResult( + val instrumentation: List, +) \ No newline at end of file From 26751a5f1804d7b0b2b7d6c70723522e08d32164 Mon Sep 17 00:00:00 2001 From: IlyaMuravjov <71839386+IlyaMuravjov@users.noreply.github.com> Date: Wed, 22 Nov 2023 15:36:22 +0300 Subject: [PATCH 041/121] Introduce and use `JcMachine.analyzeAsync` in `ContestUsvm` (#2696) --- gradle.properties | 2 +- .../kotlin/org/utbot/common/ThreadUtil.kt | 11 +- .../org/utbot/contest/usvm/ContestUsvm.kt | 167 +++++++++++------- .../converter/JcToUtExecutionConverter.kt | 5 +- 4 files changed, 110 insertions(+), 75 deletions(-) diff --git a/gradle.properties b/gradle.properties index f335e5ca8e..83d31d88cd 100644 --- a/gradle.properties +++ b/gradle.properties @@ -102,7 +102,7 @@ commonsIOVersion=2.11.0 javaxVersion=2.2 jakartaVersion=3.1.0 jacoDbVersion=1.4.1 -usvmVersion=comp-231121-1810 +usvmVersion=comp-231122-1058 # use latest Java 8 compaitable Spring and Spring Boot versions springVersion=5.3.28 diff --git a/utbot-core/src/main/kotlin/org/utbot/common/ThreadUtil.kt b/utbot-core/src/main/kotlin/org/utbot/common/ThreadUtil.kt index 1aee3398bd..2dd7fb9969 100644 --- a/utbot-core/src/main/kotlin/org/utbot/common/ThreadUtil.kt +++ b/utbot-core/src/main/kotlin/org/utbot/common/ThreadUtil.kt @@ -61,7 +61,12 @@ 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? { + fun invokeWithTimeout( + timeoutMillis: Long, + stopWatch: StopWatch? = null, + threadDeathThrowPeriodMillis: Long = 10_000, + action:() -> Any? + ) : Result? { ensureThreadIsAlive() requestQueue.offer { @@ -95,10 +100,10 @@ class ThreadBasedExecutor { t.stop() } // If somebody catches `ThreadDeath`, for now we - // just wait for at most 10s and throw another one. + // just wait for [threadDeathThrowPeriod] and throw another one. // // A better approach may be to kill instrumented process. - t.join(10_000) + t.join(threadDeathThrowPeriodMillis) } } catch (_: Throwable) {} } 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 8364cfaac3..22a7cb0af3 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 @@ -12,8 +12,11 @@ import org.jacodb.approximation.Approximations import org.jacodb.impl.features.InMemoryHierarchy import org.objectweb.asm.Type import org.usvm.UMachineOptions +import org.usvm.api.targets.JcTarget import org.usvm.instrumentation.util.jcdbSignature +import org.usvm.machine.JcMachine import org.usvm.machine.state.JcState +import org.usvm.statistics.collectors.StatesCollector import org.utbot.common.ThreadBasedExecutor import org.utbot.common.info import org.utbot.common.measureTime @@ -36,13 +39,15 @@ 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.api.util.utContext +import org.utbot.framework.plugin.api.util.withUtContext import org.utbot.framework.plugin.services.JdkInfoService import org.utbot.fuzzer.ReferencePreservingIntIdGenerator import org.utbot.fuzzer.UtFuzzedExecution import org.utbot.summary.usvm.summarizeAll import java.io.File import java.net.URLClassLoader -import kotlin.math.max +import kotlin.system.measureTimeMillis import kotlin.time.Duration.Companion.milliseconds private val logger = KotlinLogging.logger {} @@ -65,13 +70,10 @@ fun runUsvmGeneration( // 15% to terminate all activities and finalize code in file val generationTimeoutMillisWithoutCodegen: Long = timeBudgetMs - timeBudgetMs * 15 / 100 - // 15% for instrumentation - // TODO usvm-sbft: when `jcMachine.analyzeAsync(): Flow` is added run `analyze` and `execute` under common timeout - val jcMachineTimeoutMillis: Long = generationTimeoutMillisWithoutCodegen - timeBudgetMs * 15 / 100 logger.debug { "-----------------------------------------------------------------------------" } logger.info( - "Contest.runGeneration: Time budget: $timeBudgetMs ms, jcMachine timeout=$jcMachineTimeoutMillis ms, " + + "Contest.runGeneration: Time budget: $timeBudgetMs ms, generation timeout=$generationTimeoutMillisWithoutCodegen ms, " + "classpath=$classpathString, methodNameFilter=$methodNameFilter" ) @@ -80,7 +82,11 @@ fun runUsvmGeneration( val jcContainer by lazy { JcContainer( classpath = classpathFiles, - machineOptions = UMachineOptions(timeout = jcMachineTimeoutMillis.milliseconds) + machineOptions = UMachineOptions( + // TODO usvm-sbft: if we have less than CONTEST_TEST_EXECUTION_TIMEOUT time left, we should try execute + // with smaller timeout, but instrumentation currently doesn't allow to change timeout for individual runs + timeout = generationTimeoutMillisWithoutCodegen.milliseconds - CONTEST_TEST_EXECUTION_TIMEOUT + ) ) { // TODO usvm-sbft: we may want to tune these JcSettings for contest useJavaRuntime(JdkInfoService.provide().path.toFile()) @@ -107,10 +113,6 @@ fun runUsvmGeneration( logger.info { "STARTED COUNTING BUDGET FOR ${cut.classId.name}" } - val startTime = System.currentTimeMillis() - fun remainingBudgetMillisWithoutCodegen() = - max(0, generationTimeoutMillisWithoutCodegen - (System.currentTimeMillis() - startTime)) - if (cut.classLoader.javaClass != URLClassLoader::class.java) { logger.error("Seems like classloader for cut not valid (maybe it was backported to system): ${cut.classLoader}") } @@ -159,78 +161,62 @@ fun runUsvmGeneration( // nothing to process further if (jcMethods.isEmpty()) return@runBlocking statsForClass - val states = logger.info().measureTime({ "machine.analyze(${cut.classId.name})" }) { - ((ThreadBasedExecutor.threadLocal.invokeWithTimeout(jcMachineTimeoutMillis * 11 / 10) { - // TODO usvm-sbft: sometimes `machine.analyze` hangs forever, completely ignoring timeout specified for it - jcContainer.machine.analyze(jcMethods, targets = emptyList()) - } as? Result>) ?: run { - logger.error { "machine.analyze(${cut.classId.name}) timed out" } - Result.success(emptyList()) - }).getOrElse { e -> - logger.error(e) { "machine.analyze(${cut.classId.name}) failed" } - emptyList() - } - } - - val jcExecutions = logger.info().measureTime({ "executor.execute(${cut.classId.name})" }) { - states.mapNotNull { state -> - // TODO usvm-sbft: if we have less than CONTEST_TEST_EXECUTION_TIMEOUT time left, we should - // try executing with smaller timeout, but instrumentation currently doesn't allow to change timeout - if (remainingBudgetMillisWithoutCodegen() > CONTEST_TEST_EXECUTION_TIMEOUT.inWholeMilliseconds) { - runCatching { - executor.execute(state.entrypoint.typedMethod, state) - }.getOrElse { e -> - logger.error(e) { "executor.execute(${state.entrypoint}) failed" } - null - } - } else { - logger.warn { "executor.execute(${cut.classId.name}) run out of time" } - null + val timeStats = mutableMapOf() + + jcContainer.machine.analyzeAsync( + forceTerminationTimeout = (generationTimeoutMillisWithoutCodegen + timeBudgetMs) / 2, + methods = jcMethods, + targets = emptyList() + ) { state -> + val jcExecution = accumulateMeasureTime("executor.execute(${cut.classId.name})", timeStats) { + runCatching { + executor.execute(state.entrypoint.typedMethod, state) + }.getOrElse { e -> + logger.error(e) { "executor.execute(${state.entrypoint}) failed" } + return@analyzeAsync } } - } - - val utExecutions = logger.info().measureTime({"JcToUtExecutionConverter.convert(${cut.classId.name})"}) { - jcExecutions.mapNotNull { jcExecution -> - try { - val methodId = jcExecution.method.method.toExecutableId(jcContainer.cp) + val methodId = jcExecution.method.method.toExecutableId(jcContainer.cp) + val utExecution = accumulateMeasureTime("JcToUtExecutionConverter.convert(${cut.classId.name})", timeStats) { + runCatching { JcToUtExecutionConverter( jcExecution = jcExecution, jcClasspath = jcContainer.cp, idGenerator = utModelIdGenerator, instructionIdProvider = instructionIdGenerator, utilMethodProvider = codeGenerator.context.utilMethodProvider - ).convert()?.let { it to methodId } - } catch (e: Exception) { + ).convert() + // for some JcExecutions like RD faults we don't construct UtExecutions, converter logs such cases + ?: return@analyzeAsync + }.getOrElse { e -> logger.error(e) { "JcToUtExecutionConverter.convert(${jcExecution.method.method}) failed" } - null + return@analyzeAsync } } - } - - logger.info().measureTime({"Collect stats for ${cut.classId.name}"}) { - utExecutions.forEach { (utExecution, methodId) -> - try { - val className = Type.getInternalName(methodId.classId.jClass) - val statsForMethod = methodToStats.getValue(methodId) - statsForMethod.testsGeneratedCount++ - utExecution.result.exceptionOrNull()?.let { exception -> - statsForMethod.detectedExceptionFqns += exception::class.java.name - } - utExecution.coverage?.let { - statsForClass.updateCoverage( - newCoverage = it, - isNewClass = !statsForClass.testedClassNames.contains(className), - fromFuzzing = utExecution is UtFuzzedExecution - ) - } - statsForClass.testedClassNames.add(className) - testsByMethod.getOrPut(methodId) { mutableListOf() } += utExecution - } catch (e: Throwable) { - logger.error(e) { "Test generation failed during stats update for $methodId" } + runCatching { + val className = Type.getInternalName(methodId.classId.jClass) + val statsForMethod = methodToStats.getValue(methodId) + statsForMethod.testsGeneratedCount++ + utExecution.result.exceptionOrNull()?.let { exception -> + statsForMethod.detectedExceptionFqns += exception::class.java.name } + utExecution.coverage?.let { + statsForClass.updateCoverage( + newCoverage = it, + isNewClass = !statsForClass.testedClassNames.contains(className), + fromFuzzing = utExecution is UtFuzzedExecution + ) + } + statsForClass.testedClassNames.add(className) + testsByMethod.getOrPut(methodId) { mutableListOf() } += utExecution + }.getOrElse { e -> + logger.error(e) { "Test generation failed during stats update for $methodId" } } } + + timeStats.forEach { (regionName, timeMillis) -> + logger.info { "Region [$regionName] finished in $timeMillis ms" } + } } val testSets = logger.info().measureTime({ "Code generation for ${cut.classId.name}" }) { @@ -261,3 +247,48 @@ val ExecutableId.jcdbSignature: String get() = when (this) { is ConstructorId -> constructor.jcdbSignature is MethodId -> method.jcdbSignature } + +fun JcMachine.analyzeAsync( + forceTerminationTimeout: Long, + methods: List, + targets: List, + callback: (JcState) -> Unit +) { + val utContext = utContext + // TODO usvm-sbft: sometimes `machine.analyze` or `executor.execute` hangs forever, + // completely ignoring timeout specified for it, so additional hard time out is enforced here. + // Hard timeout seems to be working ok so far, however it may leave machine or executor in an inconsistent state. + // Also, `machine` or `executor` may catch `ThreadDeath` and still continue working (that is in fact what happens, + // but throwing `ThreadDeath` every 500 ms seems to eventually work). + ThreadBasedExecutor.threadLocal.invokeWithTimeout(forceTerminationTimeout, threadDeathThrowPeriodMillis = 500) { + withUtContext(utContext) { + analyze( + methods = methods, + statesCollector = object : StatesCollector { + override var count: Int = 0 + private set + + override fun addState(state: JcState) { + count++ + callback(state) + } + }, + targets = targets + ) + } + }?.onFailure { e -> + logger.error(e) { "analyzeAsync failed" } + } ?: logger.error { "analyzeAsync time exceeded hard time out" } +} + +inline fun accumulateMeasureTime( + regionName: String, + timeAccumulatorMillis: MutableMap, + block: () -> T +): T { + var res: T + timeAccumulatorMillis[regionName] = (timeAccumulatorMillis[regionName] ?: 0) + measureTimeMillis { + res = block() + } + return res +} diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtExecutionConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtExecutionConverter.kt index adab60cc8f..061f89cd42 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtExecutionConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtExecutionConverter.kt @@ -33,7 +33,6 @@ 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.UtPrimitiveModel import org.utbot.framework.plugin.api.UtStatementCallModel import org.utbot.framework.plugin.api.UtVoidModel @@ -94,14 +93,14 @@ class JcToUtExecutionConverter( is UTestExecutionInitFailedResult -> { logger.warn(convertException(executionResult.cause)) { - "Execution failed before method under test call" + "Execution failed before method under test call on ${jcExecution.method.method}" } null } is UTestExecutionFailedResult -> { logger.error(convertException(executionResult.cause)) { - "Concrete execution failed" + "Concrete execution failed on ${jcExecution.method.method}" } null } From 7ed6b08d84dea39037b090dd34b30bf43c043910 Mon Sep 17 00:00:00 2001 From: IlyaMuravjov <71839386+IlyaMuravjov@users.noreply.github.com> Date: Wed, 22 Nov 2023 18:33:02 +0300 Subject: [PATCH 042/121] Make USVM descriptor to UtModel cache consider state kind (initial or final) (#2697) --- .../contest/usvm/converter/JcToUtModelConverter.kt | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtModelConverter.kt index 67b955af2f..29f129f3ad 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtModelConverter.kt @@ -38,14 +38,15 @@ class JcToUtModelConverter( private val jcClasspath: JcClasspath, private val instToUtModelConverter: UTestInstToUtModelConverter, ) { - private val descriptorToModelCache = mutableMapOf() + private val descriptorToModelCache = + mutableMapOf, UtModel>() private val refIdAndStateKindToDescriptorCache = mutableMapOf, UTestValueDescriptor>() fun convert( valueDescriptor: UTestValueDescriptor, stateKind: EnvironmentStateKind, - ): UtModel = descriptorToModelCache.getOrPut(valueDescriptor) { + ): UtModel = descriptorToModelCache.getOrPut(valueDescriptor to stateKind) { if (stateKind == EnvironmentStateKind.INITIAL || valueDescriptor.origin is UTestMock) valueDescriptor.origin?.let { originExpr -> val model = instToUtModelConverter.findModelByInst(originExpr as UTestExpression) @@ -79,7 +80,7 @@ class JcToUtModelConverter( valueDescriptor: UTestValueDescriptor, stateKind: EnvironmentStateKind, curModelId: Int, - ): UtModel = descriptorToModelCache.getOrPut(valueDescriptor) { + ): UtModel = descriptorToModelCache.getOrPut(valueDescriptor to stateKind) { if (valueDescriptor is UTestRefDescriptor) { refIdAndStateKindToDescriptorCache[valueDescriptor.refId to stateKind] = valueDescriptor } @@ -96,7 +97,7 @@ class JcToUtModelConverter( fields = fields, ) - descriptorToModelCache[valueDescriptor] = model + descriptorToModelCache[valueDescriptor to stateKind] = model fields += valueDescriptor.fields .entries @@ -120,7 +121,7 @@ class JcToUtModelConverter( stores = stores, ) - descriptorToModelCache[valueDescriptor] = model + descriptorToModelCache[valueDescriptor to stateKind] = model valueDescriptor.value .map { elemDescr -> convert(elemDescr, stateKind) } @@ -182,6 +183,6 @@ class JcToUtModelConverter( stateKind: EnvironmentStateKind ): UtModel? = refIdAndStateKindToDescriptorCache[refId to stateKind]?.let { - descriptorToModelCache[it] + descriptorToModelCache[it to stateKind] } } \ No newline at end of file From 5d3ad213930708446b78fc5812db455f7dc10ad4 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Thu, 23 Nov 2023 15:50:16 +0300 Subject: [PATCH 043/121] Update gradle script to run tests properly --- utbot-junit-contest/build.gradle | 4 +++- .../src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt | 1 + 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/utbot-junit-contest/build.gradle b/utbot-junit-contest/build.gradle index 48daa00033..291683324e 100644 --- a/utbot-junit-contest/build.gradle +++ b/utbot-junit-contest/build.gradle @@ -32,7 +32,9 @@ compileJava { compileTestJava { options.fork = true - options.compilerArgs << "-XDignore.symbol.file" + options.forkOptions.executable = "javac" + options.forkOptions.javaHome = file(System.getProperty("java.home")) + options.compilerArgs << "-XDignore.symbol.file=true" } def testProjects = [ 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 22a7cb0af3..a23c5054e7 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 @@ -90,6 +90,7 @@ fun runUsvmGeneration( ) { // TODO usvm-sbft: we may want to tune these JcSettings for contest useJavaRuntime(JdkInfoService.provide().path.toFile()) + persistent("cachedb") installFeatures(InMemoryHierarchy, Approximations) loadByteCode(classpathFiles) } From 208aad4743001189146f3e5c33b682f8e54a35e0 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Thu, 23 Nov 2023 16:21:37 +0300 Subject: [PATCH 044/121] Update usvm version --- gradle.properties | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gradle.properties b/gradle.properties index 83d31d88cd..4a4385838c 100644 --- a/gradle.properties +++ b/gradle.properties @@ -102,7 +102,7 @@ commonsIOVersion=2.11.0 javaxVersion=2.2 jakartaVersion=3.1.0 jacoDbVersion=1.4.1 -usvmVersion=comp-231122-1058 +usvmVersion=comp-231123-1615 # use latest Java 8 compaitable Spring and Spring Boot versions springVersion=5.3.28 From e0f70800606659fbdda2e29ffa37d6cc59c944b1 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Thu, 23 Nov 2023 18:17:26 +0300 Subject: [PATCH 045/121] Remove strange hack to discuss later --- .../src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt | 1 - 1 file changed, 1 deletion(-) 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 a23c5054e7..22a7cb0af3 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 @@ -90,7 +90,6 @@ fun runUsvmGeneration( ) { // TODO usvm-sbft: we may want to tune these JcSettings for contest useJavaRuntime(JdkInfoService.provide().path.toFile()) - persistent("cachedb") installFeatures(InMemoryHierarchy, Approximations) loadByteCode(classpathFiles) } From 272ebbebc479617880ca7d3763af525875758f58 Mon Sep 17 00:00:00 2001 From: Kirill Shishin Date: Thu, 23 Nov 2023 19:04:43 +0300 Subject: [PATCH 046/121] Add support for correct generation of inner tests --- .../codegen/renderer/CgJavaRenderer.kt | 20 ++++++++++++++++--- .../codegen/tree/CgMethodConstructor.kt | 9 +++++---- 2 files changed, 22 insertions(+), 7 deletions(-) diff --git a/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/renderer/CgJavaRenderer.kt b/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/renderer/CgJavaRenderer.kt index d573e030a9..e607ccd0cc 100644 --- a/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/renderer/CgJavaRenderer.kt +++ b/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/renderer/CgJavaRenderer.kt @@ -226,9 +226,23 @@ internal class CgJavaRenderer(context: CgRendererContext, printer: CgPrinter = C } override fun visit(element: CgConstructorCall) { - print("new ") - print(element.executableId.classId.asString()) - renderExecutableCallArguments(element) + when(element.type.isInner){ + true -> { + // the first argument of inner classes is outer class + print(element.arguments.first().accept(this)) + print(".new ") + print(element.executableId.classId.simpleName) + + print("(") + element.arguments.drop(1).renderSeparated() + print(")") + } + false -> { + print("new ") + print(element.executableId.classId.asString()) + renderExecutableCallArguments(element) + } + } } override fun renderRegularImport(regularImport: RegularImport) { diff --git a/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/tree/CgMethodConstructor.kt b/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/tree/CgMethodConstructor.kt index 5fbb965f1b..1a9c3b91f6 100644 --- a/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/tree/CgMethodConstructor.kt +++ b/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/tree/CgMethodConstructor.kt @@ -1331,14 +1331,15 @@ open class CgMethodConstructor(val context: CgContext) : CgContextOwner by conte val constructorCall = currentExecutableId as ConstructorId val executionResult = currentExecution.result + // TODO usvm-sbft: delete require when #141 will be fixed + require(!constructorCall.classId.isInner) { + "Inner class ${constructorCall.classId} constructor testing is not supported yet" + } + executionResult .onSuccess { methodType = SUCCESSFUL - require(!constructorCall.classId.isInner) { - "Inner class ${constructorCall.classId} constructor testing is not supported yet" - } - actual = newVar(constructorCall.classId, "actual") { constructorCall(*methodArguments.toTypedArray()) } From 0a3db6a0cbe666710b42a7c4743071066d58e13e Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Thu, 23 Nov 2023 22:46:46 +0300 Subject: [PATCH 047/121] Update usvm version --- gradle.properties | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gradle.properties b/gradle.properties index 4a4385838c..431eba3206 100644 --- a/gradle.properties +++ b/gradle.properties @@ -102,7 +102,7 @@ commonsIOVersion=2.11.0 javaxVersion=2.2 jakartaVersion=3.1.0 jacoDbVersion=1.4.1 -usvmVersion=comp-231123-1615 +usvmVersion=comp-231123-2300 # use latest Java 8 compaitable Spring and Spring Boot versions springVersion=5.3.28 From 0eaf9ac98e1ed8a37fa86125dd071cbd5a489ce4 Mon Sep 17 00:00:00 2001 From: IlyaMuravjov <71839386+IlyaMuravjov@users.noreply.github.com> Date: Fri, 24 Nov 2023 13:31:38 +0300 Subject: [PATCH 048/121] Avoid set fields not present in `UTest` (for `UtCompositeModel`) (#2698) --- .../org/utbot/framework/plugin/api/Api.kt | 2 +- .../converter/JcToUtExecutionConverter.kt | 22 ++++++++++++++++++- .../converter/UTestInstToUtModelConverter.kt | 4 ++-- 3 files changed, 24 insertions(+), 4 deletions(-) diff --git a/utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/Api.kt b/utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/Api.kt index ffb15e7344..6b5c7480f3 100644 --- a/utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/Api.kt +++ b/utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/Api.kt @@ -1029,7 +1029,7 @@ open class ClassId @JvmOverloads constructor( // so we create a specific name for them isAnonymous -> "Anonymous${supertypeOfAnonymousClass.prettifiedName}" // in other cases where canonical name is still null, we use ClassId.name instead - else -> jClass.canonicalName ?: name // Explicit jClass reference to get null instead of exception + else -> runCatching { canonicalName }.getOrElse { name } } return baseName .substringAfterLast(".") diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtExecutionConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtExecutionConverter.kt index 061f89cd42..d6a163942b 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtExecutionConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtExecutionConverter.kt @@ -24,9 +24,11 @@ import org.utbot.framework.plugin.api.ClassId 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.FieldId import org.utbot.framework.plugin.api.Instruction import org.utbot.framework.plugin.api.UtArrayModel import org.utbot.framework.plugin.api.UtAssembleModel +import org.utbot.framework.plugin.api.UtCompositeModel import org.utbot.framework.plugin.api.UtExecutableCallModel import org.utbot.framework.plugin.api.UtExecution import org.utbot.framework.plugin.api.UtExecutionFailure @@ -170,7 +172,25 @@ class JcToUtExecutionConverter( utilMethodProvider.setFieldMethodId == (it as? UtStatementCallModel)?.statement } ) { - model.origin ?: model + UtCompositeModel( + id = model.id, + classId = model.classId, + isMock = false, + fields = model.modificationsChain.associateTo(mutableMapOf()) { + // `setFieldMethodId` call example for reference: + // setField(outputStream, "java.io.ByteArrayOutputStream", "buf", buf); + + val params = (it as UtStatementCallModel).params + val fieldId = FieldId( + declaringClass = ClassId((params[1] as UtPrimitiveModel).value as String), + name = ((params[2] as UtPrimitiveModel).value as String) + ) + // We prefer `model.origin?.fields?.get(fieldId)` over `params[3]`, because + // - `model.origin?.fields?.get(fieldId)` is created from concrete execution initial state + // - `params[3]` is created from jcMachine output, which could be a bit off + fieldId to (model.origin?.fields?.get(fieldId) ?: params[3]) + } + ) } else { model } diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/UTestInstToUtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/UTestInstToUtModelConverter.kt index be2d579ed5..7dc45583aa 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/UTestInstToUtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/UTestInstToUtModelConverter.kt @@ -240,7 +240,7 @@ class UTestInstToUtModelConverter( executable = utilMethodProvider.getFieldValueMethodId, params = listOf( instanceModel, - UtPrimitiveModel(uTestExpr.field.type), + UtPrimitiveModel(uTestExpr.field.enclosingClass.classId.name), UtPrimitiveModel(uTestExpr.field.name), ), ) @@ -258,7 +258,7 @@ class UTestInstToUtModelConverter( instance = null, executable = utilMethodProvider.getStaticFieldValueMethodId, params = listOf( - UtPrimitiveModel(uTestExpr.field.type), + UtPrimitiveModel(uTestExpr.field.enclosingClass.classId.name), UtPrimitiveModel(uTestExpr.field.name), ), ) From ac667bb0ba7dc20dfc7ca8495d55cdab1d9c5b18 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Fri, 24 Nov 2023 18:12:46 +0300 Subject: [PATCH 049/121] Use classpathWithApproximations --- utbot-junit-contest/build.gradle | 1 + .../src/main/kotlin/org/utbot/contest/usvm/jc/JcContainer.kt | 4 ++-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/utbot-junit-contest/build.gradle b/utbot-junit-contest/build.gradle index 291683324e..184372d71b 100644 --- a/utbot-junit-contest/build.gradle +++ b/utbot-junit-contest/build.gradle @@ -4,6 +4,7 @@ plugins { apply plugin: 'jacoco' repositories { + mavenLocal() mavenCentral() maven { url 'https://jitpack.io' } maven { diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcContainer.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcContainer.kt index a5e02bf520..b9728c6935 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcContainer.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcContainer.kt @@ -11,6 +11,7 @@ import org.usvm.UMachineOptions import org.usvm.instrumentation.executor.UTestConcreteExecutor import org.usvm.instrumentation.instrumentation.JcRuntimeTraceInstrumenterFactory import org.usvm.machine.JcMachine +import org.usvm.util.classpathWithApproximations import java.io.File import kotlin.time.Duration.Companion.seconds @@ -30,8 +31,7 @@ class JcContainer private constructor( init { val (db, cp) = runBlocking { val db = jacodb(builder) - // TODO usvm-sbft: use classpathWithApproximations here when approximation decoders are finished - val cp = db.classpath(classpath, listOf(UnknownClasses)) + val cp = db.classpathWithApproximations(classpath, listOf(UnknownClasses)) db to cp } this.db = db From 405444f139cee807be5f050ebd8076d2b36c2da8 Mon Sep 17 00:00:00 2001 From: IlyaMuravjov Date: Fri, 24 Nov 2023 22:09:17 +0300 Subject: [PATCH 050/121] Fix bug in `assertEquals` for `String` in codegen --- .../org/utbot/framework/codegen/tree/CgMethodConstructor.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/tree/CgMethodConstructor.kt b/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/tree/CgMethodConstructor.kt index 1a9c3b91f6..25a8bad636 100644 --- a/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/tree/CgMethodConstructor.kt +++ b/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/tree/CgMethodConstructor.kt @@ -659,7 +659,7 @@ open class CgMethodConstructor(val context: CgContext) : CgContextOwner by conte } // other primitives and string else -> { - require(expected.type.isPrimitive || expected.type == String::class.java) { + require(expected.type.isPrimitive || expected.type == stringClassId) { "Expected primitive or String but got ${expected.type}" } assertions[assertEquals](expected, actual) From 4362bd27f13a6b898af1c87b7660803778079f7b Mon Sep 17 00:00:00 2001 From: IlyaMuravjov Date: Fri, 24 Nov 2023 22:14:19 +0300 Subject: [PATCH 051/121] Add timeout execution conversion --- .../converter/JcToUtExecutionConverter.kt | 44 ++++++++++++++----- 1 file changed, 33 insertions(+), 11 deletions(-) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtExecutionConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtExecutionConverter.kt index d6a163942b..635340f9cf 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtExecutionConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtExecutionConverter.kt @@ -13,6 +13,7 @@ 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.api.UTestSetStaticFieldStatement import org.usvm.instrumentation.testcase.descriptor.Descriptor2ValueConverter import org.usvm.instrumentation.testcase.descriptor.UTestExceptionDescriptor import org.usvm.instrumentation.util.enclosingClass @@ -26,6 +27,8 @@ import org.utbot.framework.plugin.api.EnvironmentModels import org.utbot.framework.plugin.api.ExecutableId import org.utbot.framework.plugin.api.FieldId import org.utbot.framework.plugin.api.Instruction +import org.utbot.framework.plugin.api.MissingState +import org.utbot.framework.plugin.api.TimeoutException import org.utbot.framework.plugin.api.UtArrayModel import org.utbot.framework.plugin.api.UtAssembleModel import org.utbot.framework.plugin.api.UtCompositeModel @@ -37,6 +40,7 @@ import org.utbot.framework.plugin.api.UtExplicitlyThrownException import org.utbot.framework.plugin.api.UtImplicitlyThrownException import org.utbot.framework.plugin.api.UtPrimitiveModel import org.utbot.framework.plugin.api.UtStatementCallModel +import org.utbot.framework.plugin.api.UtTimeoutException import org.utbot.framework.plugin.api.UtVoidModel import org.utbot.framework.plugin.api.mapper.UtModelDeepMapper import org.utbot.framework.plugin.api.util.executableId @@ -56,15 +60,9 @@ class JcToUtExecutionConverter( ) { private val toValueConverter = Descriptor2ValueConverter(utContext.classLoader) - private var jcToUtModelConverter: JcToUtModelConverter - private var uTestProcessResult: UTestAnalysisResult - - init { - val instToModelConverter = UTestInstToUtModelConverter(jcExecution.uTest, jcClasspath, idGenerator, utilMethodProvider) - jcToUtModelConverter = JcToUtModelConverter(idGenerator, jcClasspath, instToModelConverter) - - uTestProcessResult = instToModelConverter.processUTest() - } + private val instToModelConverter = UTestInstToUtModelConverter(jcExecution.uTest, jcClasspath, idGenerator, utilMethodProvider) + private var jcToUtModelConverter = JcToUtModelConverter(idGenerator, jcClasspath, instToModelConverter) + private var uTestProcessResult = instToModelConverter.processUTest() fun convert(): UtExecution? { val coverage = convertCoverage(getTrace(jcExecution.uTestExecutionResult), jcExecution.method.enclosingType.jcClass) @@ -108,8 +106,14 @@ class JcToUtExecutionConverter( } is UTestExecutionTimedOutResult -> { - // TODO usvm-sbft - null + logger.warn { "Timeout on ${jcExecution.method.method}" } + UtUsvmExecution( + stateBefore = constructStateBeforeFromUTest(), + stateAfter = MissingState, + result = UtTimeoutException(TimeoutException("Concrete execution timed out")), + coverage = coverage, + instrumentation = uTestProcessResult.instrumentation, + ) } } ?: return null @@ -230,6 +234,24 @@ class JcToUtExecutionConverter( return EnvironmentModels(thisInstance, parameters, statics, executableId) } + private fun constructStateBeforeFromUTest(): EnvironmentModels { + val uTest = jcExecution.uTest + val method = jcExecution.method + val thisInstance = + if (method.isStatic) null + else if (method.method.isConstructor) null + else instToModelConverter.findModelByInst(uTest.callMethodExpression.instance ?: error("Unexpected null instance expression")) + val parameters = uTest.callMethodExpression.args.map { + instToModelConverter.findModelByInst(it) + } + val statics = uTest.initStatements.filterIsInstance() + .associate { + it.field.fieldId to instToModelConverter.findModelByInst(it.value) + } + val executableId: ExecutableId = method.method.toExecutableId(jcClasspath) + return EnvironmentModels(thisInstance, parameters, statics, executableId) + } + private fun createExecutionFailureResult( exceptionDescriptor: UTestExceptionDescriptor, jcTypedMethod: JcTypedMethod, From a365f4e8f7609ab4051be7d93250b7394280debd Mon Sep 17 00:00:00 2001 From: IlyaMuravjov Date: Fri, 24 Nov 2023 22:16:08 +0300 Subject: [PATCH 052/121] Improve logging time spent on concrete and conversion --- .../org/utbot/contest/usvm/ContestUsvm.kt | 21 ++++++++++++------- 1 file changed, 13 insertions(+), 8 deletions(-) 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 22a7cb0af3..7f51d2fdf5 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 @@ -47,7 +47,6 @@ import org.utbot.fuzzer.UtFuzzedExecution import org.utbot.summary.usvm.summarizeAll import java.io.File import java.net.URLClassLoader -import kotlin.system.measureTimeMillis import kotlin.time.Duration.Companion.milliseconds private val logger = KotlinLogging.logger {} @@ -168,7 +167,7 @@ fun runUsvmGeneration( methods = jcMethods, targets = emptyList() ) { state -> - val jcExecution = accumulateMeasureTime("executor.execute(${cut.classId.name})", timeStats) { + val jcExecution = accumulateMeasureTime("executor.execute(${cut.classId.name})", timeStats, state.entrypoint) { runCatching { executor.execute(state.entrypoint.typedMethod, state) }.getOrElse { e -> @@ -177,7 +176,7 @@ fun runUsvmGeneration( } } val methodId = jcExecution.method.method.toExecutableId(jcContainer.cp) - val utExecution = accumulateMeasureTime("JcToUtExecutionConverter.convert(${cut.classId.name})", timeStats) { + val utExecution = accumulateMeasureTime("JcToUtExecutionConverter.convert(${cut.classId.name})", timeStats, jcExecution.method.method) { runCatching { JcToUtExecutionConverter( jcExecution = jcExecution, @@ -281,14 +280,20 @@ fun JcMachine.analyzeAsync( } ?: logger.error { "analyzeAsync time exceeded hard time out" } } -inline fun accumulateMeasureTime( +private inline fun accumulateMeasureTime( regionName: String, timeAccumulatorMillis: MutableMap, + warnData: Any?, + millisWarnThreshold: Long = 2_000, block: () -> T ): T { - var res: T - timeAccumulatorMillis[regionName] = (timeAccumulatorMillis[regionName] ?: 0) + measureTimeMillis { - res = block() + val millisBefore = System.currentTimeMillis() + try { + return block() + } finally { + val millisTaken = System.currentTimeMillis() - millisBefore + if (millisTaken > millisWarnThreshold) + logger.warn("Spent $millisTaken ms on region [$regionName] for [$warnData]") + timeAccumulatorMillis[regionName] = (timeAccumulatorMillis[regionName] ?: 0) + millisTaken } - return res } From d7134b744309536b739636a1fd040475f93add34 Mon Sep 17 00:00:00 2001 From: IlyaMuravjov Date: Fri, 24 Nov 2023 22:22:01 +0300 Subject: [PATCH 053/121] Make logger group repeated exceptions (e.g. "(x100) message") --- utbot-junit-contest/build.gradle | 2 + .../org/utbot/contest/usvm/ContestUsvm.kt | 3 + .../usvm/log/ErrorCountingLoggerAppender.kt | 83 +++++++++++++++++++ .../src/main/resources/log4j2.xml | 6 +- 4 files changed, 92 insertions(+), 2 deletions(-) create mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/log/ErrorCountingLoggerAppender.kt diff --git a/utbot-junit-contest/build.gradle b/utbot-junit-contest/build.gradle index 184372d71b..499648521b 100644 --- a/utbot-junit-contest/build.gradle +++ b/utbot-junit-contest/build.gradle @@ -160,6 +160,8 @@ dependencies { } implementation group: 'org.apache.commons', name: 'commons-exec', version: '1.2' implementation group: 'io.github.microutils', name: 'kotlin-logging', version: kotlinLoggingVersion + implementation group: 'org.apache.logging.log4j', name: 'log4j-api', version: log4j2Version + implementation group: 'org.apache.logging.log4j', name: 'log4j-core', version: log4j2Version implementation group: 'org.jsoup', name: 'jsoup', version: '1.6.2' implementation 'org.jetbrains.kotlinx:kotlinx-serialization-json:1.4.1' implementation group: 'com.google.guava', name: 'guava', version: guavaVersion 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 7f51d2fdf5..629d74036c 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 @@ -28,6 +28,7 @@ import org.utbot.contest.usvm.converter.toExecutableId import org.utbot.contest.usvm.jc.JcContainer import org.utbot.contest.usvm.jc.JcContainer.Companion.CONTEST_TEST_EXECUTION_TIMEOUT import org.utbot.contest.usvm.jc.JcTestExecutor +import org.utbot.contest.usvm.log.ErrorCountingLoggerAppender import org.utbot.framework.codegen.domain.ProjectType import org.utbot.framework.codegen.domain.RuntimeExceptionTestsBehaviour import org.utbot.framework.codegen.domain.junitByVersion @@ -63,6 +64,8 @@ fun runUsvmGeneration( expectedExceptions: ExpectedExceptionsForClass, methodNameFilter: String? = null // For debug purposes you can specify method name ): StatsForClass = runBlocking { + ErrorCountingLoggerAppender.resetOccurrenceCounter() + val testsByMethod: MutableMap> = mutableMapOf() val timeBudgetMs = timeLimitSec * 1000 diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/log/ErrorCountingLoggerAppender.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/log/ErrorCountingLoggerAppender.kt new file mode 100644 index 0000000000..5595f5cbef --- /dev/null +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/log/ErrorCountingLoggerAppender.kt @@ -0,0 +1,83 @@ +package org.utbot.contest.usvm.log + +import org.apache.logging.log4j.Level +import org.apache.logging.log4j.LogManager +import org.apache.logging.log4j.core.Appender +import org.apache.logging.log4j.core.Core +import org.apache.logging.log4j.core.LogEvent +import org.apache.logging.log4j.core.LoggerContext +import org.apache.logging.log4j.core.config.plugins.Plugin +import org.apache.logging.log4j.core.config.plugins.PluginFactory +import org.apache.logging.log4j.core.layout.PatternLayout +import org.apache.logging.log4j.core.appender.AbstractAppender +import org.apache.logging.log4j.core.config.Property +import org.apache.logging.log4j.core.config.plugins.PluginAttribute +import org.apache.logging.log4j.core.impl.ThrowableProxy +import org.apache.logging.log4j.message.Message +import org.apache.logging.log4j.message.SimpleMessage +import java.util.concurrent.ConcurrentHashMap + +@Plugin( + name = "ErrorCountingAppender", + category = Core.CATEGORY_NAME, + elementType = Appender.ELEMENT_TYPE, + printObject = true +) +class ErrorCountingLoggerAppender(name: String, private val delegateAppenderName: String) : AbstractAppender( + name, + null, + PatternLayout.createDefaultLayout(), + false, + Property.EMPTY_ARRAY +) { + + private val delegate: Appender by lazy { + (LogManager.getContext(false) as LoggerContext) + .configuration + .getAppender(delegateAppenderName) + } + + companion object { + private val occurrenceCountsToLogAt = + generateSequence(1) { it * 10 }.take(10).toList() + listOf(2, 5, 50, 500) + private val errorOccurrenceCounts: MutableMap = ConcurrentHashMap() + + @PluginFactory + @JvmStatic + fun createAppender( + @PluginAttribute("name") name: String, + @PluginAttribute("delegateAppender") delegateAppenderName: String + ) = ErrorCountingLoggerAppender(name, delegateAppenderName) + + fun resetOccurrenceCounter() { + errorOccurrenceCounts.keys.toList().forEach { errorOccurrenceCounts[it] = 0 } + } + } + + override fun append(event: LogEvent) { + if (event.level >= Level.INFO) { + delegate.append(event) + return + } + + val key = event.thrown?.stackTrace?.firstOrNull() ?: event.message.formattedMessage + val alreadyLogged = key in errorOccurrenceCounts + val count = (errorOccurrenceCounts[key] ?: 0) + 1 + errorOccurrenceCounts[key] = count + + if (!alreadyLogged) { + delegate.append(event) + } else if (count in occurrenceCountsToLogAt) { + val modifiedMessage = "(x$count) ${event.message.formattedMessage}${ + event.thrown?.let { e -> + "\n${e.javaClass.name}: ${e.message}\n\tat ${e.stackTrace.firstOrNull()}" + }.orEmpty() + }" + delegate.append(object : LogEvent by event { + override fun getMessage(): Message = SimpleMessage(modifiedMessage) + override fun getThrown(): Throwable? = null + override fun getThrownProxy(): ThrowableProxy? = null + }) + } + } +} diff --git a/utbot-junit-contest/src/main/resources/log4j2.xml b/utbot-junit-contest/src/main/resources/log4j2.xml index fd4a216229..a6fecb2792 100644 --- a/utbot-junit-contest/src/main/resources/log4j2.xml +++ b/utbot-junit-contest/src/main/resources/log4j2.xml @@ -1,5 +1,5 @@ - + - + + + From f523512d08e4ac15c7fd4929371fd6fe80e38e87 Mon Sep 17 00:00:00 2001 From: IlyaMuravjov Date: Fri, 24 Nov 2023 22:44:33 +0300 Subject: [PATCH 054/121] Better log `JcType.classId` fails --- .../org/utbot/contest/usvm/converter/ConverterUtils.kt | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/ConverterUtils.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/ConverterUtils.kt index ffb884ad03..dc468813fb 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/ConverterUtils.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/ConverterUtils.kt @@ -67,8 +67,11 @@ private fun JcType.replaceToBoundIfGeneric(): JcType { val JcType?.classId: ClassId get() { if (this !is JcPrimitiveType) { - return this?.replaceToBoundIfGeneric()?.toJavaClass(utContext.classLoader)?.id - ?: error("Can not construct classId for $this") + return runCatching { + this?.replaceToBoundIfGeneric()?.toJavaClass(utContext.classLoader)?.id ?: error("Can not construct classId for $this") + }.getOrElse { e -> + throw IllegalStateException("JcType.classId failed on ${this?.typeName}", e) + } } val cp = this.classpath From 5c82e577228fde9af3ca84054089ed62195c48cc Mon Sep 17 00:00:00 2001 From: IlyaMuravjov Date: Fri, 24 Nov 2023 23:13:43 +0300 Subject: [PATCH 055/121] Add notice about `usvmVersion` being outdated --- gradle.properties | 2 ++ 1 file changed, 2 insertions(+) diff --git a/gradle.properties b/gradle.properties index 431eba3206..8d889ca789 100644 --- a/gradle.properties +++ b/gradle.properties @@ -102,6 +102,8 @@ commonsIOVersion=2.11.0 javaxVersion=2.2 jakartaVersion=3.1.0 jacoDbVersion=1.4.1 +# TODO left outdated here to avoid exceeding GitHub packages drive space, +# TODO run `gradle publishToMavenLocal -Pversion={usvmVersion}` locally in usvm project and update {usvmVersion} locally usvmVersion=comp-231123-2300 # use latest Java 8 compaitable Spring and Spring Boot versions From d25e3bbf4a9d70d00884570a0b917639976352a7 Mon Sep 17 00:00:00 2001 From: IlyaMuravjov Date: Fri, 24 Nov 2023 23:19:37 +0300 Subject: [PATCH 056/121] Actualise `JcTestExecutor` --- .../org/utbot/contest/usvm/ContestUsvm.kt | 2 +- .../utbot/contest/usvm/jc/JcTestExecutor.kt | 278 ++---------------- .../usvm/jc/JcTestExecutorDecoderApi.kt | 126 ++++++++ 3 files changed, 158 insertions(+), 248 deletions(-) create mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcTestExecutorDecoderApi.kt 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 629d74036c..613864e004 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 @@ -172,7 +172,7 @@ fun runUsvmGeneration( ) { state -> val jcExecution = accumulateMeasureTime("executor.execute(${cut.classId.name})", timeStats, state.entrypoint) { runCatching { - executor.execute(state.entrypoint.typedMethod, state) + executor.execute(state.entrypoint.typedMethod, state, jcContainer.machine.stringConstants) }.getOrElse { e -> logger.error(e) { "executor.execute(${state.entrypoint}) failed" } return@analyzeAsync diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcTestExecutor.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcTestExecutor.kt index c646747066..7099a3b065 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcTestExecutor.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcTestExecutor.kt @@ -1,36 +1,30 @@ package org.utbot.contest.usvm.jc -import io.ksmt.utils.asExpr import kotlinx.coroutines.runBlocking -import org.jacodb.api.* -import org.jacodb.api.ext.* -import org.usvm.* +import org.jacodb.api.JcClassType +import org.jacodb.api.JcClasspath +import org.jacodb.api.JcType +import org.jacodb.api.JcTypedMethod +import org.jacodb.api.ext.objectType +import org.usvm.UConcreteHeapRef +import org.usvm.UExpr import org.usvm.api.JcCoverage import org.usvm.api.JcTest -import org.usvm.api.typeStreamOf -import org.usvm.collection.array.UArrayIndexLValue -import org.usvm.collection.array.length.UArrayLengthLValue -import org.usvm.collection.field.UFieldLValue +import org.usvm.api.util.JcTestStateResolver import org.usvm.instrumentation.executor.UTestConcreteExecutor import org.usvm.instrumentation.testcase.UTest -import org.usvm.instrumentation.testcase.api.* +import org.usvm.instrumentation.testcase.api.UTestAllocateMemoryCall +import org.usvm.instrumentation.testcase.api.UTestExpression +import org.usvm.instrumentation.testcase.api.UTestMethodCall +import org.usvm.instrumentation.testcase.api.UTestNullExpression +import org.usvm.instrumentation.testcase.api.UTestStaticMethodCall import org.usvm.machine.JcContext -import org.usvm.machine.extractBool -import org.usvm.machine.extractByte -import org.usvm.machine.extractChar -import org.usvm.machine.extractDouble -import org.usvm.machine.extractFloat -import org.usvm.machine.extractInt -import org.usvm.machine.extractLong -import org.usvm.machine.extractShort import org.usvm.machine.state.JcState import org.usvm.machine.state.localIdx import org.usvm.memory.ULValue import org.usvm.memory.UReadOnlyMemory import org.usvm.memory.URegisterStackLValue import org.usvm.model.UModelBase -import org.usvm.types.first -import org.usvm.types.firstOrNull /** * A class, responsible for resolving a single [JcExecution] for a specific method from a symbolic state. @@ -45,12 +39,12 @@ class JcTestExecutor( /** * Resolves a [JcTest] from a [method] from a [state]. */ - fun execute(method: JcTypedMethod, state: JcState): JcExecution { + fun execute(method: JcTypedMethod, state: JcState, stringConstants: Map): JcExecution { val model = state.models.first() val ctx = state.ctx - val memoryScope = MemoryScope(ctx, model, model, method) + val memoryScope = MemoryScope(ctx, model, model, stringConstants, method) val uTest = memoryScope.createUTest() @@ -76,20 +70,21 @@ class JcTestExecutor( * @param memory a read-only memory to read [ULValue]s from. */ private class MemoryScope( - private val ctx: JcContext, - private val model: UModelBase, - private val memory: UReadOnlyMemory, - private val method: JcTypedMethod, - ) { + ctx: JcContext, + model: UModelBase, + memory: UReadOnlyMemory, + stringConstants: Map, + method: JcTypedMethod, + ) : JcTestStateResolver(ctx, model, memory, stringConstants, method) { - private val resolvedCache = mutableMapOf>>() + override val decoderApi = JcTestExecutorDecoderApi(ctx) fun createUTest(): UTest { val thisInstance = if (!method.isStatic) { val ref = URegisterStackLValue(ctx.addressSort, idx = 0) resolveLValue(ref, method.enclosingType) } else { - UTestNullExpression(ctx.cp.objectType) to listOf() + UTestNullExpression(ctx.cp.objectType) } val parameters = method.parameters.mapIndexed { idx, param -> @@ -98,230 +93,19 @@ class JcTestExecutor( resolveLValue(ref, param.type) } - val initStmts = thisInstance.second + parameters.flatMap { it.second } + val initStmts = decoderApi.initializerInstructions() val callExpr = if (method.isStatic) { - UTestStaticMethodCall(method.method, parameters.map { it.first }) + UTestStaticMethodCall(method.method, parameters) } else { - UTestMethodCall(thisInstance.first, method.method, parameters.map { it.first }) + UTestMethodCall(thisInstance, method.method, parameters) } return UTest(initStmts, callExpr) } + override fun allocateClassInstance(type: JcClassType): UTestExpression = + UTestAllocateMemoryCall(type.jcClass) - fun resolveLValue(lvalue: ULValue<*, *>, type: JcType): Pair> = - resolveExpr(memory.read(lvalue), type) - - - fun resolveExpr(expr: UExpr, type: JcType): Pair> = - when (type) { - is JcPrimitiveType -> resolvePrimitive(expr, type) - is JcRefType -> resolveReference(expr.asExpr(ctx.addressSort), type) - else -> error("Unexpected type: $type") - } - - fun resolvePrimitive( - expr: UExpr, type: JcPrimitiveType - ): Pair> { - val exprInModel = evaluateInModel(expr) - return when (type) { - ctx.cp.boolean -> UTestBooleanExpression( - value = extractBool(exprInModel) ?: false, - type = ctx.cp.boolean - ) - ctx.cp.short -> UTestShortExpression( - value = extractShort(exprInModel) ?: 0, - type = ctx.cp.short - ) - ctx.cp.int -> UTestIntExpression( - value = extractInt(exprInModel) ?: 0, - type = ctx.cp.int - ) - ctx.cp.long -> UTestLongExpression( - value = extractLong(exprInModel) ?: 0L, - type = ctx.cp.long - ) - ctx.cp.float -> UTestFloatExpression( - value = extractFloat(exprInModel) ?: 0.0f, - type = ctx.cp.float - ) - ctx.cp.double -> UTestDoubleExpression( - value = extractDouble(exprInModel) ?: 0.0, - type = ctx.cp.double - ) - ctx.cp.byte -> UTestByteExpression( - value = extractByte(exprInModel) ?: 0, - type = ctx.cp.byte - ) - ctx.cp.char -> UTestCharExpression( - value = extractChar(exprInModel) ?: '\u0000', - type = ctx.cp.char - ) - ctx.cp.void -> UTestNullExpression( - type = ctx.cp.void - ) - else -> error("Unexpected type: ${type.typeName}") - }.let { it to listOf() } - } - - fun resolveReference(heapRef: UHeapRef, type: JcRefType): Pair> { - val ref = evaluateInModel(heapRef) as UConcreteHeapRef - if (ref.address == NULL_ADDRESS) { - return UTestNullExpression(type) to listOf() - } - // to find a type, we need to understand the source of the object - val typeStream = if (ref.address <= INITIAL_INPUT_ADDRESS) { - // input object - model.typeStreamOf(ref) - } else { - // allocated object - memory.typeStreamOf(ref) - }.filterBySupertype(type) - - // We filter allocated object type stream, because it could be stored in the input array, - // which resolved to a wrong type, since we do not build connections between element types - // and array types right now. - // In such cases, we need to resolve this element to null. - - val evaluatedType = typeStream.firstOrNull() ?: return UTestNullExpression(type) to listOf() - - // We check for the type stream emptiness firsly and only then for the resolved cache, - // because even if the object is already resolved, it could be incompatible with the [type], if it - // is an element of an array of the wrong type. - - return resolvedCache.getOrElse(ref.address) { - when (evaluatedType) { - is JcArrayType -> resolveArray(ref, heapRef, evaluatedType) - is JcClassType -> resolveObject(ref, heapRef, evaluatedType) - else -> error("Unexpected type: $type") - } - } - } - - private fun resolveArray( - ref: UConcreteHeapRef, heapRef: UHeapRef, type: JcArrayType - ): Pair> { - val arrayDescriptor = ctx.arrayDescriptorOf(type) - val lengthRef = UArrayLengthLValue(heapRef, arrayDescriptor, ctx.sizeSort) - val resolvedLength = resolveLValue(lengthRef, ctx.cp.int).first as UTestIntExpression - // TODO hack - val length = - if (resolvedLength.value in 0..10_000) { - resolvedLength - } else { - UTestIntExpression(0, ctx.cp.int) - } - - val cellSort = ctx.typeToSort(type.elementType) - - fun resolveElement(idx: Int): Pair> { - val elemRef = UArrayIndexLValue(cellSort, heapRef, ctx.mkBv(idx), arrayDescriptor) - return resolveLValue(elemRef, type.elementType) - } - - val arrayInstance = UTestCreateArrayExpression(type.elementType, length) - - val arraySetters = buildList { - for (i in 0 until length.value) { - with(resolveElement(i)) { - add(UTestArraySetStatement(arrayInstance, UTestIntExpression(i, ctx.cp.int), first)) - addAll(second) - } - } - } - - resolvedCache[ref.address] = arrayInstance to arraySetters - return arrayInstance to arraySetters - } - - private fun resolveObject( - ref: UConcreteHeapRef, heapRef: UHeapRef, type: JcRefType - ): Pair> { - - if (type.jcClass == ctx.classType.jcClass && ref.address <= INITIAL_STATIC_ADDRESS) { - // Note that non-negative addresses are possible only for the result value. - return resolveAllocatedClass(ref) - } - - if (type.jcClass == ctx.stringType.jcClass && ref.address <= INITIAL_STATIC_ADDRESS) { - // Note that non-negative addresses are possible only for the result value. - return resolveAllocatedString(ref) - } - - val anyEnumAncestor = type.getEnumAncestorOrNull() - if (anyEnumAncestor != null) { - return resolveEnumValue(heapRef, anyEnumAncestor) - } - - - val exprs = mutableListOf() - val instance = UTestAllocateMemoryCall(type.jcClass) - - val fieldSetters = mutableListOf() - resolvedCache[ref.address] = instance to fieldSetters - - exprs.add(instance) - - val fields = - generateSequence(type.jcClass) { it.superClass } - .map { it.toType() } - .flatMap { it.declaredFields } - .filter { !it.isStatic } - - for (field in fields) { - val lvalue = UFieldLValue(ctx.typeToSort(field.fieldType), heapRef, field.field) - val fieldValue = resolveLValue(lvalue, field.fieldType) - val uTestSetFieldStmt = UTestSetFieldStatement(instance, field.field, fieldValue.first) - fieldSetters.addAll(fieldValue.second) - fieldSetters.add(uTestSetFieldStmt) - } - return instance to fieldSetters - } - - private fun resolveEnumValue( - heapRef: UHeapRef, - enumAncestor: JcClassOrInterface - ): Pair> { - with(ctx) { - val ordinalLValue = UFieldLValue(sizeSort, heapRef, enumOrdinalField) - val ordinalFieldValue = resolveLValue(ordinalLValue, cp.int).first as UTestIntExpression - val enumField = enumAncestor.enumValues?.get(ordinalFieldValue.value) - ?: error("Cant find enum field with index ${ordinalFieldValue.value}") - - return UTestGetStaticFieldExpression(enumField) to listOf() - } - } - - private fun resolveAllocatedClass(ref: UConcreteHeapRef): Pair> { - val classTypeField = ctx.classTypeSyntheticField - val classTypeLValue = UFieldLValue(ctx.addressSort, ref, classTypeField) - val classTypeRef = memory.read(classTypeLValue) as? UConcreteHeapRef - ?: error("No type for allocated class") - - val classType = memory.typeStreamOf(classTypeRef).first() - return UTestClassExpression(classType) to listOf() - } - - private fun resolveAllocatedString(ref: UConcreteHeapRef): Pair> { - val valueField = ctx.stringValueField - val strValueLValue = UFieldLValue(ctx.typeToSort(valueField.fieldType), ref, valueField.field) - return resolveLValue(strValueLValue, valueField.fieldType) - } - - /** - * If we resolve state after, [expr] is read from a state memory, so it requires concretization via [model]. - * - * @return a concretized expression. - */ - private fun evaluateInModel(expr: UExpr): UExpr { - return model.eval(expr) - } - - // TODO simple org.jacodb.api.ext.JcClasses.isEnum does not work with enums with abstract methods - private fun JcRefType.getEnumAncestorOrNull(): JcClassOrInterface? = - jcClass.getAllSuperHierarchyIncludingThis().firstOrNull { it.isEnum } - - private fun JcClassOrInterface.getAllSuperHierarchyIncludingThis() = - (sequenceOf(this) + allSuperHierarchySequence) + // todo: looks incorrect + override fun allocateString(value: UTestExpression): UTestExpression = value } - -} \ No newline at end of file +} diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcTestExecutorDecoderApi.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcTestExecutorDecoderApi.kt new file mode 100644 index 0000000000..c0263e10a9 --- /dev/null +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcTestExecutorDecoderApi.kt @@ -0,0 +1,126 @@ +package org.utbot.contest.usvm.jc + +import org.jacodb.api.JcClassOrInterface +import org.jacodb.api.JcField +import org.jacodb.api.JcMethod +import org.jacodb.api.JcType +import org.jacodb.api.ext.boolean +import org.jacodb.api.ext.byte +import org.jacodb.api.ext.char +import org.jacodb.api.ext.double +import org.jacodb.api.ext.float +import org.jacodb.api.ext.int +import org.jacodb.api.ext.long +import org.jacodb.api.ext.objectType +import org.jacodb.api.ext.short +import org.jacodb.api.ext.toType +import org.usvm.api.decoder.DecoderApi +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.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.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.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.usvm.instrumentation.util.stringType +import org.usvm.machine.JcContext + +// TODO usvm-sbft-refactoring: copied from `usvm/usvm-jvm/test`, extract this class back to USVM project +class JcTestExecutorDecoderApi( + private val ctx: JcContext +) : DecoderApi { + private val instructions = mutableListOf() + + fun initializerInstructions(): List = instructions + + override fun setField(field: JcField, instance: UTestExpression, value: UTestExpression) { + instructions += if (field.isStatic) { + UTestSetStaticFieldStatement(field, value) + } else { + UTestSetFieldStatement(instance, field, value) + } + } + + override fun getField(field: JcField, instance: UTestExpression): UTestExpression = + if (field.isStatic) { + UTestGetStaticFieldExpression(field) + } else { + UTestGetFieldExpression(instance, field) + } + + override fun invokeMethod(method: JcMethod, args: List): UTestExpression = + when { + method.isConstructor -> UTestConstructorCall(method, args) + method.isStatic -> UTestStaticMethodCall(method, args) + else -> UTestMethodCall(args.first(), method, args.drop(1)) + }.also { + instructions += it + } + + override fun createBoolConst(value: Boolean): UTestExpression = + UTestBooleanExpression(value, ctx.cp.boolean) + + override fun createByteConst(value: Byte): UTestExpression = + UTestByteExpression(value, ctx.cp.byte) + + override fun createShortConst(value: Short): UTestExpression = + UTestShortExpression(value, ctx.cp.short) + + override fun createIntConst(value: Int): UTestExpression = + UTestIntExpression(value, ctx.cp.int) + + override fun createLongConst(value: Long): UTestExpression = + UTestLongExpression(value, ctx.cp.long) + + override fun createFloatConst(value: Float): UTestExpression = + UTestFloatExpression(value, ctx.cp.float) + + override fun createDoubleConst(value: Double): UTestExpression = + UTestDoubleExpression(value, ctx.cp.double) + + override fun createCharConst(value: Char): UTestExpression = + UTestCharExpression(value, ctx.cp.char) + + override fun createStringConst(value: String): UTestExpression = + UTestStringExpression(value, ctx.cp.stringType()) + + override fun createClassConst(type: JcType): UTestExpression = + UTestClassExpression(type) + + override fun createNullConst(type: JcType): UTestExpression = + UTestNullExpression(type) + + override fun setArrayIndex(array: UTestExpression, index: UTestExpression, value: UTestExpression) { + instructions += UTestArraySetStatement(array, index, value) + } + + override fun getArrayIndex(array: UTestExpression, index: UTestExpression): UTestExpression = + UTestArrayGetExpression(array, index) + + override fun getArrayLength(array: UTestExpression): UTestExpression = + UTestArrayLengthExpression(array) + + override fun createArray(elementType: JcType, size: UTestExpression): UTestExpression = + UTestCreateArrayExpression(elementType, size) + + override fun castClass(type: JcClassOrInterface, obj: UTestExpression): UTestExpression = + UTestCastExpression(obj, type.toType()) +} From a751085e74c8eb099c34de1cd909a038c43da14d Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Sat, 25 Nov 2023 12:16:08 +0300 Subject: [PATCH 057/121] Update usvm version --- gradle.properties | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gradle.properties b/gradle.properties index 8d889ca789..6b017b6756 100644 --- a/gradle.properties +++ b/gradle.properties @@ -104,7 +104,7 @@ jakartaVersion=3.1.0 jacoDbVersion=1.4.1 # TODO left outdated here to avoid exceeding GitHub packages drive space, # TODO run `gradle publishToMavenLocal -Pversion={usvmVersion}` locally in usvm project and update {usvmVersion} locally -usvmVersion=comp-231123-2300 +usvmVersion=comp-231124-ev # use latest Java 8 compaitable Spring and Spring Boot versions springVersion=5.3.28 From dd5176fc146e2cdb496d8adc67bfde5dabeb1acb Mon Sep 17 00:00:00 2001 From: IlyaMuravjov Date: Mon, 27 Nov 2023 12:32:30 +0300 Subject: [PATCH 058/121] Fix invalid `UTestCyclicReferenceDescriptor` --- .../converter/JcToUtExecutionConverter.kt | 1 + .../usvm/converter/JcToUtModelConverter.kt | 27 ++++++++++++++++++- 2 files changed, 27 insertions(+), 1 deletion(-) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtExecutionConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtExecutionConverter.kt index 635340f9cf..ae14478dde 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtExecutionConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtExecutionConverter.kt @@ -118,6 +118,7 @@ class JcToUtExecutionConverter( } ?: return null return utUsvmExecution + .mapModels(jcToUtModelConverter.utCyclicReferenceModelResolver) .mapModels(constructAssemblingMapper()) .mapModels(constructAssembleToCompositeModelMapper()) .mapModels(constructConstArrayModelMapper()) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtModelConverter.kt index 29f129f3ad..9be921ddc8 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtModelConverter.kt @@ -13,16 +13,20 @@ import org.usvm.instrumentation.testcase.descriptor.UTestObjectDescriptor import org.usvm.instrumentation.testcase.descriptor.UTestRefDescriptor import org.usvm.instrumentation.testcase.descriptor.UTestValueDescriptor import org.usvm.instrumentation.util.InstrumentationModuleConstants.nameForExistingButNullString +import org.utbot.framework.plugin.api.ClassId 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.UtCustomModel 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.UtReferenceModel +import org.utbot.framework.plugin.api.mapper.UtModelDeepMapper +import org.utbot.framework.plugin.api.mapper.UtModelMapper import org.utbot.framework.plugin.api.util.classClassId import org.utbot.framework.plugin.api.util.id import org.utbot.framework.plugin.api.util.jClass @@ -33,6 +37,15 @@ enum class EnvironmentStateKind { INITIAL, FINAL } +data class UtCyclicReferenceModel( + override val id: Int?, + override val classId: ClassId, + val refId: Int, + val stateKind: EnvironmentStateKind, +) : UtCustomModel(id, classId) { + override fun shallowMap(mapper: UtModelMapper): UtCustomModel = this +} + class JcToUtModelConverter( private val idGenerator: IdGenerator, private val jcClasspath: JcClasspath, @@ -42,6 +55,13 @@ class JcToUtModelConverter( mutableMapOf, UtModel>() private val refIdAndStateKindToDescriptorCache = mutableMapOf, UTestValueDescriptor>() + val utCyclicReferenceModelResolver = UtModelDeepMapper { model -> + when (model) { + is UtCyclicReferenceModel -> getModelByRefIdAndStateKind(model.refId, model.stateKind) + ?: error("Invalid UTestCyclicReferenceDescriptor: $model") + else -> model + } + } fun convert( valueDescriptor: UTestValueDescriptor, @@ -149,7 +169,12 @@ class JcToUtModelConverter( is UTestConstantDescriptor.String -> constructString(valueDescriptor.value) is UTestCyclicReferenceDescriptor -> getModelByRefIdAndStateKind(valueDescriptor.refId, stateKind) - ?: error("Invalid UTestCyclicReferenceDescriptor: $valueDescriptor") + ?: UtCyclicReferenceModel( + id = curModelId, + classId = valueDescriptor.type.classId, + refId = valueDescriptor.refId, + stateKind = stateKind + ) is UTestEnumValueDescriptor -> UtEnumConstantModel( id = curModelId, From 1cc84fd38bd5ef5dac5b6850d10dd2b02eca8e76 Mon Sep 17 00:00:00 2001 From: IlyaMuravjov <71839386+IlyaMuravjov@users.noreply.github.com> Date: Mon, 27 Nov 2023 16:56:53 +0300 Subject: [PATCH 059/121] Automatically remove uncompilable test methods (#2699) --- .../codegen/renderer/CgAbstractRenderer.kt | 5 ++ .../main/kotlin/org/utbot/contest/Contest.kt | 10 +++ .../org/utbot/contest/ContestEstimator.kt | 61 +++++++++++++++++-- 3 files changed, 71 insertions(+), 5 deletions(-) diff --git a/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/renderer/CgAbstractRenderer.kt b/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/renderer/CgAbstractRenderer.kt index bb6863e063..ce811eefb1 100644 --- a/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/renderer/CgAbstractRenderer.kt +++ b/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/renderer/CgAbstractRenderer.kt @@ -251,12 +251,14 @@ abstract class CgAbstractRenderer( } override fun visit(element: CgTestMethod) { + visit(CgSingleLineComment(TEST_METHOD_START_MARKER)) renderMethodDocumentation(element) for (annotation in element.annotations) { annotation.accept(this) } renderMethodSignature(element) visit(element as CgMethod) + visit(CgSingleLineComment(TEST_METHOD_END_MARKER)) } override fun visit(element: CgErrorTestMethod) { @@ -953,6 +955,9 @@ abstract class CgAbstractRenderer( private fun ClassId.isAccessibleBySimpleName(): Boolean = isAccessibleBySimpleNameImpl(this) companion object { + const val TEST_METHOD_START_MARKER = "test method start marker" + const val TEST_METHOD_END_MARKER = "test method end marker" + fun makeRenderer( context: CgContext, printer: CgPrinter = CgPrinterImpl() diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/Contest.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/Contest.kt index 92a2700820..4e98919133 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/Contest.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/Contest.kt @@ -148,6 +148,16 @@ fun main(args: Array) { expectedExceptions = ExpectedExceptionsForClass(), methodNameFilter = null ) + + val compiledClassFileDir = File(outputDir.absolutePath, "compiledClassFiles") + compiledClassFileDir.mkdirs() + compileClassAndRemoveUncompilableTests( + testDir = compiledClassFileDir.absolutePath, + classPath = classpathString, + testClass = cut.generatedTestFile.absolutePath + ) + compiledClassFileDir.deleteRecursively() + println("${ContestMessage.READY}") } } 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 1b94267218..d0b75c78f1 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 @@ -32,6 +32,7 @@ import org.utbot.features.FeatureExtractorFactoryImpl import org.utbot.features.FeatureProcessorWithStatesRepetitionFactory import org.utbot.framework.PathSelectorType import org.utbot.framework.UtSettings +import org.utbot.framework.codegen.renderer.CgAbstractRenderer import org.utbot.framework.plugin.api.util.id import org.utbot.framework.plugin.api.util.withUtContext import org.utbot.framework.plugin.services.JdkInfoService @@ -49,7 +50,10 @@ private val javaHome = System.getenv("JAVA_HOME") private val javacCmd = "$javaHome/bin/javac" private val javaCmd = "$javaHome/bin/java" -private const val compileAttempts = 2 +// first attempt is for --add-opens +// second attempt is for removing test methods that still don't compile +// last attempt is for checking if final result compiles +private const val compileAttempts = 3 private data class UnnamedPackageInfo(val pack: String, val module: String) @@ -62,7 +66,16 @@ private fun findAllNotExportedPackages(report: String): List }.toList().distinct() } -private fun compileClass(testDir: String, classPath: String, testClass: String): Int { +private fun findErrorLines(report: String): List { + // (\d+) is line number + // (:(\d+)) is optional column number + val regex = """\.java:(\d+)(:(\d+))?: error""".toRegex() + return regex.findAll(report).map { + it.groupValues[1].toInt() - 1 + }.toList().distinct() +} + +fun compileClassAndRemoveUncompilableTests(testDir: String, classPath: String, testClass: String): Int = try { val exports = mutableSetOf() var exitCode = 0 @@ -93,10 +106,48 @@ private fun compileClass(testDir: String, classPath: String, testClass: String): if (errors.isNotEmpty()) logger.error { "Compilation errors: $errors" } exports += findAllNotExportedPackages(errors) + if (attemptNumber >= 1) { + val testFile = File(testClass) + val testClassLines = testFile.readLines() + val testStarts = testClassLines.withIndex() + .filter { it.value.contains(CgAbstractRenderer.TEST_METHOD_START_MARKER) } + .map { it.index } + val testEnds = testClassLines.withIndex() + .filter { it.value.contains(CgAbstractRenderer.TEST_METHOD_END_MARKER) } + .map { it.index } + val errorLines = findErrorLines(errors) + val errorRanges = errorLines.map { errorLine -> + // if error is outside test method, we can't fix that by removing test methods + val testStart = testStarts.filter { it <= errorLine }.maxOrNull() ?: return exitCode + val testEnd = testEnds.filter { it >= errorLine }.minOrNull() ?: return exitCode + testStart..testEnd + }.distinct() + if (errorRanges.size > testStarts.size / 5.0) { + logger.error { "Over 20% of test are uncompilable" } + logger.error { "Speculating that something is wrong with compilation settings, keeping all tests" } + return exitCode + } + val linesToRemove = mutableSetOf() + errorRanges.forEach { linesToRemove.addAll(it) } + val removedText = testClassLines.withIndex() + .filter { it.index in linesToRemove } + .joinToString("\n") { "${it.index}: ${it.value}" } + logger.info { "Removed uncompilable tests:\n$removedText" } + testFile.writeText(testClassLines.filterIndexed { i, _ -> i !in linesToRemove }.joinToString("\n")) + } } } - return exitCode + exitCode +} catch (e: Throwable) { + logger.error(e) { "compileClass failed" } + 1 +} finally { + val testFile = File(testClass) + testFile.writeText(testFile.readLines().filter { + !it.contains(CgAbstractRenderer.TEST_METHOD_START_MARKER) + && !it.contains(CgAbstractRenderer.TEST_METHOD_END_MARKER) + }.joinToString("\n")) } fun Array.toText() = joinToString(separator = ",") @@ -181,7 +232,7 @@ interface Tool { classStats.testClassFile = testClass logger.info().measureTime({ "Compiling class ${testClass.absolutePath}" }) { - val exitCode = compileClass( + val exitCode = compileClassAndRemoveUncompilableTests( compiledTestDir.absolutePath, project.compileClasspathString, testClass.absolutePath @@ -456,7 +507,7 @@ fun runEstimator( if (UtSettings.pathSelectorType == PathSelectorType.ML_SELECTOR || UtSettings.pathSelectorType == PathSelectorType.TORCH_SELECTOR) { Predictors.stateRewardPredictor = EngineAnalyticsContext.mlPredictorFactory() } - + logger.info { "PathSelectorType: ${UtSettings.pathSelectorType}" } if (UtSettings.pathSelectorType == PathSelectorType.ML_SELECTOR || UtSettings.pathSelectorType == PathSelectorType.TORCH_SELECTOR) { logger.info { "RewardModelPath: ${UtSettings.modelPath}" } From 7f1c3a8cd22426ea1c9a683db3ea7d8a29b058ff Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Mon, 27 Nov 2023 18:42:37 +0300 Subject: [PATCH 060/121] Update path selector strategy --- .../src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) 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 613864e004..862e7d81e7 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,7 @@ import org.jacodb.api.ext.toType import org.jacodb.approximation.Approximations import org.jacodb.impl.features.InMemoryHierarchy import org.objectweb.asm.Type +import org.usvm.PathSelectionStrategy import org.usvm.UMachineOptions import org.usvm.api.targets.JcTarget import org.usvm.instrumentation.util.jcdbSignature @@ -87,7 +88,8 @@ fun runUsvmGeneration( machineOptions = UMachineOptions( // TODO usvm-sbft: if we have less than CONTEST_TEST_EXECUTION_TIMEOUT time left, we should try execute // with smaller timeout, but instrumentation currently doesn't allow to change timeout for individual runs - timeout = generationTimeoutMillisWithoutCodegen.milliseconds - CONTEST_TEST_EXECUTION_TIMEOUT + timeout = generationTimeoutMillisWithoutCodegen.milliseconds - CONTEST_TEST_EXECUTION_TIMEOUT, + pathSelectionStrategies = listOf(PathSelectionStrategy.CLOSEST_TO_UNCOVERED_RANDOM), ) ) { // TODO usvm-sbft: we may want to tune these JcSettings for contest From 7b58a17de5f8fd3a72f60170cb2d03bcdbfe6b4c Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Tue, 28 Nov 2023 13:03:25 +0300 Subject: [PATCH 061/121] Add a copy of https://github.com/UnitTestBot/UTBotJava/pull/2627 into competitions branch --- .../kotlin/org/utbot/framework/UtSettings.kt | 6 ++++++ .../framework/minimization/Minimization.kt | 21 ++++++++++++++++--- .../main/kotlin/org/utbot/contest/Contest.kt | 1 + 3 files changed, 25 insertions(+), 3 deletions(-) diff --git a/utbot-framework-api/src/main/kotlin/org/utbot/framework/UtSettings.kt b/utbot-framework-api/src/main/kotlin/org/utbot/framework/UtSettings.kt index 0bcfd29bd7..7a4d8fb7d9 100644 --- a/utbot-framework-api/src/main/kotlin/org/utbot/framework/UtSettings.kt +++ b/utbot-framework-api/src/main/kotlin/org/utbot/framework/UtSettings.kt @@ -393,6 +393,12 @@ object UtSettings : AbstractSettings(logger, defaultKeyForSettingsPath, defaultS */ var minimizeCrashExecutions by getBooleanProperty(true) + /** + * Determines maximum number of executions with unknown coverage per method per result type. + * In [ContestUsvm] it is useful if concrete fails, so we use symbolic execution result without trace. + */ + var maxUnknownCoverageExecutionsPerMethodPerResultType by getIntProperty(10) + /** * Enable it to calculate unsat cores for hard constraints as well. * It may be usefull during debug. diff --git a/utbot-framework/src/main/kotlin/org/utbot/framework/minimization/Minimization.kt b/utbot-framework/src/main/kotlin/org/utbot/framework/minimization/Minimization.kt index 4da97d42db..847dca32e4 100644 --- a/utbot-framework/src/main/kotlin/org/utbot/framework/minimization/Minimization.kt +++ b/utbot-framework/src/main/kotlin/org/utbot/framework/minimization/Minimization.kt @@ -5,6 +5,7 @@ import org.utbot.framework.plugin.api.UtConcreteExecutionFailure import org.utbot.framework.plugin.api.UtExecution import org.utbot.framework.plugin.api.UtExecutionFailure import org.utbot.framework.plugin.api.UtExecutionResult +import org.utbot.framework.plugin.api.UtExecutionSuccess import org.utbot.framework.plugin.api.UtSymbolicExecution import org.utbot.framework.util.calculateSize import org.utbot.fuzzer.UtFuzzedExecution @@ -41,9 +42,23 @@ fun minimizeTestCase( fun minimizeExecutions(executions: List): List { val unknownCoverageExecutions = - executions.filter { it.coverage?.coveredInstructions.isNullOrEmpty() }.toSet() - // ^^^ here we add executions with empty or null coverage, because it happens only if a concrete execution failed, - // so we don't know the actual coverage for such executions + executions + .filter { it.coverage?.coveredInstructions.isNullOrEmpty() } + .groupBy { + it.result.javaClass to ( + (it.result as? UtExecutionSuccess)?.model ?: (it.result as? UtExecutionFailure)?.exception + )?.javaClass + } + .values + .flatMap { executionsGroup -> + val executionToSize = executionsGroup.associateWith { it.stateBefore.calculateSize() } + executionsGroup + .sortedBy { executionToSize[it] } + .take(UtSettings.maxUnknownCoverageExecutionsPerMethodPerResultType) + } + .toSet() + // Here we add executions with empty or null coverage, because if concrete execution failed, we don't know actual coverage. + // The amount of such executions is limited with [UtSettings.maxUnknownCoverageExecutionsPerMethodPerResultType]. val filteredExecutions = filterOutDuplicateCoverages(executions - unknownCoverageExecutions) val (mapping, executionToPriorityMapping) = buildMapping(filteredExecutions) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/Contest.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/Contest.kt index 4e98919133..b4098a2415 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/Contest.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/Contest.kt @@ -177,6 +177,7 @@ fun setOptions() { UtSettings.preferredCexOption = false UtSettings.warmupConcreteExecution = true UtSettings.testMinimizationStrategyType = TestSelectionStrategyType.COVERAGE_STRATEGY + UtSettings.maxUnknownCoverageExecutionsPerMethodPerResultType = 10 UtSettings.ignoreStringLiterals = true UtSettings.maximizeCoverageUsingReflection = true UtSettings.useSandbox = false From 9eadf926aba0284425f43857be13d00915fdb49e Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Tue, 28 Nov 2023 13:22:36 +0300 Subject: [PATCH 062/121] Update approximations version --- utbot-junit-contest/build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/utbot-junit-contest/build.gradle b/utbot-junit-contest/build.gradle index 499648521b..eb0085dd12 100644 --- a/utbot-junit-contest/build.gradle +++ b/utbot-junit-contest/build.gradle @@ -25,7 +25,7 @@ configurations { } def approximationsRepo = "com.github.UnitTestBot.java-stdlib-approximations" -def approximationsVersion = "034c49fb78" +def approximationsVersion = "d9d6f30985" compileJava { options.compilerArgs << '-XDignore.symbol.file' From 9f4af0ba2ea57e7813e62503248cda0f0b1f9f74 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Tue, 28 Nov 2023 15:30:16 +0300 Subject: [PATCH 063/121] Use symbolic result instead of concrete if it is better (#2700) --- .../converter/JcToUtExecutionConverter.kt | 126 ++++++++++++------ .../converter/UTestInstToUtModelConverter.kt | 2 +- .../org/utbot/contest/usvm/jc/JcExecution.kt | 20 ++- .../utbot/contest/usvm/jc/JcTestExecutor.kt | 23 +++- 4 files changed, 129 insertions(+), 42 deletions(-) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtExecutionConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtExecutionConverter.kt index ae14478dde..af8850c477 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtExecutionConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/JcToUtExecutionConverter.kt @@ -9,7 +9,6 @@ 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 @@ -20,6 +19,10 @@ import org.usvm.instrumentation.util.enclosingClass import org.usvm.instrumentation.util.enclosingMethod import org.utbot.common.isPublic import org.utbot.contest.usvm.jc.JcExecution +import org.utbot.contest.usvm.jc.UTestConcreteExecutionResult +import org.utbot.contest.usvm.jc.UTestResultWrapper +import org.utbot.contest.usvm.jc.UTestSymbolicExceptionResult +import org.utbot.contest.usvm.jc.UTestSymbolicSuccessResult import org.utbot.framework.codegen.domain.builtin.UtilMethodProvider import org.utbot.framework.plugin.api.ClassId import org.utbot.framework.plugin.api.Coverage @@ -65,56 +68,91 @@ class JcToUtExecutionConverter( private var uTestProcessResult = instToModelConverter.processUTest() fun convert(): UtExecution? { - val coverage = convertCoverage(getTrace(jcExecution.uTestExecutionResult), jcExecution.method.enclosingType.jcClass) + val coverage = convertCoverage(getTrace(jcExecution.uTestExecutionResultWrapper), jcExecution.method.enclosingType.jcClass) - val utUsvmExecution: UtUsvmExecution = when (val executionResult = jcExecution.uTestExecutionResult) { - is UTestExecutionSuccessResult -> UtUsvmExecution( - stateBefore = convertState(executionResult.initialState, EnvironmentStateKind.INITIAL, jcExecution.method), - stateAfter = convertState(executionResult.resultState, EnvironmentStateKind.FINAL, jcExecution.method), - // TODO usvm-sbft: ask why `UTestExecutionSuccessResult.result` is nullable - result = UtExecutionSuccess(executionResult.result?.let { - jcToUtModelConverter.convert(it, EnvironmentStateKind.FINAL) - } ?: UtVoidModel), - coverage = coverage, - instrumentation = uTestProcessResult.instrumentation, - ) - is UTestExecutionExceptionResult -> { + val utUsvmExecution: UtUsvmExecution = when (jcExecution.uTestExecutionResultWrapper) { + is UTestSymbolicExceptionResult -> { UtUsvmExecution( - stateBefore = convertState(executionResult.initialState, EnvironmentStateKind.INITIAL, jcExecution.method), - stateAfter = convertState(executionResult.resultState, EnvironmentStateKind.FINAL, jcExecution.method), + stateBefore = constructStateBeforeFromUTest(), + stateAfter = MissingState, result = createExecutionFailureResult( - executionResult.cause, - jcExecution.method, + exceptionDescriptor = UTestExceptionDescriptor( + type = jcExecution.uTestExecutionResultWrapper.exceptionType, + message = "", + stackTrace = emptyList(), + raisedByUserCode = true, + ), + jcTypedMethod = jcExecution.method, ), coverage = coverage, instrumentation = uTestProcessResult.instrumentation, ) } - is UTestExecutionInitFailedResult -> { - logger.warn(convertException(executionResult.cause)) { - "Execution failed before method under test call on ${jcExecution.method.method}" - } - null - } + is UTestSymbolicSuccessResult -> { + val resultWrapper = jcExecution.uTestExecutionResultWrapper + resultWrapper.initStatements.forEach { instToModelConverter.processInst(it) } + instToModelConverter.processInst(resultWrapper.result) - is UTestExecutionFailedResult -> { - logger.error(convertException(executionResult.cause)) { - "Concrete execution failed on ${jcExecution.method.method}" - } - null - } + val resultUtModel = instToModelConverter.findModelByInst(resultWrapper.result) - is UTestExecutionTimedOutResult -> { - logger.warn { "Timeout on ${jcExecution.method.method}" } UtUsvmExecution( stateBefore = constructStateBeforeFromUTest(), stateAfter = MissingState, - result = UtTimeoutException(TimeoutException("Concrete execution timed out")), + result = UtExecutionSuccess(resultUtModel), coverage = coverage, instrumentation = uTestProcessResult.instrumentation, ) } + + is UTestConcreteExecutionResult -> + when (val executionResult = jcExecution.uTestExecutionResultWrapper.uTestExecutionResult) { + is UTestExecutionSuccessResult -> UtUsvmExecution( + stateBefore = convertState(executionResult.initialState, EnvironmentStateKind.INITIAL, jcExecution.method), + stateAfter = convertState(executionResult.resultState, EnvironmentStateKind.FINAL, jcExecution.method), + // TODO usvm-sbft: ask why `UTestExecutionSuccessResult.result` is nullable + result = UtExecutionSuccess(executionResult.result?.let { + jcToUtModelConverter.convert(it, EnvironmentStateKind.FINAL) + } ?: UtVoidModel), + coverage = coverage, + instrumentation = uTestProcessResult.instrumentation, + ) + + is UTestExecutionExceptionResult -> { + UtUsvmExecution( + stateBefore = convertState(executionResult.initialState, EnvironmentStateKind.INITIAL, jcExecution.method), + stateAfter = convertState(executionResult.resultState, EnvironmentStateKind.FINAL, jcExecution.method), + result = createExecutionFailureResult(executionResult.cause, jcExecution.method), + coverage = coverage, + instrumentation = uTestProcessResult.instrumentation, + ) + } + + is UTestExecutionInitFailedResult -> { + logger.warn(convertException(executionResult.cause)) { + "Execution failed before method under test call on ${jcExecution.method.method}" + } + null + } + + is UTestExecutionFailedResult -> { + logger.error(convertException(executionResult.cause)) { + "Concrete execution failed on ${jcExecution.method.method}" + } + null + } + + is UTestExecutionTimedOutResult -> { + logger.warn { "Timeout on ${jcExecution.method.method}" } + UtUsvmExecution( + stateBefore = constructStateBeforeFromUTest(), + stateAfter = MissingState, + result = UtTimeoutException(TimeoutException("Concrete execution timed out")), + coverage = coverage, + instrumentation = uTestProcessResult.instrumentation, + ) + } + } } ?: return null return utUsvmExecution @@ -206,12 +244,22 @@ class JcToUtExecutionConverter( cache = mutableMapOf() )) as Throwable - private fun getTrace(executionResult: UTestExecutionResult): List? = when (executionResult) { - is UTestExecutionExceptionResult -> executionResult.trace - is UTestExecutionInitFailedResult -> executionResult.trace - is UTestExecutionSuccessResult -> executionResult.trace - is UTestExecutionFailedResult -> emptyList() - is UTestExecutionTimedOutResult -> emptyList() + /** + * Gets trace from execution result if it is present. + * + * Otherwise, (e.g. we use symbolic result if concrete fails), + * minimization will take just 'UtSettings.maxUnknownCoverageExecutionsPerMethodPerResultType' executions. + */ + private fun getTrace(executionResult: UTestResultWrapper): List? = when (executionResult) { + is UTestConcreteExecutionResult -> when (val res = executionResult.uTestExecutionResult) { + is UTestExecutionExceptionResult -> res.trace + is UTestExecutionInitFailedResult -> res.trace + is UTestExecutionSuccessResult -> res.trace + is UTestExecutionFailedResult -> emptyList() + is UTestExecutionTimedOutResult -> emptyList() + } + is UTestSymbolicExceptionResult -> emptyList() + is UTestSymbolicSuccessResult -> emptyList() } private fun convertState( diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/UTestInstToUtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/UTestInstToUtModelConverter.kt index 7dc45583aa..556a22c524 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/UTestInstToUtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/UTestInstToUtModelConverter.kt @@ -87,7 +87,7 @@ class UTestInstToUtModelConverter( } } - private fun processInst(uTestInst: UTestInst) { + fun processInst(uTestInst: UTestInst) { when (uTestInst) { is UTestExpression -> processExpr(uTestInst) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcExecution.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcExecution.kt index 92812f9d7d..18fe2bffe0 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcExecution.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcExecution.kt @@ -1,13 +1,31 @@ package org.utbot.contest.usvm.jc +import org.jacodb.api.JcType import org.jacodb.api.JcTypedMethod import org.usvm.api.JcCoverage import org.usvm.instrumentation.testcase.UTest import org.usvm.instrumentation.testcase.api.UTestExecutionResult +import org.usvm.instrumentation.testcase.api.UTestExpression +import org.usvm.instrumentation.testcase.api.UTestInst data class JcExecution( val method: JcTypedMethod, val uTest: UTest, - val uTestExecutionResult: UTestExecutionResult, + val uTestExecutionResultWrapper: UTestResultWrapper, val coverage: JcCoverage ) + +sealed interface UTestResultWrapper + +class UTestConcreteExecutionResult( + val uTestExecutionResult: UTestExecutionResult +) : UTestResultWrapper + +class UTestSymbolicExceptionResult( + val exceptionType: JcType +) : UTestResultWrapper + +class UTestSymbolicSuccessResult( + val initStatements: List, + val result: UTestExpression +) : UTestResultWrapper diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcTestExecutor.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcTestExecutor.kt index 7099a3b065..7e630626da 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcTestExecutor.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/jc/JcTestExecutor.kt @@ -14,11 +14,14 @@ import org.usvm.api.util.JcTestStateResolver import org.usvm.instrumentation.executor.UTestConcreteExecutor import org.usvm.instrumentation.testcase.UTest import org.usvm.instrumentation.testcase.api.UTestAllocateMemoryCall +import org.usvm.instrumentation.testcase.api.UTestExecutionExceptionResult +import org.usvm.instrumentation.testcase.api.UTestExecutionSuccessResult import org.usvm.instrumentation.testcase.api.UTestExpression import org.usvm.instrumentation.testcase.api.UTestMethodCall import org.usvm.instrumentation.testcase.api.UTestNullExpression import org.usvm.instrumentation.testcase.api.UTestStaticMethodCall import org.usvm.machine.JcContext +import org.usvm.machine.state.JcMethodResult import org.usvm.machine.state.JcState import org.usvm.machine.state.localIdx import org.usvm.memory.ULValue @@ -52,9 +55,27 @@ class JcTestExecutor( runner.executeAsync(uTest) } + // sometimes symbolic result is preferable that concolic: e.g. if concrete times out + val preferableResult = + if (execResult !is UTestExecutionSuccessResult && execResult !is UTestExecutionExceptionResult) { + val symbolicResult = state.methodResult + when (symbolicResult) { + is JcMethodResult.JcException -> UTestSymbolicExceptionResult(symbolicResult.type) + is JcMethodResult.Success -> { + val resultScope = MemoryScope(ctx, model, state.memory, stringConstants, method) + val resultExpr = resultScope.resolveExpr(symbolicResult.value, method.returnType) + val resultInitializer = resultScope.decoderApi.initializerInstructions() + UTestSymbolicSuccessResult(resultInitializer, resultExpr) + } + JcMethodResult.NoCall -> UTestConcreteExecutionResult(execResult) + } + } else { + UTestConcreteExecutionResult(execResult) + } + val coverage = resolveCoverage(method, state) - return JcExecution(method, uTest, execResult, coverage) + return JcExecution(method, uTest, preferableResult, coverage) } @Suppress("UNUSED_PARAMETER") From 62f25ad41446d3291934c3a12d7f28952003a17c Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Tue, 28 Nov 2023 17:31:02 +0300 Subject: [PATCH 064/121] Avoid class initialization when we evaluate ClassId --- gradle.properties | 2 +- .../org/utbot/contest/ContestEstimator.kt | 4 ++-- .../contest/usvm/converter/ConverterUtils.kt | 8 ++++++-- .../projects/seata/commons-lang-2.6.jar | Bin 284220 -> 0 bytes .../projects/seata/commons-pool-1.6.jar | Bin 111119 -> 0 bytes .../resources/projects/seata/config-1.2.1.jar | Bin 219554 -> 0 bytes .../projects/seata/netty-all-4.1.30.Final.jar | Bin 3885158 -> 0 bytes .../projects/seata/seata-common-1.2.0.jar | Bin 47372 -> 0 bytes .../seata/seata-config-core-1.2.0.jar | Bin 23383 -> 0 bytes .../projects/seata/seata-core-1.2.0.jar | Bin 210359 -> 0 bytes .../seata/seata-discovery-core-1.2.0.jar | Bin 12162 -> 0 bytes .../projects/seata/slf4j-api-1.7.22.jar | Bin 41077 -> 0 bytes 12 files changed, 9 insertions(+), 5 deletions(-) delete mode 100644 utbot-junit-contest/src/main/resources/projects/seata/commons-lang-2.6.jar delete mode 100644 utbot-junit-contest/src/main/resources/projects/seata/commons-pool-1.6.jar delete mode 100644 utbot-junit-contest/src/main/resources/projects/seata/config-1.2.1.jar delete mode 100644 utbot-junit-contest/src/main/resources/projects/seata/netty-all-4.1.30.Final.jar delete mode 100644 utbot-junit-contest/src/main/resources/projects/seata/seata-common-1.2.0.jar delete mode 100644 utbot-junit-contest/src/main/resources/projects/seata/seata-config-core-1.2.0.jar delete mode 100644 utbot-junit-contest/src/main/resources/projects/seata/seata-core-1.2.0.jar delete mode 100644 utbot-junit-contest/src/main/resources/projects/seata/seata-discovery-core-1.2.0.jar delete mode 100644 utbot-junit-contest/src/main/resources/projects/seata/slf4j-api-1.7.22.jar diff --git a/gradle.properties b/gradle.properties index 6b017b6756..41954fd026 100644 --- a/gradle.properties +++ b/gradle.properties @@ -104,7 +104,7 @@ jakartaVersion=3.1.0 jacoDbVersion=1.4.1 # TODO left outdated here to avoid exceeding GitHub packages drive space, # TODO run `gradle publishToMavenLocal -Pversion={usvmVersion}` locally in usvm project and update {usvmVersion} locally -usvmVersion=comp-231124-ev +usvmVersion=2811-2 # use latest Java 8 compaitable Spring and Spring Boot versions springVersion=5.3.28 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 d0b75c78f1..1f27cef4e1 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 @@ -425,7 +425,7 @@ fun main(args: Array) { // very special case when you run your project directly from IntellijIDEA omitting command line arguments if (args.isEmpty()) { processedClassesThreshold = 9999 //change to change number of classes to run - val timeLimit = 20 // increase if you want to debug something + val timeLimit = 30 // increase if you want to debug something val fuzzingRatio = 0.1 // sets fuzzing ratio to total test generation // Uncomment it for debug purposes: @@ -446,7 +446,7 @@ fun main(args: Array) { // config for SBST 2022 methodFilter = null - projectFilter = listOf("fastjson-1.2.50", "guava-26.0", "seata-core-0.5.0", "spoon-core-7.0.0") + projectFilter = listOf("seata-core-0.5.0") // TODO usvm-sbft-merge: add if here if we want merge contest it into main tools = listOf(Tool.USVM) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/ConverterUtils.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/ConverterUtils.kt index dc468813fb..2f0d031232 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/ConverterUtils.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/converter/ConverterUtils.kt @@ -68,7 +68,11 @@ val JcType?.classId: ClassId get() { if (this !is JcPrimitiveType) { return runCatching { - this?.replaceToBoundIfGeneric()?.toJavaClass(utContext.classLoader)?.id ?: error("Can not construct classId for $this") + this + ?.replaceToBoundIfGeneric() + ?.toJavaClass(utContext.classLoader, initialize = false) + ?.id + ?: error("Can not construct classId for $this") }.getOrElse { e -> throw IllegalStateException("JcType.classId failed on ${this?.typeName}", e) } @@ -90,7 +94,7 @@ val JcType?.classId: ClassId } val JcClassOrInterface.classId: ClassId - get() = this.toJavaClass(utContext.classLoader).id + get() = this.toJavaClass(utContext.classLoader, initialize = false).id fun TypeName.findClassId(classpath: JcClasspath): ClassId = classpath.findTypeOrNull(this.typeName)?.classId diff --git a/utbot-junit-contest/src/main/resources/projects/seata/commons-lang-2.6.jar b/utbot-junit-contest/src/main/resources/projects/seata/commons-lang-2.6.jar deleted file mode 100644 index 98467d3a653ebad776ffa3542efeb9732fe0b482..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 284220 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

|Yf_WZ!duczzo?tV8>Pnk?`BL^_(g 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%0DSh2+l;L|*$wF?P7}7wSeE*} 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%0D!QKQ7cZk<^|KedbHop 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

faTD#cVqP`Bc$9F_6Qk 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 V7&w7~N(TO&0!w$O34wS8^?!3sleYi> diff --git a/utbot-junit-contest/src/main/resources/projects/seata/commons-pool-1.6.jar b/utbot-junit-contest/src/main/resources/projects/seata/commons-pool-1.6.jar deleted file mode 100644 index 72ca75a3e6eca2158a8c607b18572f3bd87bf24e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 111119 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 Y$lnlt3qpS}@j^K8Gy2XwkUt^+11V0a8UO$Q diff --git a/utbot-junit-contest/src/main/resources/projects/seata/config-1.2.1.jar b/utbot-junit-contest/src/main/resources/projects/seata/config-1.2.1.jar deleted file mode 100644 index d2ed5a6e56656c683b171acbb7f189fc2a88ca6b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 219554 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

qK5MpGYM+}50w#?vepk1LB1;ZDm6^7%Q0Vy#K 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Π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