when:
        def constraint = new DefaultMutableVersionConstraint('')
        constraint.branch = 'custom-branch'
        def result = serialize(newSelector(UTIL, constraint, ImmutableAttributes.EMPTY, []), serializer)

        then:
        result == newSelector(UTIL, constraint, ImmutableAttributes.EMPTY, [])
    }

	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()

        }

        private ConstraintMapping createConstraintMapping(String path) {
            def constraint = new Constraint()
            constraint.name = constraintName()
            constraint.authenticate = true
            constraint.roles = [Constraint.ANY_ROLE, Constraint.ANY_AUTH, TestUserRealm.ROLE] as String[]
            def constraintMapping = new ConstraintMapping()

def GetShape: NativeCodeCall<"GetShape($0)">;

// Constraint that values in list attribute are all ones.
def IsAllOnesConstant : Constraint<CPred<"TFL::IsAllOnesConstant($0)">>;

// Constraint that checks if the transpose op is trivial. Trivial means that
// the permutation is a cyclic permutation of the original shape with only the
// identity dimensions permuted.
def IsTransposeTrivial : Constraint<CPred<

            }
        }
        if (specs.size() == 1) {
            return specs.get(0);
        }
        return Specs.intersect(specs);
    }

    private void validateLowestTestedVersion(String constraint, String value, GradleVersion minVersion) {

                project(":platform", "org.test:platform:1.9") {
                    variant("runtimeElements", ['org.gradle.usage': 'java-runtime', 'org.gradle.category': 'platform'])
                    constraint("org:foo:1.1")
                    constraint("org:bar:1.2")
                    noArtifacts()
                }
                edge('org:foo', 'org:foo:1.1') {
                    configuration = "runtime"

                    constraint("org:databind:2.9.0")
                    constraint("org:core:2.9.0")
                    constraint("org:annotations:2.9.0")
                }
                '2.9.4' {
                    asPlatform()
                    constraint("org:databind:2.9.4")
                    constraint("org:core:2.9.4")
                    constraint("org:annotations:2.9.0")
                }
                '2.9.4.1' {

                        }
                    }
                }
                // The following constraints come from the compile classpath configuration resolution result
                constraint("org:foo:{strictly 1.0}", "org:foo:1.0")
                constraint("org:fooA:{strictly 1.0}", "org:fooA:1.0")
                constraint("org:transitive:{strictly 1.0}", "org:transitive:1.0")
            }
        }
    }

	T2 interface{ int }
)

var (
	_ comparable // ERROR "cannot use type comparable outside a type constraint: interface is (or embeds) comparable"
	_ T1         // ERROR "cannot use type T1 outside a type constraint: interface is (or embeds) comparable"
	_ T2         // ERROR "cannot use type T2 outside a type constraint: interface contains type constraints"

	// least one label must be prepended, but only for URI and email
	// constraints, not DNS constraints. The code also supports that
	// behaviour for DNS constraints.

	mustHaveSubdomains := false
	if constraint[0] == '.' {
		mustHaveSubdomains = true
		constraint = constraint[1:]
	}

	constraintLabels, ok := domainToReverseLabels(constraint)
	if !ok {