this.systemPropertyAccess = systemPropertyAccess
        }

        @Override
        String toString() {
            return "definitions: ${systemPropertyDefinitions.join(", ")}, access: $systemPropertyAccess"
        }

        SystemPropertiesCompositeBuildFixture createFixtureFor(AbstractConfigurationCacheIntegrationTest test, String propertyKey) {

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

            class SneakyPlugin: Plugin<Project> {
                override fun apply(project: Project) {
                    var value = ${read.kotlinExpression}
                    println("apply = " + value)

        return "Settings file 'settings.gradle.kts'"
    }

    @Override
    void buildLogicApplication(BuildInputRead read) {
        settingsKotlinFile << """
            ${read.requiredImports().collect { "import $it" }.join("\n")}

            println("apply = " + ${read.kotlinExpression})

            gradle.rootProject {
                tasks.register("thing") {
                    doLast {

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") {
                doLast {
                    println("task = " + ${read.groovyExpression})
                }

        sourceFile << """
            import ${Action.name};
            import ${Project.name};
            import ${Plugin.name};
            import ${Task.name};
            ${read.requiredImports().collect { "import $it;" }.join("\n")}

            public class SneakyPlugin implements Plugin<Project> {
                public void apply(Project project) {
                    Object value = ${read.javaExpression};

                        into("build/output")
                    }
                """
            }
        }

        @Override
        String toString() {
            return "${locations.join(" and ")} settings${scriptLanguage}"
        }
    }

    static enum ScriptLanguage {

        GROOVY(".gradle"),
        KOTLIN(".gradle.kts")

        private final String extension

        return "Settings file 'settings.gradle'"
    }

    @Override
    void buildLogicApplication(BuildInputRead read) {
        settingsFile << """
            ${read.requiredImports().collect { "import $it" }.join("\n")}

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

        return "Build file 'build.gradle.kts'"
    }

    @Override
    void buildLogicApplication(BuildInputRead read) {
        buildKotlinFile << """
            ${read.requiredImports().collect { "import $it" }.join("\n")}

            plugins {
                println("apply = " + ${read.kotlinExpression})
            }
            tasks.register("thing") {
                doLast {

        return addToList(item) + "\n" + addToBaz(item)
    }

    static String dependencyFor(String configuration, String[] dependencies) {
        return dependencies.collect { dependency(configuration, it) }.join("\n")
    }

    static String dependency(String configuration, String dependency) {
        return dependency.startsWith("project(") ? "${configuration}(${dependency})" : "${configuration}(\"${dependency}\")"
    }

                abstract RegularFileProperty getOutputFile()

                @TaskAction
                void run() {
                    outputFile.get().asFile.text = inputFiles.files.collect { it.text }.join()
                }
            }

            def producer = tasks.register('producer', ConcatTask) {
                inputFiles.from(file("producer-input.txt"))