optimize coverage storage

Author: Rustam Sadykov

utbot-junit-contest/src/main/kotlin/org/utbot/contest/Contest.kt

@@ -483,29 +483,26 @@ internal val Method.isVisibleFromGeneratedTest: Boolean
             && (this.modifiers and Modifier.NATIVE) == 0
 
 private fun StatsForClass.updateCoverage(newCoverage: Coverage, isNewClass: Boolean, fromFuzzing: Boolean) {
-    coverage = coverage.update(newCoverage, isNewClass)
+    coverage.update(newCoverage, isNewClass)
     // other coverage type updates by empty coverage to respect new class
     val emptyCoverage = newCoverage.copy(
         coveredInstructions = emptyList()
     )
     if (fromFuzzing) {
-        fuzzedCoverage = fuzzedCoverage.update(newCoverage, isNewClass)
-        concolicCoverage = concolicCoverage.update(emptyCoverage, isNewClass)
+        fuzzedCoverage to concolicCoverage
     } else {
-        fuzzedCoverage = fuzzedCoverage.update(emptyCoverage, isNewClass)
-        concolicCoverage = concolicCoverage.update(newCoverage, isNewClass)
+        concolicCoverage to fuzzedCoverage
+    }.let { (targetSource, otherSource) ->
+        targetSource.update(newCoverage, isNewClass)
+        otherSource.update(emptyCoverage, isNewClass)
     }
 }
 
-private fun Coverage?.update(newCoverage: Coverage, isNewClass: Boolean) =
-    this?.let { oldCoverage ->
-        val instructionsCount = if (isNewClass && newCoverage.instructionsCount != null) {
-            newCoverage.instructionsCount!! + (oldCoverage.instructionsCount ?: 0)
-        } else {
-            oldCoverage.instructionsCount
+private fun CoverageInstructionsSet.update(newCoverage: Coverage, isNewClass: Boolean) {
+    if (isNewClass) {
+        newCoverage.instructionsCount?.let {
+            totalInstructions += it
         }
-        Coverage(
-            coveredInstructions = oldCoverage.coveredInstructions + newCoverage.coveredInstructions,
-            instructionsCount = instructionsCount
-        )
-    } ?: newCoverage
+    }
+    coveredInstructions.addAll(newCoverage.coveredInstructions)
+}

utbot-junit-contest/src/main/kotlin/org/utbot/contest/Statistics.kt

@@ -1,10 +1,10 @@
 package org.utbot.contest
 
+import java.io.File
 import org.utbot.common.MutableMultiset
 import org.utbot.common.mutableMultisetOf
+import org.utbot.framework.plugin.api.Instruction
 import org.utbot.framework.plugin.api.UtError
-import org.utbot.framework.plugin.api.Coverage
-import java.io.File
 
 private fun Double.format(digits: Int) = "%.${digits}f".format(this)
 
@@ -55,11 +55,11 @@ class GlobalStats {
         get() = statsForClasses.sumBy { it.concolicCoverage.getCoverageInfo(it.className).covered }
 
     val totalInstructionsCount: Int
-        get() = statsForClasses.sumBy { it.coverage?.instructionsCount?.toInt() ?: 0 }
+        get() = statsForClasses.sumBy { it.coverage.totalInstructions.toInt() }
 
     val avgCoverage: Double
         get() = statsForClasses
-            .filter { it.coverage?.instructionsCount?.let { cnt -> cnt != 0L } ?: false }
+            .filter { it.coverage.totalInstructions != 0L }
             .map { it.coverage.getCoverageInfo(it.className).run { if (total == 0) 0.0 else 100.0 * covered / total } }
             .average()
 
@@ -114,11 +114,11 @@ class StatsForClass(val className: String) {
     val methodsWithAtLeastOneException: Int get() = statsForMethods.count { it.failReasons.isNotEmpty() }
     val testcasesGenerated: Int get() = statsForMethods.sumBy { it.testsGeneratedCount }
 
-    var coverage: Coverage? = null
-    var fuzzedCoverage: Coverage? = null
-    var concolicCoverage: Coverage? = null
+    var coverage = CoverageInstructionsSet()
+    var fuzzedCoverage = CoverageInstructionsSet()
+    var concolicCoverage = CoverageInstructionsSet()
 
-    private fun Coverage?.prettyInfo(): String =
+    private fun CoverageInstructionsSet.prettyInfo(): String =
         getCoverageInfo(className).run { "$covered/$total" }
 
     override fun toString(): String = "\n<StatsForClass> :" +
@@ -178,13 +178,18 @@ class FailReason(private val throwable: Throwable) {
 
 }
 
+data class CoverageInstructionsSet(
+    val coveredInstructions: MutableSet<Instruction> = mutableSetOf(),
+    var totalInstructions: Long = 0
+)
+
 data class CoverageStatistic(val covered: Int, val total: Int)
 
-private fun Coverage?.getCoverageInfo(className: String): CoverageStatistic = this?.run {
+private fun CoverageInstructionsSet?.getCoverageInfo(className: String): CoverageStatistic = this?.run {
     CoverageStatistic(
         coveredInstructions.filter {
             instr -> instr.className.startsWith(className)
         }.toSet().size,
-        instructionsCount?.toInt() ?: 0
+        totalInstructions.toInt()
     )
 } ?: CoverageStatistic(covered = 0, total = 0)