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].
 */

            }
        }

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

        when:
        succeeds("help")

        then:

        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))
        }

                assert original.version == copied.version
                assert original.reason == copied.reason

                // ModuleDependency
                assert original.excludeRules == copied.excludeRules
                assert original.artifacts == copied.artifacts
                assert original.transitive == copied.transitive
                assert original.targetConfiguration == copied.targetConfiguration

* NamedDomainObjectProvider<Configuration>.dependencyConstraints
* NamedDomainObjectProvider<Configuration>.description
* NamedDomainObjectProvider<Configuration>.exclude
* NamedDomainObjectProvider<Configuration>.excludeRules
* NamedDomainObjectProvider<Configuration>.extendsFrom
* NamedDomainObjectProvider<Configuration>.fileCollection
* NamedDomainObjectProvider<Configuration>.files
* NamedDomainObjectProvider<Configuration>.filter

import org.gradle.api.artifacts.ExcludeRule;
import org.gradle.internal.component.model.ExcludeMetadata;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

@ServiceScope(Scope.Global.class)
public interface ExcludeRuleConverter {
    ExcludeMetadata convertExcludeRule(ExcludeRule excludeRule);
    ExcludeMetadata createExcludeRule(String group, String module);