.publish()

        bom.dependencyConstraint(moduleA, exclusions: [[group: 'group', module: 'moduleC']]).publish()

        def bom2 = mavenHttpRepo.module('group', 'bom2', '1.0').hasType("pom").allowAll()
        bom2.dependencyConstraint(moduleA, exclusions: [[group: 'group', module: 'moduleD']]).publish()


        buildFile << """

 * limitations under the License.
 */

package org.gradle.api.publish.internal.mapping;

import org.gradle.api.Action;
import org.gradle.api.artifacts.DependencyConstraint;
import org.gradle.api.artifacts.ExternalDependency;
import org.gradle.api.artifacts.ModuleIdentifier;
import org.gradle.api.artifacts.ModuleVersionIdentifier;
import org.gradle.api.artifacts.ProjectDependency;

    IvyModule dependsOn(Map<String, ?> attributes);

    IvyModule dependsOn(Module target);

    IvyModule dependsOn(Map<String, ?> attributes, Module target);

    IvyModule dependencyConstraint(Module module);

    IvyModule dependencyConstraint(Map<String, ?> attributes, Module module);

    /**
     * Responsible for exclusions at configuration level
     * @param group
     * @param module
     * @param configuration

import org.gradle.api.DomainObjectSet;

/**
 * A set of dependency constraint definitions that are associated with a configuration.
 *
 * @since 4.6
 */
public interface DependencyConstraintSet extends DomainObjectSet<DependencyConstraint> {

import com.nhaarman.mockito_kotlin.mock
import com.nhaarman.mockito_kotlin.never
import com.nhaarman.mockito_kotlin.verify
import org.gradle.api.Action
import org.gradle.api.artifacts.DependencyConstraint
import org.gradle.api.artifacts.ExternalModuleDependency
import org.gradle.api.artifacts.MinimalExternalModuleDependency
import org.gradle.api.artifacts.dsl.DependencyConstraintHandler

    MavenModule dependsOn(String group, String artifactId, String version, String type, String scope, String classifier)

    MavenModule dependencyConstraint(Module module)

    MavenModule dependencyConstraint(Map<String, ?> attributes, Module module)

    MavenModule hasPackaging(String packaging)

    /**
     * Sets the type of the main artifact for this module.
     */

        // remain consistent with the behavior for dependencies.
        for (DependencyConstraint dependencyConstraint : configuration.getDependencyConstraints()) {
            dependencyBuilder.add(dependencyMetadataFactory.createDependencyConstraintMetadata(dependencyConstraint));
        }

        for (ExcludeRule excludeRule : configuration.getExcludeRules()) {

    void selfDependency(String configuration, @Nullable String comment);

    void dependency(String configuration, @Nullable String comment, BuildInitDependency... dependencies);

    void dependencyConstraint(String configuration, @Nullable String comment, BuildInitDependency... dependencies);

        }
        for (ModuleDependencyConstraint dependencyConstraint : dependencyConstraints) {
            variant.addDependencyConstraint(dependencyConstraint.group, dependencyConstraint.module, dependencyConstraint.versionConstraint, dependencyConstraint.reason, dependencyConstraint.attributes);
        }
        for (VariantCapability capability : capabilities) {

                    module.dependencyConstraint(repository.module(*args))
                } else if (it instanceof Map) {
                    def other = repository.module(it.group, it.artifact, it.version)
                    module.dependencyConstraint(it, other)
                } else {
                    module.dependencyConstraint(it)
                }
            }
        }