for _, p := range skip {
		if strings.HasPrefix(file, p) {
			err := findExecutable(file)
			if err == nil {
				return file, nil
			}
			return "", &Error{file, err}
		}
	}

	path := os.Getenv("path")
	for _, dir := range filepath.SplitList(path) {
		path := filepath.Join(dir, file)
		if err := findExecutable(path); err == nil {
			if !filepath.IsAbs(path) {
				if execerrdot.Value() != "0" {

	}
	return nil
}

func hasExt(file string) bool {
	i := strings.LastIndex(file, ".")
	if i < 0 {
		return false
	}
	return strings.LastIndexAny(file, `:\/`) < i
}

func findExecutable(file string, exts []string) (string, error) {
	if len(exts) == 0 {
		return file, chkStat(file)
	}
	if hasExt(file) {
		if chkStat(file) == nil {
			return file, nil
		}

	if strings.Contains(file, "/") {
		err := findExecutable(file)
		if err == nil {
			return file, nil
		}
		return "", &Error{file, err}
	}
	path := os.Getenv("PATH")
	for _, dir := range filepath.SplitList(path) {
		if dir == "" {
			// Unix shell semantics: path element "" means "."
			dir = "."
		}
		path := filepath.Join(dir, file)
		if err := findExecutable(path); err == nil {
			if !filepath.IsAbs(path) {

        }
        javaExecutable = findExecutable("java");
        return javaExecutable;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public File getJavacExecutable() throws JavaHomeException {
        if (javacExecutable != null) {
            return javacExecutable;
        }
        javacExecutable = findExecutable("javac");
        return javacExecutable;
    }

        this.javaToolchain = javaToolchain;
    }

    @Override
    @Internal
    public RegularFile getExecutablePath() {
        return javaToolchain.findExecutable("java");
    }

    @Override
    public JavaInstallationMetadata getMetadata() {
        return javaToolchain;
    }

        if (executable == null) {
            executable = findExecutable(operatingSystem, exeName);
            if (executable != null) {
                executables.put(exeName, executable);
            }
        }
        return executable == null || !executable.isFile() ? new MissingTool(key, exeName, pathEntries) : new FoundTool(executable);
    }

    private File findExecutable(OperatingSystem operatingSystem, String name) {

func pathVersion(dir string, de fs.DirEntry, info fs.FileInfo) (string, bool) {
	v := gover.FromToolchain(de.Name())
	if v == "" {
		return "", false
	}

	// Mimicking exec.findExecutable here.
	// ENOSYS means Eaccess is not available or not implemented.
	// EPERM can be returned by Linux containers employing seccomp.
	// In both cases, fall back to checking the permission bits.

    }

    @Override
    public JavaInstallationMetadata getMetadata() {
        return javaToolchain;
    }

    @Override
    public RegularFile getExecutablePath() {
        return javaToolchain.findExecutable("javadoc");
    }

    @Nested
    public JavaInstallationMetadata getMetadata() {
        return javaToolchain;
    }

    @Override
    @Internal
    public RegularFile getExecutablePath() {
        return javaToolchain.findExecutable("javac");
    }

    @SuppressWarnings("unchecked")
    public <T extends CompileSpec> WorkResult execute(T spec) {
        LOGGER.info("Compiling with toolchain '{}'.", javaToolchain.getDisplayName());

        return javaHome.toString();
    }

    @Internal
    public boolean isFallbackToolchain() {
        return isFallbackToolchain;
    }

    public RegularFile findExecutable(String toolName) {
        return getInstallationPath().file(getBinaryPath(toolName));
    }

    @Override
    public String toString() {
        return "JavaToolchain(javaHome=" + getDisplayName() + ")";