import static org.gradle.testing.fixture.JUnitCoverage.LATEST_JUPITER_VERSION
import static org.junit.Assume.assumeNotNull

class JUnitPlatformOnJdk7IntegrationTest extends AbstractIntegrationSpec {

    def setup() {
        def jdk7 = AvailableJavaHomes.getJdk7()
        assumeNotNull(jdk7)
        file("gradle.properties").writeProperties("org.gradle.java.installations.paths": jdk7.javaHome.canonicalPath)

        String testDomain = getProperties().get(TestProperties.TEST_DOMAIN);
        Assume.assumeNotNull(testDomain);
        return testDomain;
    }


    protected String getTestServer () {
        String testServer = getProperties().get(TestProperties.TEST_SERVER);
        Assume.assumeNotNull(testServer);
        return testServer;
    }


    protected String getTestUserDomain () {

    }

    def "customized java home is reflected in the java.home and the build model"() {
        def jdk = AvailableJavaHomes.getAvailableJdk { targetDist.isToolingApiTargetJvmSupported(it.languageVersion) }
        Assume.assumeNotNull(jdk)

        given:
        file('build.gradle') << "project.description = new File(System.getProperty('java.home')).canonicalPath"

        when:

        BuildEnvironment env
        GradleProject project

abstract class AbstractToolchainZincScalaCompileIntegrationTest extends BasicZincScalaCompilerIntegrationTest implements JavaToolchainFixture {

    Jvm jdk

    def setup() {
        jdk = computeJdkForTest()
        Assume.assumeNotNull(jdk)
        executer.beforeExecute {
            withInstallations(jdk)
        }

        configureJavaPluginToolchainVersion(jdk)
    }

    abstract Jvm computeJdkForTest()

    fun `can use Java Toolchain to compile precompiled scripts`() {

        val currentJvm = Jvm.current()
        assumeNotNull(currentJvm)

        val newerJvm = AvailableJavaHomes.getDifferentVersion { it.languageVersion > currentJvm.javaVersion }
        assumeNotNull(newerJvm)

        val installationPaths = listOf(currentJvm!!, newerJvm!!)
            .joinToString(",") { it.javaHome.absolutePath }

    }

    def withJavaProjectUsingToolchainsForJavaVersion(String version) {
        def javaVersion = toJavaVersion(version)
        def target = AvailableJavaHomes.getJdk(javaVersion)
        Assume.assumeNotNull(target)
        withJavaProjectUsingToolchainsForJavaVersion(target)
    }

    def withJavaProjectUsingToolchainsForJavaVersion(Jvm jvm) {
        buildFile << """
            apply plugin: 'java'

        Assume.assumeNotNull(testFifoPipe);
        return "smb://" + getTestServer() + "/IPC$/" + testFifoPipe;
    }


    private String getTransactPipeUrl () {
        String testTransactPipe = getProperties().get(TestProperties.TEST_TRANSACT_PIPE);
        Assume.assumeNotNull(testTransactPipe);
        return "smb://" + getTestServer() + "/IPC$/" + testTransactPipe;

    }

    def "tooling api honours java home specified in gradle.properties"() {
        def jdk = AvailableJavaHomes.getAvailableJdk { targetDist.isToolingApiTargetJvmSupported(it.languageVersion) }
        Assume.assumeNotNull(jdk)
        String javaHomePath = TextUtil.escapeString(jdk.javaHome.canonicalPath)

        file('build.gradle') << "assert new File(System.getProperty('java.home')).canonicalPath.startsWith('$javaHomePath')"

        AvailableToolChains.InstalledToolChain sparcToolChain = AvailableToolChains.getToolChain(ToolChainRequirement.GCC)

        // This is a Junit class, but works in Spock too.
        Assume.assumeNotNull(x86ToolChain?.buildScriptConfig, sparcToolChain?.buildScriptConfig)

        when:
        buildFile << """
model {
    platforms {
        i386 {
            architecture "i386"
        }
        sparc {

import org.gradle.internal.jvm.Jvm

import static org.junit.Assume.assumeNotNull

class TestSuitesMultiTargetIntegrationTest extends AbstractIntegrationSpec implements JavaToolchainFixture {
    Jvm otherJvm

    def setup() {
        otherJvm = AvailableJavaHomes.differentVersion
        assumeNotNull(otherJvm)
    }

    private def setupBasicTestingProject(Iterable<String> extraPlugins = []) {