From e7e28419e4b1fd58159ed5b440c2c5995cc7cb34 Mon Sep 17 00:00:00 2001 From: Mikhael Bogdanov Date: Wed, 27 Sep 2017 09:46:39 +0200 Subject: [PATCH] Migrate CodegenJdkCommonTestSuite.kt to gradle --- compiler/build.gradle.kts | 44 ++++++++++- .../test/clientserver/TestProcessServer.kt | 33 +++++++- .../codegen/CodegenJdkCommonTestSuite.kt | 77 ------------------- 3 files changed, 73 insertions(+), 81 deletions(-) delete mode 100644 compiler/tests/org/jetbrains/kotlin/codegen/CodegenJdkCommonTestSuite.kt diff --git a/compiler/build.gradle.kts b/compiler/build.gradle.kts index 1f523529483..5b5b6b94aae 100644 --- a/compiler/build.gradle.kts +++ b/compiler/build.gradle.kts @@ -85,8 +85,12 @@ evaluationDependsOn(":compiler:tests-common-jvm6") fun Project.codegenTest(taskName: String, jdk: String, body: Test.() -> Unit): Test = projectTest(taskName) { dependsOn(*testDistProjects.map { "$it:dist" }.toTypedArray()) workingDir = rootDir - environment("TEST_SERVER_CLASSES_DIRS", project(":compiler:tests-common-jvm6").the().sourceSets.getByName("main").output.classesDirs.asPath) - filter.includeTestsMatching("org.jetbrains.kotlin.codegen.CodegenJdkCommonTestSuite*") + + filter.includeTestsMatching("org.jetbrains.kotlin.codegen.BlackBoxCodegenTestGenerated*") + filter.includeTestsMatching("org.jetbrains.kotlin.codegen.BlackBoxInlineCodegenTestGenerated*") + filter.includeTestsMatching("org.jetbrains.kotlin.codegen.CompileKotlinAgainstInlineKotlinTestGenerated*") + filter.includeTestsMatching("org.jetbrains.kotlin.codegen.CompileKotlinAgainstKotlinTestGenerated*") + filter.includeTestsMatching("org.jetbrains.kotlin.codegen.BlackBoxAgainstJavaCodegenTestGenerated*") if (jdk == "JDK_9") { jvmArgs = listOf("--add-opens", "java.desktop/javax.swing=ALL-UNNAMED", "--add-opens", "java.base/java.io=ALL-UNNAMED") @@ -105,9 +109,43 @@ fun Project.codegenTest(taskName: String, jdk: String, body: Test.() -> Unit): T } codegenTest("codegen-target6-jvm6-test", "JDK_18") { + dependsOn(":compiler:tests-common-jvm6:build") + + //TODO make port flexible + val port = "5100" + var jdkProcess: Process? = null + + doFirst { + logger.info("Configuring JDK 6 server...") + val jdkPath = project.property("JDK_16") ?: error("JDK_16 is not optional to run this test") + val executable = "$jdkPath/bin/java" + val main = "org.jetbrains.kotlin.test.clientserver.TestProcessServer" + + val classpath = getSourceSetsFrom(":compiler:tests-common-jvm6")["main"].output.asPath + ":" + + getSourceSetsFrom(":kotlin-stdlib")["main"].output.asPath + ":" + + getSourceSetsFrom(":kotlin-stdlib")["builtins"].output.asPath + ":" + + getSourceSetsFrom(":kotlin-test:kotlin-test-jvm")["main"].output.asPath + + logger.debug("Server classpath: $classpath") + + val builder = ProcessBuilder(executable, "-cp", classpath, main, port) + builder.directory(rootDir) + + builder.inheritIO() + builder.redirectErrorStream(true) + + logger.info("Starting JDK 6 server $executable") + jdkProcess = builder.start() + + } systemProperty("kotlin.test.default.jvm.target", "1.6") systemProperty("kotlin.test.java.compilation.target", "1.6") - systemProperty("kotlin.test.box.in.separate.process.port", "5100") + systemProperty("kotlin.test.box.in.separate.process.port", port) + + doLast { + logger.info("Stopping JDK 6 server...") + jdkProcess?.destroy() + } } codegenTest("codegen-target6-jvm9-test", "JDK_9") { diff --git a/compiler/tests-common-jvm6/src/org/jetbrains/kotlin/test/clientserver/TestProcessServer.kt b/compiler/tests-common-jvm6/src/org/jetbrains/kotlin/test/clientserver/TestProcessServer.kt index 86aa3c50a40..5033a1cf23e 100644 --- a/compiler/tests-common-jvm6/src/org/jetbrains/kotlin/test/clientserver/TestProcessServer.kt +++ b/compiler/tests-common-jvm6/src/org/jetbrains/kotlin/test/clientserver/TestProcessServer.kt @@ -25,6 +25,8 @@ import java.net.Socket import java.net.URL import java.net.URLClassLoader import java.util.concurrent.Executors +import java.util.concurrent.ScheduledFuture +import java.util.concurrent.TimeUnit fun getGeneratedClass(classLoader: ClassLoader, className: String): Class<*> { try { @@ -47,7 +49,19 @@ fun getBoxMethodOrNull(aClass: Class<*>): Method? { //Use only JDK 1.6 compatible api object TestProcessServer { - val executor = Executors.newFixedThreadPool(1)!! + private val executor = Executors.newFixedThreadPool(1)!! + + @Volatile + private var isProcessingTask = true + + @Volatile + private var lastTime = System.currentTimeMillis() + + private val scheduler = Executors.newScheduledThreadPool(1) + + private lateinit var handler: ScheduledFuture<*> + + private lateinit var serverSocket: ServerSocket @JvmStatic fun main(args: Array) { @@ -55,17 +69,34 @@ object TestProcessServer { println("Starting server on port $portNumber...") val serverSocket = ServerSocket(portNumber) + sheduleShutdownProcess() + try { while (true) { + lastTime = System.currentTimeMillis() + isProcessingTask = false val clientSocket = serverSocket.accept() + isProcessingTask = true println("Socket established...") executor.execute(ServerTest(clientSocket)) } } finally { + handler.cancel(false) + scheduler.shutdown() serverSocket.close() + println("Server stopped!") } } + + private fun sheduleShutdownProcess() { + handler = scheduler.scheduleAtFixedRate({ + if (!isProcessingTask && (System.currentTimeMillis() - lastTime) >= 60 * 1000 /*60 sec*/) { + println("Stopping server...") + serverSocket.close() + } + }, 60, 60, TimeUnit.SECONDS) + } } private class ServerTest(val clientSocket: Socket) : Runnable { diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/CodegenJdkCommonTestSuite.kt b/compiler/tests/org/jetbrains/kotlin/codegen/CodegenJdkCommonTestSuite.kt deleted file mode 100644 index 4ac90f87d9d..00000000000 --- a/compiler/tests/org/jetbrains/kotlin/codegen/CodegenJdkCommonTestSuite.kt +++ /dev/null @@ -1,77 +0,0 @@ -/* - * Copyright 2010-2017 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.kotlin.codegen - -import org.jetbrains.kotlin.test.clientserver.TestProcessServer -import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime -import org.junit.AfterClass -import org.junit.Assert.assertNotNull -import org.junit.BeforeClass -import org.junit.runner.RunWith -import org.junit.runners.Suite -import java.io.File - -/** - * This suite is used to run java codegen tests under jdk 1.6, 1.8 and 9 - * with different default targets - 1.6, 1.8, 1.9. - */ -@RunWith(Suite::class) -@Suite.SuiteClasses( - BlackBoxCodegenTestGenerated::class, - BlackBoxInlineCodegenTestGenerated::class, - CompileKotlinAgainstInlineKotlinTestGenerated::class, - CompileKotlinAgainstKotlinTestGenerated::class, - BlackBoxAgainstJavaCodegenTestGenerated::class -) -object CodegenJdkCommonTestSuite { - - private var jdkProcess: Process? = null - - @BeforeClass - @JvmStatic - fun setUp() { - val boxInSeparateProcessPort = System.getProperty(CodegenTestCase.RUN_BOX_TEST_IN_SEPARATE_PROCESS_PORT) - if (boxInSeparateProcessPort != null) { - val classpath = (System.getenv("TEST_SERVER_CLASSES_DIRS") ?: "out/test/tests-common") + - File.pathSeparatorChar + - ForTestCompileRuntime.runtimeJarForTests() + - File.pathSeparatorChar + - ForTestCompileRuntime.kotlinTestJarForTests() - - val jdk16 = System.getenv("JDK_16") - assertNotNull(jdk16, "Please specify JDK_16 system property to run codegen test in separate process") - - val builder = ProcessBuilder( - jdk16 + "/bin/java", "-cp", classpath, - TestProcessServer::class.java.name, boxInSeparateProcessPort - ) - println("Starting separate process to run test: " + builder.command().joinToString()) - builder.inheritIO() - builder.redirectErrorStream(true) - jdkProcess = builder.start() - } - } - - @AfterClass - @JvmStatic - fun tearDown() { - if (jdkProcess != null) { - println("Stop separate test process") - jdkProcess!!.destroy() - } - } -}