buildFile << """
            task incrementalTask(type: MyIncrementalTask) {
                inputDir = file('src')
            }

            class MyIncrementalTask extends DefaultTask {
                ${supportsInputChanges ? "@Incremental" : ""}
                @InputDirectory
                def File inputDir
                @TaskAction
                void doSomething(${parameterType} inputs) {}

                inputDir = file("inputs")
                inputFile = file("input.txt")
                input = "This is the text"
                outputDir = file("$buildDir/outputDir")
                outputFile = file("$buildDir/outputFile")
            }

            abstract class MyTask extends DefaultTask {
                @InputDirectory File inputDir
                @Input String input

    def "properly captures all attributes"() {
        given:
        withBuildCache()
        buildFile << """
            task customTask {
                inputs.dir('foo')
                    .withPropertyName('inputDir')
                    .withPathSensitivity(PathSensitivity.$pathSensitivity)
                    .ignoreEmptyDirectories($ignoreEmptyDirectories)
                    .normalizeLineEndings($ignoreLineEndings)

                    new File(outputDir, "source").text = "fixed"
                }
            }

            task secondTask {
                def inputDir = file("${outputDir}")
                def outputDir = file("${sourceDir}")
                inputs.dir(inputDir)
                outputs.dir(outputDir)
                doLast {
                    new File(outputDir, "source").text = "fixed"
                }
            }

 *
 *     {@literal @}OutputDirectory
 *     abstract DirectoryProperty getOutputDir()
 *
 *     {@literal @}TaskAction
 *     void execute(InputChanges inputChanges) {
 *         inputChanges.getFileChanges(inputDir).each { change ->
 *             if (change.fileType == FileType.DIRECTORY) return
 *
 *             def targetFile = outputDir.file(change.normalizedPath).get().asFile

====
[.multi-language-sample]
=====
[source,kotlin]
.build.gradle.kts
----
public class IncrementalReverseTask : DefaultTask() {

    @get:Incremental
    @get:InputDirectory
    val inputDir: DirectoryProperty = project.objects.directoryProperty()

    @get:OutputDirectory
    val outputDir: DirectoryProperty = project.objects.directoryProperty()

    @get:Input

        enableProblemsApiCheck()
        expectReindentedValidationMessage()
        file("input-file.txt").touch()

        def inputDir = file("input-dir")
        inputDir.createDir()
        buildFile """
            task test {
                inputs.${method}({ "$path" }) withPropertyName "input"
                doLast {}
            }
        """

                    task.inputFiles = originalPropertyValue
                }
            }
        """
        def inputDir1 = file("input1").createDir()
        def inputDir2 = file("input2").createDir()
        def inputFileName = "inputFile.txt"
        def inputFile = inputDir1.file(inputFileName)
        inputFile.text = "input"

        when:
        run "customTask"
        then:

                final SetProperty<Directory> inputDirs = project.objects.setProperty(Directory)
                @OutputFile
                final RegularFileProperty outputFile = project.objects.fileProperty()

                @TaskAction
                void go() {
                    def file = outputFile.asFile.get()
                    file.text = inputDirs.get()*.asFile*.listFiles().text.flatten().join(',')

        readingList.add(toKatakana(text));
        return readingList;
    }

    protected String toKatakana(final String inputStr) throws IOException {
        final StringBuilder kanaBuf = new StringBuilder();

        final Reader rd = new StringReader(inputStr);
        try (TokenStream stream = createTokenStream(rd)) {
            if (stream == null) {
                throw new IOException("Invalid tokenizer.");