azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Convert GradleImportingTestCase to Kotlin

Browse Source
This commit is contained in:
Natalia Selezneva
2018-08-10 09:17:46 +03:00
parent cf56915f03
commit c17d7e63c8
1 changed files with 177 additions and 196 deletions
Download Patch File Download Diff File Expand all files Collapse all files
idea/idea-gradle/tests/org/jetbrains/kotlin/idea/codeInsight/gradle/GradleImportingTestCase.kt
+177 -196
View File
@@ -13,223 +13,204 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package org.jetbrains.kotlin.idea.codeInsight.gradle; package org.jetbrains.kotlin.idea.codeInsight.gradle
import com.intellij.compiler.server.BuildManager; import com.intellij.compiler.server.BuildManager
import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.application.PathManager
import com.intellij.openapi.application.PathManager; import com.intellij.openapi.application.Result
import com.intellij.openapi.application.Result; import com.intellij.openapi.application.WriteAction
import com.intellij.openapi.application.WriteAction; import com.intellij.openapi.externalSystem.model.ProjectSystemId
import com.intellij.openapi.externalSystem.model.ProjectSystemId; import com.intellij.openapi.externalSystem.model.settings.ExternalSystemExecutionSettings
import com.intellij.openapi.externalSystem.model.settings.ExternalSystemExecutionSettings; import com.intellij.openapi.externalSystem.settings.ExternalProjectSettings
import com.intellij.openapi.externalSystem.settings.ExternalSystemSettingsListenerAdapter; import com.intellij.openapi.externalSystem.settings.ExternalSystemSettingsListenerAdapter
import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil; import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil
import com.intellij.openapi.fileTypes.FileTypeManager; import com.intellij.openapi.fileTypes.FileTypeManager
import com.intellij.openapi.projectRoots.JavaSdk; import com.intellij.openapi.projectRoots.JavaSdk
import com.intellij.openapi.projectRoots.ProjectJdkTable; import com.intellij.openapi.projectRoots.ProjectJdkTable
import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.projectRoots.impl.SdkConfigurationUtil
import com.intellij.openapi.projectRoots.impl.SdkConfigurationUtil; import com.intellij.openapi.ui.Messages
import com.intellij.openapi.ui.Messages; import com.intellij.openapi.ui.TestDialog
import com.intellij.openapi.ui.TestDialog; import com.intellij.openapi.util.io.FileUtil
import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.vfs.LocalFileSystem
import com.intellij.openapi.vfs.LocalFileSystem; import com.intellij.testFramework.IdeaTestUtil
import com.intellij.openapi.vfs.VirtualFile; import com.intellij.util.PathUtil
import com.intellij.testFramework.IdeaTestUtil; import com.intellij.util.containers.ContainerUtil
import com.intellij.util.PathUtil; import junit.framework.TestCase
import com.intellij.util.containers.ContainerUtil; import org.gradle.util.GradleVersion
import org.gradle.util.GradleVersion; import org.gradle.wrapper.GradleWrapperMain
import org.gradle.wrapper.GradleWrapperMain; import org.intellij.lang.annotations.Language
import org.intellij.lang.annotations.Language; import org.jetbrains.annotations.NonNls
import org.jetbrains.annotations.NonNls; import org.jetbrains.plugins.gradle.settings.DistributionType
import org.jetbrains.annotations.NotNull; import org.jetbrains.plugins.gradle.settings.GradleProjectSettings
import org.jetbrains.plugins.gradle.settings.DistributionType; import org.jetbrains.plugins.gradle.settings.GradleSettings
import org.jetbrains.plugins.gradle.settings.GradleProjectSettings; import org.jetbrains.plugins.gradle.util.GradleConstants
import org.jetbrains.plugins.gradle.settings.GradleSettings; import org.jetbrains.plugins.groovy.GroovyFileType
import org.jetbrains.plugins.gradle.util.GradleConstants; import org.junit.Assume.assumeThat
import org.jetbrains.plugins.groovy.GroovyFileType; import org.junit.Rule
import org.junit.Rule; import org.junit.rules.TestName
import org.junit.rules.TestName; import org.junit.runner.RunWith
import org.junit.runner.RunWith; import org.junit.runners.Parameterized
import org.junit.runners.Parameterized; import java.io.File
import java.io.IOException
import java.io.File; import java.io.StringWriter
import java.io.IOException; import java.net.URISyntaxException
import java.io.StringWriter; import java.util.*
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Properties;
import static org.junit.Assume.assumeThat;
// part of org.jetbrains.plugins.gradle.importing.GradleImportingTestCase // part of org.jetbrains.plugins.gradle.importing.GradleImportingTestCase
@RunWith(value = Parameterized.class) @RunWith(value = Parameterized::class)
public abstract class GradleImportingTestCase extends ExternalSystemImportingTestCase { abstract class GradleImportingTestCase : ExternalSystemImportingTestCase() {
private static final String GRADLE_JDK_NAME = "Gradle JDK";
private static final int GRADLE_DAEMON_TTL_MS = 10000;
@Rule public TestName name = new TestName(); @JvmField
@Rule
var name = TestName()
@Rule public VersionMatcherRule versionMatcherRule = new VersionMatcherRule(); @JvmField
@Rule
var versionMatcherRule = VersionMatcherRule()
@SuppressWarnings({"NullableProblems", "WeakerAccess"}) @NotNull @JvmField
@Parameterized.Parameter() public String gradleVersion; @Parameterized.Parameter
var gradleVersion: String = ""
private GradleProjectSettings myProjectSettings; private lateinit var myProjectSettings: GradleProjectSettings
private String myJdkHome; private lateinit var myJdkHome: String
@Override override fun setUp() {
public void setUp() throws Exception { myJdkHome = IdeaTestUtil.requireRealJdkHome()
myJdkHome = IdeaTestUtil.requireRealJdkHome(); super.setUp()
super.setUp(); assumeThat(gradleVersion, versionMatcherRule.matcher)
assumeThat(gradleVersion, versionMatcherRule.getMatcher()); runWrite {
new WriteAction() { ProjectJdkTable.getInstance().findJdk(GRADLE_JDK_NAME)?.let {
@Override ProjectJdkTable.getInstance().removeJdk(it)
protected void run(@NotNull Result result) throws Throwable {
Sdk oldJdk = ProjectJdkTable.getInstance().findJdk(GRADLE_JDK_NAME);
if (oldJdk != null) {
ProjectJdkTable.getInstance().removeJdk(oldJdk);
}
VirtualFile jdkHomeDir = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(new File(myJdkHome));
assert jdkHomeDir != null;
Sdk jdk = SdkConfigurationUtil.setupSdk(new Sdk[0], jdkHomeDir, JavaSdk.getInstance(), true, null, GRADLE_JDK_NAME);
assertNotNull("Cannot create JDK for " + myJdkHome, jdk);
ProjectJdkTable.getInstance().addJdk(jdk);
FileTypeManager.getInstance().associateExtension(GroovyFileType.GROOVY_FILE_TYPE, "gradle");
} }
}.execute(); val jdkHomeDir = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(File(myJdkHome))!!
myProjectSettings = new GradleProjectSettings(); val jdk = SdkConfigurationUtil.setupSdk(arrayOfNulls(0), jdkHomeDir, JavaSdk.getInstance(), true, null, GRADLE_JDK_NAME)
GradleSettings.getInstance(myProject).setGradleVmOptions("-Xmx128m -XX:MaxPermSize=64m"); TestCase.assertNotNull("Cannot create JDK for $myJdkHome", jdk)
System.setProperty(ExternalSystemExecutionSettings.REMOTE_PROCESS_IDLE_TTL_IN_MS_KEY, String.valueOf(GRADLE_DAEMON_TTL_MS)); ProjectJdkTable.getInstance().addJdk(jdk!!)
configureWrapper(); FileTypeManager.getInstance().associateExtension(GroovyFileType.GROOVY_FILE_TYPE, "gradle")
}
myProjectSettings = GradleProjectSettings()
GradleSettings.getInstance(myProject).gradleVmOptions = "-Xmx128m -XX:MaxPermSize=64m"
System.setProperty(ExternalSystemExecutionSettings.REMOTE_PROCESS_IDLE_TTL_IN_MS_KEY, GRADLE_DAEMON_TTL_MS.toString())
configureWrapper()
} }
@Override override fun tearDown() {
public void tearDown() throws Exception {
if (myJdkHome == null) {
//super.setUp() wasn't called
return;
}
try { try {
new WriteAction() { runWrite {
@Override val old = ProjectJdkTable.getInstance().findJdk(GRADLE_JDK_NAME)
protected void run(@NotNull Result result) throws Throwable { if (old != null) {
Sdk old = ProjectJdkTable.getInstance().findJdk(GRADLE_JDK_NAME); SdkConfigurationUtil.removeSdk(old)
if (old != null) { }
SdkConfigurationUtil.removeSdk(old); }
Messages.setTestDialog(TestDialog.DEFAULT)
FileUtil.delete(BuildManager.getInstance().buildSystemDirectory.toFile())
} finally {
super.tearDown()
}
}
override fun collectAllowedRoots(roots: MutableList<String>) {
roots.add(myJdkHome)
roots.addAll(ExternalSystemTestCase.collectRootsInside(myJdkHome))
roots.add(PathManager.getConfigPath())
}
override fun getName(): String {
return if (name.methodName == null) super.getName() else FileUtil.sanitizeFileName(name.methodName)
}
override fun getTestsTempDir(): String = "gradleImportTests"
override fun getExternalSystemConfigFileName(): String = "build.gradle"
protected fun importProjectUsingSingeModulePerGradleProject() {
myProjectSettings.isResolveModulePerSourceSet = false
importProject()
}
override fun importProject() {
ExternalSystemApiUtil.subscribe(
myProject,
GradleConstants.SYSTEM_ID,
object : ExternalSystemSettingsListenerAdapter<ExternalProjectSettings>() {
override fun onProjectsLinked(settings: Collection<ExternalProjectSettings>) {
val item = ContainerUtil.getFirstItem<Any>(settings)
if (item is GradleProjectSettings) {
item.gradleJvm = GRADLE_JDK_NAME
} }
} }
}.execute(); })
Messages.setTestDialog(TestDialog.DEFAULT); super.importProject()
FileUtil.delete(BuildManager.getInstance().getBuildSystemDirectory().toFile());
}
finally {
super.tearDown();
}
} }
@Override override fun importProject(@NonNls @Language("Groovy") config: String) {
protected void collectAllowedRoots(List<String> roots) throws IOException { super.importProject(
roots.add(myJdkHome); """
roots.addAll(collectRootsInside(myJdkHome)); allprojects {
roots.add(PathManager.getConfigPath()); repositories {
} maven {
url 'http://maven.labs.intellij.net/repo1'
@Override }
public String getName() { }
return name.getMethodName() == null ? super.getName() : FileUtil.sanitizeFileName(name.getMethodName());
}
@Parameterized.Parameters(name = "{index}: with Gradle-{0}")
public static Collection<Object[]> data() throws Throwable {
return Arrays.asList(AbstractModelBuilderTest.SUPPORTED_GRADLE_VERSIONS);
}
@Override
protected String getTestsTempDir() {
return "gradleImportTests";
}
@Override
protected String getExternalSystemConfigFileName() {
return "build.gradle";
}
protected void importProjectUsingSingeModulePerGradleProject() {
getCurrentExternalProjectSettings().setResolveModulePerSourceSet(false);
importProject();
}
@Override
protected void importProject() {
ExternalSystemApiUtil.subscribe(myProject, GradleConstants.SYSTEM_ID, new ExternalSystemSettingsListenerAdapter() {
@Override
public void onProjectsLinked(@NotNull Collection settings) {
Object item = ContainerUtil.getFirstItem(settings);
if (item instanceof GradleProjectSettings) {
((GradleProjectSettings) item).setGradleJvm(GRADLE_JDK_NAME);
} }
$config
""".trimIndent()
)
}
override fun getCurrentExternalProjectSettings(): GradleProjectSettings = myProjectSettings
override fun getExternalSystemId(): ProjectSystemId = GradleConstants.SYSTEM_ID
@Throws(IOException::class, URISyntaxException::class)
private fun configureWrapper() {
val distributionUri = AbstractModelBuilderTest.DistributionLocator().getDistributionFor(GradleVersion.version(gradleVersion))
myProjectSettings.distributionType = DistributionType.DEFAULT_WRAPPED
val wrapperJarFrom = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(wrapperJar())!!
val wrapperJarFromTo = createProjectSubFile("gradle/wrapper/gradle-wrapper.jar")
runWrite {
wrapperJarFromTo.setBinaryContent(wrapperJarFrom.contentsToByteArray())
}
val properties = Properties()
properties.setProperty("distributionBase", "GRADLE_USER_HOME")
properties.setProperty("distributionPath", "wrapper/dists")
properties.setProperty("zipStoreBase", "GRADLE_USER_HOME")
properties.setProperty("zipStorePath", "wrapper/dists")
properties.setProperty("distributionUrl", distributionUri.toString())
val writer = StringWriter()
properties.store(writer, null)
createProjectSubFile("gradle/wrapper/gradle-wrapper.properties", writer.toString())
}
private fun runWrite(f: () -> Unit) {
object : WriteAction<Any>() {
override fun run(result: Result<Any>) {
f()
} }
}); }.execute()
super.importProject();
} }
@Override companion object {
protected void importProject(@NonNls @Language("Groovy") String config) throws IOException { private const val GRADLE_JDK_NAME = "Gradle JDK"
config = "allprojects {\n" + private const val GRADLE_DAEMON_TTL_MS = 10000
" repositories {\n" +
" maven {\n" +
" url 'http://maven.labs.intellij.net/repo1'\n" +
" }\n" +
" }" +
"}\n" + config;
super.importProject(config);
}
@Override @JvmStatic
protected GradleProjectSettings getCurrentExternalProjectSettings() { @Parameterized.Parameters(name = "{index}: with Gradle-{0}")
return myProjectSettings; fun data(): Collection<Array<Any>> {
} return Arrays.asList(*AbstractModelBuilderTest.SUPPORTED_GRADLE_VERSIONS)
}
@Override private fun wrapperJar(): File {
protected ProjectSystemId getExternalSystemId() { return File(PathUtil.getJarPathForClass(GradleWrapperMain::class.java))
return GradleConstants.SYSTEM_ID; }
}
private void configureWrapper() throws IOException, URISyntaxException {
URI distributionUri = new AbstractModelBuilderTest.DistributionLocator().getDistributionFor(GradleVersion.version(gradleVersion));
myProjectSettings.setDistributionType(DistributionType.DEFAULT_WRAPPED);
final VirtualFile wrapperJarFrom = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(wrapperJar());
assert wrapperJarFrom != null;
final VirtualFile wrapperJarFromTo = createProjectSubFile("gradle/wrapper/gradle-wrapper.jar");
new WriteAction() {
@Override
protected void run(@NotNull Result result) throws Throwable {
wrapperJarFromTo.setBinaryContent(wrapperJarFrom.contentsToByteArray());
}
}.execute().throwException();
Properties properties = new Properties();
properties.setProperty("distributionBase", "GRADLE_USER_HOME");
properties.setProperty("distributionPath", "wrapper/dists");
properties.setProperty("zipStoreBase", "GRADLE_USER_HOME");
properties.setProperty("zipStorePath", "wrapper/dists");
properties.setProperty("distributionUrl", distributionUri.toString());
StringWriter writer = new StringWriter();
properties.store(writer, null);
createProjectSubFile("gradle/wrapper/gradle-wrapper.properties", writer.toString());
}
@NotNull
private static File wrapperJar() {
return new File(PathUtil.getJarPathForClass(GradleWrapperMain.class));
} }
} }