when:
        renderer.onOutput(userInputRequestEvent)

        then:
        renderer.eventQueue.empty

        when:
        renderer.onOutput(userInputResumeEvent)

        then:
        1 * listener.onOutput(userInputResumeEvent)
        0 * listener.onOutput(_)
        0 * userInput._
        renderer.eventQueue.empty
    }

        0 * listener.onOutput(_)
        renderer.eventQueue.empty

        when:
        def testOutputEvent1 = new TestOutputEvent()
        def testOutputEvent2 = new TestOutputEvent()
        renderer.onOutput(testOutputEvent1)
        renderer.onOutput(testOutputEvent2)

        then:
        0 * console._
        0 * listener.onOutput(_)
        renderer.eventQueue.size() == 2

        when:

    }

    private void replayEvents() {
        ListIterator<OutputEvent> iterator = eventQueue.listIterator();

        while (iterator.hasNext()) {
            delegate.onOutput(iterator.next());
            iterator.remove();
        }
    }

    List<OutputEvent> getEventQueue() {
        return eventQueue;
    }

    abstract void startInput();

        final ArrayList<Exchange> batch = new ArrayList<>(batchMaxSize);
        try {
            while (true) {
                batch.clear();
                if (eventQueue.drainTo(batch, BATCH_MAX_SIZE) == 0) {
                    batch.add(eventQueue.take());
                }
                demux(batch);
            }
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        }

        public void submit(OutputEvent event) {
            eventQueue.add(event);
        }

        @Override
        public void run() {
            try {
                while (!shouldStop) {
                    OutputEvent event = eventQueue.poll();
                    if (event == null) {
                        Thread.sleep(10);
                    } else {

     */
    void asyncResumeWhile(Closure<Boolean> isAlive) {
        def vmRef = vm
        Thread.start("VM listener") {
            while (isAlive()) {
                def event = vmRef.eventQueue().remove(100)
                if (event == null) {
                    continue
                }
                event.resume()
            }
        }
    }

    void resume() {