// all tags are both true and false at the same time.
func eval(x constraint.Expr, tags map[string]bool, prefer bool) bool {
	switch x := x.(type) {
	case *constraint.TagExpr:
		return matchTag(x.Tag, tags, prefer)
	case *constraint.NotExpr:
		return !eval(x.X, tags, !prefer)
	case *constraint.AndExpr:
		return eval(x.X, tags, prefer) && eval(x.Y, tags, prefer)
	case *constraint.OrExpr:

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

// A constraint must be an interface; it cannot
// be a type parameter, for instance.

	podLabelSet := labels.Set(updatedPod.Labels)
	for _, constraint := range s.Constraints {
		if !constraint.Selector.Matches(podLabelSet) {
			continue
		}

		if pl.enableNodeInclusionPolicyInPodTopologySpread &&
			!constraint.matchNodeInclusionPolicies(preemptorPod, node, requiredSchedulingTerm) {
			continue
		}

		k, v := constraint.TopologyKey, node.Labels[constraint.TopologyKey]
		pair := topologyPair{key: k, value: v}

    private VersionParserException parseInvalid(String constraint) {
        try {
            versionParser.parseVersionConstraint(constraint);
            fail("expected exception for constraint " + constraint);
            return null;
        } catch (VersionParserException e) {
            return e;
        }
    }

    @Test

            root(':', ':testproject:') {
                module("group:bom:1.0:platform-runtime") {
                    constraint("group:moduleA:2.0", "group:moduleA:2.0")
                    noArtifacts()
                }
                module("group:bom2:1.0:platform-runtime") {
                    constraint("group:moduleA:2.0", "group:moduleA:2.0")
                    noArtifacts()
                }

        // These are invalid and the type-checker will complain.
        _[~t] t
        _[~t|t] t
        _[t|~t] t
        _[~t|~t] t
)

type _[_ t, t] /* ERROR "missing type constraint" */ t
type _[_ ~t, t] /* ERROR "missing type constraint" */ t
type _[_ t, ~ /* ERROR "missing type parameter name" */ t] t
type _[_ ~t, ~ /* ERROR "missing type parameter name" */ t] t

type _[_ t|t, t /* ERROR "missing type parameter name" */ |t] t

                    byAncestor()
                    configuration(expectedVariant)
                    constraint('org:core:2.7.9')
                    constraint('org:databind:2.7.9')
                    constraint('org:annotations:2.7.9')
                    constraint('org:kotlin:2.7.9')
                    noArtifacts()
                    module("org:platform:2.7.9")
                }
            }

            platform.hasGradleMetadataRedirectionMarker()
            platform.parsedModuleMetadata.variant("apiElements") {
                constraint("com.acme.foo:core:$v") {
                    exists()
                }
                constraint("com.acme.foo:lib:$v") {
                    exists()
                }
                noMoreDependencies()
            }

     */
    @Nonnull
    VersionRange parseVersionRange(@Nonnull String range);

    /**
     * Parses the specified version constraint specification, for example "1.0" or "[1.0,2.0)".
     *
     * @param constraint the range specification to parse, must not be {@code null}
     * @return the parsed version constraint, never {@code null}
     * @throws VersionParserException if the range specification violates the syntax rules of this scheme
     */

    fun `can declare classpath dependency constraints`() {

        val constraint = mock<DependencyConstraint>()
        val constraintHandler = mock<DependencyConstraintHandler> {
            on { add(any(), any()) } doReturn constraint
            on { add(any(), any(), any()) } doReturn constraint
        }
        val dependencies = newDependencyHandlerMock {
            on { constraints } doReturn constraintHandler