prototype

UnitTestBot · AbdullinAM · Jun 20, 2022 · Jun 20, 2022 · Jun 22, 2022 · Jun 28, 2022
commit 9c63ba0ca5ac1f60fd84b48e131ab3e86c0a7f25
diff --git a/utbot-framework/src/main/kotlin/org/utbot/engine/UtBotSymbolicEngine.kt b/utbot-framework/src/main/kotlin/org/utbot/engine/UtBotSymbolicEngine.kt
@@ -83,9 +83,8 @@ import org.utbot.engine.pc.select
 import org.utbot.engine.pc.store
 import org.utbot.engine.selectors.*
 import org.utbot.engine.selectors.nurs.NonUniformRandomSearch
-import org.utbot.engine.selectors.strategies.DefaultScoringStrategy
 import org.utbot.engine.selectors.strategies.GraphViz
-import org.utbot.engine.selectors.strategies.ScoringStrategy
+import org.utbot.engine.selectors.strategies.ScoringStrategyBuilder
 import org.utbot.engine.symbolic.HardConstraint
 import org.utbot.engine.symbolic.SoftConstraint
 import org.utbot.engine.symbolic.SymbolicState
@@ -232,7 +231,7 @@ var nextDefaultModelId = 1500_000_000
 private fun pathSelector(
     graph: InterProceduralUnitGraph,
     typeRegistry: TypeRegistry,
-    scoringStrategy: ScoringStrategy,
+    scoringStrategy: ScoringStrategyBuilder,
 ) = when (pathSelectorType) {
     PathSelectorType.COVERED_NEW_SELECTOR -> coveredNewSelector(graph) {
         withStepsLimit(pathSelectorStepsLimit)
@@ -258,7 +257,7 @@ private fun pathSelector(
     PathSelectorType.RANDOM_PATH_SELECTOR -> randomPathSelector(graph, StrategyOption.DISTANCE) {
         withStepsLimit(pathSelectorStepsLimit)
     }
-    PathSelectorType.SCORING_PATH_SELECTOR -> scoringPathSelector(graph, scoringStrategy) {
+    PathSelectorType.SCORING_PATH_SELECTOR -> scoringPathSelector(graph, scoringStrategy.build(graph, typeRegistry)) {
         withStepsLimit(pathSelectorStepsLimit)
     }
 }
@@ -273,7 +272,7 @@ class UtBotSymbolicEngine(
     chosenClassesToMockAlways: Set<ClassId>,
     private val solverTimeoutInMillis: Int = checkSolverTimeoutMillis,
     private val postConditionConstructor: PostConditionConstructor = EmptyPostCondition,
-    scoringStrategy: ScoringStrategy = DefaultScoringStrategy
+    scoringStrategy: ScoringStrategyBuilder = ScoringStrategyBuilder()
 ) : UtContextInitializer() {
 
     private val methodUnderAnalysisStmts: Set<Stmt> = graph.stmts.toSet()
@@ -387,6 +386,12 @@ class UtBotSymbolicEngine(
             method = globalGraph.method(initStmt),
             state = initState
         )
+
+        environment = with(environment) {
+            val softConstraintsUpdate = postConditionConstructor.constructSoftPostCondition(this@UtBotSymbolicEngine)
+            copy(state = state.copy(symbolicState = state.symbolicState + softConstraintsUpdate))
+        }
+
         pathSelector.use {
 
             while (currentCoroutineContext().isActive) {
@@ -403,7 +408,8 @@ class UtBotSymbolicEngine(
                 }
 
                 stateSelectedCount++
-                pathLogger.trace { "traverse<$methodUnderTest>: choosing next state($stateSelectedCount), " +
+                pathLogger.trace {
+                    "traverse<$methodUnderTest>: choosing next state($stateSelectedCount), " +
                             "queue size=${(pathSelector as? NonUniformRandomSearch)?.size ?: -1}"
                 }
 
@@ -888,7 +894,8 @@ class UtBotSymbolicEngine(
         }
 
         val initializedStaticFieldsMemoryUpdate = MemoryUpdate(
-            initializedStaticFields = staticFields.associate { it.first.fieldId to it.second.single() }.toPersistentMap(),
+            initializedStaticFields = staticFields.associate { it.first.fieldId to it.second.single() }
+                .toPersistentMap(),
             meaningfulStaticFields = meaningfulStaticFields.map { it.first.fieldId }.toPersistentSet()
         )
 
@@ -1232,7 +1239,12 @@ class UtBotSymbolicEngine(
                     ?: error("Exception wasn't caught, stmt: $current, line: ${current.lines}")
                 val nextState = environment.state.updateQueued(
                     globalGraph.succ(current),
-                    SymbolicStateUpdate(localMemoryUpdates = localMemoryUpdate(localVariable to value, CAUGHT_EXCEPTION to null))
+                    SymbolicStateUpdate(
+                        localMemoryUpdates = localMemoryUpdate(
+                            localVariable to value,
+                            CAUGHT_EXCEPTION to null
+                        )
+                    )
                 )
                 pathSelector.offer(nextState)
             }
@@ -1447,7 +1459,8 @@ class UtBotSymbolicEngine(
                 queuedSymbolicStateUpdates += MemoryUpdate(mockInfos = persistentListOf(MockInfoEnriched(mockInfo)))
 
                 // add typeConstraint for mocked object. It's a declared type of the object.
-                queuedSymbolicStateUpdates += typeRegistry.typeConstraint(addr, mockedObject.typeStorage).all().asHardConstraint()
+                queuedSymbolicStateUpdates += typeRegistry.typeConstraint(addr, mockedObject.typeStorage).all()
+                    .asHardConstraint()
                 queuedSymbolicStateUpdates += mkEq(typeRegistry.isMock(mockedObject.addr), UtTrue).asHardConstraint()
 
                 return mockedObject
@@ -1485,7 +1498,8 @@ class UtBotSymbolicEngine(
             queuedSymbolicStateUpdates += MemoryUpdate(mockInfos = persistentListOf(MockInfoEnriched(mockInfo)))
 
             // add typeConstraint for mocked object. It's a declared type of the object.
-            queuedSymbolicStateUpdates += typeRegistry.typeConstraint(addr, mockedObject.typeStorage).all().asHardConstraint()
+            queuedSymbolicStateUpdates += typeRegistry.typeConstraint(addr, mockedObject.typeStorage).all()
+                .asHardConstraint()
             queuedSymbolicStateUpdates += mkEq(typeRegistry.isMock(mockedObject.addr), UtTrue).asHardConstraint()
 
             return mockedObject
@@ -1520,7 +1534,8 @@ class UtBotSymbolicEngine(
                         createObject(addr, refType, useConcreteType = true)
                     }
                 } else {
-                    queuedSymbolicStateUpdates += typeRegistry.typeConstraint(addr, TypeStorage(refType)).all().asHardConstraint()
+                    queuedSymbolicStateUpdates += typeRegistry.typeConstraint(addr, TypeStorage(refType)).all()
+                        .asHardConstraint()
 
                     objectValue(refType, addr, StringWrapper()).also {
                         initStringLiteral(it, this.value)
@@ -1643,7 +1658,11 @@ class UtBotSymbolicEngine(
         val arrayType = type.arrayType
         val arrayValue = createNewArray(value.length.toPrimitiveValue(), arrayType, type).also {
             val defaultValue = arrayType.defaultSymValue
-            queuedSymbolicStateUpdates += arrayUpdateWithValue(it.addr, arrayType, defaultValue as UtArrayExpressionBase)
+            queuedSymbolicStateUpdates += arrayUpdateWithValue(
+                it.addr,
+                arrayType,
+                defaultValue as UtArrayExpressionBase
+            )
         }
         queuedSymbolicStateUpdates += objectUpdate(
             stringWrapper.copy(typeStorage = TypeStorage(utStringClass.type)),
@@ -1807,7 +1826,8 @@ class UtBotSymbolicEngine(
             return objectValue.copy(addr = nullObjectAddr)
         }
 
-        val typeConstraint = typeRegistry.typeConstraint(castedObject.addr, castedObject.typeStorage).isOrNullConstraint()
+        val typeConstraint =
+            typeRegistry.typeConstraint(castedObject.addr, castedObject.typeStorage).isOrNullConstraint()
 
         // When we do downCast, we should add possible equality to null
         // to avoid situation like this:
@@ -1963,7 +1983,8 @@ class UtBotSymbolicEngine(
                     )
 
                     if (objectValue.type.isJavaLangObject()) {
-                        queuedSymbolicStateUpdates += typeRegistry.zeroDimensionConstraint(objectValue.addr).asSoftConstraint()
+                        queuedSymbolicStateUpdates += typeRegistry.zeroDimensionConstraint(objectValue.addr)
+                            .asSoftConstraint()
                     }
 
                     objectValue
@@ -2839,7 +2860,11 @@ class UtBotSymbolicEngine(
                 return listOf(
                     MethodResult(
                         newArray,
-                        memoryUpdates = arrayUpdateWithValue(newArray.addr, arrayType, selectArrayExpressionFromMemory(src))
+                        memoryUpdates = arrayUpdateWithValue(
+                            newArray.addr,
+                            arrayType,
+                            selectArrayExpressionFromMemory(src)
+                        )
                     )
                 )
             }
@@ -3326,8 +3351,18 @@ class UtBotSymbolicEngine(
             is JMulExpr -> when (sort.type) {
                 is ByteType -> lowerIntMulOverflowCheck(left, right, Byte.MIN_VALUE.toInt(), Byte.MAX_VALUE.toInt())
                 is ShortType -> lowerIntMulOverflowCheck(left, right, Short.MIN_VALUE.toInt(), Short.MAX_VALUE.toInt())
-                is IntType -> higherIntMulOverflowCheck(left, right, Int.SIZE_BITS, Int.MIN_VALUE.toLong()) { it: UtExpression -> it.toIntValue() }
-                is LongType -> higherIntMulOverflowCheck(left, right, Long.SIZE_BITS, Long.MIN_VALUE) { it: UtExpression -> it.toLongValue() }
+                is IntType -> higherIntMulOverflowCheck(
+                    left,
+                    right,
+                    Int.SIZE_BITS,
+                    Int.MIN_VALUE.toLong()
+                ) { it: UtExpression -> it.toIntValue() }
+                is LongType -> higherIntMulOverflowCheck(
+                    left,
+                    right,
+                    Long.SIZE_BITS,
+                    Long.MIN_VALUE
+                ) { it: UtExpression -> it.toLongValue() }
                 else -> null
             }
             else -> null
@@ -3543,11 +3578,19 @@ class UtBotSymbolicEngine(
         //choose types that have biggest priority
         resolvedParameters
             .filterIsInstance<ReferenceValue>()
-            .forEach { queuedSymbolicStateUpdates += constructConstraintForType(it, it.possibleConcreteTypes).asSoftConstraint() }
+            .forEach {
+                queuedSymbolicStateUpdates += constructConstraintForType(
+                    it,
+                    it.possibleConcreteTypes
+                ).asSoftConstraint()
+            }
 
         val returnValue = (symbolicResult as? SymbolicSuccess)?.value as? ObjectValue
         if (returnValue != null) {
-            queuedSymbolicStateUpdates += constructConstraintForType(returnValue, returnValue.possibleConcreteTypes).asSoftConstraint()
+            queuedSymbolicStateUpdates += constructConstraintForType(
+                returnValue,
+                returnValue.possibleConcreteTypes
+            ).asSoftConstraint()
 
             workaround(REMOVE_ANONYMOUS_CLASSES) {
                 val sootClass = returnValue.type.sootClass
@@ -3565,7 +3608,8 @@ class UtBotSymbolicEngine(
         }
 
         if (!isInNestedMethod()) {
-            val postConditionUpdates = postConditionConstructor.constructPostCondition(this@UtBotSymbolicEngine, symbolicResult)
+            val postConditionUpdates =
+                postConditionConstructor.constructPostCondition(this@UtBotSymbolicEngine, symbolicResult)
             queuedSymbolicStateUpdates += postConditionUpdates
         }
 
@@ -3622,7 +3666,15 @@ class UtBotSymbolicEngine(
         Predictors.testName.provide(state.path, predictedTestName, "")
 
         val resolver =
-            Resolver(hierarchy, updatedMemory, typeRegistry, typeResolver, holder, methodUnderTest.declaringClass.packageName, softMaxArraySize)
+            Resolver(
+                hierarchy,
+                updatedMemory,
+                typeRegistry,
+                typeResolver,
+                holder,
+                methodUnderTest.declaringClass.packageName,
+                softMaxArraySize
+            )
 
         val (modelsBefore, modelsAfter, instrumentation) = resolver.resolveModels(resolvedParameters)
 
@@ -3713,7 +3765,7 @@ class UtBotSymbolicEngine(
                 queuedSymbolicStateUpdates
             )
         } finally {
-             queuedSymbolicStateUpdates = prevSymbolicStateUpdate
+            queuedSymbolicStateUpdates = prevSymbolicStateUpdate
         }
     }
 }

diff --git a/utbot-framework/src/main/kotlin/org/utbot/engine/selectors/PathSelectorBuilder.kt b/utbot-framework/src/main/kotlin/org/utbot/engine/selectors/PathSelectorBuilder.kt
@@ -417,10 +417,11 @@ class ScoringPathSelectorBuilder internal constructor(
     val scoringStrategy: ScoringStrategy,
     context: PathSelectorContext = PathSelectorContext(graph)
 ) : PathSelectorBuilder<ScoringPathSelector>(graph, context) {
+    var seed: Int = 42
     override fun build() = ScoringPathSelector(
-        withDistanceStrategy(),
+        scoringStrategy,
         requireNotNull(context.stoppingStrategy) { "StoppingStrategy isn't specified" },
-        scoringStrategy
+        seed
     )
 }
 

diff --git a/utbot-framework/src/main/kotlin/org/utbot/engine/selectors/ScoringPathSelector.kt b/utbot-framework/src/main/kotlin/org/utbot/engine/selectors/ScoringPathSelector.kt
@@ -1,46 +1,22 @@
 package org.utbot.engine.selectors
 
 import org.utbot.engine.*
-import org.utbot.engine.selectors.strategies.ChoosingStrategy
+import org.utbot.engine.selectors.nurs.NonUniformRandomSearch
 import org.utbot.engine.selectors.strategies.ScoringStrategy
 import org.utbot.engine.selectors.strategies.StoppingStrategy
-import java.util.PriorityQueue
 
-open class ScoringPathSelector(
-    choosingStrategy: ChoosingStrategy,
+class ScoringPathSelector(
+    override val choosingStrategy: ScoringStrategy,
     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)
-    }
+    seed: Int? = 42
+) : NonUniformRandomSearch(choosingStrategy, stoppingStrategy, seed) {
 
-    override fun offerImpl(state: ExecutionState) {
-        scoringStrategy.score(state)
-        states.add(state)
+    init {
+        choosingStrategy.subscribe(this)
     }
 
-    override fun pollImpl(): ExecutionState? {
-        return states.poll()
-    }
+    override val ExecutionState.cost: Double
+        get() = choosingStrategy[this]
 
-    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()
-        }
-    }
+    override val name = "ScoringPathSelector"
 }