}

    private void assertExcludeRuleContainerHasCorrectExcludeRules(Set<ExcludeRule> excludeRules, Map... excludeRuleArgs) {
        List<Map> foundRules = new ArrayList<Map>();
        for (ExcludeRule excludeRule : excludeRules) {
            for (Map excludeRuleArg : excludeRuleArgs) {
                if (matchingExcludeRule(excludeRule, excludeRuleArg)) {
                    foundRules.add(excludeRuleArg);

        def excludeRule = Mock(ExcludeRule)
        ExcludeMetadata ivyExcludeRule = Mock(Exclude)

        when:
        def metaData = create()

        then:
        1 * configuration.runDependencyActions()

        when:
        def excludes = metaData.excludes

        then:
        1 * configuration.excludeRules >> ([excludeRule] as Set)

            }

            Set<ExcludeRule> excludeRules = dependency.getExcludeRules();
            if (excludeRules.isEmpty()) {
                return globalExcludes;
            }

            if (globalExcludes.isEmpty()) {
                return excludeRules;
            }

            return Sets.union(globalExcludes, excludeRules);
        }
    }

    /**

/**
 * See [Configuration.getExcludeRules].
 */
@Deprecated(deprecationMessage, replaceWith = ReplaceWith("get().excludeRules"), level = DeprecationLevel.HIDDEN)
val <T : Configuration> NamedDomainObjectProvider<T>.excludeRules: Set<ExcludeRule>
    get() = get().excludeRules


/**
 * See [Configuration.exclude].
 */

        delegate.addDependency(dependency)

    override fun getName(): String =
        delegate.name

    override fun getExcludeRules(): MutableSet<ExcludeRule> =
        delegate.excludeRules

    override fun addArtifact(artifact: DependencyArtifact): ModuleDependency =
        delegate.addArtifact(artifact)

    override fun artifact(configureClosure: Closure<Any>): DependencyArtifact =

            }
        }

        testingCollectorConf.dependencies.forEach {
            println("\${it.reason}")
            if (${testExcludes}) {
                ${cast("it", "ModuleDependency", dsl)}.excludeRules.forEach {
                    println("\${it.group}:\${it.module}")
                }
            }
        }
        """

        when:
        succeeds("help")

        then:

        def d3 = Stub(ExternalDependency)
        d3.group >> "g3"
        d3.name >> "m3"
        d3.versionConstraint >> requires("v3")
        d3.transitive >> true
        d3.excludeRules >> [new DefaultExcludeRule("g4", "m4"), new DefaultExcludeRule(null, "m5"), new DefaultExcludeRule("g5", null)]
        d3.attributes >> ImmutableAttributes.EMPTY

        def d4 = Stub(ExternalDependency)

        assert copy.transitive == original.transitive
        assert copy.description == original.description
        assert copy.allArtifacts as Set == original.allArtifacts as Set
        assert copy.excludeRules == original.excludeRules
        assert copy.resolutionStrategy == resolutionStrategyInCopy
        assert copy.attributes.empty && original.attributes.empty || !copy.attributes.is(original.attributes)

        if (parsedExcludeRules == null) {
            NotationParser<Object, ExcludeRule> parser = ExcludeRuleNotationConverter.parser();
            parsedExcludeRules = new LinkedHashSet<>();
            for (Object excludeRule : excludeRules) {
                parsedExcludeRules.add(parser.parseNotation(excludeRule));
            }
        }
    }

    @Override

        List<ExcludeMetadata> excludeRules = []
        if (args.exclude) {
            ComponentGraphResolveState excluded = args.exclude
            excludeRules << new DefaultExclude(moduleIdentifierFactory.module(excluded.metadata.moduleVersionId.group, excluded.metadata.moduleVersionId.name))
        }