@TaskAction
                void go() {
                    def file = outputFile.asFile.get()
                    file.text = inputFiles.get()*.asFile.text.join(',')
                }
            }

            task createFile1(type: FileOutputTask)
            task createFile2(type: FileOutputTask)
            task merge(type: MergeTask) {

            }
        )
    }

    private File setOfAutomaticAccessorsFor(Iterable<String> plugins) {
        withDefaultSettings()
        def buildFile = withBuildScript("plugins {\n${plugins.join("\n")}\n}")
        def classFilePath = accessorsClassFor(buildFile).toPath()
        return projectDir.toPath().relativize(classFilePath).toFile()
    }

    private File accessorsClassFor(File buildFile) {

            this.systemPropertyAccess = systemPropertyAccess
        }

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

        SystemPropertiesCompositeBuildFixture createFixtureFor(AbstractConfigurationCacheIntegrationTest test, String propertyKey) {

                @TaskAction
                void go() {
                    def file = outputFile.asFile.get()
                    file.text = inputDir.asFile.get().listFiles()*.text.join(',')
                }
            }

            task createDir(type: DirOutputTask)
            task merge(type: MergeTask) {
                outputFile = layout.buildDirectory.file("merged.txt")

    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};

                final RegularFileProperty outputFile = project.objects.fileProperty()

                @TaskAction
                def go() {
                    def names = sourceFiles.files.name.sort().join(",")
                    outputFile.asFile.get().text = names
                }
            }

            task generate(type: SomeTask) {
                sourceFiles.from("src")

            return accessor.getBinaryCompatibility() == BinaryCompatibility.ACCESSORS_KEPT;
        });
        if (!keptAccessors.isEmpty()) {
            String formattedLeft = CollectionUtils.join("\n", keptAccessors.keySet());
            throw new RuntimeException("The following accessors were upgraded, but didn't match any removed/changed method:\n\n" + formattedLeft);
        }