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)

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

    private final String scope;
    private final Set<ExcludeRule> excludeRules;
    private final boolean optional;

    public DefaultMavenDependency(
        String groupId,
        String artifactId,
        @Nullable String version,
        @Nullable String type,
        @Nullable String classifier,
        @Nullable String scope,
        Set<ExcludeRule> excludeRules,
        boolean optional
    ) {

 * limitations under the License.
 */

package org.gradle.api.internal.component;

import org.gradle.api.artifacts.DependencyConstraint;
import org.gradle.api.artifacts.ExcludeRule;
import org.gradle.api.artifacts.ModuleDependency;
import org.gradle.api.artifacts.PublishArtifact;
import org.gradle.api.attributes.AttributeContainer;
import org.gradle.api.capabilities.Capability;

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

        return artifact.getExtension() != null ? artifact.getExtension() : artifact.getType();
    }

    protected List<ExcludeMetadata> convertExcludeRules(Set<ExcludeRule> excludeRules) {
        return CollectionUtils.collect((Iterable<ExcludeRule>) excludeRules, excludeRuleConverter::convertExcludeRule);
    }

    protected List<IvyArtifactName> convertArtifacts(Set<DependencyArtifact> dependencyArtifacts) {

import com.google.common.collect.ImmutableSet;
import org.gradle.api.DomainObjectSet;
import org.gradle.api.artifacts.Configuration;
import org.gradle.api.artifacts.DependencyConstraint;
import org.gradle.api.artifacts.ExcludeRule;
import org.gradle.api.artifacts.ModuleDependency;
import org.gradle.api.artifacts.PublishArtifact;
import org.gradle.api.attributes.AttributeContainer;
import org.gradle.api.capabilities.Capability;

    def setup() {
        expectExcludeRuleConversion(TEST_EXCLUDE_RULE, TEST_IVY_EXCLUDE_RULE)
    }

    protected void expectExcludeRuleConversion(final ExcludeRule excludeRule, final Exclude exclude) {
        excludeRuleConverterStub.convertExcludeRule(excludeRule) >> exclude
    }

    protected static Dependency setUpDependency(ModuleDependency dependency, boolean withArtifacts) {
        ModuleDependency result = dependency;

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.api.internal.artifacts;

import org.gradle.api.artifacts.ExcludeRule;

public class DefaultExcludeRule implements ExcludeRule {
    private String group;
    private String module;

    public DefaultExcludeRule(){
    }

    public DefaultExcludeRule(String group, String module) {

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

import org.gradle.api.Named;
import org.gradle.api.artifacts.DependencyConstraint;
import org.gradle.api.artifacts.ExcludeRule;
import org.gradle.api.artifacts.ModuleDependency;
import org.gradle.api.artifacts.PublishArtifact;
import org.gradle.api.attributes.HasAttributes;
import org.gradle.api.capabilities.Capability;

import java.util.Set;