root.file(inputFileName) << 'content'

        def outputFile = file("output.txt")

        def taskName = 'inputFromFilesystemRoot'
        def script = """
            class InputDirectoryContentToOutputFileAction extends DefaultTask {
                @InputDirectory File inputDirectory
                @OutputFile File output

                @TaskAction def execute() {

        executedAndNotSkipped(":createFile")

        when:
        assert outputFile.delete()
        withBuildCache().run("createFile", "-Dfile.encoding=$fileEncoding")
        skipped(":createFile")

        then:
        output.contains("> Default charset: $fileEncoding")
        outputFile.text == "output"

        where:
        fileEncoding << DEFAULT_ENCODINGS
    }

     */
    @Nullable
    @Optional
    @OutputFile
    public File getOutputFile() {
        return outputFile;
    }

    /**
     * Sets the file which the report will be written to. Set this to {@code null} to write the report to {@code System.out}.
     *
     * @param outputFile The output file. May be null.
     */
    public void setOutputFile(@Nullable File outputFile) {
        this.outputFile = outputFile;

        then:
        executedAndNotSkipped ":run"

        when:
        def secondInputFile = file("second-input.txt")
        secondInputFile.text = inputFile.text
        run "run", "-PinputFile=${secondInputFile.absolutePath}", "-PoutputFile=${outputFile.absolutePath}"
        then:
        outputFile.text == "first"
        skipped ":run"

                Path inputFile
                @InputDirectory
                Path inputDir
                @OutputFile
                Path outputFile
                @OutputDirectory
                Path outputDir

                @TaskAction
                def go() {
                    outputFile.toFile().text = inputFile.toFile().text

                @OutputFile
                abstract RegularFileProperty getDirName()

                @TaskAction
                def produce() {
                    dirName.get().asFile.text = 'dir'
                }
            }

            abstract class Consumer extends DefaultTask {

                @OutputFile
                abstract RegularFileProperty getOutputFile()

        zipFile.stream().forEach { entry ->
            if (entry.shouldInclude()) {
                val outputFile = outputRoot.resolve(entry.name)
                outputFile.parentFile.mkdirs()
                zipFile.getInputStream(entry).use { input ->
                    outputFile.outputStream().use { output ->
                        input.copyTo(output)
                    }
                }
            }

            task myTask {
                def inputFile = file("${inputFile.name}")
                def outputFile = file("build/output.txt")
                outputs.file(outputFile)
                inputs.file(inputFile)
                doLast {
                    outputFile.text = inputFile.text
                }
            }
        """

        inputFile.text = "input"

                @OutputFile File outputFile

                @TaskAction void doSomething() {
                    outputFile.parentFile.mkdirs()
                    outputFile.text = inputFile.text + '$suffix'
                }
            }

            task customTask(type: CustomTask) {
                inputFile = file "input.txt"
                outputFile = file "build/output.txt"

                @get:InputFile @get:PathSensitive(PathSensitivity.NONE) var inputFile: File? = null
                @get:OutputFile var outputFile: File? = null
                @TaskAction fun doSomething() {
                    outputFile!!.apply {
                        parentFile.mkdirs()
                        writeText(inputFile!!.readText())
                        appendText("$suffix")