@OutputFile
                val outFile: RegularFileProperty = project.objects.fileProperty()

                @TaskAction
                fun run() {
                    outFile.get().asFile.writeText("content")
                }
            }
        """
    }

    @Override
    void taskWithNestedBeanDefinition() {
        pluginDir.file("src/main/kotlin/ProducerTask.kt") << """

        buildFile << """
            task producer(type: FileProducer) {
                output = layout.buildDir.file("text.out")
            }
            def prop = producer.output.map { it.asFile.file ? it.asFile.text : "(null)" }
            println("prop = " + prop.get())
        """

        when:
        fails("producer")

        then:

        if (!distribution.isFile) {
            throw IllegalStateException("${distribution.absolutePath} doesn't exist. Did you set the wrong base version?\n${distribution.parentFile.list()?.joinToString("\n")}")
        }
        distribution.copyTo(commitDistribution.asFile.get(), true)
    }

    private
    fun tryBuildDistribution(checkoutDir: File) {

        val message = "Hello, World!"
        val output = outputFile.get().asFile
        output.writeText( message)
        logger.quiet("Wrote '${message}' to ${output}")
    }
}

abstract class Consumer : DefaultTask() {
    @get:InputFile
    abstract val inputFile: RegularFileProperty

    @TaskAction
    fun consume() {
        val input = inputFile.get().asFile
        val message = input.readText()

// end::executableDir-conf[]

// tag::distribution-spec[]
tasks.register('createDocs') {
    def docs = layout.buildDirectory.dir('docs')
    outputs.dir docs
    doLast {
        docs.get().asFile.mkdirs()
        docs.get().file('readme.txt').asFile.write('Read me!')
    }
}

distributions {
    main {
        contents {
            from(createDocs) {
                into 'docs'
            }
        }
    }
}

    def testResultsDir = project.java.testResultsDir

    doLast {
        logger.quiet(rootDir.toPath().relativize(reportsDir.get().asFile.toPath()).toString())
        logger.quiet(rootDir.toPath().relativize(testResultsDir.get().asFile.toPath()).toString())
    }
}

    @InputArtifact
    abstract Provider<FileSystemLocation> getInput()

    @Override
    void transform(TransformOutputs outputs) {
        def outputDir = outputs.dir("${input.get().asFile.name}.loc")
        println("Running transform on ${input.get().asFile.name}, incremental: ${inputChanges.incremental}")
        inputChanges.getFileChanges(input).forEach { change ->          // <2>
            def changedFile = change.file

    }
}
// end::integTest[]

// tag::distributionPathInput[]
// Don't do this! Breaks relocatability!
tasks.named('integTest') {
    systemProperty "distribution.location", layout.buildDirectory.dir('dist').get().asFile.absolutePath
}
// end::distributionPathInput[]

// tag::distributionDirInput[]
abstract class DistributionLocationProvider implements CommandLineArgumentProvider {  // <1>
    @InputDirectory

                    def input = inputArtifact.get().asFile
                    println "processing \${input.name} using \${parameters.someFile.get().asFile.name}"
                    def output = outputs.file(input.name + ".green")
                    output.text = input.text + parameters.someFile.get().asFile.text + ".green"
                }
            }
        """

        when:

        val output = outputFile.get().asFile
        output.writeText( message)
        logger.quiet("Wrote '${message}' to ${output}")
    }
}

abstract class Consumer : DefaultTask() {
    @get:InputFiles
    abstract val inputFiles: ListProperty<RegularFile>

    @TaskAction
    fun consume() {
        inputFiles.get().forEach { inputFile ->
            val input = inputFile.asFile
            val message = input.readText()