first prototype, needs debugging and tuning

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

@@ -50,7 +50,7 @@ private val logger = KotlinLogging.logger {}
 abstract class GenerateTestsAbstractCommand(name: String, help: String) :
     CliktCommand(name = name, help = help) {
 
-    abstract val classPath:String?
+    abstract val classPath: String?
 
     private val mockStrategy by option("-m", "--mock-strategy", help = "Defines the mock strategy")
         .choice(
@@ -146,8 +146,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)
     }
 
@@ -199,7 +201,11 @@ abstract class GenerateTestsAbstractCommand(name: String, help: String) :
         // Set UtSettings parameters.
         UtSettings.treatOverflowAsError = treatOverflowAsError == TreatOverflowAsError.AS_ERROR
 
-        UtBotTestCaseGenerator.init(workingDirectory, classPathNormalized, System.getProperty("java.class.path")) { false }
+        UtBotTestCaseGenerator.init(
+            workingDirectory,
+            classPathNormalized,
+            System.getProperty("java.class.path")
+        ) { false }
     }
 
     private fun initializeCodeGenerator(testFramework: String, classUnderTest: KClass<*>): ModelBasedTestCodeGenerator {

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

@@ -384,7 +384,12 @@ enum class PathSelectorType {
     /**
      * [RandomPathSelector]
      */
-    RANDOM_PATH_SELECTOR
+    RANDOM_PATH_SELECTOR,
+
+    /**
+     * [ScoringPathSelector]
+     */
+    SCORING_PATH_SELECTOR
 }
 
 enum class TestSelectionStrategyType {

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

@@ -81,19 +81,11 @@ import org.utbot.engine.pc.mkNot
 import org.utbot.engine.pc.mkOr
 import org.utbot.engine.pc.select
 import org.utbot.engine.pc.store
-import org.utbot.engine.selectors.PathSelector
-import org.utbot.engine.selectors.StrategyOption
-import org.utbot.engine.selectors.coveredNewSelector
-import org.utbot.engine.selectors.cpInstSelector
-import org.utbot.engine.selectors.forkDepthSelector
-import org.utbot.engine.selectors.inheritorsSelector
-import org.utbot.engine.selectors.nnRewardGuidedSelector
+import org.utbot.engine.selectors.*
 import org.utbot.engine.selectors.nurs.NonUniformRandomSearch
-import org.utbot.engine.selectors.pollUntilFastSAT
-import org.utbot.engine.selectors.randomPathSelector
-import org.utbot.engine.selectors.randomSelector
+import org.utbot.engine.selectors.strategies.DefaultScoringStrategy
 import org.utbot.engine.selectors.strategies.GraphViz
-import org.utbot.engine.selectors.subpathGuidedSelector
+import org.utbot.engine.selectors.strategies.ScoringStrategy
 import org.utbot.engine.symbolic.HardConstraint
 import org.utbot.engine.symbolic.SoftConstraint
 import org.utbot.engine.symbolic.SymbolicState
@@ -116,21 +108,8 @@ import org.utbot.framework.UtSettings.pathSelectorType
 import org.utbot.framework.UtSettings.preferredCexOption
 import org.utbot.framework.UtSettings.substituteStaticsWithSymbolicVariable
 import org.utbot.framework.UtSettings.useDebugVisualization
-import org.utbot.framework.plugin.api.ClassId
-import org.utbot.framework.plugin.api.ConcreteExecutionFailureException
-import org.utbot.framework.plugin.api.EnvironmentModels
-import org.utbot.framework.plugin.api.FieldId
-import org.utbot.framework.plugin.api.MethodId
-import org.utbot.framework.plugin.api.MissingState
+import org.utbot.framework.plugin.api.*
 import org.utbot.framework.plugin.api.Step
-import org.utbot.framework.plugin.api.UtConcreteExecutionFailure
-import org.utbot.framework.plugin.api.UtError
-import org.utbot.framework.plugin.api.UtExecution
-import org.utbot.framework.plugin.api.UtOverflowFailure
-import org.utbot.framework.plugin.api.UtResult
-import org.utbot.framework.plugin.api.classId
-import org.utbot.framework.plugin.api.graph
-import org.utbot.framework.plugin.api.id
 import org.utbot.framework.plugin.api.util.id
 import org.utbot.framework.plugin.api.util.jClass
 import org.utbot.framework.plugin.api.util.utContext
@@ -250,33 +229,39 @@ private var stateSelectedCount = 0
 //all id values of synthetic default models must be greater that for real ones
 var nextDefaultModelId = 1500_000_000
 
-private fun pathSelector(graph: InterProceduralUnitGraph, typeRegistry: TypeRegistry) =
-    when (pathSelectorType) {
-        PathSelectorType.COVERED_NEW_SELECTOR -> coveredNewSelector(graph) {
-            withStepsLimit(pathSelectorStepsLimit)
-        }
-        PathSelectorType.INHERITORS_SELECTOR -> inheritorsSelector(graph, typeRegistry) {
-            withStepsLimit(pathSelectorStepsLimit)
-        }
-        PathSelectorType.SUBPATH_GUIDED_SELECTOR -> subpathGuidedSelector(graph, StrategyOption.DISTANCE) {
-            withStepsLimit(pathSelectorStepsLimit)
-        }
-        PathSelectorType.CPI_SELECTOR -> cpInstSelector(graph, StrategyOption.DISTANCE) {
-            withStepsLimit(pathSelectorStepsLimit)
-        }
-        PathSelectorType.FORK_DEPTH_SELECTOR -> forkDepthSelector(graph, StrategyOption.DISTANCE) {
-            withStepsLimit(pathSelectorStepsLimit)
-        }
-        PathSelectorType.NN_REWARD_GUIDED_SELECTOR -> nnRewardGuidedSelector(graph, StrategyOption.DISTANCE) {
-            withStepsLimit(pathSelectorStepsLimit)
-        }
-        PathSelectorType.RANDOM_SELECTOR -> randomSelector(graph, StrategyOption.DISTANCE) {
-            withStepsLimit(pathSelectorStepsLimit)
-        }
-        PathSelectorType.RANDOM_PATH_SELECTOR -> randomPathSelector(graph, StrategyOption.DISTANCE) {
-            withStepsLimit(pathSelectorStepsLimit)
-        }
+private fun pathSelector(
+    graph: InterProceduralUnitGraph,
+    typeRegistry: TypeRegistry,
+    scoringStrategy: ScoringStrategy,
+) = when (pathSelectorType) {
+    PathSelectorType.COVERED_NEW_SELECTOR -> coveredNewSelector(graph) {
+        withStepsLimit(pathSelectorStepsLimit)
+    }
+    PathSelectorType.INHERITORS_SELECTOR -> inheritorsSelector(graph, typeRegistry) {
+        withStepsLimit(pathSelectorStepsLimit)
     }
+    PathSelectorType.SUBPATH_GUIDED_SELECTOR -> subpathGuidedSelector(graph, StrategyOption.DISTANCE) {
+        withStepsLimit(pathSelectorStepsLimit)
+    }
+    PathSelectorType.CPI_SELECTOR -> cpInstSelector(graph, StrategyOption.DISTANCE) {
+        withStepsLimit(pathSelectorStepsLimit)
+    }
+    PathSelectorType.FORK_DEPTH_SELECTOR -> forkDepthSelector(graph, StrategyOption.DISTANCE) {
+        withStepsLimit(pathSelectorStepsLimit)
+    }
+    PathSelectorType.NN_REWARD_GUIDED_SELECTOR -> nnRewardGuidedSelector(graph, StrategyOption.DISTANCE) {
+        withStepsLimit(pathSelectorStepsLimit)
+    }
+    PathSelectorType.RANDOM_SELECTOR -> randomSelector(graph, StrategyOption.DISTANCE) {
+        withStepsLimit(pathSelectorStepsLimit)
+    }
+    PathSelectorType.RANDOM_PATH_SELECTOR -> randomPathSelector(graph, StrategyOption.DISTANCE) {
+        withStepsLimit(pathSelectorStepsLimit)
+    }
+    PathSelectorType.SCORING_PATH_SELECTOR -> scoringPathSelector(graph, scoringStrategy) {
+        withStepsLimit(pathSelectorStepsLimit)
+    }
+}
 
 class UtBotSymbolicEngine(
     private val controller: EngineController,
@@ -287,14 +272,15 @@ class UtBotSymbolicEngine(
     mockStrategy: MockStrategy = NO_MOCKS,
     chosenClassesToMockAlways: Set<ClassId>,
     private val solverTimeoutInMillis: Int = checkSolverTimeoutMillis,
-    private val postConditionConstructor: PostConditionConstructor = EmptyPostCondition
+    private val postConditionConstructor: PostConditionConstructor = EmptyPostCondition,
+    scoringStrategy: ScoringStrategy = DefaultScoringStrategy
 ) : UtContextInitializer() {
 
     private val methodUnderAnalysisStmts: Set<Stmt> = graph.stmts.toSet()
     private val visitedStmts: MutableSet<Stmt> = mutableSetOf()
     private val globalGraph = InterProceduralUnitGraph(graph)
     internal val typeRegistry: TypeRegistry = TypeRegistry()
-    private val pathSelector: PathSelector = pathSelector(globalGraph, typeRegistry)
+    private val pathSelector: PathSelector = pathSelector(globalGraph, typeRegistry, scoringStrategy)
 
     private val classLoader: ClassLoader
         get() = utContext.classLoader

utbot-framework/src/main/kotlin/org/utbot/engine/selectors/BasePathSelector.kt

@@ -59,14 +59,14 @@ abstract class BasePathSelector(
     /**
      * @return true if [utSolver] constraints are satisfiable
      */
-    private fun checkUnsat(utSolver: UtSolver): Boolean =
-        utSolver.assertions.isNotEmpty() && utSolver.check(respectSoft = false).statusKind != SAT
+    protected fun checkUnsat(state: ExecutionState): Boolean =
+        state.solver.assertions.isNotEmpty() && state.solver.check(respectSoft = false).statusKind != SAT
 
     /**
      * check fast unsat on forks
      */
     private fun checkUnsatIfFork(state: ExecutionState) =
-        state.path.isNotEmpty() && choosingStrategy.graph.isFork(state.path.last()) && checkUnsat(state.solver)
+        state.path.isNotEmpty() && choosingStrategy.graph.isFork(state.path.last()) && checkUnsat(state)
 
     override fun poll(): ExecutionState? {
         if (stoppingStrategy.shouldStop()) {

utbot-framework/src/main/kotlin/org/utbot/engine/selectors/PathSelectorBuilder.kt

@@ -17,14 +17,7 @@ import org.utbot.engine.selectors.nurs.NeuroSatSelector
 import org.utbot.engine.selectors.nurs.RPSelector
 import org.utbot.engine.selectors.nurs.SubpathGuidedSelector
 import org.utbot.engine.selectors.nurs.VisitCountingSelector
-import org.utbot.engine.selectors.strategies.ChoosingStrategy
-import org.utbot.engine.selectors.strategies.DistanceStatistics
-import org.utbot.engine.selectors.strategies.EdgeVisitCountingStatistics
-import org.utbot.engine.selectors.strategies.GeneratedTestCountingStatistics
-import org.utbot.engine.selectors.strategies.StatementsStatistics
-import org.utbot.engine.selectors.strategies.StepsLimitStoppingStrategy
-import org.utbot.engine.selectors.strategies.StoppingStrategy
-import org.utbot.engine.selectors.strategies.SubpathStatistics
+import org.utbot.engine.selectors.strategies.*
 import org.utbot.framework.UtSettings.seedInPathSelector
 
 /**
@@ -145,6 +138,15 @@ fun randomSelector(
     builder: RandomSelectorBuilder.() -> Unit
 ) = RandomSelectorBuilder(graph, strategy).apply(builder).build()
 
+/**
+ * build [scoringPathSelector] using [ScoringPathSelectorBuilder]
+ */
+fun scoringPathSelector(
+    graph: InterProceduralUnitGraph,
+    scoringStrategy: ScoringStrategy,
+    builder: ScoringPathSelectorBuilder.() -> (Unit)
+) = ScoringPathSelectorBuilder(graph, scoringStrategy).apply(builder).build()
+
 /**
  * build [RPSelector] using [RPSelectorBuilder]
  */
@@ -405,6 +407,23 @@ class RandomSelectorBuilder internal constructor(
     )
 }
 
+/**
+ * Builder for [ScoringSelector]. Used in [scoringSelector]
+ *
+ * @param strategy [ScoringStrategy] for choosingStrategy for this PathSelector
+ */
+class ScoringPathSelectorBuilder internal constructor(
+    graph: InterProceduralUnitGraph,
+    val scoringStrategy: ScoringStrategy,
+    context: PathSelectorContext = PathSelectorContext(graph)
+) : PathSelectorBuilder<ScoringPathSelector>(graph, context) {
+    override fun build() = ScoringPathSelector(
+        withDistanceStrategy(),
+        requireNotNull(context.stoppingStrategy) { "StoppingStrategy isn't specified" },
+        scoringStrategy
+    )
+}
+
 /**
  * Builder for [RPSelector]. Used in [rpSelector]
  *

utbot-framework/src/main/kotlin/org/utbot/engine/selectors/ScoringPathSelector.kt

@@ -0,0 +1,46 @@
+package org.utbot.engine.selectors
+
+import org.utbot.engine.*
+import org.utbot.engine.selectors.strategies.ChoosingStrategy
+import org.utbot.engine.selectors.strategies.ScoringStrategy
+import org.utbot.engine.selectors.strategies.StoppingStrategy
+import java.util.PriorityQueue
+
+open class ScoringPathSelector(
+    choosingStrategy: ChoosingStrategy,
+    stoppingStrategy: StoppingStrategy,
+    protected val scoringStrategy: ScoringStrategy,
+) : BasePathSelector(choosingStrategy, stoppingStrategy) {
+    private val states = PriorityQueue<ExecutionState> { a, b ->
+        val aScore = scoringStrategy.score(a)
+        val bScore = scoringStrategy.score(b)
+        aScore.compareTo(bScore)
+    }
+
+    override fun offerImpl(state: ExecutionState) {
+        scoringStrategy.score(state)
+        states.add(state)
+    }
+
+    override fun pollImpl(): ExecutionState? {
+        return states.poll()
+    }
+
+    override fun peekImpl(): ExecutionState? {
+        return states.firstOrNull()
+    }
+
+    override fun removeImpl(state: ExecutionState): Boolean {
+        return states.remove(state)
+    }
+
+    override fun isEmpty() = states.isEmpty()
+
+    override val name = "ScoringSelector"
+
+    override fun close() {
+        states.forEach {
+            it.close()
+        }
+    }
+}