}

    @Override
    public int size() {
        int i = 0;
        // NOTE: There isn't much we can do about collection.matching { } filters as the spec requires a realized element, unless make major changes
        for (T o : this) {
            if (accept(o)) {
                ++i;
            }
        }
        return i;
    }

    @Override

    }

    def "name based filtering does not realize pending"() {
        given:
        container.add(new Bean("realized1"))
        container.addLater(new TestNamedProvider("unrealized1", new Bean("unrealized1")))
        container.add(new Bean("realized2"))
        container.addLater(new TestNamedProvider("unrealized2", new Bean("unrealized2")))

        expect: "unrealized elements remain as such"

    }
    def "resolution result does not realize artifact tasks"() {
        createDirs("producer")
        settingsFile << "include 'producer'"
        file("producer/build.gradle") << """
            plugins {
                id("base")
            }

            def fooTask = tasks.register("foo", Zip) {
                throw new RuntimeException("Realized artifact task")
            }

        "using replace()"         | 'replace("foo", Second)'
        "using create(overwrite)" | 'create(name: "foo", type: Second, overwrite: true)'
    }

    def "throws exception when replace realized task"() {
        buildFile << '''
            tasks.register("foo", First).get()
            tasks.replace("foo", Second)
        '''

        expect:
        fails 'help'

 * <p>
 * Properties of any other type must have their getter annotated with {@link Unmanaged}.
 * An unmanaged property is not transparent to the model infrastructure and is guaranteed to be immutable when realized.
 *
 * <h3>Named types</h3>
 * <p>
 * Managed types may implement/extend the {@link org.gradle.api.Named} interface.

            tasks.create("foo", Foo)
            tasks.register("bar", Foo) {
                assert false : "This should not be realized"
            }
            tasks.create("builtInTask", Copy)
            tasks.register("defaultTask") {
                assert false : "This should not be realized"
            }

            def schema = tasks.collectionSchema.elements.collectEntries { e ->

import org.gradle.test.preconditions.IntegTestPreconditions

class DeferredTaskFailureIntegrationTest extends AbstractDeferredTaskDefinitionIntegrationTest {
    def "reports failure in task constructor when task realized"() {
        createDirs("child")
        settingsFile << """
            include "child"
        """
        file("child/build.gradle") << """
            class Broken extends DefaultTask {
                Broken() {

                    Provider<?> value = lazyAttributes.get(key);
                    // Between getting the list of keys and realizing the values
                    // some lazy attributes have been realized and removed from the map
                    // This can happen when a side effect of calculating the value of a Provider
                    // causes dependency resolution or evaluation of the attributes of

    }

    def "name based filtering does not realize pending"() {
        given:
        list.add("realized1")
        list.addLater(new TestNamedProvider("unrealized1", "unrealized1"))
        list.add("realized2")
        list.addLater(new TestNamedProvider("unrealized2", "unrealized2"))

        expect: "unrealized elements remain as such"
        list.index.asMap().size() == 2

    /**
     * Adds an {@code Action} to be executed when an object is added to this collection.
     * <p>
     * Like {@link #all(Action)}, this method will cause all objects in this container to be realized.
     * </p>
     * @param action The action to be executed
     * @return the supplied action
     */
    Action<? super T> whenObjectAdded(Action<? super T> action);

    /**