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"
        container.index.asMap().size() == 2
        container.index.pendingAsMap.size() == 2

        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
        list.index.pendingAsMap.size() == 2

            "${containerType}#named(String, Class)": "testContainer.named('unrealized', testContainer.type)",
            "${containerType}#findAll(Closure)":     "testContainer.findAll { it.name == 'unrealized' }",
            "${containerType}#findByName(String)":   "testContainer.findByName('unrealized')",
            "${containerType}#TaskProvider.get()":   "unrealized.get()",

//===----------------------------------------------------------------------===//
// StableHLO+TFL --> VHLO+TFL Ops
//===----------------------------------------------------------------------===//

// Wrap op result uses in an unrealized cast to create a cast to buffer
// any type changes to result, and apply type converter to result:
//   result = op(V0)
//   V1     = op2(result)
//   ==>
//   result = op(V0)
//   V1     = unrealized_cast(result)

                }
            }
            class Second extends First { }
            class Third extends Second { }
        """
    }

    def "can replace an unrealized task when #description"() {
        buildFile << """
            tasks.register("foo", First)
            tasks.${api} // ok
        """

        expect:
        succeeds 'help'

            container.configure {
                thing {}
            }
        }

        then:
        container.names.toList() == ["thing"]
    }

    def "can remove unrealized registered element using register provider"() {
        when:
        def provider = container.register('obj')

        then:
        provider.present

        when:
        container.remove(provider)

        boolean addResult = source.add("foo")
        provider1.value = []

        then:
        addResult
        source.iterator().collect() == ["foo"]
    }

    def "adding is not ignored when an unrealized provider currently has the same value"() {
        def provider1 = setProvider("foo")

        when:
        source.addPendingCollection(provider1)
        boolean addResult = source.add("foo")

        noExceptionThrown()
        replaced == newTask
        container.getByName("task") == newTask

        and:
        1 * taskFactory.create(_ as TaskIdentity) >> newTask
    }

    void "replaces unrealized registered task will execute configuration action against new task"() {
        given:
        def action = Mock(Action)
        def provider = container.register("task", action)
        provider.configure(action)

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