*     of the Java collection this collection property corresponds to</li>
 *     <li>{@link CollectingSupplier}, when the collection is still being added to - in that case,
 *     the collecting supplier will wrap a {@link Collector} that lazily represents the yet-to-be realized contents of the collection - see below for details</li>
 * </ul>
 *

    }

    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")
            }

            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 ->

    }

    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

        output.contains("plugin name: windows 10")
        output.contains("script input: Family 'windows'")
        output.contains("script name: windows 10")
    }

    def "target of reference is realized when used as an input"() {
        when:
        buildScript '''
            @Managed
            interface Platforms {
                OperatingSystem getCurrent()

            dependencies {
                testImplementation 'junit:junit:4.13'
            }

            tasks.withType(Test).configureEach {
                throw new RuntimeException("Test task should not have been realized")
            }""".stripIndent()

        file("src/main/java/com/example/SampleClass.java") << """
            package com.example;

            public class SampleClass {

            })
        }
        expect:
        container.asImmutable().keySet().size() == 100
        actual == expected
    }

    def "realizing the value of lazy attributes may cause other attributes to be realized"() {
        def container = new DefaultMutableAttributeContainer(attributesFactory)
        def firstAttribute = Attribute.of("first", String)
        def secondAttribute = Attribute.of("second", String)

        then:
        container.resolveTask(":task") == task
    }

    void "realizes task graph"() {
        given:
        def aTask = addTask("a")
        def bTask = addTask("b")
        aTask.dependsOn(bTask)

        when:
        container.realize()

        then:
        0 * aTask.getTaskDependencies()
        0 * bTask.getTaskDependencies()
    }

     * The returned collection is live, so that when matching objects are added to this collection,
     * they are also visible in the filtered collection.
     * This method will NOT cause any pending objects in this container to be realized.
     *
     * @param nameFilter The specification to test names against.
     * @return The collection of objects with names satisfying the filter. Returns an empty collection if there are no such objects in this collection.