restruct statistics by projects

Author: SBOne-Kenobi

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

@@ -61,40 +61,39 @@ private fun findAllNotExportedPackages(report: String): List<UnnamedPackageInfo>
 }
 
 private fun compileClass(testDir: String, classPath: String, testClass: String): Int {
-    val opens = mutableSetOf<UnnamedPackageInfo>()
+    val exports = mutableSetOf<UnnamedPackageInfo>()
     var exitCode = 0
-    var errors = ""
 
     repeat(triesToCompile) { tryNumber ->
-        logger.debug { "Compile try ${tryNumber + 1}" }
         val cmd = arrayOf(
             javacCmd,
-            *opens.flatMap {
-                listOf("--add-opens", "${it.module}/${it.pack}=ALL-UNNAMED")
+            *exports.flatMap {
+                listOf("--add-exports", "${it.module}/${it.pack}=ALL-UNNAMED")
             }.toTypedArray(),
             "-d", testDir,
             "-cp", classPath,
             "-nowarn",
             "-XDignore.symbol.file",
             testClass
         )
+        logger.debug { "Compile try ${tryNumber + 1}" }
 
         logger.trace { cmd.toText() }
+
         val process = Runtime.getRuntime().exec(cmd)
 
-        errors = process.errorStream.reader().buffered().readText()
+        val errors = process.errorStream.reader().buffered().readText()
 
         exitCode = process.waitFor()
         if (exitCode == 0) {
             return 0
         } else {
-            opens += findAllNotExportedPackages(errors)
+            if (errors.isNotEmpty())
+                logger.error { "Compilation errors: $errors" }
+            exports += findAllNotExportedPackages(errors)
         }
     }
 
-    if (errors.isNotEmpty())
-        logger.error { "Compilation errors: $errors" }
-
     return exitCode
 }
 
@@ -135,7 +134,7 @@ enum class Tool {
             timeLimit: Long,
             fuzzingRatio: Double,
             methodNameFilter: String?,
-            globalStats: GlobalStats,
+            statsForProject: StatsForProject,
             compiledTestDir: File,
             classFqn: String
         ) {
@@ -160,7 +159,7 @@ enum class Tool {
                 return
             }
 
-            globalStats.statsForClasses.add(classStats)
+            statsForProject.statsForClasses.add(classStats)
 
             try {
                 val testClass = cut.generatedTestFile
@@ -206,7 +205,7 @@ enum class Tool {
             timeLimit: Long,
             fuzzingRatio: Double,
             methodNameFilter: String?,
-            globalStats: GlobalStats,
+            statsForProject: StatsForProject,
             compiledTestDir: File,
             classFqn: String
         ) {
@@ -277,7 +276,7 @@ enum class Tool {
         timeLimit: Long,
         fuzzingRatio: Double, // maybe create some specific settings
         methodNameFilter: String?,
-        globalStats: GlobalStats,
+        statsForProject: StatsForProject,
         compiledTestDir: File,
         classFqn: String
     )
@@ -432,6 +431,9 @@ fun runEstimator(
             outer@ for (project in projects) {
                 if (projectFilter != null && project.name !in projectFilter) continue
 
+                val statsForProject = StatsForProject(project.name)
+                globalStats.projectStats.add(statsForProject)
+
                 logger.info { "------------- project [${project.name}] ---- " }
 
                 // take all the classes from the corresponding jar if a list of the specified classes is empty
@@ -453,7 +455,7 @@ fun runEstimator(
 
                     logger.info { "------------- [${project.name}] ---->--- [$classIndex:$classFqn] ---------------------" }
 
-                    tool.run(project, cut, timeLimit, fuzzingRatio, methodNameFilter, globalStats, compiledTestDir, classFqn)
+                    tool.run(project, cut, timeLimit, fuzzingRatio, methodNameFilter, statsForProject, compiledTestDir, classFqn)
                 }
             }
         }

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

@@ -12,13 +12,16 @@ private fun Double.format(digits: Int) = "%.${digits}f".format(this)
 fun <T> Iterable<T>.printMultiline(printer: (T) -> Any?) = "\n" + joinToString("\n") { "${printer(it)}" } + "\n"
 
 class GlobalStats {
+    val projectStats = mutableListOf<StatsForProject>()
+    var duration: Long? = null
+}
+
+class StatsForProject(val project: String) {
 
     companion object {
         const val PRECISION: Int = 2
     }
 
-    var duration: Long? = null
-
     val statsForClasses = mutableListOf<StatsForClass>()
 
     val classesForGeneration: Int

utbot-junit-contest/src/main/kotlin/org/utbot/monitoring/MonitoringReport.kt

@@ -7,21 +7,17 @@ import org.utbot.contest.StatsForClass
 @Serializable
 data class MonitoringReport(
     val parameters: MonitoringParameters,
-    val summarised_metrics: SummarisedMetricsReport,
     val targets: List<TargetReport>,
 ) {
-    constructor(parameters: MonitoringParameters, targets: List<TargetReport>): this(
-        parameters,
-        SummarisedMetricsReport(targets),
-        targets
-    )
 
     constructor(parameters: MonitoringParameters, stats: GlobalStats) : this(
         parameters,
-        stats.statsForClasses.map {
+        stats.projectStats.map { projectStats ->
             TargetReport(
-                TargetDescription(it.project, it.className),
-                ClassMetricsReport(it)
+                projectStats.project,
+                projectStats.statsForClasses.map {
+                    ClassReport(it.className, ClassMetricsReport(it))
+                }
             )
         }
     )
@@ -36,14 +32,21 @@ data class MonitoringParameters(
 
 @Serializable
 data class TargetReport(
-    val target: TargetDescription,
-    val metrics: ClassMetricsReport
-)
+    val target: String,
+    val summarised_metrics: SummarisedMetricsReport,
+    val metrics_by_class: List<ClassReport>
+) {
+    constructor(target: String, metrics_by_class: List<ClassReport>): this(
+        target,
+        SummarisedMetricsReport(metrics_by_class),
+        metrics_by_class
+    )
+}
 
 @Serializable
-data class TargetDescription(
-    val project: String,
-    val classname: String
+data class ClassReport(
+    val class_name: String,
+    val metrics: ClassMetricsReport
 )
 
 private fun Int.cover(total: Int): Double =
@@ -100,7 +103,7 @@ data class SummarisedMetricsReport(
     val bytecode_instructions_coverage_by_concolic: Double = covered_bytecode_instructions_by_concolic.cover(total_bytecode_instructions),
     val averaged_bytecode_instruction_coverage_by_classes: Double
 ) {
-    constructor(targets: Collection<TargetReport>) : this(
+    constructor(targets: Collection<ClassReport>) : this(
         total_classes = targets.size,
         testcases_generated = targets.sumOf { it.metrics.testcases_generated },
         classes_failed_to_compile = targets.count { it.metrics.failed_to_compile },

utbot-junit-contest/src/main/kotlin/org/utbot/monitoring/StatisticsMonitoring.kt

@@ -21,6 +21,8 @@ private val javaHome = System.getenv("JAVA_HOME")
 private val logger = KotlinLogging.logger {}
 
 fun main(args: Array<String>) {
+    val outputFile = args.getOrNull(0)?.let { File(it) }
+
     logger.info { "Monitoring Settings:\n$MonitoringSettings" }
 
     val methodFilter: String?
@@ -75,7 +77,6 @@ fun main(args: Array<String>) {
     if (measurementResults.isEmpty())
         exitProcess(1)
 
-    val outputFile = args.getOrNull(0)?.let { File(it) }
     outputFile?.let { file ->
         val format = Json { prettyPrint = true }
         val jsonString = format.encodeToString(measurementResults)