Global refactorings

Author: DaniilStepanov

settings.gradle.kts

@@ -23,6 +23,7 @@ include("utbot-intellij")
 include("utbot-sample")
 include("utbot-fuzzers")
 include("utbot-fuzzing")
+include("utbot-greyboxfuzzer")
 include("utbot-junit-contest")
 include("utbot-analytics")
 include("utbot-analytics-torch")

utbot-cli/src/main/kotlin/org/utbot/cli/GenerateTestsAbstractCommand.kt

@@ -39,7 +39,6 @@ import java.nio.file.Path
 import java.nio.file.Paths
 import java.time.LocalDateTime
 import java.time.temporal.ChronoUnit
-import org.utbot.engine.greyboxfuzzer.util.CustomClassLoader
 
 private const val LONG_GENERATION_TIMEOUT = 1_200_000L
 
@@ -145,11 +144,16 @@ abstract class GenerateTestsAbstractCommand(name: String, help: String) :
         val classRelativePath = classFqnToPath(classFqn) + ".class"
         val classAbsoluteURL = classLoader.getResource(classRelativePath) ?: return null
         val classAbsolutePath =
-            if (classAbsoluteURL.toURI().scheme == "jar") {
-                replaceSeparator(classAbsoluteURL.file.removePrefix("file:"))
-                    .removeSuffix(classRelativePath)
-                    .removeSuffix("/")
-                    .removeSuffix("!")
+            if (UtSettings.useGreyBoxFuzzing) {
+                if (classAbsoluteURL.toURI().scheme == "jar") {
+                    replaceSeparator(classAbsoluteURL.file.removePrefix("file:"))
+                        .removeSuffix(classRelativePath)
+                        .removeSuffix("/")
+                        .removeSuffix("!")
+                } else {
+                    replaceSeparator(classAbsoluteURL.toPath().toString())
+                        .removeSuffix(classRelativePath)
+                }
             } else {
                 replaceSeparator(classAbsoluteURL.toPath().toString())
                     .removeSuffix(classRelativePath)
@@ -164,7 +168,6 @@ abstract class GenerateTestsAbstractCommand(name: String, help: String) :
         searchDirectory: Path,
         chosenClassesToMockAlways: Set<ClassId>
     ): List<UtMethodTestSet> {
-        CustomClassLoader.classLoader = classLoader
         return testCaseGenerator.generate(
             targetMethods,
             mockStrategy,

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

@@ -8,12 +8,7 @@ import java.lang.reflect.Method
  * NOTE: vararg parameters must be passed as an array of the corresponding type.
  */
 fun Method.invokeCatching(obj: Any?, args: List<Any?>) = try {
-    val invocation =
-        try {
-            invoke(obj, *args.toTypedArray())
-        } catch (e: Throwable) {
-            null
-        }
+    val invocation = invoke(obj, *args.toTypedArray())
     Result.success(invocation)
 } catch (e: InvocationTargetException) {
     Result.failure<Nothing>(e.targetException)

utbot-framework-api/src/main/kotlin/org/utbot/framework/UtSettings.kt

@@ -244,7 +244,12 @@ object UtSettings : AbstractSettings(logger, defaultKeyForSettingsPath, defaultS
     /**
      * Set to true to use grey-box fuzzing
      */
-    var useGreyBoxFuzzing: Boolean by getBooleanProperty(true)
+    var useGreyBoxFuzzing: Boolean by getBooleanProperty(false)
+
+    /**
+     * Set to true to use grey-box fuzzing in competition mode (without asserts generation)
+     */
+    var greyBoxFuzzingCompetitionMode: Boolean by getBooleanProperty(false)
 
     /**
      * Set to true to use UtCompositeModels in grey-box fuzzing process

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

@@ -480,7 +480,7 @@ data class UtArrayModel(
  * @param instantiationCall is an [UtExecutableCallModel] to instantiate represented object. It **must** not return `null`.
  * @param modificationsChain is a chain of [UtStatementModel] to construct object state.
  */
-data class UtAssembleModel constructor(
+data class UtAssembleModel private constructor(
     override val id: Int?,
     override val classId: ClassId,
     override val modelName: String,

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

@@ -70,6 +70,9 @@ class ConcreteExecutionFailureException(cause: Throwable, errorFile: File, val p
             appendLine("Cause:\n${cause.message}")
             appendLine("Last 1000 lines of the error log ${errorFile.absolutePath}:")
             appendLine("----------------------------------------")
+            if (!errorFile.exists()) {
+                errorFile.createNewFile()
+            }
             errorFile.useLines { lines ->
                 val lastLines = LinkedList<String>()
                 for (line in lines) {
@@ -103,11 +106,6 @@ inline fun UtExecutionResult.onFailure(action: (exception: Throwable) -> Unit):
     return this
 }
 
-fun UtExecutionResult.getOrThrow(): UtModel = when (this) {
-    is UtExecutionSuccess -> model
-    is UtExecutionFailure -> throw exception
-}
-
 fun UtExecutionResult.exceptionOrNull(): Throwable? = when (this) {
     is UtExecutionFailure -> rootCauseException
     is UtExecutionSuccess -> null

utbot-framework/build.gradle

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

utbot-framework/src/main/kotlin/org/utbot/engine/UtBotSymbolicEngine.kt

@@ -11,7 +11,6 @@ import org.utbot.api.exception.UtMockAssumptionViolatedException
 import org.utbot.common.bracket
 import org.utbot.common.debug
 import org.utbot.engine.MockStrategy.NO_MOCKS
-import org.utbot.engine.greyboxfuzzer.GreyBoxFuzzer
 import org.utbot.engine.pc.*
 import org.utbot.engine.selectors.*
 import org.utbot.engine.selectors.nurs.NonUniformRandomSearch
@@ -33,9 +32,8 @@ import org.utbot.framework.UtSettings.pathSelectorStepsLimit
 import org.utbot.framework.UtSettings.pathSelectorType
 import org.utbot.framework.UtSettings.processUnknownStatesDuringConcreteExecution
 import org.utbot.framework.UtSettings.useDebugVisualization
-import org.utbot.framework.concrete.UtConcreteExecutionData
-import org.utbot.framework.concrete.UtConcreteExecutionResult
-import org.utbot.framework.concrete.UtExecutionInstrumentation
+import org.utbot.framework.concrete.*
+import org.utbot.framework.concrete.constructors.UtModelConstructor
 import org.utbot.framework.plugin.api.*
 import org.utbot.framework.plugin.api.Step
 import org.utbot.framework.plugin.api.util.*
@@ -44,11 +42,14 @@ import org.utbot.framework.util.sootMethod
 import org.utbot.fuzzer.*
 import org.utbot.fuzzing.*
 import org.utbot.fuzzing.utils.Trie
+import org.utbot.greyboxfuzzer.GreyBoxFuzzer
+import org.utbot.greyboxfuzzer.util.FuzzerUtModelConstructor
 import org.utbot.instrumentation.ConcreteExecutor
 import ru.vyarus.java.generics.resolver.context.GenericsInfoFactory
 import soot.jimple.Stmt
 import soot.tagkit.ParamNamesTag
 import java.lang.reflect.Method
+import java.util.*
 import kotlin.system.measureTimeMillis
 
 val logger = KotlinLogging.logger {}
@@ -330,7 +331,7 @@ class UtBotSymbolicEngine(
     fun fuzzing(until: Long = Long.MAX_VALUE, transform: (JavaValueProvider) -> JavaValueProvider = { it }) = flow {
         val isFuzzable = methodUnderTest.parameters.all { classId ->
             classId != Method::class.java.id && // causes the instrumented process crash at invocation
-                classId != Class::class.java.id  // causes java.lang.IllegalAccessException: java.lang.Class at sun.misc.Unsafe.allocateInstance(Native Method)
+                    classId != Class::class.java.id  // causes java.lang.IllegalAccessException: java.lang.Class at sun.misc.Unsafe.allocateInstance(Native Method)
         }
         val hasMethodUnderTestParametersToFuzz = methodUnderTest.parameters.isNotEmpty()
         if (!isFuzzable || !hasMethodUnderTestParametersToFuzz && methodUnderTest.isStatic) {
@@ -422,13 +423,22 @@ class UtBotSymbolicEngine(
             if (!isFuzzable) {
                 return@flow
             }
+            val utModelConstructor = UtModelConstructor(IdentityHashMap())
+            val fuzzerUtModelConstructor = FuzzerUtModelConstructor(
+                utModelConstructor::construct,
+                utModelConstructor::computeUnusedIdAndUpdate
+            )
 
             try {
                 emitAll(
                     GreyBoxFuzzer(
-                        concreteExecutor.pathsToUserClasses,
-                        concreteExecutor.pathsToDependencyClasses,
                         methodUnderTest,
+                        collectConstantsForGreyBoxFuzzer(methodUnderTest.sootMethod, utModelConstructor),
+                        fuzzerUtModelConstructor,
+                        FuzzerConcreteExecutor(
+                            concreteExecutor.pathsToUserClasses,
+                            concreteExecutor.pathsToDependencyClasses
+                        )::execute,
                         timeBudget
                     ).fuzz()
                 )
@@ -567,7 +577,7 @@ private fun ResolvedModels.constructStateForMethod(methodUnderTest: ExecutableId
     return EnvironmentModels(thisInstanceBefore, paramsBefore, statics)
 }
 
-private suspend fun ConcreteExecutor<UtConcreteExecutionResult, UtExecutionInstrumentation>.executeConcretely(
+internal suspend fun ConcreteExecutor<UtConcreteExecutionResult, UtExecutionInstrumentation>.executeConcretely(
     methodUnderTest: ExecutableId,
     stateBefore: EnvironmentModels,
     instrumentation: List<UtInstrumentation>

utbot-framework/src/main/kotlin/org/utbot/engine/greyboxfuzzer/quickcheck/internal/Zilch.kt

@@ -4,7 +4,6 @@ import org.utbot.common.PathUtil
 import org.utbot.common.WorkaroundReason
 import org.utbot.common.isStatic
 import org.utbot.common.workaround
-import org.utbot.engine.greyboxfuzzer.util.UtGreyBoxFuzzedExecution
 import org.utbot.framework.assemble.assemble
 import org.utbot.framework.codegen.domain.ForceStaticMocking
 import org.utbot.framework.codegen.domain.ParametrizedTestSource
@@ -155,6 +154,7 @@ import org.utbot.framework.plugin.api.util.longStreamToArrayMethodId
 import org.utbot.framework.plugin.api.util.streamClassId
 import org.utbot.framework.plugin.api.util.streamToArrayMethodId
 import org.utbot.framework.plugin.api.util.isStatic
+import org.utbot.greyboxfuzzer.util.UtGreyBoxFuzzedExecution
 
 private const val DEEP_EQUALS_MAX_DEPTH = 5 // TODO move it to plugin settings?
 

utbot-framework/src/main/kotlin/org/utbot/engine/greyboxfuzzer/quickcheck/internal/generator/ZilchGenerator.kt

@@ -0,0 +1,91 @@
+package org.utbot.framework.concrete
+
+import org.utbot.framework.UtSettings
+import org.utbot.framework.plugin.api.EnvironmentModels
+import org.utbot.framework.plugin.api.ExecutableId
+import org.utbot.framework.plugin.api.UtInstrumentation
+import org.utbot.framework.plugin.api.util.utContext
+import org.utbot.greyboxfuzzer.util.UtFuzzingConcreteExecutionResult
+import org.utbot.instrumentation.ConcreteExecutor
+
+class FuzzerConcreteExecutor(
+    private val pathsToUserClasses: String,
+    private val pathsToDependencyClasses: String,
+) {
+
+    suspend fun execute(
+        methodUnderTest: ExecutableId,
+        stateBefore: EnvironmentModels,
+        instrumentation: List<UtInstrumentation>
+    ): UtFuzzingConcreteExecutionResult {
+//        val fuzzingExecutor =
+//            ConcreteExecutor(
+//                UtFuzzingExecutionInstrumentation/*(UtSettings.greyBoxFuzzingCompetitionMode)*/,
+//                pathsToUserClasses,
+//                pathsToDependencyClasses
+//            ).apply { this.classLoader = utContext.classLoader }
+//        val executionResult = fuzzingExecutor.executeConcretelyFuzz(methodUnderTest, stateBefore, instrumentation)
+//        return UtFuzzingConcreteExecutionResult(
+//            null,
+//            executionResult.result,
+//            executionResult.coverage,
+//            executionResult.methodInstructionsIds
+//        )
+        return if (UtSettings.greyBoxFuzzingCompetitionMode) {
+            val fuzzingExecutor =
+                ConcreteExecutor(
+                    UtFuzzingExecutionInstrumentation,
+                    pathsToUserClasses,
+                    pathsToDependencyClasses
+                ).apply { this.classLoader = utContext.classLoader }
+            val executionResult = fuzzingExecutor.executeConcretelyFuzz(methodUnderTest, stateBefore, instrumentation)
+            UtFuzzingConcreteExecutionResult(
+                null,
+                executionResult.result,
+                executionResult.coverage,
+                executionResult.methodInstructions
+            )
+        } else {
+            val fuzzingExecutor =
+                ConcreteExecutor(
+                    UtFuzzingExecutionInstrumentationWithStateAfterCollection,
+                    pathsToUserClasses,
+                    pathsToDependencyClasses
+                ).apply { this.classLoader = utContext.classLoader }
+            val executionResult = fuzzingExecutor.executeConcretelyFuzzWithStateAfterCollection(
+                methodUnderTest,
+                stateBefore,
+                instrumentation
+            )
+            UtFuzzingConcreteExecutionResult(
+                executionResult.stateAfter,
+                executionResult.result,
+                executionResult.coverage,
+                executionResult.methodInstructions
+            )
+        }
+    }
+
+    private suspend fun ConcreteExecutor<UtFuzzingConcreteExecutionResult, UtFuzzingExecutionInstrumentation>.executeConcretelyFuzz(
+        methodUnderTest: ExecutableId,
+        stateBefore: EnvironmentModels,
+        instrumentation: List<UtInstrumentation>
+    ): UtFuzzingConcreteExecutionResult = executeAsync(
+        methodUnderTest.classId.name,
+        methodUnderTest.signature,
+        arrayOf(),
+        parameters = UtConcreteExecutionData(stateBefore, instrumentation)
+    )
+
+    private suspend fun ConcreteExecutor<UtFuzzingConcreteExecutionResult, UtFuzzingExecutionInstrumentationWithStateAfterCollection>.executeConcretelyFuzzWithStateAfterCollection(
+        methodUnderTest: ExecutableId,
+        stateBefore: EnvironmentModels,
+        instrumentation: List<UtInstrumentation>
+    ): UtFuzzingConcreteExecutionResult = executeAsync(
+        methodUnderTest.classId.name,
+        methodUnderTest.signature,
+        arrayOf(),
+        parameters = UtConcreteExecutionData(stateBefore, instrumentation)
+    )
+
+}