then:
        defaultBuildComponentSelector.projectPath == ":project:path"
        defaultBuildComponentSelector.projectName == "projectName"
        defaultBuildComponentSelector.displayName == "project :id:path"
        defaultBuildComponentSelector.toString() == "project :id:path"
    }

        def id = new DefaultProjectComponentIdentifier(Stub(BuildIdentifier), Path.path(":id:path"), Path.path(":project:path"), "projectName")

        then:
        id.projectPath == ':project:path'
        id.projectName == 'projectName'
        id.displayName == 'project :id:path'
        id.buildTreePath == ':id:path'
        id.toString() == 'project :id:path'
    }

    def "can compare with other instance (#projectPath)"() {

        return javaMetadata.computeIfAbsent(javaHome, file -> delegate.getMetadata(javaInstallationLocation));
    }

    private File resolveSymlink(File jdkPath) {
        try {
            return jdkPath.getCanonicalFile();
        } catch (IOException e) {
            return jdkPath;
        }
    }

    @Override
    public void invalidateItemsMatching(Predicate<JvmInstallationMetadata> predicate) {

	allErrs := field.ErrorList{}
	fldPath := field.NewPath("limitedResources")
	for i, limitedResource := range config.LimitedResources {
		idxPath := fldPath.Index(i)
		if len(limitedResource.Resource) == 0 {
			allErrs = append(allErrs, field.Required(idxPath.Child("resource"), ""))
		}
	}
	return allErrs

import java.io.File;
import java.util.List;

public interface MutableCommandLineToolContext extends CommandLineToolContext {

    void setArgAction(Action<List<String>> argAction);

    void addPath(File pathEntry);

    void addPath(List<File> path);

    void addEnvironmentVar(String key, String value);

	for i, mnt := range mounts {
		idxPath := fldPath.Index(i)
		if len(mnt.Name) == 0 {
			allErrs = append(allErrs, field.Required(idxPath.Child("name"), ""))
		}
		if !IsMatchedVolume(mnt.Name, volumes) {
			allErrs = append(allErrs, field.NotFound(idxPath.Child("name"), mnt.Name))
		}
		if len(mnt.MountPath) == 0 {
			allErrs = append(allErrs, field.Required(idxPath.Child("mountPath"), ""))
		}

    @Override
    public void setArgAction(Action<List<String>> argAction) {
        postArgsAction = argAction;
    }

    @Override
    public void addPath(File pathEntry) {
        this.path.add(pathEntry);
    }

    @Override
    public void addPath(List<File> path) {
        this.path.addAll(path);
    }

    @Override
    public List<File> getPath() {
        return path;
    }

    @Override

	for ci, ctr := range containers {
		idxPath := fldPath.Index(ci)
		portsPath := idxPath.Child("ports")
		for pi := range ctr.Ports {
			idxPath := portsPath.Index(pi)
			port := ctr.Ports[pi].HostPort
			if port == 0 {
				continue
			}
			str := fmt.Sprintf("%d/%s", port, ctr.Ports[pi].Protocol)
			if accumulator.Has(str) {
				allErrs = append(allErrs, field.Duplicate(idxPath.Child("hostPort"), str))
			} else {

		if err = MkdirAll(dpath, 0777); err != nil {
			t.Fatalf("MkdirAll %q: %s", dpath, err)
		}

		for _, s := range []string{fpath, dpath + "/file1", path + "/zzz"} {
			fd, err = Create(s)
			if err != nil {
				t.Fatalf("create %q: %s", s, err)
			}
			fd.Close()
		}
		if err = Chmod(dpath, 0); err != nil {
			t.Fatalf("Chmod %q 0: %s", dpath, err)
		}

                (1..n).inject(new Exception("lastLine")) { acc, it -> new Exception("line${n - it}", acc) }
        }

        def jdkPath = testLocation("path")
        defineJdks(
            new JvmToolchainMetadata(JvmInstallationMetadata.failure(jdkPath.location, createFailureWithNCauses(nCauses)), jdkPath),
        )
        toolchainConfiguration.isAutoDetectEnabled() >> true
        toolchainConfiguration.isDownloadEnabled() >> true