tasks.register('originalInputs') {
    def inputsDir = layout.projectDirectory.dir('inputs')
    outputs.dir(inputsDir)
    doLast {
        inputsDir.file('1.txt').asFile.text = 'Content for file 1.'
        inputsDir.file('2.txt').asFile.text = 'Content for file 2.'
        inputsDir.file('3.txt').asFile.text = 'Content for file 3.'
    }
}

// tag::updated-inputs[]
tasks.register('updateInputs') {

                             it.outputLocation.asFile.get() << project.value
                         } else {
                             assert it.outputLocation.asFile.get().exists() && it.outputLocation.asFile.get().directory
                             new File(it.outputLocation.asFile.get(), "file1") << project.value

                @OutputFile
                abstract RegularFileProperty getOutputFile()
                @TaskAction
                void doStuff() {
                    outputFile.get().asFile.text = inputFile.get().asFile.text
                }
            }
            tasks.register("myTask", MyTask) {
                inputFile = file("input.txt")
                outputFile = project.layout.buildDirectory.file("output.txt")

        task.scalaCompileOptions.incrementalOptions.analysisFile.get().asFile == new File("$project.buildDir/tmp/scala/compilerAnalysis/compileCustomScala.analysis")
        task.scalaCompileOptions.incrementalOptions.classfileBackupDir.get().asFile == new File("$project.buildDir/tmp/scala/classfileBackup/compileCustomScala.bak")
        task.scalaCompileOptions.incrementalOptions.publishedCode.get().asFile == project.tasks['customJar'].archiveFile.get().asFile

        return gson.toJson(subprojects) + '\n'
    }

    private
    fun generateSubprojectsDirectories(): List<File> {
        val subprojectRoots = platformsFolder.asFile.listFiles(File::isDirectory).plus(subprojectsFolder.asFile).plus(testingFolder.asFile)
        return subprojectRoots.map { it.listFiles(File::isDirectory).asList() }.flatten()
    }

    private
    fun generateSubprojects(): List<GradleSubproject> {

        execOps.exec {
            executable = javaExecutable.get().asFile.absolutePath
            args = listOf("-version")
            standardOutput = outputBytes
            errorOutput = outputBytes
        }
        require(outputBytes.toString("UTF-8").contains("version \"11")) {
            "unexpected '${javaExecutable.get().asFile.absolutePath} -version' output"
        }
    }
}

        }
    }

    @Override
    public Reader asReader() {
        File file = asFile();
        try {
            return Files.newReader(asFile(), charset);
        } catch (FileNotFoundException e) {
            throw ResourceExceptions.readMissing(file, e);
        }
    }

    @Override
    public File asFile(String targetCharset) {
        try {

    @Inject
    abstract ProjectLayout getProjectLayout()

    @TaskAction
    void run() {
        File bundleFile = projectLayout.buildDirectory.file("bundle.js").get().asFile
        File[] scriptsFiles = projectLayout.projectDirectory.dir("scripts").asFile.listFiles()

        bundleFile.withOutputStream { stream ->
            scriptsFiles.sort().each {
                stream.write(it.bytes)
            }
        }
    }
}

        srcDir = projectDirectory.file('src').asFile
        println "Contents of $srcDir.name"
        collection.collect { projectDirectory.asFile.relativePath(it) }.sort().each { println it }

        srcDir = projectDirectory.file('src2').asFile
        println "Contents of $srcDir.name"
        collection.collect { projectDirectory.asFile.relativePath(it) }.sort().each { println it }
    }
}
// end::closure[]

        task instanceof War
        dependsOn(JvmConstants.CLASSES_TASK_NAME, JvmConstants.COMPILE_JAVA_TASK_NAME).matches(task)
        task.destinationDirectory.get().asFile == project.libsDirectory.get().asFile

        when:
        task = project.tasks[BasePlugin.ASSEMBLE_TASK_NAME]

        then:
        dependsOn(WarPlugin.WAR_TASK_NAME).matches(task)
    }