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' {

class FloatValueEquals<string val> : Constraint<CPred<
  "FloatValueEquals($0, " # val # ")">>;

class IsBoolAttrEqual<string true_or_false> : Constraint<CPred<
  "$0.getValue() == "#true_or_false#"">>;

// Flattens a constant tensor to 1D.
def FlattenTo1D : NativeCodeCall<"FlattenTo1D($0)">;

def HasOneUse : Constraint<CPred<"$0.hasOneUse()">>;

def HasSameStaticShapes : Constraint<

                    byConstraint()
                }
                constraint('org:test:1.0', 'org:test:1.0')
            }
        }

        and:
        outputDoesNotContain("Cannot set attributes for constraint \"org:test:1.0\": it was probably created by a plugin using internal APIs")
    }

    def "attributes declared on constraints contribute to graph selection"() {
        given:
        settingsFile << """

            }
            constraint('commons-logging:commons-logging:1.1') { rejects() }

            noMoreDependencies()
        }

        javaLibrary.parsedModuleMetadata.variant('runtimeElements') {
            dependency('org.springframework:spring-core:1.2.9') {
                rejects()
                noMoreExcludes()
            }
            constraint('commons-logging:commons-logging:1.1') { rejects() }

			// | P{foo} | P{foo, bar} |        | P{foo} P{bar} |
			// +--------+-------------+--------+---------------+
			// For the first constraint (zone): the matching pods spread as 2/2/1/1
			// For the second constraint (node): the matching pods spread as 0/1/0/1
			name: "two Constraints on zone and node, with different labelSelectors",
			pod: st.MakePod().Name("p").Label("foo", "").Label("bar", "").

    /*
     * When a node exits the graph, its constraints need to be cleaned up.
     * This means:
     * * Rescheduling any deferred selection impacted by a constraint coming from this node
     * * Making sure we no longer are registered as pending interest on nodes pointed by constraints
     */
    private void cleanupConstraints() {

			}
			st.advance(1)
			ret = &BitIntType{Size: size, Signed: signed}

		case 'k':
			constraint, _ := st.name()
			ret = &SuffixType{
				Base:   constraint,
				Suffix: "auto",
			}

		case 'K':
			constraint, _ := st.name()
			ret = &SuffixType{
				Base:   constraint,
				Suffix: "decltype(auto)",
			}

		default:
			st.fail("unrecognized D code in type")
		}

                constraint("org.gradle.test:lib-ext:{strictly [1.0,1.1)}", "org.gradle.test:lib-ext:1.0")
                edge("org.gradle.test:lib-core:1.+", "org.gradle.test:lib-core:1.0") {
                    notRequested()
                    byReasons(["rejected version 1.1", "constraint"])
                }
                edge("org.gradle.test:lib-ext", "org.gradle.test:lib-ext:1.0") {
                    byConstraint()

    }

    def 'locking constraints are not transitive'() {
        given:
        def constraint = DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId('org', 'foo'), '1.1')
        resolutionStrategy.isDependencyLockingEnabled() >> true
        dependencyLockingProvider.loadLockState("conf", _) >> new DefaultDependencyLockingState(true, [constraint] as Set, {entry -> false })

        when:

			t.Fatalf("failed to drop constraint %v, got error %v", name, err)
		}

		if DB.Migrator().HasConstraint(&User{}, name) {
			t.Fatalf("constraint %v should been deleted", name)
		}

		if err := DB.Migrator().CreateConstraint(&User{}, name); err != nil {
			t.Fatalf("failed to create constraint %v, got error %v", name, err)
		}