abstract class AbstractToolchainGroovyCompileIntegrationTest extends AbstractApiGroovyCompilerIntegrationSpec implements JavaToolchainFixture {

    Jvm jdk

    def setup() {
        jdk = computeJdkForTest()
        Assume.assumeNotNull(jdk)
        Assume.assumeTrue(GroovyCoverage.supportsJavaVersion(MultiVersionIntegrationSpec.version, jdk.javaVersion))

        executer.beforeExecute {
            withInstallations(jdk)
        }
    }

    @Requires(UnitTestPreconditions.Jdk9OrLater)
    def "can debug Java exec with socket server debugger (server = true) on explicitly any host with task :#taskName"() {
        def jdwpHost = nonLoopbackAddress()
        Assume.assumeNotNull(jdwpHost)

        debugClient.host = jdwpHost

        sampleProject """
            debugOptions {
                enabled = true
                server = true
                suspend = true

    def "respects fork options settings and ignores executable"() {
        Jvm differentJvm = AvailableJavaHomes.differentJdkWithValidJre
        Assume.assumeNotNull(differentJvm)
        def differentJavacExecutablePath = normaliseFileSeparators(differentJvm.javacExecutable.absolutePath)

        file("src/main/groovy/JavaThing.java") << "public class JavaThing {}"

        given:
        executer.requireDaemon().requireIsolatedDaemons()

        JDWPUtil jdwpClient = new JDWPUtil()

        def jdwpHost = nonLoopbackAddress()
        Assume.assumeNotNull(jdwpHost)
        jdwpClient.host = jdwpHost


        def port = jdwpClient.port

        def host = jdwpClient.host
        when:
        def gradle = startWithDebug(port, host)

    def configureForVersion(JavaVersion javaVersion) {
        String version = javaVersion.majorVersion

        def target = AvailableJavaHomes.getJdk(javaVersion)
        Assume.assumeNotNull(target)

        file("included/src/main/java/com/example/BlankPlugin.java") << """
            package com.example;

            import org.gradle.api.Plugin;
            import org.gradle.api.Project;

import static org.gradle.integtests.fixtures.SuggestionsMessages.SCAN
import static org.gradle.integtests.fixtures.SuggestionsMessages.STACKTRACE_MESSAGE
import static org.junit.Assume.assumeNotNull
import static org.junit.Assume.assumeTrue

class JavaCompileToolchainIntegrationTest extends AbstractIntegrationSpec implements JavaToolchainFixture {

    def setup() {

        given:
        def swiftc3 = AvailableToolChains.getToolChain(ToolChainRequirement.SWIFTC_3)
        def swiftc4 = AvailableToolChains.getToolChain(ToolChainRequirement.SWIFTC_4)
        Assume.assumeNotNull(swiftc3, swiftc4)

        initScript.text = """
            allprojects { p ->
                apply plugin: ${swiftc3.pluginClass}

                model {
                      toolChains {

        def otherVersion = ScalaCoverage.SUPPORTED_BY_JDK.find { it != currentScalaVersion }
        // Occasionally there can be no other version of scala supported by this JDK
        Assume.assumeNotNull(otherVersion)
        return otherVersion
    }

    def getDocsPath() {
        return classes.isScala3() ? "build/docs/scaladoc/_empty_" : "build/docs/scaladoc"
    }

    def setup() {

    }

    def "worker daemons honor different executable specified in fork options"() {
        def differentJvm = AvailableJavaHomes.differentJdkWithValidJre
        Assume.assumeNotNull(differentJvm)
        def differentJavacExecutablePath = normaliseFileSeparators(differentJvm.getJavaExecutable().absolutePath)
        def workAction = getWorkActionThatVerifiesExecutable(differentJvm)

import org.gradle.internal.jvm.Jvm
import org.gradle.internal.os.OperatingSystem
import org.gradle.util.internal.TextUtil
import spock.lang.Issue

import static org.junit.Assume.assumeNotNull

class JavaCompileCompatibilityIntegrationTest extends AbstractIntegrationSpec implements JavaToolchainFixture {

    def setup() {
        file("src/main/java/Foo.java") << "public class Foo {}"
    }