Extract IncrementalJvmCompilerRunnerTest

compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalCompilerRunnerTestBase.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2016 JetBrains s.r.o.
+ * 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.
@@ -19,20 +19,17 @@ package org.jetbrains.kotlin.incremental
 import com.intellij.util.containers.HashMap
 import org.jetbrains.kotlin.TestWithWorkingDir
 import org.jetbrains.kotlin.cli.common.ExitCode
-import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
+import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
-import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.incremental.testingUtils.*
-import org.jetbrains.kotlin.incremental.utils.TestMessageCollector
+import org.jetbrains.kotlin.incremental.utils.TestCompilationResult
+import org.junit.Assert
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.Parameterized
 import java.io.File
-import java.util.*
 
 @RunWith(Parameterized::class)
-class KotlinStandaloneIncrementalCompilationTest : TestWithWorkingDir() {
+abstract class IncrementalCompilerRunnerTestBase<Args : CommonCompilerArguments> : TestWithWorkingDir() {
     @Parameterized.Parameter
     lateinit var testDir: File
 
@@ -40,6 +37,8 @@ class KotlinStandaloneIncrementalCompilationTest : TestWithWorkingDir() {
     @Parameterized.Parameter(value = 1)
     lateinit var readableName: String
 
+    protected abstract fun createCompilerArguments(destinationDir: File, testDir: File): Args
+
     @Test
     fun testFromJps() {
         fun Iterable<File>.relativePaths() =
@@ -51,10 +50,7 @@ class KotlinStandaloneIncrementalCompilationTest : TestWithWorkingDir() {
 
         val mapWorkingToOriginalFile = HashMap(copyTestSources(testDir, srcDir, filePrefix = ""))
         val sourceRoots = listOf(srcDir)
-        val args = K2JVMCompilerArguments()
+        val args = createCompilerArguments(outDir, testDir)
-        args.destination = outDir.path
-        args.moduleName = testDir.name
-        args.classpath = compileClasspath()
         // initial build
         make(cacheDir, sourceRoots, args)
 
@@ -62,9 +58,9 @@ class KotlinStandaloneIncrementalCompilationTest : TestWithWorkingDir() {
         val buildLogFile = buildLogFinder.findBuildLog(testDir) ?: throw IllegalStateException("build log file not found in $workingDir")
         val buildLogSteps = parseTestBuildLog(buildLogFile)
         val modifications = getModificationsToPerform(testDir,
-                moduleNames = null,
+                                                      moduleNames = null,
-                allowNoFilesWithSuffixInTestData = false,
+                                                      allowNoFilesWithSuffixInTestData = false,
-                touchPolicy = TouchPolicy.CHECKSUM)
+                                                      touchPolicy = TouchPolicy.CHECKSUM)
 
         assert(modifications.size == buildLogSteps.size) {
             "Modifications count (${modifications.size}) != expected build log steps count (${buildLogSteps.size})"
@@ -91,19 +87,18 @@ class KotlinStandaloneIncrementalCompilationTest : TestWithWorkingDir() {
         }
 
         if (expectedSBWithoutErrors.toString() != actualSBWithoutErrors.toString()) {
-            assertEquals(expectedSB.toString(), actualSB.toString())
+            Assert.assertEquals(expectedSB.toString(), actualSB.toString())
         }
 
         // todo: also compare caches
         run rebuildAndCompareOutput@ {
             val rebuildOutDir = File(workingDir, "rebuild-out").apply { mkdirs() }
             val rebuildCacheDir = File(workingDir, "rebuild-cache").apply { mkdirs() }
-            args.destination = rebuildOutDir.path
+            val rebuildResult = make(rebuildCacheDir, sourceRoots, createCompilerArguments(rebuildOutDir, testDir))
-            val rebuildResult = make(rebuildCacheDir, sourceRoots, args)
 
             val rebuildExpectedToSucceed = buildLogSteps.last().compileSucceeded
             val rebuildSucceeded = rebuildResult.exitCode == ExitCode.OK
-            assertEquals("Rebuild exit code differs from incremental exit code", rebuildExpectedToSucceed, rebuildSucceeded)
+            Assert.assertEquals("Rebuild exit code differs from incremental exit code", rebuildExpectedToSucceed, rebuildSucceeded)
 
             if (rebuildSucceeded) {
                 assertEqualDirectories(outDir, rebuildOutDir, forgiveExtraFiles = rebuildSucceeded)
@@ -111,33 +106,7 @@ class KotlinStandaloneIncrementalCompilationTest : TestWithWorkingDir() {
         }
     }
 
-    private fun compileClasspath(): String {
+    protected abstract fun make(cacheDir: File, sourceRoots: Iterable<File>, args: Args): TestCompilationResult
-        val currentClasspath = System.getProperty("java.class.path").split(File.pathSeparator)
-        val stdlib = currentClasspath.find { it.contains("kotlin-stdlib") }
-        val runtime = currentClasspath.find { it.contains("kotlin-runtime") }
-        return listOf(stdlib, runtime).joinToString(File.pathSeparator)
-    }
-
-    data class CompilationResult(val exitCode: ExitCode, val compiledSources: Iterable<File>, val compileErrors: Collection<String>)
-
-    private fun make(cacheDir: File, sourceRoots: Iterable<File>, args: K2JVMCompilerArguments): CompilationResult {
-        val compiledSources = arrayListOf<File>()
-        var resultExitCode = ExitCode.OK
-
-        val reporter = object : ICReporter {
-            override fun report(message: ()->String) {
-            }
-
-            override fun reportCompileIteration(sourceFiles: Collection<File>, exitCode: ExitCode) {
-                compiledSources.addAll(sourceFiles)
-                resultExitCode = exitCode
-            }
-        }
-
-        val messageCollector = TestMessageCollector()
-        makeIncrementally(cacheDir, sourceRoots, args, reporter = reporter, messageCollector = messageCollector)
-        return CompilationResult(resultExitCode, compiledSources, messageCollector.errors)
-    }
 
     private fun stepLogAsString(step: Int, ktSources: Iterable<String>, errors: Collection<String>, includeErrors: Boolean = true): String {
         val sb = StringBuilder()
@@ -167,6 +136,9 @@ class KotlinStandaloneIncrementalCompilationTest : TestWithWorkingDir() {
     }
 
     companion object {
+        @JvmStatic
+        protected val bootstrapKotlincLib: File = File("dependencies/bootstrap-compiler/Kotlin/kotlinc/lib")
+
         private val jpsResourcesPath = File("jps-plugin/testData/incremental")
         private val ignoredDirs = setOf(File(jpsResourcesPath, "cacheVersionChanged"),
                                         File(jpsResourcesPath, "changeIncrementalOption"),

compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunnerTest.kt

@@ -0,0 +1,39 @@
+/*
+ * 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.incremental
+
+import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
+import org.jetbrains.kotlin.incremental.utils.TestCompilationResult
+import org.jetbrains.kotlin.incremental.utils.TestICReporter
+import org.jetbrains.kotlin.incremental.utils.TestMessageCollector
+import java.io.File
+
+class IncrementalJvmCompilerRunnerTest : IncrementalCompilerRunnerTestBase<K2JVMCompilerArguments>() {
+    override fun make(cacheDir: File, sourceRoots: Iterable<File>, args: K2JVMCompilerArguments): TestCompilationResult {
+        val reporter = TestICReporter()
+        val messageCollector = TestMessageCollector()
+        makeIncrementally(cacheDir, sourceRoots, args, reporter = reporter, messageCollector = messageCollector)
+        return TestCompilationResult(reporter, messageCollector)
+    }
+
+    override fun createCompilerArguments(destinationDir: File, testDir: File): K2JVMCompilerArguments =
+            K2JVMCompilerArguments().apply {
+                moduleName = testDir.name
+                destination = destinationDir.path
+                classpathAsList = listOf(File(bootstrapKotlincLib, "kotlin-stdlib.jar"))
+            }
+}

compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/utils/TestCompilationResult.kt

@@ -0,0 +1,31 @@
+/*
+ * 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.incremental.utils
+
+import org.jetbrains.kotlin.cli.common.ExitCode
+import java.io.File
+
+data class TestCompilationResult(
+        val exitCode: ExitCode,
+        val compiledSources: Iterable<File>,
+        val compileErrors: Collection<String>
+) {
+    constructor(
+            icReporter: TestICReporter,
+            messageCollector: TestMessageCollector
+    ) : this(icReporter.exitCode, icReporter.compiledSources, messageCollector.errors)
+}

compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/utils/TestICReporter.kt

@@ -0,0 +1,39 @@
+/*
+ * 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.incremental.utils
+
+import org.jetbrains.kotlin.cli.common.ExitCode
+import org.jetbrains.kotlin.incremental.ICReporter
+import java.io.File
+
+class TestICReporter : ICReporter {
+    private val compiledSourcesMutable = arrayListOf<File>()
+
+    val compiledSources: List<File>
+        get() = compiledSourcesMutable
+
+    var exitCode: ExitCode = ExitCode.OK
+        private set
+
+    override fun report(message: ()->String) {
+    }
+
+    override fun reportCompileIteration(sourceFiles: Collection<File>, exitCode: ExitCode) {
+        compiledSourcesMutable.addAll(sourceFiles)
+        this.exitCode = exitCode
+    }
+}