def "handles non-existing jdk directory when listing java homes"() {
        given:
        def jdkCacheDirectory = new DefaultJdkCacheDirectory(newHomeDirProvider(), Mock(FileOperations), mockLockManager(), mockDetector(), tmpFileProvider())


        when:
        def homes = jdkCacheDirectory.listJavaHomes()

        then:
        homes.isEmpty()
    }

    def "list java homes on MacOs"() {

        registry.getSubkeys(WindowsRegistry.Key.HKEY_LOCAL_MACHINE, _) >> { throw new MissingRegistryEntryException() }
        def supplier = createSupplier()

        when:
        def locations = supplier.get()

        then:
        locations*.location.path.containsAll(home + "${File.separator}8.0-home", home + "${File.separator}9.0-home")

    }

    /**
     * Creates JVM instance for given java home. Attempts to validate if provided javaHome is a valid jdk or jre location.
     * This method is intended to be used for user supplied java homes.
     *
     * @param javaHome - location of your jdk or jre (jdk is safer), cannot be null
     * @return jvm for given java home

    }

    private String getUnsatisfiedReason() {
        new DaemonCompatibilitySpec(request).whyUnsatisfied(candidate)
    }

    def "contexts with different java homes are incompatible"() {
        clientWants(Jvm.forHome(javaHome))

        def daemonJdkHome = tmp.createDir("daemon-jdk")
        daemonJdkHome.file("bin", OperatingSystem.current().getExecutableName("java")).touch()

import org.gradle.testkit.runner.internal.DefaultGradleRunner
import org.gradle.util.internal.GFileUtils
import org.intellij.lang.annotations.Language

/**
 * Miscellaneous usage scenarios that don't have more specific homes.
 */
@Requires(value = IntegTestPreconditions.NotEmbeddedExecutor, reason = NOT_EMBEDDED_REASON)
class GradleRunnerMiscEndUserIntegrationTest extends BaseTestKitEndUserIntegrationTest implements TestKitDependencyBlock {

// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Tests of internal functions and things with no better homes.

package http

import (
	"bytes"
	"internal/testenv"
	"io/fs"
	"net/url"
	"os"
	"reflect"
	"regexp"
	"strings"
	"testing"
)

func TestForeachHeaderElement(t *testing.T) {
	tests := []struct {

				v.resetArgs()
				if v.Pos.IsStmt() == src.PosIsStmt && reachable[b.ID] {
					pendingLines.set(v.Pos, int32(i)) // TODO could be more than one pos for a line
				}
			}
		}
	}

	// Find new homes for lost lines -- require earliest in data flow with same line that is also in same block
	for i := len(order) - 1; i >= 0; i-- {
		w := order[i]
		if j := pendingLines.get(w.Pos); j > -1 && f.Blocks[j] == w.Block {

			postStmt = false
		}

	}
	if postStmt {
		postStmt = !findBlockPos(post)
	}

	// If simpleStmt and/or postStmt are still true, then try harder
	// to find the corresponding statement marks new homes.

	// setBlockPos determines if b contains a can-be-statement value
	// that has the same line number as the Pos for b itself, and
	// puts a statement mark on it, and returns whether it succeeded
	// in this operation.

	errorTmpl := assets.ParseTemplate(template.Must(layout.Clone()), "templates/404.html")

	_ = router.NewRoute().PathPrefix("/").Methods("GET").HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
		if req.URL.Path == "/" {
			// home page
			fw.RenderHTML(w, homeTmpl, getHomeInfo())
		} else if req.URL.Path == "/homej" || req.URL.Path == "/homej/" {

{{ template "last-refresh" .}}

<script>
    "use strict"

    function refreshHomeInfo() {
        var url = window.location.protocol + "//" + window.location.host + "/homej/";

        var ajax = new XMLHttpRequest();
        ajax.onload = onload;
        ajax.onerror = onerror;
        ajax.open("GET", url, true);
        ajax.send();

        function onload() {