[rd-factoring]

Domonion · Domonion · commit 6cecfefbeb14 · 2022-11-25T17:40:39.000+03:00
review fix
diff --git a/docs/RD for UnitTestBot.md b/docs/RD for UnitTestBot.md
@@ -138,7 +138,7 @@ Other processes ask this process for settings via RD RPC.
 
 ### Engine process
 
-`TestCaseGenerator` and `UtBotSymbolicEngine` runs here. Process classpath contains all plugin jars(more precisely - it uses plugin classpath). 
+`TestCaseGenerator` and `UtBotSymbolicEngine` run here. Process classpath contains all plugin jars(more precisely - it uses plugin classpath). 
 
 ___Must___ run on JDK, which uses project we analyze. Otherwise there will be numerous problems with code analysis, soot, reflection and 
 devirgention of generated code Java API. 
diff --git a/docs/contributing/InterProcessDebugging.md b/docs/contributing/InterProcessDebugging.md
@@ -32,7 +32,7 @@ For engine and instrumented processes you need to enable some options:
 4. Additionally, you can set additional options for JDWP agent if debug is enabled:
    * `engineProcessDebugPort` and `instrumentedProcessDebugPort` - port for debugging. 
    Default values - 5005 for Engine and 5006 for Instrumented processes. 
-   * `engineProcessDebugSuspendPolicy` and `instrumentedProcessSuspendPolicy` - whether JDWP agent should
+   * `suspendEngineProcessExecutionInDebugMode` and `suspendInstrumentedProcessExecutionInDebugMode` - whether JDWP agent should
    suspend process until debugger is connected. 
 
    More formally, if debug is enabled following switch is added to engine process JVM at start by default:
@@ -44,7 +44,7 @@ For engine and instrumented processes you need to enable some options:
    ```
    runEngineProcessWithDebug=true
    engineProcessDebugPort=12345
-   engineProcessDebugSuspendPolicy=false
+   suspendEngineProcessExecutionInDebugMode=false
    ```
    result switch will be:
    ```
diff --git a/utbot-framework-api/src/main/kotlin/org/utbot/framework/UtSettings.kt b/utbot-framework-api/src/main/kotlin/org/utbot/framework/UtSettings.kt
@@ -20,7 +20,7 @@ private const val defaultKeyForSettingsPath = "utbot.settings.path"
 /**
  * Default concrete execution timeout (in milliseconds).
  */
-const val DEFAULT_CONCRETE_EXECUTION_TIMEOUT_IN_INSTRUMENTED_PROCESS_MS = 1000L
+const val DEFAULT_EXECUTION_TIMEOUT_IN_INSTRUMENTED_PROCESS_MS = 1000L
 
 object UtSettings : AbstractSettings(
     logger, defaultKeyForSettingsPath, defaultSettingsPath
@@ -261,7 +261,7 @@ object UtSettings : AbstractSettings(
      * Timeout for specific concrete execution (in milliseconds).
      */
     var concreteExecutionTimeoutInInstrumentedProcess: Long by getLongProperty(
-        DEFAULT_CONCRETE_EXECUTION_TIMEOUT_IN_INSTRUMENTED_PROCESS_MS
+        DEFAULT_EXECUTION_TIMEOUT_IN_INSTRUMENTED_PROCESS_MS
     )
 
 // region engine process debug
@@ -274,35 +274,39 @@ object UtSettings : AbstractSettings(
     var engineProcessLogConfigFile by getStringProperty("")
 
     /**
-     * Property useful only for idea
-     * If true - runs engine process with the ability to attach a debugger
+     * The property is useful only for the IntelliJ IDEs.
+     * If the property is set in true the engine process opens a debug port.
      * @see runInstrumentedProcessWithDebug
      * @see org.utbot.intellij.plugin.process.EngineProcess
      */
     var runEngineProcessWithDebug by getBooleanProperty(false)
 
     /**
-     * Port which will be used for debugging engine process
+     * The engine process JDWP agent's port of the instrumented process.
+     * A debugger attaches to the port in order to debug the process.
      */
     var engineProcessDebugPort by getIntProperty(5005)
 
     /**
-     * Whether engine process should suspend until debugger attached
+     * Value of the suspend mode for the JDWP agent of the engine process.
+     * If the value is true, the engine process will suspend until a debugger attaches to it.
      */
-    var engineProcessDebugSuspendPolicy by getBooleanProperty(true)
+    var suspendEngineProcessExecutionInDebugMode by getBooleanProperty(true)
 
 // endregion
 
 // region instrumented process debug
     /**
-     * Port which will be used for debugging instrumented process
+     * The instrumented process JDWP agent's port of the instrumented process.
+     * A debugger attaches to the port in order to debug the process.
      */
     var instrumentedProcessDebugPort by getIntProperty(5006)
 
     /**
-     * Whether instrumented process should suspend until debugger attached
+     * Value of the suspend mode for the JDWP agent of the instrumented process.
+     * If the value is true, the instrumented process will suspend until a debugger attaches to it.
      */
-    var instrumentedProcessSuspendPolicy by getBooleanProperty(true)
+    var suspendInstrumentedProcessExecutionInDebugMode by getBooleanProperty(true)
 
     /**
      * If true, runs the instrumented process with the ability to attach a debugger.
diff --git a/utbot-framework-api/src/main/kotlin/org/utbot/framework/process/OpenModulesContainer.kt b/utbot-framework-api/src/main/kotlin/org/utbot/framework/process/OpenModulesContainer.kt
@@ -4,9 +4,9 @@ import org.utbot.framework.plugin.services.JdkInfoService
 
 object OpenModulesContainer {
     private val modulesContainer: List<String>
-    val javaVersionSpecificArguments: List<String>?
+    val javaVersionSpecificArguments: List<String>
         get() = modulesContainer
-            .takeIf { JdkInfoService.provide().version > 8 }
+            .takeIf { JdkInfoService.provide().version > 8 } ?: emptyList()
 
     init {
         modulesContainer = buildList {
diff --git a/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/domain/Domain.kt b/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/domain/Domain.kt
@@ -1,6 +1,6 @@
 package org.utbot.framework.codegen.domain
 
-import org.utbot.framework.DEFAULT_CONCRETE_EXECUTION_TIMEOUT_IN_INSTRUMENTED_PROCESS_MS
+import org.utbot.framework.DEFAULT_EXECUTION_TIMEOUT_IN_INSTRUMENTED_PROCESS_MS
 import org.utbot.framework.codegen.domain.builtin.mockitoClassId
 import org.utbot.framework.codegen.domain.builtin.ongoingStubbingClassId
 import org.utbot.framework.codegen.domain.models.CgClassId
@@ -581,7 +581,7 @@ data class HangingTestsTimeout(val timeoutMs: Long) {
     constructor() : this(DEFAULT_TIMEOUT_MS)
 
     companion object {
-        const val DEFAULT_TIMEOUT_MS = DEFAULT_CONCRETE_EXECUTION_TIMEOUT_IN_INSTRUMENTED_PROCESS_MS
+        const val DEFAULT_TIMEOUT_MS = DEFAULT_EXECUTION_TIMEOUT_IN_INSTRUMENTED_PROCESS_MS
         const val MIN_TIMEOUT_MS = 100L
         const val MAX_TIMEOUT_MS = 1_000_000L
     }
diff --git a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/ConcreteExecutor.kt b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/ConcreteExecutor.kt
@@ -242,7 +242,7 @@ class ConcreteExecutor<TIResult, TInstrumentation : Instrumentation<TIResult>> p
             val parametersByteArray = kryoHelper.writeObject(parameters)
             val params = InvokeMethodCommandParams(className, signature, argumentsByteArray, parametersByteArray)
 
-            val ba = chidlProcessModel.invokeMethodCommand.startSuspending(lifetime, params).result
+            val ba = instrumentedProcessModel.invokeMethodCommand.startSuspending(lifetime, params).result
             kryoHelper.readObject(ba)
         }
     } catch (e: Throwable) {
@@ -282,7 +282,7 @@ class ConcreteExecutor<TIResult, TInstrumentation : Instrumentation<TIResult>> p
                 if (alive) {
                     try {
                         processInstance?.run {
-                            chidlProcessModel.stopProcess.start(lifetime, Unit)
+                            instrumentedProcessModel.stopProcess.start(lifetime, Unit)
                         }
                     } catch (_: Exception) {}
                     processInstance = null
@@ -296,7 +296,7 @@ class ConcreteExecutor<TIResult, TInstrumentation : Instrumentation<TIResult>> p
 
 fun ConcreteExecutor<*,*>.warmup() = runBlocking {
     withProcess {
-        chidlProcessModel.warmup.start(lifetime, Unit)
+        instrumentedProcessModel.warmup.start(lifetime, Unit)
     }
 }
 
@@ -308,7 +308,7 @@ fun <T> ConcreteExecutor<*, *>.computeStaticField(fieldId: FieldId): Result<T> =
         val fieldIdSerialized = kryoHelper.writeObject(fieldId)
         val params = ComputeStaticFieldParams(fieldIdSerialized)
 
-        val result = chidlProcessModel.computeStaticField.startSuspending(lifetime, params)
+        val result = instrumentedProcessModel.computeStaticField.startSuspending(lifetime, params)
 
         kryoHelper.readObject(result.result)
     }
diff --git a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/coverage/CoverageInstrumentation.kt b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/coverage/CoverageInstrumentation.kt
@@ -103,6 +103,6 @@ fun ConcreteExecutor<Result<*>, CoverageInstrumentation>.collectCoverage(clazz:
     withProcess {
         val clazzByteArray = kryoHelper.writeObject(clazz)
 
-        kryoHelper.readObject(chidlProcessModel.collectCoverage.startSuspending(lifetime, CollectCoverageParams(clazzByteArray)).coverageInfo)
+        kryoHelper.readObject(instrumentedProcessModel.collectCoverage.startSuspending(lifetime, CollectCoverageParams(clazzByteArray)).coverageInfo)
     }
 }
diff --git a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/process/InstrumentedProcessRunner.kt b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/process/InstrumentedProcessRunner.kt
@@ -18,7 +18,7 @@ private val logger = KotlinLogging.logger {}
 class InstrumentedProcessRunner {
     private val cmds: List<String> by lazy {
         val debugCmd = listOfNotNull(DEBUG_RUN_CMD.takeIf { UtSettings.runInstrumentedProcessWithDebug })
-        val javaVersionSpecificArguments = OpenModulesContainer.javaVersionSpecificArguments ?: emptyList()
+        val javaVersionSpecificArguments = OpenModulesContainer.javaVersionSpecificArguments
         val pathToJava = JdkInfoService.provide().path
 
         listOf(pathToJava.resolve("bin${File.separatorChar}${osSpecificJavaExecutable()}").toString()) +
@@ -59,7 +59,7 @@ class InstrumentedProcessRunner {
     }
 
     companion object {
-        private fun suspendValue(): String = if (UtSettings.engineProcessDebugSuspendPolicy) "y" else "n"
+        private fun suspendValue(): String = if (UtSettings.suspendInstrumentedProcessExecutionInDebugMode) "y" else "n"
 
         private const val UTBOT_INSTRUMENTATION = "utbot-instrumentation"
         private const val ERRORS_FILE_PREFIX = "utbot-instrumentedprocess-errors"
diff --git a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/rd/InstrumentedProcess.kt b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/rd/InstrumentedProcess.kt
@@ -32,7 +32,7 @@ class InstrumentedProcess private constructor(
     val kryoHelper = KryoHelper(lifetime.createNested()).apply {
         classLoader?.let { setKryoClassLoader(it) }
     }
-    val chidlProcessModel: InstrumentedProcessModel = onSchedulerBlocking { protocol.instrumentedProcessModel }
+    val instrumentedProcessModel: InstrumentedProcessModel = onSchedulerBlocking { protocol.instrumentedProcessModel }
 
     companion object {
         suspend operator fun <TIResult, TInstrumentation : Instrumentation<TIResult>> invoke(
@@ -65,15 +65,15 @@ class InstrumentedProcess private constructor(
             }
 
             logger.trace("sending add paths")
-            proc.chidlProcessModel.addPaths.startSuspending(
+            proc.instrumentedProcessModel.addPaths.startSuspending(
                 proc.lifetime, AddPathsParams(
                     pathsToUserClasses,
                     pathsToDependencyClasses
                 )
             )
 
             logger.trace("sending instrumentation")
-            proc.chidlProcessModel.setInstrumentation.startSuspending(
+            proc.instrumentedProcessModel.setInstrumentation.startSuspending(
                 proc.lifetime, SetInstrumentationParams(
                     proc.kryoHelper.writeObject(instrumentation)
                 )
diff --git a/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/process/EngineProcess.kt b/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/process/EngineProcess.kt
@@ -90,7 +90,7 @@ class EngineProcess private constructor(val project: Project, rdProcess: Process
 
         private val log4j2ConfigSwitch = "-Dlog4j2.configurationFile=${log4j2ConfigFile.canonicalPath}"
 
-        private fun suspendValue(): String = if (UtSettings.engineProcessDebugSuspendPolicy) "y" else "n"
+        private fun suspendValue(): String = if (UtSettings.suspendEngineProcessExecutionInDebugMode) "y" else "n"
 
         private val debugArgument: String?
             get() = "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspendValue()},quiet=y,address=${UtSettings.engineProcessDebugPort}"
@@ -111,7 +111,10 @@ class EngineProcess private constructor(val project: Project, rdProcess: Process
         private fun obtainEngineProcessCommandLine(port: Int) = buildList {
             add(javaExecutablePathString.pathString)
             add("-ea")
-            OpenModulesContainer.javaVersionSpecificArguments?.let { addAll(it) }
+            val javaVersionSpecificArgs = vaOpenModulesContainer.javaVersionSpecificArguments
+            if (javaVersionSpecificArgs.isNotEmpty()) {
+                addAll(it)
+            }
             debugArgument?.let { add(it) }
             add(log4j2ConfigSwitch)
             add("-cp")
diff --git a/utbot-rd/src/main/kotlin/org/utbot/rd/ClientProcessUtil.kt b/utbot-rd/src/main/kotlin/org/utbot/rd/ClientProcessUtil.kt
@@ -30,7 +30,7 @@ internal fun childCreatedFileName(port: Int): String {
     return "$port.created"
 }
 
-internal fun signalInstrumentedReady(port: Int) {
+internal fun signalProcessReady(port: Int) {
     processSyncDirectory.mkdirs()
 
     val signalFile = File(processSyncDirectory, childCreatedFileName(port))
@@ -161,7 +161,7 @@ class ClientProtocolBuilder {
                 clientProtocol.block(synchronizer)
             }
 
-            signalInstrumentedReady(port)
+            signalProcessReady(port)
             logger.info { "signalled" }
             clientProtocol.synchronizationModel.synchronizationSignal.let { sync ->
                 val answerFromMainProcess = sync.adviseForConditionAsync(ldef) {
diff --git a/utbot-rd/src/main/kotlin/org/utbot/rd/RdSettingsContainer.kt b/utbot-rd/src/main/kotlin/org/utbot/rd/RdSettingsContainer.kt
@@ -35,7 +35,7 @@ class RdSettingsContainer(val logger: KLogger, val key: String, val settingsMode
                 }
 
                 override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
-                    throw NotImplementedError("Setting properties allowed only from plugin process")
+                    throw IllegalStateException("Setting properties allowed only from plugin process")
                 }
             }
         }
diff --git a/utbot-rd/src/main/kotlin/org/utbot/rd/UtRdCoroutineScope.kt b/utbot-rd/src/main/kotlin/org/utbot/rd/UtRdCoroutineScope.kt
@@ -11,7 +11,7 @@ class UtRdCoroutineScope(lifetime: Lifetime) : RdCoroutineScope(lifetime) {
     companion object {
         val current = UtRdCoroutineScope(Lifetime.Eternal)
         fun initialize() {
-            // only to initialize load and initialize class
+            // only to load and initialize class
         }
     }
 
diff --git a/utbot-rd/src/main/kotlin/org/utbot/rd/UtRdUtil.kt b/utbot-rd/src/main/kotlin/org/utbot/rd/UtRdUtil.kt
@@ -22,7 +22,6 @@ suspend fun <T> ProcessWithRdServer.onScheduler(block: () -> T): T {
 
 fun <T> ProcessWithRdServer.onSchedulerBlocking(block: () -> T): T = runBlocking { onScheduler(block) }
 
-
 fun <TReq, TRes> IRdCall<TReq, TRes>.startBlocking(req: TReq): TRes {
     val call = this
     // We do not use RdCall.sync because it requires timeouts for execution, after which request will be stopped.
@@ -75,11 +74,12 @@ suspend fun <T> IScheduler.pump(lifetime: Lifetime, block: (Lifetime) -> T): T {
 suspend fun <T> IScheduler.pump(block: (Lifetime) -> T): T = this.pump(Lifetime.Eternal, block)
 
 /**
- * Advises provided condition on source and returns Deferred,
- * which will be completed when condition satisfied, or cancelled when provided lifetime terminated.
- * If you don't need this condition no more - you can cancel deferred.
+ * Asynchronously checks the condition.
+ * The condition can be satisfied or canceled.
+ * As soon as the condition is checked, the lifetime is terminated.
+ * In order to cancel the calculation, use the function return value of Deferred type.
  *
- * N.B. in case you need timeout - wrap deferred in withTimeout coroutine builder
+ * @see kotlinx.coroutines.withTimeout coroutine builder in case you need cancel the calculation by timeout.
  */
 fun <T> ISource<T>.adviseForConditionAsync(lifetime: Lifetime, condition: (T) -> Boolean): Deferred<Unit> {
     val ldef = lifetime.createNested()
diff --git a/utbot-rd/src/main/kotlin/org/utbot/rd/exceptions/InstantProcessDeathException.kt b/utbot-rd/src/main/kotlin/org/utbot/rd/exceptions/InstantProcessDeathException.kt
@@ -1,5 +1,9 @@
 package org.utbot.rd.exceptions
 
+/**
+ * This exception is designed to be thrown any time you start child process,
+ * but
+ */
 abstract class InstantProcessDeathException(private val debugPort: Int, private val isProcessDebug: Boolean) : Exception() {
     override val message: String?
         get() {

Original file line number	Diff line number	Diff line change
`@@ -242,7 +242,7 @@ class ConcreteExecutor<TIResult, TInstrumentation : Instrumentation<TIResult>> p`
`242`	`242`	`val parametersByteArray = kryoHelper.writeObject(parameters)`
`243`	`243`	`val params = InvokeMethodCommandParams(className, signature, argumentsByteArray, parametersByteArray)`
`244`	`244`
`245`		`- val ba = chidlProcessModel.invokeMethodCommand.startSuspending(lifetime, params).result`
	`245`	`+ val ba = instrumentedProcessModel.invokeMethodCommand.startSuspending(lifetime, params).result`
`246`	`246`	`kryoHelper.readObject(ba)`
`247`	`247`	`}`
`248`	`248`	`} catch (e: Throwable) {`
`@@ -282,7 +282,7 @@ class ConcreteExecutor<TIResult, TInstrumentation : Instrumentation<TIResult>> p`
`282`	`282`	`if (alive) {`
`283`	`283`	`try {`
`284`	`284`	`processInstance?.run {`
`285`		`- chidlProcessModel.stopProcess.start(lifetime, Unit)`
	`285`	`+ instrumentedProcessModel.stopProcess.start(lifetime, Unit)`
`286`	`286`	`}`
`287`	`287`	`} catch (_: Exception) {}`
`288`	`288`	`processInstance = null`
`@@ -296,7 +296,7 @@ class ConcreteExecutor<TIResult, TInstrumentation : Instrumentation<TIResult>> p`
`296`	`296`
`297`	`297`	`fun ConcreteExecutor<,>.warmup() = runBlocking {`
`298`	`298`	`withProcess {`
`299`		`- chidlProcessModel.warmup.start(lifetime, Unit)`
	`299`	`+ instrumentedProcessModel.warmup.start(lifetime, Unit)`
`300`	`300`	`}`
`301`	`301`	`}`
`302`	`302`
`@@ -308,7 +308,7 @@ fun <T> ConcreteExecutor<, >.computeStaticField(fieldId: FieldId): Result<T> =`
`308`	`308`	`val fieldIdSerialized = kryoHelper.writeObject(fieldId)`
`309`	`309`	`val params = ComputeStaticFieldParams(fieldIdSerialized)`
`310`	`310`
`311`		`- val result = chidlProcessModel.computeStaticField.startSuspending(lifetime, params)`
	`311`	`+ val result = instrumentedProcessModel.computeStaticField.startSuspending(lifetime, params)`
`312`	`312`
`313`	`313`	`kryoHelper.readObject(result.result)`
`314`	`314`	`}`
Original file line number	Diff line number	Diff line change
`@@ -103,6 +103,6 @@ fun ConcreteExecutor<Result<*>, CoverageInstrumentation>.collectCoverage(clazz:`
`103`	`103`	`withProcess {`
`104`	`104`	`val clazzByteArray = kryoHelper.writeObject(clazz)`
`105`	`105`
`106`		`- kryoHelper.readObject(chidlProcessModel.collectCoverage.startSuspending(lifetime, CollectCoverageParams(clazzByteArray)).coverageInfo)`
	`106`	`+ kryoHelper.readObject(instrumentedProcessModel.collectCoverage.startSuspending(lifetime, CollectCoverageParams(clazzByteArray)).coverageInfo)`
`107`	`107`	`}`
`108`	`108`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ class InstrumentedProcess private constructor(`
`32`	`32`	`val kryoHelper = KryoHelper(lifetime.createNested()).apply {`
`33`	`33`	`classLoader?.let { setKryoClassLoader(it) }`
`34`	`34`	`}`
`35`		`- val chidlProcessModel: InstrumentedProcessModel = onSchedulerBlocking { protocol.instrumentedProcessModel }`
	`35`	`+ val instrumentedProcessModel: InstrumentedProcessModel = onSchedulerBlocking { protocol.instrumentedProcessModel }`
`36`	`36`
`37`	`37`	`companion object {`
`38`	`38`	`suspend operator fun <TIResult, TInstrumentation : Instrumentation<TIResult>> invoke(`
`@@ -65,15 +65,15 @@ class InstrumentedProcess private constructor(`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`logger.trace("sending add paths")`
`68`		`- proc.chidlProcessModel.addPaths.startSuspending(`
	`68`	`+ proc.instrumentedProcessModel.addPaths.startSuspending(`
`69`	`69`	`proc.lifetime, AddPathsParams(`
`70`	`70`	`pathsToUserClasses,`
`71`	`71`	`pathsToDependencyClasses`
`72`	`72`	`)`
`73`	`73`	`)`
`74`	`74`
`75`	`75`	`logger.trace("sending instrumentation")`
`76`		`- proc.chidlProcessModel.setInstrumentation.startSuspending(`
	`76`	`+ proc.instrumentedProcessModel.setInstrumentation.startSuspending(`
`77`	`77`	`proc.lifetime, SetInstrumentationParams(`
`78`	`78`	`proc.kryoHelper.writeObject(instrumentation)`
`79`	`79`	`)`