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.

	}
	return br[i].Revision < br[j].Revision
}

func (br byRevision) Swap(i, j int) {
	br[i], br[j] = br[j], br[i]
}

// Interface provides an interface allowing for management of a Controller's history as realized by recorded
// ControllerRevisions. An instance of Interface can be retrieved from NewHistory. Implementations must treat all
// pointer parameters as "in" parameter, and they must not be mutated.
type Interface interface {

    }

    void realize() {
        registry.realizeNode(path)
    }

    void selfClose() {
        registry.atState(path, ModelNode.State.SelfClosed)
    }

    ModelMap<T> realizeAsModelMap() {
        registry.realize(path, modelMapType)
    }

    T realizeChild(String name) {
        registry.realize(path.child(name), itemType)
    }

    }

    @Issue("https://github.com/gradle/gradle/issues/18622")
    def "custom Test tasks eagerly realized prior to Java and Test Suite plugin application do not fail to be configured when combined with test suites"() {
        buildFile << """
            tasks.withType(Test) {
                // realize all test tasks
            }
            tasks.register("mytest", Test)
            apply plugin: 'java'

        registry.realize("parent") // TODO - should not need this: parent mutations should be applied before mutating element

        expect:
        registry.realize("parent.bar", Bean).value == "prefix: bar"
        registry.realize("parent.foo", String) == "ignore me"
        registry.realize("parent.bar.child1", Bean).value == "prefix: baz"
        registry.realize("parent.bar.child2", String) == "ignore me too"

- `TaskContainer.clear()`
- `TaskContainer.iterator().remove()`

Additionally, the following deprecated functionality now results in an error:

- Replacing a task that has already been realized.
- Replacing a registered (unrealized) task with an incompatible type. A compatible type is the same type or a sub-type of the registered type.
- Replacing a task that has never been registered.

==== Replaced and Removed APIs