}


    def "cacheability for a task with no outputs is NOT_ENABLED_FOR_TASK"() {
        buildFile """
            task noOutputs(type: NoOutputs) {}
        """
        when:
        withBuildCache().run "noOutputs"
        then:
        assertCachingDisabledFor NOT_ENABLED_FOR_TASK, "Caching has not been enabled for the task"
    }

    def outputFile = file('src.a.txt')
    inputs.files inputFile
    outputs.file outputFile
    outputs.upToDateWhen { isUpToDate.get() }
    doFirst {
        outputFile.text = "[\${inputFile.text}]"
    }
}
task noOutputs {
    inputs.file 'src.txt'
    outputs.upToDateWhen { isUpToDate.get() }
    doFirst { }
}
task nothing {
    outputs.upToDateWhen { isUpToDate.get() }
    doFirst { }
}
"""

        }
        // Only false if no declared outputs AND no Task.upToDateWhen spec. We force to true for incremental tasks.
        AndSpec<? super TaskInternal> upToDateSpec = task.getOutputs().getUpToDateSpec();
        if (!properties.hasDeclaredOutputs() && upToDateSpec.isEmpty()) {
            if (requiresInputChanges(task)) {

        }

        def noOutputs = executionResult.testClass("org.NoOutputsTest")
                .assertTestCount(1, 0, 0)
                .assertTestsExecuted("passing").assertTestPassed("passing")

        if (executionResult instanceof HtmlTestExecutionResult || outputAssociation == WITH_SUITE) {
            noOutputs
                    .assertStdout(equalTo(""))

    def inputs = Stub(TaskInputsInternal)
    def outputs = Stub(TaskOutputsInternal)
    def taskProperties = Mock(TaskProperties)
    def task = Stub(TaskInternal)
    def upToDateSpec = Mock(AndSpec)

    def setup() {
        _ * task.getInputs() >> inputs
        _ * task.getOutputs() >> outputs
        _ * outputs.getUpToDateSpec() >> upToDateSpec
    }

    def "untracked"() {
        when:

        return INCREMENTAL;
    }

    /**
     * The execution mode when task did not declare any outputs.
     * The message will be `Task has not declared any outputs despite executing actions.`.
     */
    public static TaskExecutionMode noOutputs() {
        return NO_OUTPUTS;
    }

    /**
     * The execution mode when the command was run with --rerun-tasks.

    }

    def "up to date when task has no output files"() {
        when:
        def noOutputs = builder.withOutputFiles([:]).build()
        execute(noOutputs)

        then:
        upToDate noOutputs
    }

    def "invalid work is not executed"() {
        def invalidWork = builder
            .withValidator { validationContext ->

        then:
        operations.hasOperation(SnapshotTaskInputsBuildOperationType)
    }

    def "handles task with no outputs"() {
        when:
        buildScript """
            task noOutputs {
                doLast {}
            }
        """
        succeeds('noOutputs', "--build-cache")

        then:
        def result = operations.first(SnapshotTaskInputsBuildOperationType).result

overlapping-outputs-timeline.png...

overlapping-outputs-input-comparison.png...