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
	}
	oldGo, oldToolchain := toolchainVersions(oldReqs)
	newGo, newToolchain := toolchainVersions(newReqs)

        File propertiesFile,
        JavaVersion toolchainVersion,
        @Nullable JvmVendor toolchainVendor,
        @Nullable JvmImplementation toolchainImplementation
    ) {
        validateToolchainVersion(toolchainVersion);

        Properties daemonJvmProperties = new Properties();
        daemonJvmProperties.put(DaemonJvmPropertiesDefaults.TOOLCHAIN_VERSION_PROPERTY, toolchainVersion.getMajorVersion());

        when:
        fails 'help'
        then:
        failure.assertHasDescription("Value 'stringVersion' given for toolchainVersion is an invalid Java version")
    }

    def "Given negative toolchain version When execute any task Then fails with expected exception message"() {
        given:

        metadata.languageVersion >> JavaLanguageVersion.of(toolchainVersion)
        metadata.installationPath >> TestFiles.fileFactory().dir(javaHome)
        compiler.metadata >> metadata

        when:
        javaCompile.javaCompiler.set(compiler)
        def spec = javaCompile.createSpec()

        then:
        spec.sourceCompatibility == JavaVersion.toVersion(toolchainVersion).toString()

public class DaemonJvmPropertiesDefaults {
    public static final String DAEMON_JVM_PROPERTIES_FILE = "gradle/gradle-daemon-jvm.properties";

    public static final String TOOLCHAIN_VERSION_PROPERTY = "toolchainVersion";
    public static final String TOOLCHAIN_VENDOR_PROPERTY = "toolchainVendor";
    public static final String TOOLCHAIN_IMPLEMENTATION_PROPERTY = "toolchainImplementation";

    private void configureCompatibilityOptions(DefaultScalaJavaJointCompileSpec spec) {
        String toolchainVersion = JavaVersion.toVersion(getToolchain().getLanguageVersion().asInt()).toString();
        String sourceCompatibility = getSourceCompatibility();
        if (sourceCompatibility == null) {
            sourceCompatibility = toolchainVersion;
        }
        String targetCompatibility = getTargetCompatibility();

        def otherJvmMetadata = AvailableJavaHomes.getJvmInstallationMetadata(otherJvm)
        captureJavaHome()
        file("gradle.properties")
            .writeProperties(
                "toolchainVersion": otherJvmMetadata.javaVersion,
                "toolchainVendor": otherJvmMetadata.vendor.knownVendor.name()
            )

        expect:
        succeeds("help")
        assertDaemonUsedJvm(Jvm.current())

        } else {
            String toolchainVersion = JavaVersion.toVersion(getToolchain().getLanguageVersion().asInt()).toString();
            String sourceCompatibility = getSourceCompatibility();
            // Compatibility can be null if no convention was configured, e.g. when JavaBasePlugin is not applied
            if (sourceCompatibility == null) {
                sourceCompatibility = toolchainVersion;
            }

        String toolchainVersion = JavaVersion.toVersion(getToolchain().getLanguageVersion().asInt()).toString();
        String sourceCompatibility = getSourceCompatibility();
        // Compatibility can be null if no convention was configured, e.g. when JavaBasePlugin is not applied
        if (sourceCompatibility == null) {
            sourceCompatibility = toolchainVersion;
        }

	if p.Internal.OmitDebug || cfg.Goos == "plan9" || cfg.Goarch == "wasm" {
		defaultGcFlags = append(defaultGcFlags, "-dwarf=false")
	}
	if strings.HasPrefix(ToolchainVersion, "go1") && !strings.Contains(os.Args[0], "go_bootstrap") {
		defaultGcFlags = append(defaultGcFlags, "-goversion", ToolchainVersion)
	}
	if p.Internal.Cover.Cfg != "" {
		defaultGcFlags = append(defaultGcFlags, "-coveragecfg="+p.Internal.Cover.Cfg)
	}
	if pgoProfile != "" {