then:
        source.iteratorNoFlush().collect() == ["fuzz", "fizz"]

        when:
        iterator.next()
        iterator.set("buzz")

        then:
        source.iteratorNoFlush().collect() == ["fuzz", "buzz"]

        when:
        iterator.previous()
        iterator.set("bazz")

        then:
        source.iteratorNoFlush().collect() == ["bazz", "buzz"]

        and:

        then:
        source.iteratorNoFlush().collect() == iterationOrder("fizz")

        when:
        source.addPending(provider("fuzz"))
        iterator = source.iteratorNoFlush()
        next = iterator.next()

        then:
        next == "fizz"

        when:
        iterator.remove()

        then:
        !iterator.hasNext()
        source.iteratorNoFlush().collect() == []

        when:

        then:
        source.iteratorNoFlush().collect() == iterationOrder("foo")

        when:
        source.addPending(provider("fuzz"))
        iterator = source.iteratorNoFlush()
        next = iterator.next()

        then:
        next == "foo"

        when:
        iterator.remove()

        then:
        !iterator.hasNext()
        source.iteratorNoFlush().collect() == []

        when:

        source.addPending(provider("fizz"))
        source.addPendingCollection(setProvider("fuzz", "bazz"))

        then:
        source.iteratorNoFlush().collect() == iterationOrder("bar", "baz")

        when:
        source.realizePending()

        then:
        source.iteratorNoFlush().collect() == iterationOrder("foo", "bar", "baz", "fizz", "fuzz", "bazz")
    }

    def "can add only providers"() {
        when:

    @Override
    public Iterator<T> iterator() {
        return new IteratorImpl(store.iterator());
    }

    Iterator<T> iteratorNoFlush() {
        if (store.constantTimeIsEmpty()) {
            return Collections.emptyIterator();
        }

        return new IteratorImpl(store.iteratorNoFlush());
    }

    @Override
    public void all(Action<? super T> action) {
        assertMutable("all(Action)");

        private final int estimatedSize;

        private S next;

        FilteringIterator(ElementSource<T> collection, CollectionFilter<S> filter) {
            this.iterator = collection.iteratorNoFlush();
            this.filter = filter;
            this.estimatedSize = collection.estimatedSize();
            this.next = findNext();
        }

        @Nullable
        private S findNext() {

     */
    @Override
    Iterator<T> iterator();

    /**
     * Iterates over only the realized elements (without flushing any pending elements)
     */
    Iterator<T> iteratorNoFlush();

    /**
     * Returns false if this source is not empty or it is not fast to determine this.
     */
    boolean constantTimeIsEmpty();

    @Override
    int estimatedSize();

    @Override
    public Iterator<T> iterator() {
        realizePending();
        return new RealizedElementCollectionIterator(getInserted(), NO_DUPLICATES);
    }

    @Override
    public Iterator<T> iteratorNoFlush() {
        return new RealizedElementCollectionIterator(getInserted(), NO_DUPLICATES);
    }

    @Override
    public boolean add(T element) {
        modCount++;
        if (nonProvidedValues.add(element)) {

    }

    def "can add the same element multiple times"() {
        when:
        3.times { source.add("foo") }
        3.times { source.addPending(provider("bar"))}

        then:
        source.iteratorNoFlush().collect() == ["foo"]

        and:
        source.iterator().collect() == ["foo", "bar"]
    }

    def "can re-add an ordinary value after removal"() {
        when:
        source.add("a")

    @Override
    public Iterator<T> iterator() {
        realizePending();
        return listIterator();
    }

    @Override
    public Iterator<T> iteratorNoFlush() {
        return listIterator();
    }

    @Override
    public ListIterator<T> listIterator() {
        return new RealizedElementListIterator(getInserted(), ALWAYS_ACCEPT);
    }

    @Override