def idPath = Path.path(":$name")
        def buildIdentifier = new DefaultBuildIdentifier(idPath)

        def gradle = Stub(GradleInternal)
        def services = Stub(ServiceRegistry)

        def includedBuild = Stub(IncludedBuildState)
        includedBuild.buildRootDir >> buildDefinition.buildRootDir
        includedBuild.identityPath >> idPath

# Defaults to 1.

set -e

if [ ! -f ../bin/go ]; then
	echo 'run.bash must be run from $GOROOT/src after installing cmd/go' 1>&2
	exit 1
fi

export GOENV=off
eval $(../bin/go tool dist env)

unset CDPATH	# in case user has it set

export GOHOSTOS
export CC

# no core files, please
ulimit -c 0

# Raise soft limits to hard limits for NetBSD/OpenBSD.
# We need at least ~300 MB of bss.

	allErrs := field.ErrorList{}
	hasObjectMetrics := false
	hasExternalMetrics := false

	for i, metricSpec := range metrics {
		idxPath := fldPath.Index(i)
		if targetErrs := validateMetricSpec(metricSpec, idxPath); len(targetErrs) > 0 {
			allErrs = append(allErrs, targetErrs...)
		}
		if metricSpec.Type == autoscaling.ObjectMetricSourceType {
			hasObjectMetrics = true
		}

        // The visual C++ tools use the path to find other executables
        // TODO:ADAM - restrict this to the specific path for the target tool
        invocationContext.addPath(visualCpp.getPath());
        invocationContext.addPath(sdk.getPath());
        // Clear environment variables that might effect cl.exe & link.exe
        clearEnvironmentVars(invocationContext, "INCLUDE", "CL", "LIBPATH", "LINK", "LIB");

        MessageDigest md = MessageDigest.getInstance("MD5");
        md.update(artifact.getId().getBytes());
        byte[] digest = md.digest();

        String md5path = repository.pathOf(artifact) + ".md5";
        File md5artifactFile = new File(repository.getBasedir(), md5path);
        try (Writer writer =
                new OutputStreamWriter(new FileOutputStream(md5artifactFile), StandardCharsets.ISO_8859_1)) {

func IsDomainPrefixedPath(fldPath *field.Path, dpPath string) field.ErrorList {
	var allErrs field.ErrorList
	if len(dpPath) == 0 {
		return append(allErrs, field.Required(fldPath, ""))
	}

	segments := strings.SplitN(dpPath, "/", 2)
	if len(segments) != 2 || len(segments[0]) == 0 || len(segments[1]) == 0 {
		return append(allErrs, field.Invalid(fldPath, dpPath, "must be a domain-prefixed path (such as \"acme.io/foo\")"))
	}

	for i, term := range topologies {
		idxPath := fldPath.Index(i)
		exprMap, termErrs := apivalidation.ValidateTopologySelectorTerm(term, fldPath.Index(i))
		allErrs = append(allErrs, termErrs...)

		// TODO (verult) consider improving runtime
		for _, t := range rawTopologies {
			if helper.Semantic.DeepEqual(exprMap, t) {
				allErrs = append(allErrs, field.Duplicate(idxPath.Child("matchLabelExpressions"), ""))
			}
		}

set -o nounset
set -o pipefail

# Short-circuit if init.sh has already been sourced
[[ $(type -t kube::init::loaded) == function ]] && return 0

# Unset CDPATH so that path interpolation can work correctly
# https://github.com/kubernetes/kubernetes/issues/52255
unset CDPATH

# The root of the build/dist directory
KUBE_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd -P)"

        def projectState = Mock(ProjectState)
        projectState.componentIdentifier >> Stub(ProjectComponentIdentifier)
        def project = Mock(ProjectInternal)
        project.identityPath >> Path.path(":id:path")
        project.projectPath >> Path.path(":bar")
        project.name >> "bar"
        project.owner >> projectState

        when:
        details.useTarget(project)

        then:

            }
            validateNameIsNotBuildSrc(buildName, buildDir);
            Path idPath = buildPath != null ? buildPath : assignPath(rootBuild, buildName, buildDir);
            BuildIdentifier buildIdentifier = idFor(idPath);

            includedBuild = includedBuildFactory.createBuild(buildIdentifier, buildDefinition, isImplicit, rootBuild);