when:
        executer.withJavaHome(java8Home).withArguments("-Porg.gradle.java.installations.paths=$java8Home,$java11Home")
        succeeds("printFoo")

        then:
        outputContains("JAR = DEFAULT")

        when:
        executer.withJavaHome(java11Home).withArguments("-Porg.gradle.java.installations.paths=$java8Home,$java11Home")
        succeeds("printFoo")

        then:

        "assigned tool" | "when configured"                    | "other"  | null         | null           | "other"
    }

    def "uses toolchain from forkOptions #forkOption when it points outside of installations"() {
        def currentJdk = Jvm.current()
        def otherJdk = AvailableJavaHomes.differentVersion

        def path = TextUtil.normaliseFileSeparators(otherJdk.javaHome.absolutePath.toString() + appendPath)

    }

    def "can run tests with custom security manager"() {
        executer
                .withArgument("-Porg.gradle.java.installations.paths=${AvailableJavaHomes.getAvailableJvms().collect { it.javaHome.absolutePath }.join(",")}")
                .withToolchainDetectionEnabled()

        given:

This README provides quickstart instructions on running MinIO on bare metal hardware, including container-based installations. For Kubernetes environments, use the [MinIO Kubernetes Operator](https://github.com/minio/operator/blob/master/README.md).

## Container Installation

Use the following commands to run a standalone MinIO server as a container.

                throw new IOException("Failed to create install parent directory: " + installFolder.getParentFile());
            }
            // Before checking existence, lock the install folder name to prevent concurrent installations
            // An extra string is added to prevent the lock from being created inside the install folder

On the next execution of Gradle, the launcher will use this file to locate a compatible JVM installation and start the daemon with it.

=== Daemon JVM discovery

To locate a compatible JVM installation, Gradle re-uses the mechanism provided by the <<toolchains.adoc#toolchains,Java Toolchains>> feature.
This feature is used to locate a JVM installation that matches the criteria specified in the `gradle/gradle-daemon-jvm.properties` file.

        // In a nutshell, this tests that we don't even try to load classes that are there, but that we shouldn't see.

        when:
        executer
            .withArgument("-Porg.gradle.java.installations.paths=${AvailableJavaHomes.getAvailableJvms().collect { it.javaHome.absolutePath }.join(",")}")
            .withToolchainDetectionEnabled()
        buildFile << """
            plugins {
                id("java")

        uses: gradle/actions/setup-gradle@v3

      - name: Run Checks
        run: ./gradlew test -Dtest.java.version=8 -Dokhttp.platform=jdk8alpn -Dalpn.boot.version=8.1.13.v20181017 -Dorg.gradle.java.installations.paths=/opt/hostedtoolcache/Java_Adopt_jdk/8.0.242-8.1/x64

  testopenjsse:
    runs-on: ubuntu-latest
    if: contains(github.event.pull_request.labels.*.name, 'providers')

    steps:
      - name: Checkout

	if IsDocker() {
		// Construct release tag name.
		return fmt.Sprintf("podman pull quay.io/minio/minio:%s", releaseTag)
	}

	// For binary only installations, we return link to the latest binary.
	if runtime.GOOS == "windows" {
		return MinioReleaseURL + "minio.exe"
	}

	return MinioReleaseURL + "minio"
}

Go 1.20 removed the preinstalled `.a` files for the standard library
from the Go distribution.
Installations now build and cache the standard library like
packages in other modules.
The [`installgoroot` setting](/cmd/go#hdr-Compile_and_install_packages_and_dependencies)
restores the installation and use of preinstalled `.a` files.

There is no plan to remove any of these settings.

### Go 1.19