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

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

        when:

            </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()) {

        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)

        def sarifSupported = isSarifSupported(currentToolVersion)

        if (isHtmlReportEnabledOnly(isXmlRequired, isHtmlRequired)) {
            xmlOutputLocation = new File(parameters.temporaryDir.asFile.get(), xmlOutputLocation.name)
        }

        if (configDir) {
            // User provided their own config_loc
            def userProvidedConfigLoc = configProperties[CONFIG_LOC_PROPERTY]

            @CacheableTask
            class CustomTask extends DefaultTask {
                @Input
                String val

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

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