int testForkEvery = getProperty('testForkEvery') as Integer

tasks.withType(JavaCompile) {
    options.fork = true
    options.forkOptions.memoryInitialSize=compilerMemory
    options.forkOptions.memoryMaximumSize=compilerMemory
}
tasks.withType(Test) {
    minHeapSize = testRunnerMemory
    maxHeapSize = testRunnerMemory
    maxParallelForks = 4
    forkEvery = testForkEvery
}

<% if (groovyProject) { %>

                </tr>
            </thead>
            <tr>
                <td>memoryInitialSize</td>
                <td><literal>null</literal></td>
            </tr>
            <tr>
                <td>memoryMaximumSize</td>
                <td><literal>null</literal></td>
            </tr>
            <tr>
                <td>jvmArgs</td>
                <td><literal>[]</literal></td>
            </tr>
        </table>

            tasks.withType(GroovyCompile) {
                options.forkOptions.executable = "${differentJavacExecutablePath}"
                options.forkOptions.memoryInitialSize = "128m"
                options.forkOptions.memoryMaximumSize = "256m"
                options.forkOptions.jvmArgs = ["-Dfoo=bar"]

                doLast {
                    assert services.get(WorkerDaemonClientsManager).idleClients.find {

            import org.gradle.internal.jvm.Jvm

            tasks.withType(JavaCompile) {
                options.forkOptions.memoryInitialSize = "128m"
                options.forkOptions.memoryMaximumSize = "256m"
                options.forkOptions.jvmArgs = ["-Dfoo=bar"]

                doLast {
                    assert services.get(WorkerDaemonClientsManager).idleClients.find {

        def classpath = createFiles(numFiles)
        def spec = new DefaultJavaCompileSpec()
        spec.compileOptions = TestUtil.newInstance(CompileOptions, TestUtil.objectFactory())
        spec.compileOptions.forkOptions.memoryMaximumSize = "256m"
        spec.sourceFiles = sources
        spec.compileClasspath = classpath
        spec.tempDir = tempDir.testDirectory
        spec
    }

    def createFiles(numFiles) {

    }

    def "can include/exclude launcher options"() {
        spec.compileOptions.forkOptions.with {
            memoryInitialSize = "64m"
            memoryMaximumSize = "1g"
        }

        when:
        builder.includeLauncherOptions(true)

        then:
        builder.build() == ["-J-Xms64m", "-J-Xmx1g"] + defaultOptions

        when:

            tasks.withType(ScalaCompile) {
                options.forkOptions.executable = "${differentJavaExecutablePath}"
                options.forkOptions.memoryInitialSize = "128m"
                options.forkOptions.memoryMaximumSize = "256m"
                options.forkOptions.jvmArgs = ["-Dfoo=bar"]

                doLast {
                    assert services.get(WorkerDaemonClientsManager).idleClients.find {

}

packageCycles {
    excludePatterns.add("org/gradle/**")
}

tasks.test {
    setForkEvery(200)
}

tasks.compileTestGroovy {
    groovyOptions.fork("memoryInitialSize" to "128M", "memoryMaximumSize" to "1G")
}

tasks.isolatedProjectsIntegTest {
    enabled = true
}

integTest.usesJavadocCodeSnippets = true

    options.release = 8
    options.encoding = "utf-8"
    options.isIncremental = true
    options.isFork = true
    options.forkOptions.jvmArgs?.add("-XX:+HeapDumpOnOutOfMemoryError")
    options.forkOptions.memoryMaximumSize = "1g"
    options.compilerArgs.addAll(mutableListOf("-Xlint:-options", "-Xlint:-path"))
}

fun addDependencies() {
    dependencies {
        testCompileOnly(libs.junit)

        given:
        goodCode()

        and:
        buildFile << """
            compileJava.options.forkOptions.with {
                memoryInitialSize = '64m'
                memoryMaximumSize = '128m'
            }
        """

        when:
        succeeds("compileJava")

        then:
        output.contains(logStatement())