container.addAllLater(provider1)

        when:
        container.all(action)

        then:
        1 * action.execute(c)
        _ * provider1.elementType >> type
        1 * provider1.calculateValue(_) >> ValueSupplier.Value.of([c])
        _ * provider1.size() >> 1
        0 * _

        when:
        container.addAllLater(provider2)

        then:

        then:
        result == [value]
    }

    @NotYetImplemented
    def "withType works with addAllLater for list"() {
        given:
        def value = Mock(Subtype)

        when:
        container.addAllLater(TestUtil.providerFactory().provider { [value] })
        def result = collect(container.withType(Subtype))

        then:
        result == [value]

    def "withType works with addAllLater"() {
        given:
        def value = Mock(Subtype)

        when:
        container.addAllLater(TestUtil.providerFactory().provider { [value] })
        def result = collect(container.withType(Subtype))

        then:
        result == [value]
    }

    @NotYetImplemented
    def "withType works for addAllLater and list property"() {

        // resolution.
        implementation.withDependencies(dependencySet ->
            dependencySet.addAllLater(getTestToolchain().map(JvmTestToolchain::getImplementationDependencies)
                .orElse(Collections.emptyList()))
        );
        runtimeOnly.withDependencies(dependencySet ->
            dependencySet.addAllLater(getTestToolchain().map(JvmTestToolchain::getRuntimeOnlyDependencies)

        artifacts.add(publishArtifact);
        configureAction.execute(publishArtifact);
    }

    @Override
    public void artifacts(Provider<? extends Iterable<? extends Object>> provider) {
        artifacts.addAllLater(provider.map(iterable -> {
            List<PublishArtifact> results = new ArrayList<>();
            iterable.forEach(notation -> results.add(artifactNotationParser.parseNotation(notation)));
            return results;

                a
                b
                create("default")
            }

            dependencies {
                a project
            }

            configurations.b.dependencies.addAllLater provider(() -> {
                configurations.a.files
                []
            })

            configurations.a.files
        """

        expect:
        succeeds(":help")
    }

     * @since 8.7
     */
    @Incubating
    default void fromDependencyCollector(DependencyCollector collector) {
        getDependencies().addAllLater(collector.getDependencies());
        getDependencyConstraints().addAllLater(collector.getDependencyConstraints());
    }

    /**
     * Returns the artifacts of this configuration excluding the artifacts of extended configurations.
     *

        given:
        buildFile << """
            Task foo = tasks.create("foo")
            Task bar = tasks.create("bar")

            tasks.addAllLater(provider { [foo, bar] })
        """

        when:
        fails("help")

        then:
        failure.assertHasCause("Adding a task provider directly to the task container is not supported.")
    }

        throw new UnsupportedOperationException("Adding a task provider directly to the task container is not supported.  Use the register() method instead.");
    }

    @Override
    public void addAllLater(Provider<? extends Iterable<Task>> provider) {
        throw new UnsupportedOperationException("Adding a task provider directly to the task container is not supported.  Use the register() method instead.");
    }