instant.willStop
            executor.stop()
            instant.stopped
        }

        then:
        instant.stopped > instant.completed1
        instant.stopped > instant.completed2
    }

    def factoryStopBlocksUntilAllScheduledRunningJobsAreCompleted() {
        given:
        def action1 = {
            instant.started1
            thread.blockUntil.willStop
            thread.block()

import java.time.Duration;
import java.time.Instant;

/**
 * Represents when cache cleanup should be triggered.
 *
 * @since 8.0
 */
public interface CleanupFrequency {
    /**
     * Trigger cleanup once every 24 hours.
     */
    CleanupFrequency DAILY = new CleanupFrequency() {
        @Override
        public boolean requiresCleanup(@Nullable Instant lastCleanupTime) {
            if (lastCleanupTime == null) {

     *             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) {

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

        then:
        instant.finished < instant.stopped
    }

        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"),

            thread.blockUntil.requested2
            stream.received(bytes2)
        }

        then:
        1 * dispatch.onOutput({ it instanceof ReadStdInEvent }) >> { instant.requested1 }
        1 * dispatch.onOutput({ it instanceof ReadStdInEvent }) >> { instant.requested2 }
    }

    def "read bytes returns when stream is closed"() {
        def dispatch = Mock(OutputEventListener)
        def stream = new StdInStream(dispatch)

            instant.idle
            assert result == DaemonStopState.Clean
        }

        then:
        stopped
        instant.idle > instant.actionFinished

        and:
        1 * onStartCommand.run()
        1 * command.run() >> {
            instant.actionStarted
            thread.block()
            instant.actionFinished
        }
        0 * _._
    }

    }

    def createsTestProcessorAndBlocksUntilEndOfProcessingReceived() {
        when:
        async {
            worker.execute(workerContext)
            instant.completed
        }

        then:
        instant.completed > instant.stopped
        System.properties['org.gradle.test.worker'] == '<worker-id>'

        and:
        1 * factory.create(_, _, _) >> processor

        when:
        async {
            start {
                cacheAccess.withFileLock {
                    instant.action1
                    thread.blockUntil.action2
                }
            }
            start {
                cacheAccess.withFileLock {
                    instant.action2
                    thread.blockUntil.action1
                }
            }
        }

        then: