instant.message1Dispatched < instant.message2Dispatched
        instant.message2Dispatched < instant.longDispatched

        cleanup:
        connection.stop()
    }

    def "queued outgoing messages are dispatched asynchronously to connection when connection is added"() {
        RemoteConnection<InterHubMessage> outgoing = Mock()

                    instant.worker2
                    thread.block()
                    instant.worker2Finished
                }
            }
        }

        then:
        instant.acquired > instant.worker2Finished

        cleanup:
        registry?.stop()
    }

    def "does not release worker lease when locks can be acquired without blocking"() {

                state.applyToMutableState {
                    assert state.hasMutableState()
                    instant.thread2
                }
                assert !state.hasMutableState()
            }
        }

        then:
        instant.thread2 > instant.thread1
    }

    def "a given thread can only access the state of one project at a time"() {
        given:

                workerLeaseService.withLocks([taskLease]) {
                    instant.worker1Locked
                    thread.block()
                    instant.worker1Unlocked
                }
            }
            start {
                thread.blockUntil.worker1Locked
                workerLeaseService.withLocks([taskLease]) {
                    instant.worker2Locked
                    assert lockIsHeld(taskLease)

     *             to {@link #MavenBuildTimestamp(Instant, String)} instead.
     */
    @Deprecated
    public MavenBuildTimestamp(Instant time, Properties properties) {
        this(time, properties != null ? properties.getProperty(BUILD_TIMESTAMP_FORMAT_PROPERTY) : null);
    }

    public MavenBuildTimestamp(Instant time, String timestampFormat) {

                cache.get("key1", {
                    instant.one
                    thread.block()
                    instant.one_done
                    return "one"
                }, Stub(Runnable))
            }
            start {
                cache.get("key2", {
                    instant.two
                    thread.block()
                    instant.two_done
                    return "two"

            start {
                lifecycle.use {
                    instant.running
                    thread.block()
                    instant.finished
                }
            }
            thread.blockUntil.running
            lifecycle.stop()
            instant.stopped
        }

        then:
        instant.finished < instant.stopped
    }

        instant.dispatched < instant.resultAvailable
        instant.resultAvailable < instant.resultReceived
    }

    def "run() blocks until result is available"() {
        GradleProject result = Mock()

        given:
        asyncConnection.run(!null, !null) >> { args ->
            def handler = args[1]
            start {
                thread.block()
                instant.resultAvailable

                    instant."worker${i}Started"
                }
            }
            5.times { i ->
                thread.blockUntil."worker${i}Started"
            }
            workerThread {
                instant.waitStarted
                asyncWorkTracker.waitForCompletion(operation, RELEASE_PROJECT_LOCKS)
                instant.waitFinished
            }

        instant.dispatched < instant.resultAvailable
        instant.resultAvailable < instant.resultReceived
    }

    def "get() blocks until model is available"() {
        GradleProject result = Mock()

        given:
        asyncConnection.run(!null, !null) >> { args ->
            def handler = args[1]
            start {
                thread.block()
                instant.resultAvailable