private static final String INCREMENTAL_TASK_NAME = "incrementalTask"

    @Issue("https://github.com/gradle/gradle/issues/9320")
    def "incremental task with NAME_ONLY input (matching file names and content) detects changed input"() {
        def inputs = folderNames().collect { file("${it}/input.txt").createFile() }
        def modifiedInput = inputs[1]

        switch (pathSensitivity) {
            case NONE:
                return IGNORE_PATH;
            case NAME_ONLY:
                return NAME_ONLY;
            case RELATIVE:
                return RELATIVE_PATH;
            case ABSOLUTE:
                return ABSOLUTE_PATH;
            default:

 */

package org.gradle.api.tasks

import org.gradle.integtests.fixtures.AbstractIntegrationSpec

import static org.gradle.api.tasks.PathSensitivity.ABSOLUTE
import static org.gradle.api.tasks.PathSensitivity.NAME_ONLY
import static org.gradle.api.tasks.PathSensitivity.NONE
import static org.gradle.api.tasks.PathSensitivity.RELATIVE

abstract class AbstractPathSensitivityIntegrationSpec extends AbstractIntegrationSpec {

        super(new NameOnlyFingerprintingStrategy(directorySensitivity, normalizedContentHasher), fileCollectionSnapshotter);
    }

    @Override
    public FileNormalizer getNormalizer() {
        return InputNormalizer.NAME_ONLY;
    }

        then:
        executedAndNotSkipped(":taskWithInputs")

        where:
        [api, pathSensitivity] << [Api.values(), [PathSensitivity.RELATIVE, PathSensitivity.ABSOLUTE, PathSensitivity.NAME_ONLY]].combinations()
    }

    def "input directories ignore empty directories by default (#api)"() {
        buildFile """
            @CacheableTask
            abstract class TaskWithInputs extends DefaultTask {

// tag::incremental-task[]
abstract class IncrementalReverseTask : DefaultTask() {
    @get:Incremental
    @get:PathSensitive(PathSensitivity.NAME_ONLY)
    @get:InputDirectory
    abstract val inputDir: DirectoryProperty

    @get:OutputDirectory
    abstract val outputDir: DirectoryProperty

    @get:Input
    abstract val inputProperty: Property<String>

 *
 * {@literal @}CacheableTransform
 * public abstract class MyTransform implements TransformAction<TransformParameters.None> {
 *     {@literal @}PathSensitive(PathSensitivity.NAME_ONLY)
 *     {@literal @}InputArtifact
 *     public abstract Provider<FileSystemLocation> getInputArtifact();
 *
 *     {@literal @}Classpath
 *     {@literal @}InputArtifactDependencies

         */
        @InputFiles
        @PathSensitive(PathSensitivity.NAME_ONLY)
        ConfigurableFileCollection getTypeHierarchyAnalysis();
    }

    @Inject
    public abstract ObjectFactory getObjects();

    @PathSensitive(PathSensitivity.NAME_ONLY)
    @InputArtifact
    public abstract Provider<FileSystemLocation> getInput();

    @Override

@CompileStatic
@DisableCachingByDefault(because = "Only filters the input artifact")
abstract class FindGradleClasspath implements TransformAction<TransformParameters.None> {

    @PathSensitive(PathSensitivity.NAME_ONLY)
    @InputArtifact
    abstract Provider<FileSystemLocation> getArtifact()

    @Override
    void transform(TransformOutputs outputs) {
        File artifactFile = artifact.get().asFile

incrementalReverse.mustRunAfter(originalInputs, updateInputs, removeInput, removeOutput)

// tag::incremental-task[]
abstract class IncrementalReverseTask extends DefaultTask {
    @Incremental
    @PathSensitive(PathSensitivity.NAME_ONLY)
    @InputDirectory
    abstract DirectoryProperty getInputDir()

    @OutputDirectory
    abstract DirectoryProperty getOutputDir()

    @Input
    abstract Property<String> getInputProperty()