}
                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>

}](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"))

// The core type of M2 unifies with the type of m1
// during function argument type inference.
// M2's constraint is unnamed.
func f1[K1 comparable, E1 any](m1 map[K1]E1) {}

func f2[M2 map[string]int](m2 M2) {
	f1(m2)
}

// The core type of M3 unifies with the type of m1
// during function argument type inference.
// M3's constraint is named.
type Map3 map[string]int

func f3[M3 Map3](m3 M3) {
	f1(m3)
}

package p

type t[a, b /* ERROR missing type constraint */ ] struct{}
type t[a t, b t, c /* ERROR missing type constraint */ ] struct{}
type t struct {
	t [n]byte
	t[a]
	t[a, b]
}
type t interface {
	t[a]
	m /* ERROR method must have no type parameters */ [_ _, /* ERROR mixed */ _]()
	t[a, b]
}

func f[ /* ERROR empty type parameter list */ ]()
func f[a, b /* ERROR missing type constraint */ ]()