add test for multiple processors at once

Author: yigit

ksp/src/main/kotlin/com/tschuchort/compiletesting/Ksp.kt

@@ -11,7 +11,7 @@ private const val KSP_PLUGIN_ID = "org.jetbrains.kotlin.ksp"
 
 // TODO can we add support for instances?
 fun KotlinCompilation.symbolProcessor(
-    vararg processors : Class<out SymbolProcessor>
+    vararg processors: Class<out SymbolProcessor>
 ) {
     check(processors.isNotEmpty()) {
         "Must provide at least 1 symbol processor"
@@ -42,8 +42,8 @@ fun KotlinCompilation.symbolProcessor(
         PluginOption(KSP_PLUGIN_ID, "classes", classesFolder.path),
         PluginOption(KSP_PLUGIN_ID, "sources", sourceFolder.path)
     )
-    compilerPlugins += KotlinSymbolProcessingComponentRegistrar()
-    commandLineProcessors += listOf(KotlinSymbolProcessingCommandLineProcessor())
-    pluginOptions += kspOptions
+    compilerPlugins = compilerPlugins + KotlinSymbolProcessingComponentRegistrar()
+    commandLineProcessors = commandLineProcessors + listOf(KotlinSymbolProcessingCommandLineProcessor())
+    pluginOptions = pluginOptions + kspOptions
     this.kaptSourceDir
 }

ksp/src/test/kotlin/com/tschuchort/compiletesting/DelegatingSymbolProcessorRule.kt

@@ -6,6 +6,10 @@ import org.jetbrains.kotlin.ksp.processing.SymbolProcessor
 import org.junit.rules.TestWatcher
 import org.junit.runner.Description
 
+/**
+ * A processor implementation that delegates to an instance given in test.
+ * Must be used via [DelegatingSymbolProcessorRule] until we move this support into internals.
+ */
 internal class DelegateProcessor : SymbolProcessor {
     private val delegate
         get() = checkNotNull(Companion.delegate) {
@@ -33,6 +37,9 @@ internal class DelegateProcessor : SymbolProcessor {
     }
 }
 
+/**
+ * JUnit test rule that can trigger a single KSP processor
+ */
 class DelegatingSymbolProcessorRule : TestWatcher() {
     fun delegateTo(processor: SymbolProcessor): Class<out SymbolProcessor> {
         check(DelegateProcessor.delegate == null) {

ksp/src/test/kotlin/com/tschuchort/compiletesting/KspTest.kt

@@ -97,6 +97,45 @@ class KspTest {
         assertThat(result.exitCode).isEqualTo(ExitCode.OK)
     }
 
+    @Test
+    fun multipleProcessors() {
+        // access generated code by multiple processors
+        val source = SourceFile.kotlin(
+            "foo.bar.Dummy.kt", """
+            package foo.bar
+            import generated.A
+            import generated.B
+            class Dummy(val a:A, val b:B)
+        """.trimIndent()
+        )
+        val result = KotlinCompilation().apply {
+            sources = listOf(source)
+            symbolProcessor(Write_foo_bar_A::class.java, Write_foo_bar_B::class.java)
+        }.compile()
+        assertThat(result.exitCode).isEqualTo(ExitCode.OK)
+    }
+
+    @Suppress("ClassName")
+    internal class Write_foo_bar_A() : ClassGeneratingProcessor("generated", "A")
+
+    @Suppress("ClassName")
+    internal class Write_foo_bar_B() : ClassGeneratingProcessor("generated", "B")
+
+    internal open class ClassGeneratingProcessor(
+        private val packageName: String,
+        private val className: String
+    ) : AbstractSymbolProcessor() {
+        override fun process(resolver: Resolver) {
+            super.process(resolver)
+            codeGenerator.createNewFile(packageName, className).writeText(
+                """
+                package $packageName
+                class $className() {}
+            """.trimIndent()
+            )
+        }
+    }
+
     companion object {
         private val DUMMY_KOTLIN_SRC = SourceFile.kotlin(
             "foo.bar.Dummy.kt", """