@Override
    public boolean excludes(ModuleIdentifier module) {
        return moduleIds.contains(module);
    }

    @Override
    public boolean excludesArtifact(ModuleIdentifier module, IvyArtifactName artifactName) {
        return false;
    }

    @Override
    public boolean mayExcludeArtifacts() {
        return false;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {

        reader.beginObject();
        String artifactName = null;
        String type = null;
        String extension = null;
        String classifier = null;
        while (reader.peek() != END_OBJECT) {
            String name = reader.nextName();
            switch (name) {
                case "name":
                    artifactName = reader.nextString();
                    break;

        if (mapping == deduplicationDependencyCache.size()) {
            ModuleComponentSelector requested = getComponentSelectorSerializer().read(decoder);
            IvyArtifactName artifactName = IvyArtifactNameSerializer.INSTANCE.readNullable(decoder);
            List<ExcludeMetadata> mavenExcludes = readMavenExcludes(decoder);
            MavenScope scope = MavenScope.values()[decoder.readSmallInt()];

            String moduleName = readString();
            IvyArtifactName artifactName = IvyArtifactNameSerializer.INSTANCE.readNullable(decoder);
            String[] confs = readStringArray();
            String matcher = readNullableString();
            return new DefaultExclude(moduleIdentifierFactory.module(moduleOrg, moduleName), artifactName, confs, matcher);
        }

        write(value.targetVariantAttributes)
        writeCollection(value.capabilities.asSet())
        val files = mutableListOf<Artifact>()
        value.delegate.visitExternalArtifacts { files.add(Artifact(file, artifactName.classifier)) }
        write(files)
        val steps = unpackTransformSteps(value.steps)
        writeCollection(steps)
    }

        def metadata = createWithArtifacts(requested, [artifact1, artifact2, artifact3])

        expect:
        metadata.getConfigurationArtifacts(fromConfiguration) == [artifact1.artifactName, artifact3.artifactName]
    }

    def "excludes nothing when no exclude rules provided"() {
        def dep = createWithExcludes(requested, [])
        def moduleExclusions = new ModuleExclusions()

        expect:

class NormalizingExcludeFactoryTest extends Specification implements ExcludeTestSupport {

    def setup() {
        factory = new NormalizingExcludeFactory(factory)
    }

    @Shared
    private DefaultIvyArtifactName artifactName = new DefaultIvyArtifactName("a", "b", "c")

    @Unroll("#left ∪ #right = #expected")
    def "union of two elements"() {
        expect:
        factory.anyOf(left, right) == expected

                targetAttributes == [artifactType: "size", usage: "api"]
                capabilities == [[group: "root", name: "lib", version: "unspecified"]]
                artifactName == "lib.jar"
                dependenciesConfigurationIdentity == null
            }
            transformActionClass == "FileSizer"
        }
    }

        this.reason = reason;
    }

    private static List<IvyArtifactName> asImmutable(List<IvyArtifactName> artifactNames) {
        return artifactNames.isEmpty() ? Collections.emptyList() : artifactNames instanceof ImmutableList ? artifactNames : ImmutableList.copyOf(artifactNames);
    }

    @Override
    public String toString() {
        return "dependency: " + selector + " to-conf: " + dependencyConfiguration;

                    def depModuleNames = result.get().dependencies*.selected*.moduleVersion*.name
                    def artifactNames = artifacts.artifacts.collect { it.file.name }

                    assert depModuleNames.contains('other')
                    assert artifactNames.contains("other.jar")
                }
            }

            def detached = project.configurations.detachedConfiguration()