Use execution source priority as a secondary sort key

Author: dtim

utbot-framework-test/src/test/kotlin/org/utbot/framework/minimization/MinimizationGreedyEssentialTest.kt

@@ -9,19 +9,19 @@ import org.junit.jupiter.api.Test
 class MinimizationGreedyEssentialTest {
     @Test
     fun testEmpty() {
-        val executions = emptyMap<Int, List<Int>>()
+        val executions = emptyMap<Int, Pair<Int, List<Int>>>()
         val minimizedExecutions = GreedyEssential.minimize(executions)
         assertTrue(minimizedExecutions.isEmpty())
     }
 
     @Test
     fun testCustom1() {
         val executions = mapOf(
-            1 to listOf(1, 2, 3, 4, 5),
-            2 to listOf(2, 3, 4, 5, 6, 7),
-            3 to listOf(1, 7),
-            4 to listOf(8),
-            5 to listOf(1, 8)
+            1 to (0 to listOf(1, 2, 3, 4, 5)),
+            2 to (0 to listOf(2, 3, 4, 5, 6, 7)),
+            3 to (0 to listOf(1, 7)),
+            4 to (0 to listOf(8)),
+            5 to (0 to listOf(1, 8))
         )
         val minimizedExecutions = GreedyEssential.minimize(executions)
         assertEquals(listOf(2, 5), minimizedExecutions)
@@ -30,11 +30,11 @@ class MinimizationGreedyEssentialTest {
     @Test
     fun testCustom2() {
         val executions = mapOf(
-            10 to listOf(1, 2, 3, 4, 5),
-            20 to listOf(2, 3, 4, 5, 6, 7),
-            21 to listOf(1, 7, 2, 3, 5),
-            24 to listOf(8, 5, 6, 7),
-            50 to listOf(1, 8)
+            10 to (0 to listOf(1, 2, 3, 4, 5)),
+            20 to (0 to listOf(2, 3, 4, 5, 6, 7)),
+            21 to (0 to listOf(1, 7, 2, 3, 5)),
+            24 to (0 to listOf(8, 5, 6, 7)),
+            50 to (0 to listOf(1, 8))
         )
         val minimizedExecutions = GreedyEssential.minimize(executions)
         assertEquals(listOf(20, 50), minimizedExecutions)
@@ -44,9 +44,9 @@ class MinimizationGreedyEssentialTest {
     fun testBigExecutionAndSmallExecutions() {
         val size = 10000
         val executions = (1..size)
-            .associateWith { listOf(it, it + size, it + 2 * size) }
+            .associateWith { 0 to listOf(it, it + size, it + 2 * size) }
             .toMutableMap().apply {
-                put(0, (1..3 * size).toList())
+                put(0, 0 to (1..3 * size).toList())
             }
         val minimizedExecutions = GreedyEssential.minimize(executions)
         assertEquals(listOf(0), minimizedExecutions.sorted())
@@ -56,15 +56,15 @@ class MinimizationGreedyEssentialTest {
     fun testSameSizeExecutions() {
         val size = 2000
         val executionSize = 100
-        val executions = (0 until size).associateWith { (it until min(size, it + executionSize)).toList() }
+        val executions = (0 until size).associateWith { 0 to (it until min(size, it + executionSize)).toList() }
         val minimizedExecutions = GreedyEssential.minimize(executions)
         assertEquals(fromClosedRange(0, size - 1, executionSize).toList(), minimizedExecutions.sorted())
     }
 
     @Test
     fun testManyExcluding() {
         val size = 10000
-        val executions = (1..size).associateWith { listOf(it, it + size, it + 2 * size) }
+        val executions = (1..size).associateWith { 0 to listOf(it, it + size, it + 2 * size) }
         val minimizedExecutions = GreedyEssential.minimize(executions)
         assertEquals((1..size).toList(), minimizedExecutions.sorted())
     }

utbot-framework/src/main/kotlin/org/utbot/framework/minimization/GreedyEssential.kt

@@ -1,34 +1,58 @@
 package org.utbot.framework.minimization
 
+import org.utbot.framework.UtSettings
 import java.util.PriorityQueue
 
-private inline class ExecutionNumber(val number: Int)
+@JvmInline
+private value class ExecutionNumber(val number: Int)
 
-private inline class LineNumber(val number: Int)
+@JvmInline
+private value class LineNumber(val number: Int)
+
+@JvmInline
+private value class SourcePriority(val number: Int)
+
+private data class CoveredLinesWithSourcePriority(
+    val sourcePriority: SourcePriority,
+    val coveredLines: List<LineNumber>
+)
 
 /**
  * [Greedy essential algorithm](CONFLUENCE:Test+Minimization)
  */
 class GreedyEssential private constructor(
-    executionToCoveredLines: Map<ExecutionNumber, List<LineNumber>>
+    executionToCoveredLines: Map<ExecutionNumber, CoveredLinesWithSourcePriority>
 ) {
+    private val executionToSourcePriority: Map<ExecutionNumber, SourcePriority> =
+        executionToCoveredLines
+            .mapValues { it.value.sourcePriority }
+
     private val executionToUsefulLines: Map<ExecutionNumber, MutableSet<LineNumber>> =
         executionToCoveredLines
-            .mapValues { it.value.toMutableSet() }
+            .mapValues { it.value.coveredLines.toMutableSet() }
 
     private val lineToUnusedCoveringExecutions: Map<LineNumber, MutableSet<ExecutionNumber>> =
         executionToCoveredLines
-            .flatMap { (execution, lines) -> lines.map { it to execution } }
+            .flatMap { (execution, lines) -> lines.coveredLines.map { it to execution } }
             .groupBy({ it.first }) { it.second }
             .mapValues { it.value.toMutableSet() }
 
+    private val executionComparator = if (UtSettings.preferSymbolicExecutionsDuringMinimization) {
+        compareByDescending<Triple<ExecutionNumber, Int, SourcePriority>> { it.second }
+            .thenBy { it.third.number }
+            .thenBy { it.first.number }
+    } else {
+        compareByDescending<Triple<ExecutionNumber, Int, SourcePriority>> { it.second }
+            .thenBy { it.first.number }
+    }
+
     private val executionByPriority =
-        PriorityQueue(compareByDescending<Pair<ExecutionNumber, Int>> { it.second }.thenBy { it.first.number })
+        PriorityQueue(executionComparator)
             .apply {
                 addAll(
                     executionToCoveredLines
                         .keys
-                        .map { it to executionToUsefulLines[it]!!.size }
+                        .map { Triple(it, executionToUsefulLines[it]!!.size, executionToSourcePriority[it]!!) }
                 )
             }
 
@@ -69,7 +93,7 @@ class GreedyEssential private constructor(
     }
 
     private fun executionToPriority(execution: ExecutionNumber) =
-        execution to executionToUsefulLines[execution]!!.size
+        Triple(execution, executionToUsefulLines[execution]!!.size, executionToSourcePriority[execution]!!)
 
     private fun removeLineFromExecution(execution: ExecutionNumber, line: LineNumber) {
         executionByPriority.remove(executionToPriority(execution))
@@ -89,10 +113,15 @@ class GreedyEssential private constructor(
          *
          * @return retained execution ids.
          */
-        fun minimize(executions: Map<Int, List<Int>>): List<Int> {
+        fun minimize(executions: Map<Int, Pair<Int, List<Int>>>): List<Int> {
             val convertedExecutions = executions
                 .entries
-                .associate { (execution, lines) -> ExecutionNumber(execution) to lines.map { LineNumber(it) } }
+                .associate { (execution, coveredLinesWithSourcePriority) ->
+                    ExecutionNumber(execution) to CoveredLinesWithSourcePriority(
+                        SourcePriority(coveredLinesWithSourcePriority.first),
+                        coveredLinesWithSourcePriority.second.map { LineNumber(it) }
+                    )
+                }
 
             val prioritizer = GreedyEssential(convertedExecutions)
             val list = mutableListOf<ExecutionNumber>()

utbot-framework/src/main/kotlin/org/utbot/framework/minimization/Minimization.kt

@@ -13,11 +13,14 @@ 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.UtExecutionResult
+import org.utbot.framework.plugin.api.UtFailedExecution
 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.UtStatementModel
+import org.utbot.framework.plugin.api.UtSymbolicExecution
 import org.utbot.framework.plugin.api.UtVoidModel
+import org.utbot.fuzzer.UtFuzzedExecution
 
 
 /**
@@ -64,6 +67,13 @@ fun minimizeExecutions(executions: List<UtExecution>): List<UtExecution> {
     }
 }
 
+private fun UtExecution.getSourcePriority(): Int = when (this) {
+    is UtSymbolicExecution -> 0
+    is UtFuzzedExecution -> 1
+    is UtFailedExecution -> 2
+    else -> 3
+}
+
 /**
  * Groups the [executions] by their `paths` on `first` [branchInstructionsNumber] `branch` instructions.
  *
@@ -144,11 +154,11 @@ private fun <T : Any> groupExecutionsByTestSuite(
 /**
  * Builds a mapping from execution id to edges id.
  */
-private fun buildMapping(executions: List<UtExecution>): Map<Int, List<Int>> {
+private fun buildMapping(executions: List<UtExecution>): Map<Int, Pair<Int, List<Int>>> {
     // (inst1, instr2) -> edge id --- edge represents as a pair of instructions, which are connected by this edge
     val allCoveredEdges = mutableMapOf<Pair<Long, Long>, Int>()
     val thrownExceptions = mutableMapOf<String, Long>()
-    val mapping = mutableMapOf<Int, List<Int>>()
+    val mapping = mutableMapOf<Int, Pair<Int, List<Int>>>()
 
 
     executions.forEachIndexed { idx, execution ->
@@ -167,7 +177,7 @@ private fun buildMapping(executions: List<UtExecution>): Map<Int, List<Int>> {
                 for (i in 0 until instructions.size - 1) {
                     edges += allCoveredEdges[instructions[i] to instructions[i + 1]]!!
                 }
-                mapping[idx] = edges
+                mapping[idx] = execution.getSourcePriority() to edges
             }
         }
     }