@OutputDirectories
                final SetProperty<Directory> outputDirs = project.objects.setProperty(Directory)

                @TaskAction
                void go() {
                    def content = inputFile.get().asFile.text
                    outputDirs.get().each { outputDir ->
                         new File(outputDir.asFile, "file.txt").text = content
                    }
                }

     * 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()}")
            }
        """

    Logger logger = Mock()
    def outputDir = tmpDirProvider.testDirectory.file("logs")
    DefaultBuildOperationLoggerFactory factory = new DefaultBuildOperationLoggerFactory(logger)

    def "enabling debug causes all failures to be logged"() {
        given:
        logger.isDebugEnabled() >> debugEnabled
        def outputFile = outputDir.file("test.out")
        when:

        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 {