from.attribute(summarized, false)
        to.attribute(summarized, true)
    }
}

val sourceFiles by configurations.creating {
    isCanBeConsumed = false
    isCanBeResolved = false
}

val summarizedFiles by configurations.creating {
    extendsFrom(sourceFiles)
    isCanBeConsumed = false
    isCanBeResolved = true
    attributes {
        attribute(summarized, true)

                    // I didn't find a way to make the test configuration cache compatible without the extra sources property and doing this configuration in the task registration.
                    sourceFiles.from(sources.map {
                        if (countResolved == ${countResolvedBeforeTaskExecution}) {
                            println "resolving input"

import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.test.fixtures.file.TestFile

trait KotlinPluginImplementation {
    void kotlinPlugin(TestFile sourceFile, BuildInputRead read) {
        sourceFile << """
            import ${Project.name}
            import ${Plugin.name}
            ${read.requiredImports().collect { "import $it" }.join("\n")}

            class SneakyPlugin: Plugin<Project> {

import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.test.fixtures.file.TestFile

trait GroovyPluginImplementation {
    void groovyDsl(TestFile sourceFile, BuildInputRead read) {
        sourceFile << """
            ${read.requiredImports().collect { "import $it" }.join("\n")}

            println("apply = " + ${read.groovyExpression})
            tasks.register("thing") {

import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.api.Task
import org.gradle.test.fixtures.file.TestFile

trait JavaPluginImplementation {
    void javaPlugin(TestFile sourceFile, BuildInputRead read) {
        sourceFile << """
            import ${Action.name};
            import ${Project.name};
            import ${Plugin.name};
            import ${Task.name};

                toolchain {
                    languageVersion = JavaLanguageVersion.of(${version.majorVersion})
                }
            }
        """

        def sourceFile = file("src/main/java/Thing.java")
        sourceFile << """
            import java.util.List;
            import java.util.ArrayList;

            public class Thing {
                public Thing() {

) : KaKlibSourceFileNameProvider() {
    override fun getKlibSourceFileName(declaration: KaDeclarationSymbol): String? {
        require(declaration is KaFirSymbol<*>)
        val sourceFile = declaration.firSymbol.klibSourceFile ?: return null
        return sourceFile.name
    }

        debugX86Binary.name == 'mainDebugX86'
        debugX86Binary.variantName == 'debugX86'
        debugX86Binary.baseName == 'app'
        debugX86Binary.compilationDetails.sources.sourceFile as Set == [src1, src2] as Set
        debugX86Binary.compilationDetails.sources.objectFile.each { assert it != null }
        debugX86Binary.compilationDetails.headerDirs == [headerDir] as Set

import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
import org.jetbrains.kotlin.analysis.api.symbols.KaDeclarationSymbol
import org.jetbrains.kotlin.descriptors.SourceFile
import org.jetbrains.kotlin.psi.KtDeclaration

@KaAnalysisNonPublicApi
public abstract class KaKlibSourceFileNameProvider : KaSessionComponent() {

        private final TestFile sourceFile
        private int warningIndex = 0
        private int errorIndex = 0

        ProblematicClassGenerator(String className = "Foo", String sourceSet = "main") {
            this.sourceFile = file("src/${sourceSet}/java/${className}.java")

            // Get the class name from the file name
            this.sourceFile << """\
public class ${className} {

"""