Import Kotlin JUnit run configuration settings from Gradle

idea/idea-gradle/tests/org/jetbrains/kotlin/idea/codeInsight/gradle/GradleTestRunConfigurationTest.kt

@@ -5,13 +5,15 @@
 
 package org.jetbrains.kotlin.idea.codeInsight.gradle
 
+import com.intellij.execution.RunManagerEx
+import com.intellij.execution.configurations.ConfigurationType
+import com.intellij.execution.configurations.ConfigurationTypeUtil
+import com.intellij.execution.junit.JUnitConfiguration
+import com.intellij.execution.junit.JUnitConfigurationType
 import org.junit.Test
 import com.intellij.testFramework.runInEdtAndWait
 import com.intellij.util.PlatformUtils
-import org.jetbrains.kotlin.idea.run.KotlinGradleRunConfiguration
-import org.jetbrains.kotlin.idea.run.KotlinJvmTestClassGradleConfigurationProducer
-import org.jetbrains.kotlin.idea.run.KotlinJvmTestMethodGradleConfigurationProducer
-import org.jetbrains.kotlin.idea.run.getConfiguration
+import org.jetbrains.kotlin.idea.run.*
 import org.jetbrains.kotlin.idea.util.application.runReadAction
 import org.jetbrains.plugins.gradle.execution.test.runner.TestClassGradleConfigurationProducer
 import org.jetbrains.plugins.gradle.execution.test.runner.TestMethodGradleConfigurationProducer
@@ -51,6 +53,37 @@ class GradleTestRunConfigurationTest : GradleImportingTestCase() {
         }
     }
 
+    @Test
+    @TargetVersions("4.7+")
+    fun testKotlinJUnitSettings() {
+        if (!PlatformUtils.isIntelliJ()) {
+            return
+        }
+
+        importProjectFromTestData()
+
+        runInEdtAndWait {
+            runReadAction {
+                fun getConfiguration(cls: Class<out ConfigurationType>): JUnitConfiguration {
+                    val configurationFactory = ConfigurationTypeUtil
+                        .findConfigurationType(cls).configurationFactories[0]
+                    val runManager = RunManagerEx.getInstanceEx(myProject)
+                    val kotlinRunnerAndConfigurationSettings = runManager.getConfigurationTemplate(configurationFactory)
+                    return kotlinRunnerAndConfigurationSettings.configuration as JUnitConfiguration
+                }
+
+                val javaConfiguration = getConfiguration(JUnitConfigurationType::class.java)
+                val kotlinConfiguration = getConfiguration(KotlinJUnitConfigurationType::class.java)
+
+                assert(javaConfiguration !== kotlinConfiguration)
+                assert(javaConfiguration.javaClass != kotlinConfiguration.javaClass)
+
+                assertEquals("-Dfoo=bar", javaConfiguration.persistentData.vmParameters)
+                assertEquals("-Dfoo=bar", kotlinConfiguration.persistentData.vmParameters)
+            }
+        }
+    }
+
     override fun testDataDirName(): String {
         return "testRunConfigurations"
     }

idea/idea-jvm/src/org/jetbrains/kotlin/idea/run/KotlinJUnitRunConfigurationImporter.kt

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.idea.run
+
+import com.intellij.execution.RunManagerEx
+import com.intellij.execution.configurations.ConfigurationTypeUtil
+import com.intellij.execution.configurations.RunConfiguration
+import com.intellij.execution.junit.JUnitRunConfigurationImporter
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider
+import com.intellij.openapi.externalSystem.service.project.settings.RunConfigurationImporter
+import com.intellij.openapi.project.Project
+import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstance
+
+@Suppress("UnstableApiUsage")
+class KotlinJUnitRunConfigurationImporter : RunConfigurationImporter {
+    private fun Any?.isTrue(): Boolean = this != null && this is Boolean && this
+
+    override fun canImport(typeName: String) = "junit" == typeName
+
+    private fun getOriginalImporter(): JUnitRunConfigurationImporter {
+        return RunConfigurationImporter.EP_NAME.extensions.firstIsInstance()
+    }
+
+    override fun getConfigurationFactory() = getOriginalImporter().configurationFactory
+
+    override fun process(
+        project: Project,
+        runConfiguration: RunConfiguration,
+        cfg: MutableMap<String, Any>,
+        modelsProvider: IdeModifiableModelsProvider
+    ) {
+        getOriginalImporter().process(project, runConfiguration, cfg, modelsProvider)
+
+        if (runConfiguration !is KotlinJUnitConfiguration && cfg["defaults"].isTrue()) {
+            val runManager = RunManagerEx.getInstanceEx(project)
+            val configurationFactory = ConfigurationTypeUtil
+                .findConfigurationType(KotlinJUnitConfigurationType::class.java).configurationFactories[0]
+            val kotlinRunnerAndConfigurationSettings = runManager.getConfigurationTemplate(configurationFactory)
+            process(project, kotlinRunnerAndConfigurationSettings.configuration, cfg, modelsProvider)
+
+            (cfg["beforeRun"] as? List<*>)?.let {
+                val beforeRunTasks = runManager.getBeforeRunTasks(runConfiguration)
+                runManager.setBeforeRunTasks(kotlinRunnerAndConfigurationSettings.configuration, beforeRunTasks)
+            }
+        }
+    }
+}

idea/resources/META-INF/junit.xml

@@ -1,6 +1,7 @@
 <idea-plugin>
   <extensions defaultExtensionNs="com.intellij">
     <runConfigurationProducer implementation="org.jetbrains.kotlin.idea.run.KotlinJUnitRunConfigurationProducer"/>
+    <externalSystem.runConfigurationImporter implementation="org.jetbrains.kotlin.idea.run.KotlinJUnitRunConfigurationImporter" order="first"/>
     <runConfigurationProducer implementation="org.jetbrains.kotlin.idea.run.KotlinPatternConfigurationProducer"/>
     <junitRecognizer implementation="org.jetbrains.kotlin.idea.run.KotlinMultiplatformJUnitRecognizer"/>
   </extensions>

idea/testData/gradle/testRunConfigurations/kotlinJunitSettings/build.gradle

@@ -0,0 +1,30 @@
+plugins {
+    id 'java'
+    id 'org.jetbrains.kotlin.jvm' version '1.3.61'
+    id "org.jetbrains.gradle.plugin.idea-ext" version "0.7"
+}
+
+sourceCompatibility = 1.8
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
+    testCompile "junit:junit:4.12"
+}
+
+import org.jetbrains.gradle.ext.*
+
+idea {
+    project {
+        settings {
+            runConfigurations {
+                defaults(JUnit) {
+                    vmParameters = "-Dfoo=bar"
+                }
+            }
+        }
+    }
+}

idea/testData/gradle/testRunConfigurations/kotlinJunitSettings/src/test/kotlin/MyKotlinTest.kt

@@ -0,0 +1,7 @@
+import org.junit.Test
+
+class MyKotlinTest {
+    @Test
+    fun testA() {
+    }
+}