when:
        1 * daemon.getStateCoordinator() >> { daemonStateCoordinator }
        1 * daemonStateCoordinator.getIdleMillis() >> { 1000001L }

        then:
        DaemonExpirationResult result = expirationStrategy.checkExpiration()
        result.status == QUIET_EXPIRE

        this.idleTimeout = Preconditions.checkNotNull(timeoutClosure);
    }

    @Override
    public DaemonExpirationResult checkExpiration() {
        long idleMillis = daemon.getStateCoordinator().getIdleMillis();
        boolean idleTimeoutExceeded = idleMillis > idleTimeout.apply(null);
        if (idleTimeoutExceeded) {

            _ * getDaemonContext() >> { info.getContext() }
            _ * getStateCoordinator() >> Stub(DaemonStateCoordinator) {
                getState() >> info.state
                getIdleMillis(_) >> { long now -> return IDLE_COMPATIBLE_TIMEOUT + (timeoutReached ?  1 : -1) }
            }
        }

        if (info in compatible) {
            compatibleWithCurrent = compatible.collect { it.context }

        then:
        1 * command.run() >> {
            coordinator.getIdleMillis() == 0L
        }
    }

    def "idle millis is > 0 when daemon is idle"() {
        when:
        coordinator.updateActivityTimestamp()
        sleep(10)

        then:
        idle
        coordinator.getIdleMillis() > 0
    }

    boolean isNotStopped() {

        lock.lock();
        try {
            return idleTimer.getElapsedMillis() / 1000.0 / 60.0;
        } finally {
            lock.unlock();
        }
    }

    public long getIdleMillis() {
        if (state == State.Idle) {
            return idleTimer.getElapsedMillis();
        } else {
            return 0L;
        }
    }

    boolean isWillRefuseNewCommands() {