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();

	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 {

        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 }

            return daemonInfo.getState() == Idle;
        }
    });

    @SuppressWarnings("unchecked")
    private final Spec<DaemonInfo> busySpec = Specs.<DaemonInfo>intersect(allSpec, new Spec<DaemonInfo>() {
        public boolean isSatisfiedBy(DaemonInfo daemonInfo) {
            return daemonInfo.getState() != Idle;
        }
    });

    @SuppressWarnings("unchecked")

                return daemonInfo.getState() == Idle;
            }
        });
    }

    @Override
    public List<DaemonInfo> getNotIdle() {
        return getDaemonsMatching(new Spec<DaemonInfo>() {
            @Override
            public boolean isSatisfiedBy(DaemonInfo daemonInfo) {
                return daemonInfo.getState() != Idle;
            }
        });
    }

    }

    @Override
    public ModelRuleDescriptor getDescriptor() {
        return descriptor;
    }

    @Override
    public ModelNode.State getState() {
        return state;
    }

    public void setState(ModelNode.State state) {
        this.state = state;
    }

    @Override
    public boolean isMutable() {
        return state.mutable;
    }

    @Nullable

        0 * listener2.onDiscovered(_)
    }

    def node(String path, Class<?> type = String, State state = State.Discovered) {
        def node = new TestNode(path, type)
        node.setState(state)
        return node
    }

    def root() {
        return node("", Void, State.Created)
    }

    private ModelListener allAcceptingListener() {
        return Mock(ModelListener) {