UP_TO_DATE(true, true, "UP-TO-DATE"),
    SKIPPED(true, false, "SKIPPED"),
    NO_SOURCE(true, false, "NO-SOURCE"),
    EXECUTED(false, false, null);

    private final boolean skipped;
    private final boolean upToDate;
    private final String message;

    TaskExecutionOutcome(boolean skipped, boolean upToDate, @Nullable String message) {
        this.skipped = skipped;
        this.upToDate = upToDate;

        file('build/input.txt').makeOlder()

        when:
        succeeds "copy"
        then:
        skipped ":copy"

        buildFile << """
            task other {}
        """

        when:
        succeeds "copy"
        then:
        skipped ":copy"
    }

    def "task with type declared in build script is not up-to-date after build script change"() {

        then:
        skipped ":appVisualStudioSolution"
        executedAndNotSkipped getComponentTasks("main")

        and:
        final projectFile = projectFile("mainExe.vcxproj")
        assert projectFile.sourceFiles.contains('src/main/cpp/foo.cpp')

        when:
        run "visualStudio"

        then:
        skipped ":appVisualStudioSolution"
        skipped getComponentTasks("main")
    }

        1 * context.progress("2 entries deleted, 1 skipped")
    }

    def "always reports deleted, even if all entries are skipped"() {
        when:
        progressMonitor.incrementSkipped()

        then:
        1 * context.progress("0 entries deleted, 1 skipped")
    }

        }
    }

    def "captures skipped test progress logging events" () {
        withSkippedTestClasses(10)

        when:
        succeeds("test")

        then:
        events.statusLogged("0 tests completed")
        events.statusLogged("1 test completed, 1 skipped")
        (2..10).each { count ->
            assert events.statusLogged("${count} tests completed, ${count} skipped")
        }
    }

        when:
        logging.events STARTED, SKIPPED

        then:
        logging.events == [STARTED, SKIPPED] as Set
    }

    def "allows events to be added as string values"() {
        when:
        logging.events "started", "skipped"

        then:
        logging.events == [STARTED, SKIPPED] as Set
    }

    def "allows stack trace formats to be added as enum values"() {

        when:
        succeeds "clean", "write"

        then:
        skipped ":write"
        with(origin(":write")) {
            buildInvocationId == thirdBuildId
            buildCacheKey == thirdBuildCacheKey
        }

        when:
        succeeds  "write"

        then:
        skipped ":write"
        originBuildInvocationId(":write") == thirdBuildId

        when:

		{"", "TestFoo/skipped", "", "TestFoo", true, false},
		{"TestFoo", "TestFoo/skipped", "", "TestFoo", true, false},
		{"TestFoo/", "TestFoo/skipped", "", "TestFoo", true, true},
		{"TestFoo/bar/baz", "TestFoo/skipped", "", "TestFoo", true, true},
		{"TestFoo", "TestFoo/skipped", "", "TestBar", false, false},
		{"TestFoo/", "TestFoo/skipped", "", "TestBar", false, false},

        withBuildCache().run compilationTask

        then:
        skipped compilationTask
        // Local state is removed when loaded from cache
        classes.analysisFile.assertDoesNotExist()

        when:
        cleanBuildDir()
        withBuildCache().run compilationTask

        then:
        skipped compilationTask
        // Local state is removed when loaded from cache

import org.gradle.api.tasks.TaskState
import spock.lang.Specification

class TaskExecutionTest extends Specification {

    def "knows task status"() {
        def skipped = Stub(TaskState) {
            getSkipped() >> true
            getSkipMessage() >> "Skipped for a good reason."
        }
        def busy = Stub(TaskState) {
            getSkipped() >> false
            getDidWork() >> true
        }