protected Throwable failure

    AbstractAsyncAction(ConcurrentTestUtil owner) {
        this.owner = owner
    }

    protected Date shortTimeout() {
        return owner.shortTimeout()
    }

    protected void onFailure(Throwable throwable) {
        withLock {
            failure = throwable
            condition.signalAll()
        }
    }

    @Rule StressHttpServer server = new StressHttpServer()
    @Rule ConcurrentTestUtil concurrent = new ConcurrentTestUtil()

    def setup() {
        concurrent.shortTimeout = 180000
    }

    def cleanup() {
        new DaemonLogsAnalyzer(workspace.file("daemon")).daemons.each { it.kill() }
    }

    def "handles concurrent access to changing artifacts"() {
        expect:

import java.util.concurrent.TimeUnit
import org.spockframework.mock.TooManyInvocationsError
import spock.lang.FailsWith

class ConcurrentSpecificationTest extends ConcurrentSpecification {
    def setup() {
        shortTimeout = 2000
    }

    def "can check that an action calls a mock method asynchronously"() {
        Runnable action = Mock()
        def executed = startsAsyncAction()

        when:
        executed.started {

    final GradleDistribution dist = new UnderDevelopmentGradleDistribution()
    final ToolingApi toolingApi = new ToolingApi(dist, temporaryFolder)

    int threads = 3

    def setup() {
        concurrent.shortTimeout = 180000
        settingsFile.touch()
    }

    def "handles the same target gradle version concurrently"() {
        buildFile << "apply plugin: 'java'"

        when:
        threads.times {