private final MavenArtifact mainArtifact;
    private final Set<MavenArtifact> allArtifacts;

    public MavenNormalizedPublication(
        String name,
        MavenPublicationCoordinates projectIdentity,
        String packaging,
        MavenArtifact pomArtifact,
        MavenArtifact mainArtifact,
        Set<MavenArtifact> allArtifacts
    ) {
        this.name = name;

    private final Set<IvyArtifact> allArtifacts;
    private final ModuleVersionIdentifier coordinates;

    public IvyNormalizedPublication(String name, ModuleVersionIdentifier coordinates, File ivyDescriptorFile, Set<IvyArtifact> allArtifacts) {
        this.name = name;
        this.coordinates = coordinates;
        this.ivyDescriptorFile = ivyDescriptorFile;
        this.allArtifacts = allArtifacts;
    }

    public String getName() {

                } else {
                    List<Artifact> allArtifacts = new ArrayList<>();
                    allArtifacts.addAll(artifacts);
                    allArtifacts.addAll(directArtifacts);

                    Map<String, Artifact> mergedArtifacts = new LinkedHashMap<>();
                    for (Artifact artifact : allArtifacts) {
                        String conflictId = artifact.getDependencyConflictId();

        allArtifacts
    }, parentAttributes, TestUtil.instantiatorFactory().decorateLenient(), artifactNotationParser, capabilityNotationParser, fileCollectionFactory, attributesFactory,
        TestUtil.domainObjectCollectionFactory(), TestFiles.taskDependencyFactory()
    )

    def setup() {
        artifacts.whenObjectAdded { allArtifacts.add(it) }
    }

                this.allArtifacts = CompositeResolvedArtifactSet.of(Lists.reverse(resolvedArtifactsById));
            } else {
                this.allArtifacts = CompositeResolvedArtifactSet.of(resolvedArtifactsById);
            }
        }

        @Override
        public ResolvedArtifactSet getArtifacts() {
            return allArtifacts;
        }

        @Override

        if (allModuleArtifactsCache == null) {
            Set<ResolvedArtifact> allArtifacts = new LinkedHashSet<>(getModuleArtifacts());
            for (ResolvedDependency childResolvedDependency : getChildren()) {
                allArtifacts.addAll(childResolvedDependency.getAllModuleArtifacts());
            }
            allModuleArtifactsCache = allArtifacts;
        }
        return allModuleArtifactsCache;
    }

        TaskDependencyFactory taskDependencyFactory
    ) {
        this.displayName = displayName;
        this.artifacts = artifacts;
        this.allArtifacts = allArtifacts;
        this.parentAttributes = parentAttributes;
        this.instantiator = instantiator;
        this.artifactNotationParser = artifactNotationParser;

            </tr>
            <tr>
                <td>allDependencies</td>
            </tr>
            <tr>
                <td>artifacts</td>
            </tr>
            <tr>
                <td>allArtifacts</td>
            </tr>
            <tr>
                <td>excludeRules</td>
            </tr>
            <tr>
                <td>resolutionStrategy</td>
            </tr>
        </table>
    </section>

        when:
        projectDependency.buildDependencies.visitDependencies(context)

        then:
        1 * context.add(conf)
        1 * context.add({ it.is(conf.allArtifacts) })
        0 * _
    }

    void "doesn't allow selection of configuration is not consumable"() {
        def context = Mock(TaskDependencyResolveContext)

        project.configurations.create('conf') {

        masterParent2.extendsFrom masterParent2Parent1, masterParent2Parent2

        def allArtifacts = master.allArtifacts

        def added = []
        allArtifacts.whenObjectAdded { added << it.name }
        def removed = []
        allArtifacts.whenObjectRemoved { removed << it.name }

        expect:
        allArtifacts.empty

        when:
        masterParent1.artifacts << artifact("p1-1")