rebase

Author: yigit

core/src/main/kotlin/com/tschuchort/compiletesting/HostClasspaths.kt

@@ -5,5 +5,6 @@ buildscript {
 dependencies {
     testImplementation project(':core')
     testImplementation project(':ksp')
+    testImplementation "org.jetbrains.kotlin:kotlin-compiler-embeddable:$kotlin_version"
     testImplementation "com.google.devtools.ksp:symbol-processing-api:$ksp_version"
 }

profiling/build.gradle

@@ -4,6 +4,8 @@ import com.google.devtools.ksp.processing.CodeGenerator
 import com.google.devtools.ksp.processing.KSPLogger
 import com.google.devtools.ksp.processing.Resolver
 import com.google.devtools.ksp.processing.SymbolProcessor
+import org.jetbrains.kotlin.cli.common.KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY
+import org.junit.Before
 import org.junit.ClassRule
 import org.junit.Rule
 import org.junit.Test
@@ -30,13 +32,20 @@ class ProfilingTest(
         }
     }
 
+    @Before
+    fun setCompilerCache() {
+        val existingValue:String? = System.getProperty(KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY)
+        System.setProperty(
+            KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY,
+            if (testConfiguration.useCachedCompilerEnv) "true" else "false"
+        )
+    }
+
     private fun newKotlinCompilation() = KotlinCompilation().apply {
         when (testConfiguration.processorType) {
             ProcessorType.KAPT -> annotationProcessors = listOf(DoNothingKapt())
             ProcessorType.KSP -> symbolProcessors = listOf(DonothingKsp())
         }
-        useCachedHostClasspath = testConfiguration.enableClasspathCache
-        useMyClasspath = testConfiguration.useGoogleCompileTestingClasspath
         verbose = false
     }
 
@@ -109,24 +118,9 @@ class ProfilingTest(
 
     data class TestConfiguration(
         val processorType: ProcessorType,
-        val enableClasspathCache: Boolean,
-        val useGoogleCompileTestingClasspath: Boolean,
+        val useCachedCompilerEnv: Boolean
     ) {
-        companion object {
-            fun buildVariations(): List<TestConfiguration> {
-                return ProcessorType.values().flatMap { processorType ->
-                    arrayOf(true, false).flatMap { enableClasspathCache ->
-                         arrayOf(true, false).map { useGoogleCompileTestingClasspath ->
-                             TestConfiguration(
-                                 processorType = processorType,
-                                 enableClasspathCache = enableClasspathCache,
-                                 useGoogleCompileTestingClasspath = useGoogleCompileTestingClasspath
-                             )
-                         }
-                    }
-                }
-            }
-        }
+
     }
 
     companion object {
@@ -136,20 +130,11 @@ class ProfilingTest(
             listOf(
                 TestConfiguration(
                     processorType = ProcessorType.KAPT,
-                    enableClasspathCache = true,
-                    useGoogleCompileTestingClasspath = false
-                ),
-                TestConfiguration(
-                    processorType = ProcessorType.KAPT,
-                    enableClasspathCache = false,
-                    useGoogleCompileTestingClasspath = false
-                ),
-                TestConfiguration(
-                    processorType = ProcessorType.KAPT,
-                    enableClasspathCache = false,
-                    useGoogleCompileTestingClasspath = true
+                    useCachedCompilerEnv = false
                 )
             )
+        }.flatMap {
+            listOf(it, it.copy(useCachedCompilerEnv = true))
         }
 
         @get:ClassRule

profiling/src/test/kotlin/com/tschuchort/compiletesting/ProfilingTest.kt

@@ -53,33 +53,12 @@ class TimeTracking : TestRule {
         measurements: Map<ProfilingTest.TestConfiguration, List<Long>>
     ) {
         System.err.println("report for $testName")
-        System.err.println("use Google true:")
-
-        val groupedBy_enableClasspathCache = measurements.entries.groupBy {
-            it.key.enableClasspathCache
-        }
-        groupedBy_enableClasspathCache.entries.forEach { (key, value) ->
-            value.flatMap { it.value }.groupBy {
-                it
-            }
-        }
-
-        measurements.entries.filter {
-            it.key.useGoogleCompileTestingClasspath
-        }.groupBy {
-            it.key
-        }.forEach {
-            val analysis = analyze(it.value.flatMap { it.value }.removeOutliers())
-            System.err.println("${it.key}: ${analysis.toString()}")
-        }
-        System.err.println("use Google false:")
-        measurements.entries.filter {
-            !it.key.useGoogleCompileTestingClasspath
-        }.groupBy {
-            it.key
+        measurements.mapValues {
+            analyze(it.value.removeOutliers())
+        }.entries.sortedBy {
+            it.value.avg
         }.forEach {
-            val analysis = analyze(it.value.flatMap { it.value }.removeOutliers())
-            System.err.println("${it.key}: ${analysis.toString()}")
+            System.err.println("${it.key} (${it.value.avg}) : ${it.value}")
         }
     }
 
@@ -123,15 +102,13 @@ class TimeTracking : TestRule {
                 sources = listOf(SourceFile.kotlin("Foo.kt", ""))
                 annotationProcessors = listOf(ProfilingTest.DoNothingKapt())
                 symbolProcessors = listOf(ProfilingTest.DonothingKsp())
-                useCachedHostClasspath = true
             }.compile()
         }
         repeat(2) {
             KotlinCompilation().apply {
                 sources = listOf(SourceFile.kotlin("Foo.kt", ""))
                 annotationProcessors = listOf(ProfilingTest.DoNothingKapt())
                 symbolProcessors = listOf(ProfilingTest.DonothingKsp())
-                useMyClasspath = true
             }.compile()
         }
     }