}

    def "can run tasks via tooling API when configuration cache is enabled"() {
        buildFile << """
            plugins {
                id("java")
            }
            println("script log statement")
        """

        when:
        configurationCacheRun("assemble")

        then:
        outputContains("script log statement")

        when:
        configurationCacheRun("assemble")

        noExceptionThrown()
    }

    def "throws exception when attempting to use service after it has stopped"() {
        when:
        lifecycle.stop()
        lifecycle.use { }

        then:
        IllegalStateException e = thrown()
        e.message == 'Cannot use [service] as it has been stopped.'
    }

    def "throws exception when attempting to use service after stop has been requested"() {
        when:

}
"""

        given:
        run "someTask"

        when:
        run "someTask"

        then:
        skipped(":someTask")

        // Change the build script
        when:
        buildFile << """
task someOtherTask
"""
        and:
        run "someTask"

        then:
        executedAndNotSkipped(":someTask")

        when:
        run "someTask"

        then:

        then:
        thrown(IllegalStateException)
    }

    def "cannot get meta-data when has no result"() {
        when:
        descriptor.metaData

        then:
        thrown(IllegalStateException)
    }

    def "cannot get authoritative flag when has no result"() {
        when:
        descriptor.authoritative

        then:
        thrown(IllegalStateException)
    }

    def "prevents time from going backwards"() {
        when:
        setNanos 0

        then:
        clock.currentTime == START_MILLIS + 0

        when:
        setNanos 10

        then:
        clock.currentTime == START_MILLIS + 10

        when:
        setNanos 8

        then:
        clock.currentTime == START_MILLIS + 10

        when:
        setNanos 10

        then:

    def "cannot get artifacts when no result specified"() {
        when:
        result.result

        then:
        IllegalStateException e = thrown()
        e.message == 'No result has been specified.'
    }

    def "cannot get failure when no result specified"() {
        when:
        result.failure

        then:
        IllegalStateException e = thrown()

        when:
        generator.started(operation, startEvent)

        then:
        0 * _

        when:
        generator.progress(operationId, progressEvent)

        then:
        0 * _

        when:
        generator.finished(operation, finishEvent)

        then:
        0 * _
    }

        def supplier = Mock(Supplier)

        when:
        def lazy = factory(supplier)

        then:
        0 * supplier._

        when:
        lazy.use {
            assert it == 123
        }

        then:
        1 * supplier.get() >> 123

        when:
        lazy.get()

        then:
        0 * supplier.get()

        when:
        lazy.use {

        instant.actionExecuted
    }

    def "fails when waiting for an instant that is not defined by any thread"() {
        instant.timeout = 100

        when:
        thread.blockUntil.unknown

        then:
        IllegalStateException e = thrown()
        e.message == "Timeout waiting for instant 'unknown' to be defined by another thread."

        when:
        async {
            thread.blockUntil.unknown

            }
        """

        when:
        run "signCustomFile"

        then:
        executedAndNotSkipped(":signCustomFile")
        file("input.txt.asc").exists()

        when:
        inputFile.text = "bar"
        run "signCustomFile"

        then:
        executedAndNotSkipped(":signCustomFile")

        when:
        run "signCustomFile"

        then: