[utbot-rd]

more logs, dump mode fixes

Author: Domonion

utbot-framework/src/main/kotlin/org/utbot/framework/plugin/api/TestCaseGenerator.kt

@@ -1,6 +1,5 @@
 package org.utbot.framework.plugin.api
 
-import com.google.protobuf.compiler.PluginProtos
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.cancel
@@ -186,6 +185,7 @@ open class TestCaseGenerator(
                                 }
                         } catch (e: Exception) {
                             logger.error(e) {"Error in engine"}
+                            throw e
                         }
                     }
                     controller.paused = true
@@ -194,6 +194,7 @@ open class TestCaseGenerator(
                 // All jobs are in the method2controller now (paused). execute them with timeout
 
                 GlobalScope.launch {
+                    logger.debug("test generator global scope lifecycle check started")
                     while (isActive) {
                         var activeCount = 0
                         for ((method, controller) in method2controller) {
@@ -219,6 +220,7 @@ open class TestCaseGenerator(
                         }
                         if (activeCount == 0) break
                     }
+                    logger.debug("test generator global scope lifecycle check ended")
                 }
             }
         }

utbot-framework/src/main/kotlin/org/utbot/framework/process/EngineMain.kt

@@ -112,7 +112,9 @@ private fun EngineProcessModel.setup(
                 isFuzzingEnabled = params.isFuzzingEnabled
                 fuzzingValue = params.fuzzingValue
             })
+            .apply { logger.info("generation ended, starting summarization, result size: ${this.size}") }
             .map { it.summarize(Paths.get(params.searchDirectory)) }
+            .apply { logger.info("summarization ended") }
             .filterNot { it.executions.isEmpty() && it.errors.isEmpty() }
 
         val id = ++idCounter

utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/generator/UtTestsDialogProcessor.kt

@@ -155,25 +155,24 @@ object UtTestsDialogProcessor {
                         }
 
                         for (srcClass in model.srcClasses) {
-                            val (methods, className) = ReadAction.nonBlocking<Pair<List<ExecutableId>, String?>> {
-                                val canonicalName = srcClass.canonicalName
-                                val classId = proc.obtainClassId(canonicalName)
-                                psi2KClass[srcClass] = classId
-
-                                val srcMethods = if (model.extractMembersFromSrcClasses) {
-                                    val chosenMethods = model.selectedMembers.filter { it.member is PsiMethod }
-                                    val chosenNestedClasses =
-                                        model.selectedMembers.mapNotNull { it.member as? PsiClass }
-                                    chosenMethods + chosenNestedClasses.flatMap {
-                                        it.extractClassMethodsIncludingNested(false)
+                            val (methods, className) = DumbService.getInstance(project)
+                                .runReadActionInSmartMode(Computable {
+                                    val canonicalName = srcClass.canonicalName
+                                    val classId = proc.obtainClassId(canonicalName)
+                                    psi2KClass[srcClass] = classId
+
+                                    val srcMethods = if (model.extractMembersFromSrcClasses) {
+                                        val chosenMethods = model.selectedMembers.filter { it.member is PsiMethod }
+                                        val chosenNestedClasses =
+                                            model.selectedMembers.mapNotNull { it.member as? PsiClass }
+                                        chosenMethods + chosenNestedClasses.flatMap {
+                                            it.extractClassMethodsIncludingNested(false)
+                                        }
+                                    } else {
+                                        srcClass.extractClassMethodsIncludingNested(false)
                                     }
-                                } else {
-                                    srcClass.extractClassMethodsIncludingNested(false)
-                                }
-                                DumbService.getInstance(project).runReadActionInSmartMode(Computable {
-                                    proc.findMethodsInClassMatchingSelected(classId, srcMethods)
-                                }) to srcClass.name
-                            }.executeSynchronously()
+                                    proc.findMethodsInClassMatchingSelected(classId, srcMethods) to srcClass.name
+                                })
 
                             if (methods.isEmpty()) {
                                 logger.error { "No methods matching selected found in class $className." }

utbot-rd/src/main/kotlin/org/utbot/rd/ClientProcessUtil.kt

@@ -11,7 +11,9 @@ import com.jetbrains.rd.util.lifetime.isAlive
 import com.jetbrains.rd.util.lifetime.plusAssign
 import com.jetbrains.rd.util.threading.SingleThreadScheduler
 import com.jetbrains.rd.util.trace
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.channels.trySendBlocking
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.withTimeoutOrNull
 import org.utbot.common.*
@@ -63,21 +65,23 @@ class CallsSynchronizer(private val ldef: LifetimeDefinition, val timeout: Durat
 
     private val synchronizer: Channel<State> = Channel(1)
 
-    fun <T> measureExecutionForTermination(block: () -> T): T = runBlocking {
+    init {
+        ldef.onTermination { synchronizer.close(CancellationException("Client terminated")) }
+    }
+
+    fun <T> measureExecutionForTermination(block: () -> T): T {
         try {
-            synchronizer.send(State.STARTED)
-            return@runBlocking block()
+            synchronizer.trySendBlocking(State.STARTED)
+            return block()
         } finally {
-            synchronizer.send(State.ENDED)
+            synchronizer.trySendBlocking(State.ENDED)
         }
     }
 
     fun <T, R> measureExecutionForTermination(call: RdCall<T, R>, block: (T) -> R) {
         call.set { it ->
-            runBlocking {
-                measureExecutionForTermination {
-                    block(it)
-                }
+            measureExecutionForTermination {
+                block(it)
             }
         }
     }