then:
        if (supportedInMetadata(metadataType)) {
            assert dependencies.size() == 2
            assert dependencies[0].constraint == addAllDependenciesAsConstraints()
            assert dependencies[1].constraint == addAllDependenciesAsConstraints()
        } else {
            assert dependencies.empty
        }

        where:
        metadataType | metadataImplementation

            root(":", ":test:") {
                edge('org:foo', 'org:foo:1.0') {
                    byConstraint()
                    artifact(type: 'distribution-tgz')
                }
                constraint('org:foo:1.0')
            }
        }
    }

    def "The first artifact is used as replacement for metadata if multiple artifacts are declared using #declaration"() {

        ImmutableVersionConstraint constraint = DefaultImmutableVersionConstraint.of(dependencyConstraint);
        ModuleMetadataSpec.Version version = versionFor(constraint, identifier.getVersion());

        return new ModuleMetadataSpec.DependencyCoordinates(identifier.getGroup(), identifier.getName(), version);
    }

            action()
            view
        }

        DependencyConstraintView constraint(String notation, @DelegatesTo(value=DependencyConstraintView, strategy= Closure.DELEGATE_FIRST) Closure<Void> action = { exists() }) {
            def (String group, String module, String version) = notation.split(':') as List
            constraint(group, module, version, action)
        }

        List<Capability> getCapabilities() {

[[sub:terminology_dependency_constraint]]
== Dependency constraint

A dependency constraint defines requirements that need to be met by a module to make it a valid resolution result for the dependency.
For example, a dependency constraint can narrow down the set of supported module versions.
Dependency constraints can be used to express such requirements for transitive dependencies.

| By constraint
| A <<dependency_constraints#sec:adding-constraints-transitive-deps, dependency constraint>> participated in the version selection.
May be followed by a `because` text.

| By ancestor
| There is a <<rich_versions#rich-version-constraints, rich version>> with a `strictly` which enforces the version of this dependency.

| Selected by rule

	// ResourceVersion provides a resource version constraint to apply to the list operation
	// as a "not older than" constraint: the result contains data at least as new as the provided
	// ResourceVersion. The newest available data is preferred, but any data not older than this
	// ResourceVersion may be served.
	ResourceVersion string
	// ResourceVersionMatch provides the rule for how the resource version constraint applies. If set

    private final static DependencyConstraint DUMMY_CONSTRAINT = new DependencyConstraint() {
        private InvalidUserCodeException shouldNotBeCalled() {
            return new InvalidUserCodeException("You shouldn't use a dependency constraint created via a Provider directly");
        }

        @Override
        public void version(Action<? super MutableVersionConstraint> configureAction) {
            throw shouldNotBeCalled();
        }

// Check that an empty replicate is invalid (replicate needs a region).
func.func @verifier_replicate_no_block() {
  "tf_device.replicate" () ({
// expected-error@-1 {{'tf_device.replicate' op region #0 ('body') failed to verify constraint: region with 1 blocks}}
  }) {n = 2 : i32, operandSegmentSizes = array<i32: 0, 0>} : () -> ()
  func.return
}

// -----

// Check that an empty replicate block is invalid.

            }
        }
        return dependencies.build();
    }

    private ImmutableList<ModuleDependencyMetadata> withConstraints(boolean constraint, ImmutableList<ModuleDependencyMetadata> configDependencies) {
        if (configDependencies.isEmpty()) {
            return ImmutableList.of();
        }
        int count = 0;