def execution = testExecution({
            instant.executionStarted
            println("I'm running!")
            thread.block()
            instant.executionFinished
        })

        when:
        async {
            queue.submit(execution)
            execution.await()
            instant.awaitFinished
        }

        then:
        instant.awaitFinished > instant.executionFinished
    }

    }

    Instant getEnd() {
        def instant = end.get()
        if (instant == null) {
            throw new IllegalStateException("Operation '$name' has not completed yet.")
        }
        return instant
    }

    Duration getDuration() {
        return getEnd() - start
    }

    void completed(Instant when) {
        end.compareAndSet(null, when)
    }

        def target = {param ->
            if (param == 'param') {
                instant.param1Start
                thread.block()
                instant.param1End
            } else if (param == 'param2') {
                instant.param2Start
            }
        } as TargetObject

        def actor = factory.createBlockingActor(target)

                instant.start3
                container.finalizeIfNotAlready()
                instant.finish3
                assert container.get() == 1
            }
        }

        then:
        container.get() == 1
        instant.finish1 > instant.finishCalculation
        instant.finish2 > instant.finishCalculation
        instant.finish3 > instant.finishCalculation
    }

        getLastCleanupTime()
            .ifPresent(this::performCleanupIfNecessary);
    }

    private void performCleanupIfNecessary(Instant lastCleanupTime) {
        if (LOGGER.isDebugEnabled()) {
            Duration timeSinceLastCleanup = Duration.between(lastCleanupTime, Instant.now());
            LOGGER.debug("{} has last been fully cleaned up {} hours ago", cleanableStore.getDisplayName(), timeSinceLastCleanup.toHours());
        }

        async {
            start {
                def result = userInputReader.readInput()
                instant.read
                assert result == response
            }
            thread.block()
            instant.put
            userInputReader.putInput(response)
        }
        instant.read > instant.put

        where:
        response << [
            new UserInputReader.TextResponse("answer"),

        }

        then:
        instant.idle < instant.created
        1 * target.create(distro, factory, _ as InternalBuildProgressListener, params, cancellationToken) >> {
            instant.busy
            thread.block()
            instant.idle
            Stub(ConsumerConnection)
        }

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

    def "run() blocks until result is available"() {
        given:
        asyncConnection.run(!null, !null) >> { def consumerAction, ResultHandlerVersion1 adaptedHandler ->
            start {
                thread.block()
                instant.resultAvailable
                adaptedHandler.onComplete(null)

        }

        then:
        instant.bReceived > instant.aHandled
    }

    def notifyDoesNotBlockWhenAnotherThreadIsNotifyingOnDifferentType() {
        given:
        def listener1 = { String p ->
            instant.aReceived
            thread.block()
            instant.aHandled
        } as TestFooListener
        def listener2 = {
            instant.bReceived
        } as TestBarListener

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

    def "run() blocks until build is finished"() {
        given:
        asyncConnection.run(!null, !null) >> { args ->
            def handler = args[1]
            start {
                thread.block()
                instant.resultAvailable
                handler.onComplete(null)
            }