library {
                    def generatorTask = tasks.register('generatePublicHeaders', Sync) {
                        from(rootProject.file('staging-includes'))
                        into({ temporaryDir })
                    }

                    publicHeaders.from(generatorTask)
                }
            '''
        }
        writeLogLibrary()

        when:

        file("output.txt").bytes = bytes

        buildFile << """
            @CacheableTask
            abstract class CustomTask extends DefaultTask {
                @OutputFile File outputFile = new File(temporaryDir, "output.txt")
                @Input String run = project.findProperty("run") ?: ""
                @javax.inject.Inject abstract FileSystemOperations getFs()
                @TaskAction
                void generate() {

            </tr>
            <tr>
                <td>localState</td>
            </tr>
            <tr>
                <td>destroyables</td>
            </tr>
            <tr>
                <td>temporaryDir</td>
            </tr>
            <tr>
                <td>taskDependencies</td>
            </tr>
            <tr>
                <td>dependsOn</td>
            </tr>
            <tr>

                FileCollection getProcessorListFile() {
                    this.processorListFile
                }

                @OutputFile
                File outputFile = new File(temporaryDir, "output")

                @TaskAction
                void doSomething() {
                    outputFile.text = "done"
                }
            }

            task broken(type: Broken) {

    @TaskAction
    void checkoutAndCopy() {
        outputDirectory.deleteDir()
        File checkoutDir = checkout(fsOps, execOps, remoteUri.get(), ref.get(), temporaryDir)
        moveToOutputDir(checkoutDir, outputDirectory, subdirectory.getOrNull())
    }

    private static File cleanTemporaryDir(FileSystemOperations fsOps, File tmpDir) {
        if (tmpDir.exists()) {

        logging.captureStandardOutput(LogLevel.INFO)
        logging.captureStandardError(LogLevel.INFO)

        def destDir = destinationDirectory.get().asFile
        fs.delete {
            delete(destDir, temporaryDir)
        }

        def xslClasspath = classpath.plus(objects.fileCollection().from(ClasspathUtil.getClasspathForClass(XslTransformer)))

        fs.copy {
            from(getStylesheetDirectory()) {

                generateTypeSafeAccessorsFor(projectScriptPlugins)
            }
        }
    }

    private
    fun recreateTaskDirectories() {
        recreate(temporaryDir)
        recreate(sourceCodeOutputDir.get().asFile)
        recreate(metadataOutputDir.get().asFile)
    }

    private

        val commit = commitBaseline.map { it.substring(it.lastIndexOf('-') + 1) }
        val checkoutDir = RemoteProject.checkout(fsOps, execOps, rootProjectDir, commit.get(), temporaryDir)

        tryBuildDistribution(checkoutDir)
        copyToFinalDestination(checkoutDir)

        println("Building the commit distribution in $checkoutDir succeeded, now the baseline is ${commitBaseline.get()}")
    }

                    @get: Nested
                    lateinit var action: ${actionType}

                    @get: OutputFile
                    var outputFile: File = File(temporaryDir, "output.txt")

                    @TaskAction
                    fun generate() {
                        action${actionInvocation}(outputFile)
                    }
                }
            """

    private static String customTaskCode() {
        """
            @CacheableTask
            class CustomTask extends DefaultTask {
                @OutputFile
                File outputFile = new File(temporaryDir, "output.txt")

                @TaskAction
                void generate() {
                    outputFile.text = "done"
                }
            }

            task customTask(type: CustomTask)