Сonstraint model synthesis

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

@@ -143,8 +143,10 @@ abstract class GenerateTestsAbstractCommand(name: String, help: String) :
     protected fun getWorkingDirectory(classFqn: String): Path? {
         val classRelativePath = classFqnToPath(classFqn) + ".class"
         val classAbsoluteURL = classLoader.getResource(classRelativePath) ?: return null
-        val classAbsolutePath = replaceSeparator(classAbsoluteURL.toPath().toString())
+        val classAbsolutePath = replaceSeparator(classAbsoluteURL.file.removePrefix("file:"))
             .removeSuffix(classRelativePath)
+            .removeSuffix("/")
+            .removeSuffix("!")
         return Paths.get(classAbsolutePath)
     }
 
@@ -222,7 +224,9 @@ abstract class GenerateTestsAbstractCommand(name: String, help: String) :
 
     protected fun saveToFile(snippet: String, outputPath: String?) =
         outputPath?.let {
-            Files.write(it.toPath(), listOf(snippet))
+            val path = it.toPath()
+            path.toFile().parentFile?.mkdirs()
+            Files.write(path, listOf(snippet))
         }
 
     protected fun now(): LocalDateTime = LocalDateTime.now()

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

@@ -380,6 +380,28 @@ object UtSettings : AbstractSettings(
      */
     var ignoreStaticsFromTrustedLibraries by getBooleanProperty(true)
 
+    /**
+     * Flag for enabling model synthesis
+     */
+    var enableSynthesis by getBooleanProperty(false)
+
+    /**
+     * Flag for enabling model synthesis
+     */
+    var enableSynthesisCache by getBooleanProperty(true)
+
+    /**
+     * Timeout model synthesis
+     *
+     */
+    var synthesisTimeoutInMillis by getLongProperty(60000L)
+
+    /**
+     * Max depth for synthesis search
+     *
+     */
+    var synthesisMaxDepth by getIntProperty(10)
+
     /**
      * Use the sandbox in the concrete executor.
      *
@@ -439,7 +461,12 @@ enum class PathSelectorType {
     /**
      * [RandomPathSelector]
      */
-    RANDOM_PATH_SELECTOR
+    RANDOM_PATH_SELECTOR,
+
+    /**
+     * [ScoringPathSelector]
+     */
+    SCORING_PATH_SELECTOR
 }
 
 enum class TestSelectionStrategyType {

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

@@ -136,7 +136,8 @@ class UtSymbolicExecution(
     coverage: Coverage? = null,
     summary: List<DocStatement>? = null,
     testMethodName: String? = null,
-    displayName: String? = null
+    displayName: String? = null,
+    val constrainedExecution: ConstrainedExecution? = null
 ) : UtExecution(stateBefore, stateAfter, result, coverage, summary, testMethodName, displayName) {
     /**
      * By design the 'before' and 'after' states contain info about the same fields.
@@ -169,7 +170,12 @@ class UtSymbolicExecution(
         append(")")
     }
 
-    fun copy(stateAfter: EnvironmentModels, result: UtExecutionResult, coverage: Coverage): UtResult {
+    fun copy(
+        stateBefore: EnvironmentModels,
+        stateAfter: EnvironmentModels,
+        result: UtExecutionResult,
+        coverage: Coverage?,
+    ): UtExecution {
         return UtSymbolicExecution(
             stateBefore,
             stateAfter,
@@ -180,7 +186,8 @@ class UtSymbolicExecution(
             coverage,
             summary,
             testMethodName,
-            displayName
+            displayName,
+            constrainedExecution
         )
     }
 }
@@ -468,6 +475,80 @@ data class UtArrayModel(
     }
 }
 
+/**
+ * Models for values with constraints
+ */
+sealed class UtConstraintModel(
+    open val variable: UtConstraintVariable
+) : UtModel(variable.classId) {
+    abstract val utConstraints: Set<UtConstraint>
+}
+
+data class UtPrimitiveConstraintModel(
+    override val variable: UtConstraintVariable,
+    override val utConstraints: Set<UtConstraint>,
+    val concrete: Any? = null
+) : UtConstraintModel(variable) {
+}
+
+data class UtReferenceConstraintModel(
+    override val variable: UtConstraintVariable,
+    override val utConstraints: Set<UtConstraint>,
+) : UtConstraintModel(variable) {
+    fun isNull() = utConstraints.any {
+        it is UtRefEqConstraint && it.lhv == variable && it.rhv is UtConstraintNull
+    }
+}
+
+data class UtReferenceToConstraintModel(
+    override val variable: UtConstraintVariable,
+    val reference: UtModel,
+    override val utConstraints: Set<UtConstraint> = emptySet()
+) : UtConstraintModel(variable)
+
+sealed class UtElementContainerConstraintModel(
+    override val variable: UtConstraintVariable,
+    open val length: UtModel,
+    open val elements: Map<UtModel, UtModel>,
+    open val baseConstraints: Set<UtConstraint> = emptySet()
+) : UtConstraintModel(variable) {
+    final override val utConstraints: Set<UtConstraint> get() =
+        baseConstraints + elements.toList().fold((length as UtConstraintModel).utConstraints) { acc, pair ->
+            acc +
+                    ((pair.first as? UtConstraintModel)?.utConstraints ?: emptySet()) +
+                    ((pair.second as? UtConstraintModel)?.utConstraints ?: emptySet())
+        }
+}
+
+data class UtArrayConstraintModel(
+    override val variable: UtConstraintVariable,
+    override val length: UtModel,
+    override val elements: Map<UtModel, UtModel>,
+    override val baseConstraints: Set<UtConstraint> = emptySet()
+) : UtElementContainerConstraintModel(variable, length, elements)
+
+data class UtListConstraintModel(
+    override val variable: UtConstraintVariable,
+    override val length: UtModel,
+    override val elements: Map<UtModel, UtModel>,
+    override val baseConstraints: Set<UtConstraint> = emptySet()
+) : UtElementContainerConstraintModel(variable, length, elements)
+
+data class UtSetConstraintModel(
+    override val variable: UtConstraintVariable,
+    override val length: UtModel,
+    override val elements: Map<UtModel, UtModel>,
+    override val baseConstraints: Set<UtConstraint> = emptySet()
+) : UtElementContainerConstraintModel(variable, length, elements)
+
+data class UtMapConstraintModel(
+    override val variable: UtConstraintVariable,
+    override val length: UtModel,
+    override val elements: Map<UtModel, UtModel>,
+    override val baseConstraints: Set<UtConstraint> = emptySet()
+) : UtElementContainerConstraintModel(variable, length, elements)
+
+
 /**
  * Model for complex objects with assemble instructions.
  *

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

@@ -0,0 +1,51 @@
+package org.utbot.framework.plugin.api
+
+interface UtConstraintVariableVisitor<T> {
+    fun visitUtConstraintParameter(expr: UtConstraintParameter): T
+    fun visitUtConstraintNull(expr: UtConstraintNull): T
+    fun visitUtConstraintFieldAccess(expr: UtConstraintFieldAccess): T
+    fun visitUtConstraintArrayAccess(expr: UtConstraintArrayAccess): T
+    fun visitUtConstraintArrayLengthAccess(expr: UtConstraintArrayLength): T
+    fun visitUtConstraintBoolConstant(expr: UtConstraintBoolConstant): T
+    fun visitUtConstraintCharConstant(expr: UtConstraintCharConstant): T
+    fun visitUtConstraintNumericConstant(expr: UtConstraintNumericConstant): T
+    fun visitUtConstraintAdd(expr: UtConstraintAdd): T
+    fun visitUtConstraintAnd(expr: UtConstraintAnd): T
+    fun visitUtConstraintCmp(expr: UtConstraintCmp): T
+    fun visitUtConstraintCmpg(expr: UtConstraintCmpg): T
+    fun visitUtConstraintCmpl(expr: UtConstraintCmpl): T
+    fun visitUtConstraintDiv(expr: UtConstraintDiv): T
+    fun visitUtConstraintMul(expr: UtConstraintMul): T
+    fun visitUtConstraintOr(expr: UtConstraintOr): T
+    fun visitUtConstraintRem(expr: UtConstraintRem): T
+    fun visitUtConstraintShl(expr: UtConstraintShl): T
+    fun visitUtConstraintShr(expr: UtConstraintShr): T
+    fun visitUtConstraintSub(expr: UtConstraintSub): T
+    fun visitUtConstraintUshr(expr: UtConstraintUshr): T
+    fun visitUtConstraintXor(expr: UtConstraintXor): T
+    fun visitUtConstraintNot(expr: UtConstraintNot): T
+
+    fun visitUtConstraintNeg(expr: UtConstraintNeg): T
+
+    fun visitUtConstraintCast(expr: UtConstraintCast): T
+}
+
+interface UtConstraintVisitor<T> {
+    fun visitUtNegatedConstraint(expr: UtNegatedConstraint): T
+
+    fun visitUtRefEqConstraint(expr: UtRefEqConstraint): T
+
+    fun visitUtRefGenericEqConstraint(expr: UtRefGenericEqConstraint): T
+
+    fun visitUtRefTypeConstraint(expr: UtRefTypeConstraint): T
+    fun visitUtRefGenericTypeConstraint(expr: UtRefGenericTypeConstraint): T
+
+    fun visitUtBoolConstraint(expr: UtBoolConstraint): T
+    fun visitUtEqConstraint(expr: UtEqConstraint): T
+    fun visitUtLtConstraint(expr: UtLtConstraint): T
+    fun visitUtGtConstraint(expr: UtGtConstraint): T
+    fun visitUtLeConstraint(expr: UtLeConstraint): T
+    fun visitUtGeConstraint(expr: UtGeConstraint): T
+    fun visitUtAndConstraint(expr: UtAndConstraint): T
+    fun visitUtOrConstraint(expr: UtOrConstraint): T
+}