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

 * limitations under the License.
 */
package org.gradle.api.artifacts;

/**
 * An {@code ExcludeRule} is used to describe transitive dependencies that should be excluded when resolving
 * dependencies.
 */
public interface ExcludeRule {
    String GROUP_KEY = "group";
    String MODULE_KEY = "module";

    /**

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

        this.addedRules = new HashSet<ExcludeRule>(addedRules);
    }

    @Override
    public void add(Map<String, String> args) {
        maybeAdd(args);
    }

    public boolean maybeAdd(Map<String, String> args) {
        if (addedRules == null) {
            addedRules = new HashSet<ExcludeRule>();
        }

package org.gradle.api.publish.ivy.internal.dependency;

import org.gradle.api.artifacts.ExcludeRule;

public class DefaultIvyExcludeRule implements IvyExcludeRule {

    private final ExcludeRule excludeRule;
    private final String ivyConfiguration;

    public DefaultIvyExcludeRule(ExcludeRule excludeRule, String ivyConfiguration) {
        this.excludeRule = excludeRule;
        this.ivyConfiguration = ivyConfiguration;
    }

    @Override

import javax.annotation.Nullable;

public class ExcludeRuleNotationConverter extends MapNotationConverter<ExcludeRule> {

    private static final NotationParser<Object, ExcludeRule> PARSER =
            NotationParserBuilder.toType(ExcludeRule.class).converter(new ExcludeRuleNotationConverter()).toComposite();

    public static NotationParser<Object, ExcludeRule> parser() {
        return PARSER;
    }

    @Override

import org.gradle.api.InvalidUserDataException
import org.gradle.api.artifacts.ExcludeRule
import org.gradle.internal.typeconversion.NotationParserBuilder
import org.gradle.util.internal.WrapUtil
import spock.lang.Specification

class ExcludeRuleNotationConverterTest extends Specification {
    def parser = NotationParserBuilder.toType(ExcludeRule).converter(new ExcludeRuleNotationConverter()).toComposite()

    def "with group"() {

        ArtifactId id = excludeRule.getId();
        IvyArtifactName artifactExclusion = artifactForIvyExclude(id);
        return new DefaultExclude(
            moduleIdentifierFactory.module(id.getModuleId().getOrganisation(), id.getModuleId().getName()), artifactExclusion, excludeRule.getConfigurations(), excludeRule.getMatcher().getName());
    }

                }
                for (ExcludeRule excludeRule : dependency.getExcludeRules()) {
                    writeDependencyExclude(excludeRule, xmlWriter);
                }
                xmlWriter.endElement();
            }
            for (IvyExcludeRule excludeRule : model.globalExcludes) {
                writeGlobalExclude(excludeRule, xmlWriter);
            }
            xmlWriter.endElement();

        this.moduleIdentifierFactory = moduleIdentifierFactory;
    }

    @Override
    public DefaultExclude convertExcludeRule(ExcludeRule excludeRule) {
        return createExcludeRule(excludeRule.getGroup(), excludeRule.getModule());
    }

    @Override
    public DefaultExclude createExcludeRule(String group, String module) {
        group = GUtil.elvis(group, PatternMatchers.ANY_EXPRESSION);