])
                }
            }
        }

    }

    @Issue("gradle/gradle#8312")
    def "can resolve a platform with a constraint to determine the platform version via a transitive constraint"() {
        def platform = mavenHttpRepo.module("org", "platform", "1.0")
            .hasType("pom")
            .allowAll()
            .publish()

        createDirs("sub")

namespace ph = std::placeholders;

LogicalResult DeviceTarget::RegisterKernel(
    llvm::StringRef kernel, const KernelSpecs::Signature& signature,
    const ScaleConstraintType constraint) {
  if (failed(specs_[kernel].Add(signature, {constraint, {}}))) return failure();
  switch (constraint) {
    case ScaleConstraintType::OutputInputSameScale:
      specs_[kernel].WithImpl(std::bind(&DeviceTarget::DecomposeSameScale,

        }

        ((DependencyConstraintInternal) dependencyConstraint).addMutationValidator(constraint -> {
            if (((PropertyInternal<?>) getDependencyConstraints()).isFinalized()) {
                throw new InvalidUserCodeException("Cannot mutate dependency constraint " + constraint + " after it has been finalized");
            }
        });

        return dependencyConstraint;
    }

				if tset.comparable {
					check.softErrorf(e, MisplacedConstraintIface, "cannot use type %s outside a type constraint: interface is (or embeds) comparable", typ)
				} else {
					check.softErrorf(e, MisplacedConstraintIface, "cannot use type %s outside a type constraint: interface contains type constraints", typ)
				}
			}
		}
	}).describef(e, "check var type %s", typ)
}

				if tset.comparable {
					check.softErrorf(pos, MisplacedConstraintIface, "cannot use type %s outside a type constraint: interface is (or embeds) comparable", typ)
				} else {
					check.softErrorf(pos, MisplacedConstraintIface, "cannot use type %s outside a type constraint: interface contains type constraints", typ)
				}
			}
		}
	}).describef(e, "check var type %s", typ)
}

        then:
        expectStandardJVM()
    }

    def "can enforce standard JVM variant on Android by constraint"() {
        given:
        prepareResolve('releaseCompileClasspath', 'jre')

        buildFile << """
            dependencies {
                constraints {
                    implementation('org:producer:1.0') {
                        attributes {

package schema

import (
	"gorm.io/gorm/clause"
)

// ConstraintInterface database constraint interface
type ConstraintInterface interface {
	GetName() string
	Build() (sql string, vars []interface{})
}

// GormDataTypeInterface gorm data type interface
type GormDataTypeInterface interface {
	GormDataType() string
}

// FieldNewValuePool field new scan value pool
type FieldNewValuePool interface {
	Get() interface{}

                        byAncestor()
                        byConstraint()
                        configuration('extra')
                    }
                }
                constraint("org:foo:{strictly 1.0}", "org:foo:1.0")
                constraint("org:bar:{strictly 1.0}", "org:bar:1.0")
            }
        }
    }

    // TODO: This is not desired behavior. We should deprecate and forbid this.

                    (TFL_HardSwishOp $input)>;

def IsNchwLayoutOp: Constraint<CPred<
  "$0.get(\"is_nchw_op\") && $0.get(\"is_nchw_op\").dyn_cast<BoolAttr>() "
      "== mlir::BoolAttr::get($_builder.getContext(), true)">>;

def IsNhwcLayoutOp: Constraint<Neg<IsNchwLayoutOp.predicate>>;

// TODO(b/343278954): Move the creation of transposes to a separate prepare pass

package org.gradle.api.internal.artifacts.dsl.dependencies;

import org.gradle.api.artifacts.DependencyConstraint;
import org.gradle.api.artifacts.dsl.DependencyConstraintFactory;

/**
 * Internal API for dependency constraint creation.
 */
public interface DependencyConstraintFactoryInternal extends DependencyConstraintFactory {
    DependencyConstraint createDependencyConstraint(Object dependencyNotation);