def "computes target jvm version when using toolchain"() {
        given:
        def jdk = AvailableJavaHomes.differentVersion
        def javaVersion = jdk.javaVersion.getMajorVersion()

        and:
        goodCode()
        buildFile << """
            java.toolchain {
                languageVersion = JavaLanguageVersion.of(${javaVersion})
            }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.jvm.toolchain;

import org.gradle.api.Incubating;
import org.gradle.jvm.toolchain.internal.DefaultJavaLanguageVersion;

/**
 * Represents a Java Language version
 *
 * @since 6.7
 */

import org.gradle.internal.os.OperatingSystem
import org.gradle.jvm.toolchain.JavaLanguageVersion
import org.gradle.jvm.toolchain.JvmImplementation
import org.gradle.jvm.toolchain.JvmVendorSpec
import org.gradle.launcher.daemon.configuration.DaemonParameters
import org.gradle.launcher.daemon.toolchain.DaemonJvmCriteria
import org.gradle.test.fixtures.file.TestFile

The -toolchain=name flag sets the Go toolchain to use.

The -print flag prints the final go.work in its text format instead of
writing it back to go.mod.

The -json flag prints the final go.work file in JSON format instead of
writing it back to go.mod. The JSON output corresponds to these Go types:

	type GoWork struct {
		Go        string
		Toolchain string
		Godebug   []Godebug
		Use       []Use

    testFixturesImplementation(project(":internal-integ-testing"))

    testRuntimeOnly(project(":distributions-jvm")) {
        because("ProjectBuilder tests load services from a Gradle distribution.  Toolchain usage requires JVM distribution.")
    }
    integTestDistributionRuntimeOnly(project(":distributions-full"))

            }

            scala {
                zincVersion = "1.7.1"
            }

            java {
                toolchain {
                    languageVersion = JavaLanguageVersion.of(
                        !providers.gradleProperty("changed").isPresent()
                            ? ${jdk8.languageVersion.majorVersion}

//
// We have to handle the -C flag this way for two reasons:
//
//  1. Toolchain selection needs to be in the right directory to look for go.mod and go.work.
//
//  2. A toolchain switch later on reinvokes the new go command with the same arguments.
//     The parent toolchain has already done the chdir; the child must not try to do it again.
func handleChdirFlag() {
	_, used := lookupCmd(os.Args[1:])

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.jvm.toolchain.internal;

import org.gradle.api.internal.jvm.JavaVersionParser;
import org.gradle.jvm.toolchain.JavaLanguageVersion;

import java.io.Serializable;

public class DefaultJavaLanguageVersion implements JavaLanguageVersion, Serializable {

			changes[path] = change{path, old, new}
		}
	}

	// Toolchain diffs are easier than requirements: diff old and new directly.
	toolchainVersions := func(reqs []module.Version) (goV, toolchain string) {
		for _, req := range reqs {
			if req.Path == "go" {
				goV = req.Version
			}
			if req.Path == "toolchain" {
				toolchain = req.Version
			}
		}
		return
	}

import org.gradle.internal.service.scopes.ServiceScope;
import org.gradle.jvm.toolchain.internal.InstallationLocation;

import java.util.List;


@NonNullApi
@ServiceScope({ Scope.Build.class, Scope.Global.class })
public interface JavaInstallationRegistry {
    List<JvmToolchainMetadata> toolchains();

    void addInstallation(InstallationLocation downloadedInstallation);