}
                edge("org:foo:{strictly 1.1}", "org:foo:1.1")
                constraint("org:foo:1.0", "org:foo:1.1")
            }
        }

        where:
        unique << [true, false]
    }

    def 'does not fail when lock file conflicts with declared version constraint (initial unique: #unique)'() {
        given:
        mavenRepo.module('org', 'foo', '1.0').publish()

        this.reason = reason;
        this.selected = selected;
        this.failure = failure;
        this.constraint = constraint;
        this.fromVariant = fromVariant;
        this.targetVariant = targetVariant;
    }

    @Override
    public ComponentSelector getRequested() {
        return requested;
    }

    @Override
    public Long getSelected() {
        return selected;
    }

    @Override

// is deterministic.
func StructuralTerms(tparam *types.TypeParam) ([]*types.Term, error) {
	constraint := tparam.Constraint()
	if constraint == nil {
		return nil, fmt.Errorf("%s has nil constraint", tparam)
	}
	iface, _ := constraint.Underlying().(*types.Interface)
	if iface == nil {
		return nil, fmt.Errorf("constraint is %T, not *types.Interface", constraint.Underlying())
	}
	return InterfaceTermSet(iface)
}

}

// CHECK-LABEL: func @failed_to_propagate_constraints
func.func @failed_to_propagate_constraints(%arg0 : tensor<?x?xf32>)
    -> (tensor<?x?xf32> { tf.constraint = "value"  }) {
  // expected-error@below {{failed to propagate results constraints: 0:value}}
  %0 = "test.OpC"(%arg0) : (tensor<?x?xf32>) -> tensor<?x?xf32>
  // expected-remark@below {{operand #0 constrained to: value}}
  func.return %0 : tensor<?x?xf32>

        call(self, dependencyOrDependencyConstraint, null);
    }

    /**
     * Add a dependency or dependency constraint.
     *
     * @param dependencyOrDependencyConstraint dependency or dependency constraint to add
     * @param configuration an action to configure the dependency or dependency constraint
     */

}](v T) {
}

func _() {
	var v A2
	// Use function type inference to infer type A2 for T.
	// Don't use constraint type inference before function
	// type inference for typed arguments, otherwise it would
	// infer type [2]uint64 for T which doesn't have method m
	// (was the bug).
	f[int](v)
}

// Keep using constraint type inference before function type
// inference for untyped arguments so we infer type float64

Otherwise, the constraint has no effect.
Dependency constraints can also define a <<rich_versions.adoc#rich-version-constraints,rich version constraint>> and support <<rich_versions.adoc#sec:strict-version,strict versions>> to enforce a version even if it contradicts with the version defined by a transitive dependency (e.g. if the version needs to be downgraded).

            return new DetachedResolvedGraphDependency(requested, selectedId, null, null, constraint, fromVariant, selectedVariantId);
        } else if (resultByte == SUCCESSFUL_NOTHING_SELECTED) {
            long selectedId = decoder.readSmallLong();
            return new DetachedResolvedGraphDependency(requested, selectedId, null, null, constraint, fromVariant, null);
        } else if (resultByte == FAILED) {

 */

package org.gradle.integtests.tooling.fixture

import org.gradle.util.GradleVersion
import spock.lang.Specification

class GradleVersionSpecTest extends Specification {
    def "greater-than-or-equal version constraint matches all versions with specified base version and later"() {
        def spec = new GradleVersionSpec().toSpec(">=1.0")

        expect:
        spec.isSatisfiedBy(GradleVersion.version("1.0"))

        add("api", constraintNotation)


    /**
     * Adds a dependency constraint to the 'api' configuration.
     *
     * @param constraintNotation the dependency constraint notation
     * @param block the block to use to configure the dependency constraint
     *
     * @return the added dependency constraint
     *
     * @see [DependencyConstraintHandler.add]
     */