outputContains("withType(Sub) called on")
    }

    def "addAllLater(Base) triggers configuration with eager all"() {
        buildFile << """
            container.all {
                println "all called on " + it
            }
            def list = objects.listProperty(Base)
            list.addAll(create(Base))
            container.addAllLater(list)
        """
        expect:
        succeeds("help")

        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]

    }

    @Override
    public void addLater(Provider<? extends T> provider) {
        delegate.addLater(provider);
    }

    @Override
    public void addAllLater(Provider<? extends Iterable<T>> provider) {
        delegate.addAllLater(provider);
    }

    @Override
    public boolean add(T o) {
        return delegate.add(o);
    }

    @Override

import org.gradle.internal.Factory;

import java.util.List;

public interface ConfigurationVariantInternal extends ConfigurationVariant {

    // TODO: Remove this and replace usages with getArtifacts().addAllLater(Provider)
    void artifactsProvider(Factory<List<PublishArtifact>> artifacts);

    void preventFurtherMutation();

    void setDescription(String description);

    DisplayName getDisplayName();

    override fun configure(configureClosure: Closure<Any>): NamedDomainObjectContainer<T> =
        delegate.configure(configureClosure)

    override fun addAllLater(provider: Provider<out Iterable<T>>) =
        delegate.addAllLater(provider)

    override fun create(name: String): T =
        delegate.create(name)

    override fun create(name: String, configureClosure: Closure<Any>): T =

        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;

    }

    public void addCandidate(PublishArtifact artifact) {
        if (defaultArtifactProvider == null) {
            defaultArtifactProvider = new DefaultArtifactProvider();
            artifactContainer.addAllLater(defaultArtifactProvider);
        }
        defaultArtifactProvider.addArtifact(artifact);
    }

    DefaultArtifactProvider getDefaultArtifactProvider() {
        return defaultArtifactProvider;
    }

    override fun configure(configureClosure: Closure<Any>): NamedDomainObjectContainer<Task> =
        delegate.configure(configureClosure)

    override fun addAllLater(provider: Provider<out Iterable<Task>>) =
        delegate.addAllLater(provider)

    override fun create(options: Map<String, *>): Task =
        delegate.create(options)

    }

}

class MyNamedDomainObjectCollection<T> implements NamedDomainObjectCollection<T> {
    @Override
    void addLater(Provider<? extends T> provider) {

    }

    @Override
    void addAllLater(Provider<? extends Iterable<T>> provider) {

    }

    @Override
    <S extends T> DomainObjectCollection<S> withType(Class<S> type, Action<? super S> configureAction) {
        return null
    }

    def "adds provider to artifact set"() {
        when:
        publication.addCandidate(artifact(artifactType))

        then:
        1 * publications.addAllLater(_)

        where:
        artifactType << ["jar", "war", "ear", "other"]
    }

    def "adds jar artifact to publication"() {
        def artifact = artifact("jar")

        when: