} else {
            throw new GradleException(message, e);
        }
    }

    @OutputDirectory
    public File getOutputDir() {
        return outputDir;
    }

    public void setOutputDir(File outputDir) {
        this.outputDir = outputDir;
    }

    /**
     * {@inheritDoc}
     */
    @Input
    @Override
    public boolean getIgnoreFailures() {
        return ignoreFailures;
    }

     * The output directory for production classes.
     * If {@code null}, no entry will be created.
     */
    public Path getOutputDir() {
        return outputDir;
    }

    public void setOutputDir(Path outputDir) {
        this.outputDir = outputDir;
    }

    /**
     * The output directory for test classes.
     * If {@code null}, no entry will be created.
     */

).document


private
fun writePluginsBlockTo(
    outputDir: File,
    scriptPlugin: PrecompiledScriptPlugin,
    program: Program.Plugins
) {
    outputFileFor(scriptPlugin, outputDir).writeText(
        packageDeclarationOf(scriptPlugin) + lineNumberPreservingTextOf(program)
    )
}


private
fun outputFileFor(scriptPlugin: PrecompiledScriptPlugin, outputDir: File) =

    templateEngine = TemplateEngineType.FREEMARKER
    sourceFiles.from(fileTree("src/templates"))
    templateData.name = "test"
    templateData.variables = mapOf("year" to "2012")
    outputDir = file(layout.buildDirectory.dir("genOutput"))
}

interface Injected {
    @get:Inject val fs: FileSystemOperations
}

// tag::ad-hoc-task[]
tasks.register("processTemplatesAdHoc") {

                parameters.destinationDir = outputDir
            }
        }

        // Wait for all asynchronous work submitted to this queue to complete before continuing
        workQueue.await()
        logger.lifecycle("Created ${outputDir.get().asFile.listFiles().length} reversed files in ${projectLayout.projectDirectory.asFile.relativePath(outputDir.get().asFile)}")

        // end::wait-for-completion[]
    }

                void processChanges(InputChanges changes) {
                    outputDir.file("output.txt").get().asFile.text = input.get()
                }
            }

            task incremental(type: IncrementalTask) {
                sources = file("sources")
                input = providers.systemProperty("outputDir")
                outputDir = file("build/\${input.get()}")
            }
        """

        source.forEach { file ->
            workQueue.submit(ReverseFile::class) {
                fileToReverse = file
                destinationDir = outputDir
            }
        }
    }
}
// end::task-implementation[]

tasks.register<ReverseFiles>("reverseFiles") {
    outputDir = layout.buildDirectory.dir("reversed")
    source("sources")

                packageName
            )
        }
        metadataOutputDir.withOutputDirectory { outputDir ->
            outputDir.resolve("implicit-imports").writeText(
                "$packageName.*"
            )
        }
    }

    private
    fun createPackageDirIn(outputDir: File, packageName: String) =
        outputDir.resolve(packagePath(packageName)).apply { mkdirs() }

    private

        File outputDir;
        if (crossVersion) {
            String version = ((GradleBuildExperimentSpec) spec).getInvocation().getGradleDistribution().getVersion().getVersion();
            outputDir = new File(outputDirSelector.outputDirFor(testId), version);
        } else {

        def outputFile = temporaryFolder.file("output.txt")
        def outputDir = temporaryFolder.file("outputDir")
        def outputDirFile = outputDir.file("file.txt")
        def input = temporaryFolder.createFile("input")
        def entity = entity(
            prop("outputDir", DIRECTORY, outputDir),
            prop("outputFile", FILE, outputFile)
        )