def logDir = new File(daemonsFixture.daemonBaseDir, daemonsFixture.getVersion())
        logDir.mkdirs()
        def log = new File(logDir, "daemon-fake.log")
        log << "DefaultDaemonContext[uid=0000,javaHome=javaHome,javaVersion=11,daemonRegistryDir=daemonRegistryDir,pid=-9999,idleTimeout=120000,daemonOpts=daemonOpts]\n"
        log << exceptionInDaemon
    }

    ForkOptions forkOptions = TestUtil.newInstance(ForkOptions)

    def 'initial values of forkOptions'() {
        expect:
        forkOptions.executable == null
        forkOptions.javaHome == null
        forkOptions.memoryInitialSize == null
        forkOptions.memoryMaximumSize == null
        forkOptions.tempDir == null
        forkOptions.jvmArgs == []
    }

@TargetGradleVersion(">=3.0 <4.2.1")
class JavaVersionCrossVersionTest extends ToolingApiSpecification {
    def configureJava8() {
        projectDir.file("gradle.properties").writeProperties("org.gradle.java.home": AvailableJavaHomes.jdk8.javaHome.absolutePath)
    }

    @Requires([UnitTestPreconditions.Jdk9OrLater, IntegTestPreconditions.Java8HomeAvailable])
    def "smoke test for JavaVersion scheme patch"() {
        configureJava8()

        if (toolchain != null) {
            def isCurrent = toolchain == "current"
            javaToolchain = Mock(JavaToolchain)
            javaToolchain.installationPath >> TestFiles.fileFactory().dir(Jvm.current().javaHome)
            javaToolchain.isCurrentJvm() >> isCurrent
            javaToolchain.languageVersion >> JavaLanguageVersion.of(isCurrent ? "8" : toolchain)
        }

        when:

        }

        return getForkingSpec(fallbackJavaHome, languageVersion);
    }

    abstract protected T getCommandLineSpec(File executable);

    abstract protected T getForkingSpec(File javaHome, int javaLanguageVersion);

    abstract protected T getDefaultSpec();

        when:
        withInstallations(currentJdk, otherJdk).run(":test", "--info")

        then:
        executedAndNotSkipped(":test")
        outputContains("Tests running with ${targetJdk.javaHome.absolutePath}")

        where:
        // Some cases are skipped, because the executable (when configured) must match the resulting toolchain, otherwise the build fails

        def listener = new ProblemProgressListener()

        when:
        withConnection {
            it.model(CustomModel)
                .setJavaHome(jdk.javaHome)
                .addProgressListener(listener)
                .get()
        }
        def problems = listener.problems

        then:
        problems.size() == 1

        where:
        jdk << [

            put(CommonConfigurationKeys.MODULE_NAME, "parser")

            configureKotlinCompilerForGradleBuild()

            addJvmClasspathRoots(PathUtil.getJdkClassesRoots(Jvm.current().javaHome))
            addJvmClasspathRoots(compilationClasspath)
            addKotlinSourceRoots(sourceRoots.map { it.canonicalPath })
        }

    def "project is relocatable"() {
        def originalDir = file("original-dir")
        def originalJavaHome = Jvm.current().javaHome
        originalDir.file("settings.gradle") << localCacheConfiguration()
        setupProjectIn(originalDir)

        def relocatedDir = file("relocated-dir")
        def relocatedJavaHome = file("relocated-java-home")

                }
            }
        """
    }

    def runWithToolchainConfigured(Jvm jvm) {
        result = executer
            .withArgument("-Porg.gradle.java.installations.paths=" + jvm.javaHome.absolutePath)
            .withTasks("check", "javadoc")
            .run()
    }

    private static String testClass(String className) {
        return """
            import org.junit.*;