if (envVariables != null) {
            daemonParams.setEnvironmentVariables(envVariables);
        }

        File javaHome = operationParameters.getJavaHome();
        if (javaHome != null) {
            daemonParams.setRequestedJvmBasedOnJavaHome(Jvm.forHome(javaHome));
        }

        DaemonRequestContext requestContext = configureForRequestContext(daemonParams);

    }

    private JvmInstallationMetadata getUncheckedMetadata(File root) {
        File javaHome = getJavaHome(root);
        return detector.getMetadata(InstallationLocation.autoProvisioned(javaHome, "provisioned toolchain"));
    }

    private static void validateMetadataMatchesSpec(JavaToolchainSpec spec, URI uri, JvmInstallationMetadata metadata) {

        JvmInstallationMetadata jdkMetadata = AvailableJavaHomes.getJvmInstallationMetadata(AvailableJavaHomes.differentJdk)
        def path = TextUtil.normaliseFileSeparators(jdkMetadata.javaHome.toString() + appendPath)

        def compatibilityVersion = [curJdk, jdkMetadata].collect { it.languageVersion }.min()

        buildFile << """
            compileJava {
                options.fork = true

    }

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

        given:
        file('src/test/java/org/gradle/JUnitTest.java') << """
            package org.gradle;

        def metadata = Mock(JvmInstallationMetadata)
        metadata.getLanguageVersion() >> Jvm.current().javaVersion
        metadata.getCapabilities() >> Collections.emptySet()
        metadata.getJavaHome() >> Jvm.current().javaHome.toPath()
        def toolchain = new JavaToolchain(metadata, TestFiles.fileFactory(), Mock(JavaToolchainInput), false)
        def launcher = new DefaultToolchainJavaLauncher(toolchain)

        when:

            assert params.tasks == []
            assert params.standardOutput == null
            assert params.standardError == null
            assert params.standardInput == null
            assert params.javaHome == null
            assert params.jvmArguments == null
            assert params.arguments == null
            assert params.progressListener != null
            assert params.cancellationToken != null

        ]
    }

    private static List<String> toolchainParameters() {
        return [
            "-Porg.gradle.java.installations.paths=${AvailableJavaHomes.getAvailableJvms().collect { it.javaHome.absolutePath }.join(",")}" as String,
            '-Porg.gradle.java.installations.auto-detect=false',
            '-Porg.gradle.java.installations.auto-download=false',
        ]
    }

        File customJavaHome = forkOptions.getJavaHome();
        if (customJavaHome != null) {
            JavaExecutableUtils.validateMatchingFiles(
                customJavaHome, "Toolchain from `javaHome` property on `ForkOptions`",
                toolchainJavaHome, "toolchain from `javaCompiler` property"
            );
        }

        String customExecutablePath = forkOptions.getExecutable();

        checkModel(actual, expected, [
            { it.languageLevel },
            { it.targetBytecodeVersion },
            { it.jdk?.javaVersion },
            { it.jdk?.javaHome },
        ])
    }

    private static List<String> models(Object... models) {
        models.collect { it instanceof String ? it : (it as Class<?>).getName() }
    }

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