context.seenFromEol.add('\r');
                context.setState(WINDOWS_EOL_PARSING_ODDITY_STATE);
            } else if (context.isCurrentCharEquals('\n')) {
                context.flushLineText();
                context.flushEndLine("\n");
                context.next();
                context.reset();
                context.setState(START_LINE_STATE);
            } else {
                context.next();

                        setState(State.Idle);
                    } catch (Throwable throwable) {
                        setState(State.Broken);
                        throw UncheckedException.throwAsUncheckedException(throwable);
                    }
                    break;
                case StopRequested:
                    setState(State.Idle);

	foo.ReportProgress()
	expect(`- Processing resources for ` + cnpo + `.`)

	foo.ReportFinished()
	expect(`🧠 ` + cnpo + ` installed`)

	p.SetState(StatePruning)
	expect(`- Pruning removed resources`)

	p.SetState(StateComplete)
	expect(`✅ Installation complete`)

	p.SetState(StateUninstallComplete)
	expect(`✅ Uninstall complete`)

        }
    }

    private void doRequestStop() {
        setState(State.Stopped);
    }

    /**
     * Stops accepting new messages, and blocks until all queued messages have been dispatched.
     */
    @Override
    public void stop() {
        lock.lock();
        try {
            setState(State.Stopped);
            waitForAllMessages();
        } finally {

        return Collections.unmodifiableMap(environment);
    }

    @Override
    public ExecHandleState getState() {
        lock.lock();
        try {
            return state;
        } finally {
            lock.unlock();
        }
    }

    private void setState(ExecHandleState state) {
        lock.lock();
        try {
            LOGGER.debug("Changing state to: {}", state);

        private ThreadHandle blockingThread;

        public void expectBlocks(Closure action) {
            try {
                setState(State.Idle, State.Blocking);
                setBlockingThread(start(action));
                setState(State.Blocking, State.Blocked);
                waitForState(State.Unblocked, State.Failed);
            } catch (InterruptedException e) {

        this.token = Preconditions.checkNotNull(token);
        this.clock = Preconditions.checkNotNull(busyClock);
        this.lastBusy = -1; // Will be overwritten by setIdle if not idle.
        setState(state);
    }

    private DaemonInfo(Address address, DaemonContext context, byte[] token, State state, long lastBusy) {
        this.address = address;
        this.context = context;
        this.token = token;

    private final Map<File, SourceFileState> sourceFileStates = new HashMap<File, SourceFileState>();

    public Set<File> getSourceInputs() {
        return sourceFileStates.keySet();
    }

    public void setState(File file, SourceFileState sourceFileState) {
        sourceFileStates.put(file, sourceFileState);
    }

    public CompilationState snapshot() {
        return new CompilationState(ImmutableMap.copyOf(sourceFileStates));

        DaemonContext context = Mock(DaemonContext) {
            _ * getUid() >> uid
        }
        DaemonInfo info = new DaemonInfo(daemonAddress, context, "password".bytes, Busy, new MockClock(lastIdleTime))
        info.setState(state)
        registry.store(info)
        return info
    }

    private static Address createAddress(int i) {
        new Address() {
            int getNum() { i }

		n.methods = methods
		n.loader = nil
	}

	n.setState(complete)
	return n
}

// state atomically accesses the current state of the receiver.
func (n *Named) state() namedState {
	return namedState(atomic.LoadUint32(&n.state_))
}

// setState atomically stores the given state for n.
// Must only be called while holding n.mu.
func (n *Named) setState(state namedState) {