return new FilteringIterator<T, S>(collection, filter);
    }

    @Override
    public void realizePending() {
        realizePending(filter.getType());
    }

    @Override
    public void realizePending(Class<?> type) {
        collection.realizePending(type);
    }

    @Override
    public boolean addPending(ProviderInternal<? extends S> provider) {

import org.gradle.api.Action;
import org.gradle.api.internal.provider.CollectionProviderInternal;
import org.gradle.api.internal.provider.ProviderInternal;

public interface PendingSource<T> {
    void realizePending();

    void realizePending(Class<?> type);

    boolean addPending(ProviderInternal<? extends T> provider);

    boolean removePending(ProviderInternal<? extends T> provider);

    }

    def "realizes pending elements on flush"() {
        when:
        source.addPending(provider1)
        source.addPending(provider2)
        source.addPending(provider3)
        source.realizePending()

        then:
        source.iteratorNoFlush().collect() == ["provider1", "provider2", "provider3"]
    }

    def "realizes only pending elements with a given type"() {
        given:

        source.removePending(provider2)
        source.removePendingCollection(provider4)

        then:
        0 * _ // can remove pending without running side effects

        when:
        source.realizePending()

        then:
        0 * sideEffect1.execute("v1")

        then: // ensure ordering
        0 * sideEffect3.execute("v3")

        then: // ensure ordering
        0 * sideEffect5.execute("v5")

        return size();
    }

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

    @Override
    public Iterator<T> iteratorNoFlush() {
        return values.iterator();
    }

    @Override
    public boolean contains(Object element) {
        realizePending();
        return values.contains(element);
    }

    @Override

        }

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

        @Override
        public void realizePending() {

        }

        @Override
        public void realizePending(Class<?> type) {

        }

        @Override
        public boolean addPending(ProviderInternal<? extends T> provider) {

        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:

     * from that subset in constant time.
     */
    private final Set<T> nonProvidedValues = new HashSet<>();

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

    @Override
    public Iterator<T> iteratorNoFlush() {

        source.add("foo")
        source.addPending(provider("bar"))
        source.addPendingCollection(listProvider("baz", "buzz"))
        source.add("fizz")
        source.add("fuzz")
        source.realizePending()

        when:
        def iterator = source.listIterator()

        then:
        iterator.next() == "foo"
        iterator.next() == "bar"
        iterator.next() == "baz"

        then:

        source.addPendingCollection(setProvider(new StringBuffer("fuzz"), new StringBuffer("bazz")))

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

        when:
        source.realizePending(StringBuffer.class)

        then:
        source.iteratorNoFlush().collect { it.toString() } == iterationOrder("bar", "baz", "fuzz", "bazz")

        and: