Android Studio fixes (#634, #635)

Multiple test modules supported.
Removed unused jdkVersion from model, added for convenience to JdkPathService.
Removed unnecessary classpath modification parts for Android.

Author: nikitavlaev

utbot-framework-api/src/main/kotlin/org/utbot/framework/JdkPathDefaultProvider.kt

@@ -6,4 +6,7 @@ import java.nio.file.Paths
 open class JdkPathDefaultProvider: JdkPathProvider() {
     override val jdkPath: Path
         get() = Paths.get(System.getProperty("java.home"))
+
+    override val jdkVersion: String
+        get() = System.getProperty("java.version")
 }

utbot-framework-api/src/main/kotlin/org/utbot/framework/JdkPathProvider.kt

@@ -9,4 +9,6 @@ abstract class JdkPathProvider {
     }
 
     abstract val jdkPath: Path
+
+    abstract val jdkVersion: String
 }

utbot-framework-api/src/main/kotlin/org/utbot/framework/JdkPathService.kt

@@ -16,4 +16,7 @@ object JdkPathService {
     // Kotlin delegates do not support changing in runtime, so use simple getter
     val jdkPath: Path
         get() = jdkPathProvider.jdkPath
+
+    val jdkVersion: String
+        get() = jdkPathProvider.jdkVersion
 }

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

@@ -39,9 +39,7 @@ import org.utbot.framework.plugin.api.util.withUtContext
 import org.utbot.intellij.plugin.generator.CodeGenerationController.generateTests
 import org.utbot.intellij.plugin.models.GenerateTestsModel
 import org.utbot.intellij.plugin.ui.GenerateTestsDialogWindow
-import org.utbot.intellij.plugin.ui.utils.jdkVersion
 import org.utbot.intellij.plugin.ui.utils.showErrorDialogLater
-import org.utbot.intellij.plugin.ui.utils.testModule
 import org.utbot.intellij.plugin.util.AndroidApiHelper
 import org.utbot.intellij.plugin.util.PluginJdkPathProvider
 import org.utbot.intellij.plugin.util.signature
@@ -56,6 +54,7 @@ import org.utbot.engine.util.mockListeners.ForceStaticMockListener
 import org.utbot.framework.plugin.api.testFlow
 import org.utbot.intellij.plugin.settings.Settings
 import org.utbot.intellij.plugin.util.isAbstract
+import org.utbot.intellij.plugin.ui.utils.testModules
 import kotlin.reflect.KClass
 import kotlin.reflect.full.functions
 
@@ -79,23 +78,15 @@ object UtTestsDialogProcessor {
         focusedMethod: MemberInfo?,
     ): GenerateTestsDialogWindow? {
         val srcModule = findSrcModule(srcClasses)
-        val testModule = srcModule.testModule(project)
-
-        JdkPathService.jdkPathProvider = PluginJdkPathProvider(project, testModule)
-        val jdkVersion = try {
-            testModule.jdkVersion()
-        } catch (e: IllegalStateException) {
-            // Just ignore it here, notification will be shown in
-            // org.utbot.intellij.plugin.ui.utils.ModuleUtilsKt.jdkVersionBy
-            return null
-        }
+        val testModules = srcModule.testModules(project)
+
+        JdkPathService.jdkPathProvider = PluginJdkPathProvider(project)
 
         return GenerateTestsDialogWindow(
             GenerateTestsModel(
                 project,
                 srcModule,
-                testModule,
-                jdkVersion,
+                testModules,
                 srcClasses,
                 if (focusedMethod != null) setOf(focusedMethod) else null,
                 UtSettings.utBotGenerationTimeoutInMillis,
@@ -286,12 +277,6 @@ object UtTestsDialogProcessor {
         val pathsList = OrderEnumerator.orderEntries(srcModule).recursively().pathsList
 
         val (classpath, classpathList) = if (AndroidApiHelper.isAndroidStudio()) {
-            // Add $JAVA_HOME/jre/lib/rt.jar to path.
-            // This allows Soot to analyze real java instead of stub version in Android SDK on local machine.
-            pathsList.add(
-                System.getenv("JAVA_HOME") + File.separator + Paths.get("jre", "lib", "rt.jar")
-            )
-
             // Filter out manifests from classpath.
             val filterPredicate = { it: String ->
                 !it.contains("manifest", ignoreCase = true)

utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/models/GenerateTestsModel.kt

@@ -11,26 +11,40 @@ import org.utbot.framework.plugin.api.CodegenLanguage
 import org.utbot.framework.plugin.api.MockFramework
 import org.utbot.framework.plugin.api.MockStrategyApi
 import com.intellij.openapi.module.Module
+import com.intellij.openapi.module.ModuleUtil
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.projectRoots.JavaSdkVersion
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.PsiClass
 import com.intellij.refactoring.util.classMembers.MemberInfo
 import org.jetbrains.kotlin.idea.core.getPackage
 import org.utbot.framework.util.ConflictTriggers
+import org.utbot.intellij.plugin.ui.utils.jdkVersion
 
 data class GenerateTestsModel(
     val project: Project,
     val srcModule: Module,
-    val testModule: Module,
-    val jdkVersion: JavaSdkVersion,
+    val potentialTestModules: List<Module>,
     var srcClasses: Set<PsiClass>,
     var selectedMethods: Set<MemberInfo>?,
     var timeout:Long,
     var generateWarningsForStaticMocking: Boolean = false,
     var fuzzingValue: Double = 0.05
 ) {
+    var testModule: Module = potentialTestModules.first()
+    val jdkVersion: JavaSdkVersion?
+        get() = try {
+            testModule.jdkVersion()
+        } catch (e: IllegalStateException) {
+            null
+        }
+
     var testSourceRoot: VirtualFile? = null
+        set(value) {
+            requireNotNull(value)
+            testModule = ModuleUtil.findModuleForFile(value, project) ?: error("Could not find module for $value")
+            field = value
+        }
     var testPackageName: String? = null
     lateinit var testFramework: TestFramework
     lateinit var mockStrategy: MockStrategyApi

utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/ui/GenerateTestsDialogWindow.kt

@@ -10,6 +10,7 @@ import com.intellij.openapi.command.WriteCommandAction
 import com.intellij.openapi.components.service
 import com.intellij.openapi.editor.colors.EditorColorsManager
 import com.intellij.openapi.module.Module
+import com.intellij.openapi.module.ModuleUtil
 import com.intellij.openapi.options.ShowSettingsUtil
 import com.intellij.openapi.projectRoots.JavaSdkVersion
 import com.intellij.openapi.roots.ContentEntry
@@ -510,6 +511,8 @@ class GenerateTestsDialogWindow(val model: GenerateTestsModel) : DialogWrapper(m
     private fun createTestRootAndPackages(): Boolean {
         model.testSourceRoot = createDirectoryIfMissing(model.testSourceRoot)
         val testSourceRoot = model.testSourceRoot ?: return false
+        model.testModule = ModuleUtil.findModuleForFile(testSourceRoot, model.project) ?: error("Could not find module")
+
         if (model.testSourceRoot?.isDirectory != true) return false
         if (getOrCreateTestRoot(testSourceRoot)) {
             if (cbSpecifyTestPackage.isSelected) {

utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/ui/components/TestFolderComboWithBrowseButton.kt

@@ -3,6 +3,7 @@ package org.utbot.intellij.plugin.ui.components
 import com.intellij.openapi.application.ReadAction
 import com.intellij.openapi.fileChooser.FileChooser
 import com.intellij.openapi.fileChooser.FileChooserDescriptor
+import com.intellij.openapi.module.ModuleUtil
 import com.intellij.openapi.project.guessProjectDir
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.openapi.vfs.newvfs.impl.FakeVirtualFile
@@ -50,8 +51,11 @@ class TestFolderComboWithBrowseButton(private val model: GenerateTestsModel) : C
             }
         }
 
-        val testRoots = model.testModule.suitableTestSourceRoots().toMutableList()
-        model.testModule.addDedicatedTestRoot(testRoots)
+        // this part is blocked for Gradle, where multiple test modules can exist
+        val defaultModuleTestRoots = model.testModule.suitableTestSourceRoots().toMutableList()
+        model.testModule.addDedicatedTestRoot(defaultModuleTestRoots)
+
+        val testRoots = model.potentialTestModules.flatMap { it.suitableTestSourceRoots().toMutableList() }
         if (testRoots.isNotEmpty()) {
             configureRootsCombo(testRoots)
         } else {

utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/ui/utils/ModuleUtils.kt

@@ -83,35 +83,37 @@ fun Module.getOrCreateSarifReportsPath(testSourceRoot: VirtualFile?): Path {
 }
 
 /**
- * Find test module by current source module.
+ * Find test modules by current source module.
  */
-fun Module.testModule(project: Project): Module {
-    var testModule = findPotentialModuleForTests(project, this)
-    val testRootUrls = testModule.suitableTestSourceRoots()
+fun Module.testModules(project: Project): List<Module> {
+    var testModules = findPotentialModulesForTests(project, this)
+    val testRootUrls = testModules.flatMap { it.suitableTestSourceRoots() }
 
     //if no suitable module for tests is found, create tests in the same root
-    if (testRootUrls.isEmpty() && testModule.suitableTestSourceFolders().isEmpty()) {
-        testModule = this
+    if (testRootUrls.isEmpty() && testModules.flatMap { it.suitableTestSourceFolders() }.isEmpty()) {
+        testModules = listOf(this)
     }
-    return testModule
+    return testModules
 }
 
-private fun findPotentialModuleForTests(project: Project, srcModule: Module): Module {
+private fun findPotentialModulesForTests(project: Project, srcModule: Module): List<Module> {
+    val modules = mutableListOf<Module>()
     for (module in ModuleManager.getInstance(project).modules) {
         if (srcModule == TestModuleProperties.getInstance(module).productionModule) {
-            return module
+            modules += module
         }
     }
+    if (modules.isNotEmpty()) return modules
 
     if (srcModule.suitableTestSourceFolders().isEmpty()) {
         val modules = mutableSetOf<Module>()
         ModuleUtilCore.collectModulesDependsOn(srcModule, modules)
         modules.remove(srcModule)
 
         val modulesWithTestRoot = modules.filter { it.suitableTestSourceFolders().isNotEmpty() }
-        if (modulesWithTestRoot.size == 1) return modulesWithTestRoot[0]
+        if (modulesWithTestRoot.size == 1) return modulesWithTestRoot
     }
-    return srcModule
+    return listOf(srcModule)
 }
 
 /**

utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/util/PluginJdkPathProvider.kt

@@ -2,31 +2,35 @@ package org.utbot.intellij.plugin.util
 
 import org.utbot.common.PathUtil.toPath
 import org.utbot.framework.JdkPathDefaultProvider
-import com.intellij.openapi.module.Module
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.projectRoots.ProjectJdkTable
-import com.intellij.openapi.roots.ModuleRootManager
+import com.intellij.openapi.projectRoots.Sdk
 import com.intellij.openapi.roots.ProjectRootManager
 import java.nio.file.Path
 
 class PluginJdkPathProvider(
-    private val project: Project,
-    private val testModule: Module,
+    private val project: Project
 ) : JdkPathDefaultProvider() {
 
-    override val jdkPath: Path
-        get() =
+    private val sdk: Sdk?
+        get() {
             if (AndroidApiHelper.isAndroidStudio()) {
                 // Get Gradle JDK for Android
                 AndroidApiHelper.gradleSDK(project)
                     ?.let { sdkName ->
-                        ProjectJdkTable.getInstance().findJdk(sdkName)?.homePath?.toPath()
+                        ProjectJdkTable.getInstance().findJdk(sdkName) ?.let {
+                            return it
+                        }
                     }
-            } else {
-                // Use testModule JDK (or Project SDK) as analyzed JDK
-                (ModuleRootManager.getInstance(testModule).sdk
-                    ?.homePath ?: ProjectRootManager.getInstance(project).projectSdk?.homePath)
-                    ?.toPath()
-            } ?: super.jdkPath // Return default JDK in case of failure
+            }
+
+            // Use Project SDK as analyzed JDK
+            return ProjectRootManager.getInstance(project).projectSdk
+        }
+
+    override val jdkPath: Path
+        get() = sdk?.let { it.homePath?.toPath() } ?: super.jdkPath // Return default JDK in case of failure
 
+    override val jdkVersion: String
+        get() = sdk?.versionString ?: super.jdkVersion // Return default JDK in case of failure
 }