queue.addAll(classTrees.getOrDefault(className, emptySet()))
            }
        }

        JarOutputStream(BufferedOutputStream(FileOutputStream(jarFile.get().asFile))).use { jarOutputStream ->
            if (!manifests.isEmpty) {
                jarOutputStream.addJarEntry(JarFile.MANIFEST_NAME, manifests.first())
            }
            if (!buildReceiptFile.isEmpty) {

                            file("test-api-changes.json"),
                            rootProject.layout.projectDirectory,
                            newUpgradedPropertiesFile.get().asFile,
                            oldUpgradedPropertiesFile.get().asFile
                        )
                    }
                    """
                )
            }
        }
    }

    internal

                        outputFile << "[END \$event.status]\\n"
                    }
                }

                private File getOutputFile() {
                    parameters.outputFile.get().asFile
                }

                void started(BuildOperationDescriptor buildOperation, OperationStartEvent startEvent) {}

                @OutputFile
                abstract RegularFileProperty getOutputFile()

                @TaskAction
                void myAction() {
                    def output = outputFile.get().asFile
                    output << launcher1.get().executablePath
                }
            }

            tasks.register("myToolchainTask", ToolchainTask) {

checkstyle {
    toolVersion = "8.12"
    config = configFile("checkstyle.xml")
    val projectDirectory = layout.projectDirectory
    configDirectory = rules.elements.map {
        projectDirectory.dir(it.single().asFile.absolutePath).dir("checkstyle")
    }
}

plugins.withType<GroovyBasePlugin> {
    the<SourceSetContainer>().all {
        tasks.register<Checkstyle>(getTaskName("checkstyle", "groovy")) {

                @Input
                Thing thing

                @OutputFile
                RegularFile outputFile

                @TaskAction def go() {
                    outputFile.asFile.text = thing.name
                }
            }

            task a(type: ThingTask) {
                thing = objects.named(Thing, providers.systemProperty('name').getOrElse('a'))

                    })
                }

                @TaskAction
                void zipSources() {
                    ${server.callFromBuild("zipFileSnapshottingFinished")}
                    zipFile.get().asFile.text = "output"
                }
            }

            task srcZip(type: ZipSrc) {
                sources = rootProject.file("lib")
                zipFile = file("build/srcZip.zip")
            }

                @OutputFile
                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"))

            selectHighestVersion()
        }
    }
}

fun readCapabilitiesFromJson() {
    val capabilitiesFile = repoRoot().file("gradle/dependency-management/capabilities.json").asFile
    val capabilities: List<CapabilitySpec> = readCapabilities(capabilitiesFile)
    capabilities.forEach {
        it.configure(dependencies.components, configurations)
    }
}

                @Inject abstract ArchiveOperations getArchiveOperations()

                @TaskAction
                void update() {
                    FileTree tree = archiveOperations.${archiveType}Tree(archive.asFile.get())
                    tree.visit(new EditingFileVisitor())
                }

                private final class EditingFileVisitor implements FileVisitor {
                    @Override