@OutputFile
    abstract RegularFileProperty getDestination()

    @TaskAction
    def greet() {
        def file = getDestination().get().asFile
        if (source.get().asFile.exists()) {
            file.write("Hello ${source.get().asFile.text}!")
        } else {
            file.write 'Hello missing file!'
        }
    }
}
// end::task[]

// tag::config[]

    @get:OutputFile
    abstract val destination: RegularFileProperty

    @TaskAction
    fun greet() {
        val file = destination.get().asFile
        if (source.get().asFile.exists()) {
            file.writeText("Hello ${source.get().asFile.readText()}")
        } else {
            file.writeText("Hello missing file!")
        }
    }
}
// end::task[]

// tag::config[]

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

                @TaskAction
                void run() {
                    def input = inputDirectory.file("output.txt").get().asFile
                    if (input.file) {
                        outputFile.asFile.get().text = input.text
                    } else {
                        outputFile.asFile.get().text = "<empty>"
                    }
                }
            }

            task sourceTask(type: Producer) {

    @Inject
    abstract ProjectLayout getProjectLayout()

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

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

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

        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"
        }
    }
}