runWork()

        then: 'it is skipped because UP-TO-DATE'
        result.assertTaskSkipped ':runWork'
        outputContains ':runWork UP-TO-DATE'

        and:
        outputDoesNotContain expectedOutput

        when: 'the outputs are deleted'
        file('build').deleteDir()

        and: 'task runs for the 3rd time'
        runWork()

        then: 'it is skipped because FROM-CACHE'

        final available = isToolChainAvailable(annotation)
        spec.skipped |= !available
    }

    @Override
    void visitFeatureAnnotation(RequiresInstalledToolChain annotation, FeatureInfo feature) {
        final available = isToolChainAvailable(annotation)
        feature.skipped |= !available
    }

    private static boolean isToolChainAvailable(RequiresInstalledToolChain annotation) {

        then:
        listCacheFiles().any { it.name == cacheOperations.getCacheKeyForTask(taskPath) }

        when:
        withBuildCache().run("clean", "cacheable")

        then:
        skipped ":cacheable"
    }

    def "task is cacheable after previous failure"() {
        buildFile << """
            task foo {
                def outFile = project.file("out.txt")
                outputs.file(outFile)

        expect:
        succeeds("test")
    }

    def "test is skipped if no test source detected"() {
        buildFile << "apply plugin: 'java'"

        file("src/test/java/not_a_test.txt")

        when:
        succeeds("test")

        then:
        skipped(":test")
    }

    def createBuildFileWithJUnitJupiter() {
        buildFile << """
            plugins {

        then:
        executedAndNotSkipped taskName

        when:
        succeeds taskName
        then:
        skipped taskName

        when:
        moveFilesAround()
        succeeds taskName
        then:
        skipped(taskName)

        when:
        removeResults()
        succeeds taskName
        def movedResults = extractResults()
        then:

        state.completed(new TestCompleteEvent(200L, ResultType.SKIPPED))

        when:
        def result = new DefaultTestResult(state)

        then:
        result.getStartTime() == 100L
        result.getEndTime() == 200L
        result.resultType == ResultType.SKIPPED
        result.exceptions == state.failures.collect { it.rawFailure }
        result.testCount == state.testCount

        testClass("Thing")

        then:
        succeeds "testReport"

        // verify incremental behavior on 2nd invocation
        succeeds "testReport"
        skipped ":testReport"
    }

    def "test report task is skipped when there are no results"() {
        given:
        buildFile << """
            ${junitSetup}
            tasks.register('testReport', TestReport) {

        def taskOutput = getTaskOutput(result)
        matchesTaskOutput(taskOutput, testLogEventRegex(TestLogEvent.FAILED.consoleMarker))
    }

    def "can group skipped test log event with task if configured"() {
        given:
        buildFile << testLoggingEvents(TestLogEvent.SKIPPED.testLoggingIdentifier)

        file(JAVA_TEST_FILE_PATH) << """
            import org.junit.Test;
            import org.junit.Ignore;

     */
    TaskInputFilePropertyBuilder skipWhenEmpty();

    /**
     * Sets whether executing the task should be skipped if the property contains no files.
     * If there are multiple properties with {code skipWhenEmpty = true}, then they all need to be empty for the task to be skipped.
     */
    TaskInputFilePropertyBuilder skipWhenEmpty(boolean skipWhenEmpty);

        if (GradleContextualExecuter.isConfigCache()) {
            if (isAllIterations(annotation.iterationMatchers()) && isEnabledBottomSpec(annotation.bottomSpecs(), { spec.bottomSpec.name == it })) {
                spec.skipped = true
            } else {
                spec.features.each { feature ->
                    feature.getFeatureMethod().addInterceptor(new IterationMatchingMethodInterceptor(annotation.iterationMatchers()))
                }