Laura Kassovic <******@****.***> 1701107622 -0800

                inputFile: file(providers.gradleProperty('inputFile').get())
            )
        """
        file('inputFile.txt').text = "Test"

        expect:
        succeeds "test", "-PinputFile=inputFile.txt"

        when:
        file('different-file.txt').text = "Test"
        file("inputFile.txt").delete()
        run "test", "-PinputFile=different-file.txt"

        then:
        skipped(":test")

        when:

    public File getInputFile() {
        return inputFile != null ? inputFile : getOutputFile();
    }

    // Workaround for when the task is given an input file that doesn't exist
    @Nullable  @Optional
    @PathSensitive(PathSensitivity.NONE)
    @InputFile
    protected File getInputFileIfExists() {
        File inputFile = getInputFile();
        if (inputFile != null && inputFile.exists()) {
            return inputFile;

        def inputFile = file("input.txt")
        buildFile << """
            def inputFile = file("input.txt")
            def outputFile = file("build/output.txt")

            task consumer {
                inputs.file(inputFile)
                outputs.file(outputFile)
                doLast {
                    outputFile.text = inputFile.text
                }

import org.gradle.api.tasks.CacheableTask
import org.gradle.api.tasks.InputFile
import org.gradle.api.tasks.OutputFile
import org.gradle.api.tasks.PathSensitive
import org.gradle.api.tasks.PathSensitivity
import org.gradle.api.tasks.TaskAction

@CacheableTask
class MyCacheableTask extends DefaultTask {
    @InputFile
    @PathSensitive(PathSensitivity.NONE)
    File inputFile
    @OutputFile
    File outputFile

    @TaskAction

        output.text = message
        logger.quiet("Wrote '${message}' to ${output}")
    }
}

abstract class Consumer extends DefaultTask {
    @InputFile
    abstract RegularFileProperty getInputFile()

    @TaskAction
    void consume() {
        def input = inputFile.get().asFile
        def message = input.text
        logger.quiet("Read '${message}' from ${input}")
    }
}

        when:
        task.inputFile = null

        then:
        task.inputFile == task.outputFile

        when:
        task.inputFile = inputFile

        then:
        task.inputFile == inputFile
    }

    def mergesConfigurationWhenInputFileExists() {
        def configObject = new TestConfigurationObject()
        inputFile.text = 'config'

        when:
        task.generate()

    def workerDaemonIdentityFileName = "build/workerId"
    def workerDaemonIdentityFile = file(workerDaemonIdentityFileName)
    def inputFile = file("inputFile")

    def setup() {
        workerDaemonIdentityFile.createFile()
        buildFile << """
            $taskTypeUsingWorkerDaemon
        """
        inputFile.text = "build 1"
    }

    def "reuses worker daemons across builds in a single session"() {
        buildFile << """

        skipped(":signCustomFile")
    }

    def "up-to-date when order of signed files changes"() {
        given:
        def inputFile1 = file("input1.txt") << "foo"
        def inputFile2 = file("input2.txt") << "bar"
        def writeBuildFile = { TestFile... inputFiles ->
            buildFile.text = """
            apply plugin: 'signing'
            ${keyInfo.addAsPropertiesScript()}
            signing {

    def projectDir = file("project")
    def inputFile = projectDir.file("input.txt")

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