home.create {
            jre {
                bin {
                    file theOs.getExecutableName('java')
                    file theOs.getExecutableName('javadoc')
                }
            }
        }

        then:
        home.file(theOs.getExecutableName("jre/bin/javadoc")).absolutePath ==
            Jvm.forHome(home.file("jre")).getExecutable("javadoc").absolutePath
    }

    public boolean isLinux() {
        return false;
    }

    public abstract String getNativePrefix();

    public abstract String getScriptName(String scriptPath);

    public abstract String getExecutableName(String executablePath);

    public abstract String getExecutableSuffix();

    public abstract String getSharedLibraryName(String libraryName);

    public abstract String getSharedLibrarySuffix();

        def binDir = jdkHome.createDir("bin")
        binDir.createFile(OperatingSystem.LINUX.getExecutableName("java"))

        // Make it look like a macOS installation
        def macOsJdkHomeBinDir = jdkHome.createDir("Contents/Home/bin")
        macOsJdkHomeBinDir.createFile(OperatingSystem.LINUX.getExecutableName("java"))

        when:
        def registry = createRegistry([jdkHome], OperatingSystem.LINUX)

    private DaemonContext candidate = Mock(DaemonContext)

    private TestFile javaHome = tmp.createDir("jdk")

    def setup() {
        javaHome.file("bin", OperatingSystem.current().getExecutableName("java")).touch()
    }

    DaemonRequestContext clientWants(Map args) {
        clientWants(args.requestedJvm,
            args.daemonOpts ?: [],
            args.applyInstrumentationAgent ?: false,

        }
        return null;
    }

    private File commandLocation(String command) {
        File exec = new File(getJavaHome(), "bin/" + command);
        return new File(os.getExecutableName(exec.getAbsolutePath()));
    }

    private File findExecutable(String command) {
        File executable = commandLocation(command);
        if (executable.isFile()) {
            return executable;

        "java home"  | 'options.forkOptions.javaHome = file("<path>")' | ''
        "executable" | 'options.forkOptions.executable = "<path>"'     | OperatingSystem.current().getExecutableName('/bin/javac')
    }

    @Issue("https://github.com/gradle/gradle/issues/22398")
    def "ignore #forkOption if not forking"() {
        def curJvm = Jvm.current()

            GFileUtils.deleteQuietly(tmpDir);
        }
    }


    private static File javaExecutable(File jdkPath) {
        return new File(new File(jdkPath, "bin"), OperatingSystem.current().getExecutableName("java"));
    }

    private JvmInstallationMetadata parseExecOutput(File jdkPath, String probeResult) {
        String[] split = Arrays.stream(probeResult.split(System.getProperty("line.separator")))

            return standaloneJre;
        }
        return potentialHome;
    }

    private boolean hasJavaExecutable(File potentialHome) {
        return new File(potentialHome, os.getExecutableName("bin/java")).exists();
    }

    public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
        Set<Object> seen = ConcurrentHashMap.newKeySet();

                    .filter(file -> file.getName().toLowerCase().contains("jdk") || file.getName().toLowerCase().contains("jre"))
                    .filter(file -> new File(file, OperatingSystem.current().getExecutableName("bin/java")).exists())
                    .map(file -> InstallationLocation.autoDetected(file, getSourceName()))
                    .collect(Collectors.toSet());
            }
            return Collections.emptySet();

        "java home"  | { "options.forkOptions.javaHome = file('$it')" } | ''
        "executable" | { "options.forkOptions.executable = '$it'" }     | OperatingSystem.current().getExecutableName('/bin/javac')
    }

    def "source and target compatibility override toolchain (source #source, target #target)"() {
        def jdk11 = AvailableJavaHomes.getJdk(JavaVersion.VERSION_11)