ext.unrealized = testContainer.register('unrealized')
                    ext.realized = testContainer.register('realized')
                    realized.get()
                }
            }
        """
    }

    Map<String, String> getQueryMethods() {
        [
            "${containerType}#getByName(String)":    "testContainer.getByName('unrealized')",

    }

    def "cannot add elements after collection is realized"() {
        given:
        container.add(Stub(SwiftBinary))
        container.realizeNow()

        when:
        container.add(Stub(SwiftBinary))

        then:
        def e = thrown(IllegalStateException)
        e.message == 'Cannot add an element to this collection as it has already been realized.'
    }

        @Override
        public void collectInto(ImmutableCollection.Builder<T> builder) {
            if (!realized) {
                realize();
            }
            builder.addAll(cache);
        }

        List<T> getValues() {
            if (!realized) {
                realize();
            }
            return cache;
        }

        public boolean remove(T value) {

        }
        elements.add(element);
    }

    /**
     * Realizes the contents of this collection, running configuration actions and firing notifications. No further elements can be added.
     */
    public void realizeNow() {
        if (state != State.Collecting) {

        // Realize all object of type `type`
        def element = container.withType(type).iterator().next()

        when:
        def didRemoved = container.remove(element)

        then:
        didRemoved

        and:
        0 * _
    }

    def "will execute remove action when removing external provider only for realized elements"() {

        expect:
        succeeds "help"

        where:
        queryMethod << getQueryMethods()
    }

    def "can execute query method #queryMethod.key from Provider.configure (realized)"() {
        buildFile << """
            realized.configure {
                ${queryMethod.value}
            }
            toBeRealized.get()
        """

        expect:
        succeeds "help"

        where:

            // Collect elements discarding potential side effects aggregated in the returned value
            collector.collectInto(builder);
            List<T> realized = builder.build();
            for (T element : realized) {
                doAddRealized(element);
            }
        }
    }

    private void doAddRealized(T value) {
        if (values.add(value) && addRealizedAction != null) {

public interface ElementSource<T> extends Iterable<T>, WithEstimatedSize, PendingSource<T>, WithMutationGuard {
    /**
     * Iterates over and realizes each of the elements of this source.
     */
    @Override
    Iterator<T> iterator();

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

    /**

            tasks.register("bar", Delete)
        """

        when:
        succeeds "help"

        then:
        // help task is realized and configured
        outputContains("configured :help")

        // are "built-in" tasks realized and configured?
        if (realizesBuiltInTasks) {
            outputContains("configured :tasks")
            outputContains("configured :projects")
        } else {

    def "cannot execute mutation method #mutationMethod.key from Provider.configure (realized)"() {
        buildFile << """
            realized.configure {
                ${mutationMethod.value}
            }
            toBeRealized.get()
        """

        expect:
        fails "help"