Name       string
	Constraint string // length(phone) >= 10
	*Field
}

func (chk *CheckConstraint) GetName() string { return chk.Name }

func (chk *CheckConstraint) Build() (sql string, vars []interface{}) {
	return "CONSTRAINT ? CHECK (?)", []interface{}{clause.Column{Name: chk.Name}, clause.Expr{SQL: chk.Constraint}}
}

// ParseCheckConstraints parse schema check constraints

        1 * dependencyConstraintFactory.createDependencyConstraint("someOther") >> constraint2
        1 * dependencyConstraintSet.add(constraint1)
        1 * dependencyConstraintSet.add(constraint2)
    }

    void "can use dynamic method to add multiple dependency constraint from nested lists"() {
        def constraint1 = Mock(DependencyConstraint)

        protected final List<Object> constraints;

        public RecursiveOrderSpec(List<Object> constraints) {
            this.constraints = constraints;
        }

        protected int checkConstraint(Object constraint, int lastIndex, List<String> executedTaskPaths) {
            int index;
            if (constraint instanceof String) {
                index = executedTaskPaths.indexOf(constraint);

package event

// SchedReqs is a set of constraints on what the scheduling
// context must look like.
type SchedReqs struct {
	Thread    Constraint
	Proc      Constraint
	Goroutine Constraint
}

// Constraint represents a various presence requirements.
type Constraint uint8

const (
	MustNotHave Constraint = iota
	MayHave
	MustHave
)

            ${createDependenciesAndConfiguration()}

            dependencies {
                implementation(constraint("com:foo:1.0"))
            }

            def constraint = configurations.conf.dependencyConstraints.find { it.name == "foo" }
            constraint.version {
                require("2.0")
            }
        """

        when:
        fails("help")

        then:

    private final List<ExcludeMetadata> excludes;
    private final boolean constraint;
    private final boolean endorsing;
    private final String reason;
    private final boolean force;
    private final List<IvyArtifactName> artifacts;

// than one type will result in a panic.
//
// The constraint argument can be nil, and set later via SetConstraint. If the
// constraint is non-nil, it must be fully defined.
func NewTypeParam(obj *TypeName, constraint Type) *TypeParam {
	return (*Checker)(nil).newTypeParam(obj, constraint)
}

// check may be nil
func (check *Checker) newTypeParam(obj *TypeName, constraint Type) *TypeParam {

def AreTheSameElementType : Constraint<
  CPred<"$0.getType() == $1.getType()">>;

// Checks if the given two values are the same.
def AreTheSameValue : Constraint<
  CPred<"$0 == $1">>;

// Checks if the value has rank.
def HasRank : Constraint<
  CPred<"$0.getType().cast<ShapedType>().hasRank()">>;

// Checks if the value has rank of `n`.
class HasRankOf<int n> : Constraint<

	goBuildPos   token.Pos       // position of first go:build line found
	plusBuildPos token.Pos       // position of first "+build" line found
	goBuild      constraint.Expr // go:build constraint found
	plusBuild    constraint.Expr // AND of +build constraints found
}

func (check *checker) init(pass *analysis.Pass) {
	check.pass = pass
	check.goBuildOK = true
	check.plusBuildOK = true
	check.crossCheck = true
}

	results := map[string]schema.CheckConstraint{
		"name_checker": {
			Name:       "name_checker",
			Constraint: "name <> 'jinzhu'",
		},
		"chk_user_checks_name2": {
			Name:       "chk_user_checks_name2",
			Constraint: "name <> 'jinzhu'",
		},
		"chk_user_checks_name3": {
			Name:       "chk_user_checks_name3",
			Constraint: "name <> 'jinzhu'",
		},
	}

	checks := user.ParseCheckConstraints()