id 'java-library'
            }

            ${mavenCentralRepository()}

            test {
                useJUnitPlatform()

                systemProperties.isJava9 = "\${JavaVersion.current().isJava9Compatible()}"
                systemProperties.testSysProperty = 'value'
                systemProperties.projectDir = projectDir
                environment.TEST_ENV_VAR = 'value'

}

task run(type: aQute.bnd.gradle.Bndrun) {
    dependsOn tasks.named("jar")
    bndrun = file("${pathToBndrun}")
    javaLauncher = javaToolchains.launcherFor {
        languageVersion = JavaLanguageVersion.of(JavaVersion.current().getMajorVersion())
    }
}
"""

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

import org.osgi.framework.BundleActivator;

  public void testToString_delayedTimeout() throws Exception {
    Integer javaVersion = Ints.tryParse(JAVA_SPECIFICATION_VERSION.value());
    // Parsing to an integer might fail because Java 8 returns "1.8" instead of "8."
    // We can continue if it's 1.8, and we can continue if it's an integer in [9, 20).
    if (javaVersion != null && javaVersion >= 20) {
      // TODO(b/261217224): Make this test work under newer JDKs.
      return;

  public void testToString_delayedTimeout() throws Exception {
    Integer javaVersion = Ints.tryParse(JAVA_SPECIFICATION_VERSION.value());
    // Parsing to an integer might fail because Java 8 returns "1.8" instead of "8."
    // We can continue if it's 1.8, and we can continue if it's an integer in [9, 20).
    if (javaVersion != null && javaVersion >= 20) {
      // TODO(b/261217224): Make this test work under newer JDKs.
      return;

                        `java-gradle-plugin`
                    }

                    java {
                        sourceCompatibility = JavaVersion.VERSION_11
                        targetCompatibility = JavaVersion.VERSION_11
                    }

                    gradlePlugin {
                        plugins {
                            register("java11") {

        given:
        def userQuestions = Mock(UserQuestions)
        def buildInitializer = Mock(BuildInitializer)
        buildInitializer.supportsJavaTargets() >> true
        init.javaVersion = "11"

        when:
        def version = init.getJavaLanguageVersion(userQuestions, buildInitializer)

        then:
        version.asInt() == 11
    }

      beforeMerged {
        hooks << 'beforeMerged'
      }
      whenMerged {
        hooks << 'whenMerged'
        assert '1.1' != it.targetCompatibility.toString()
        it.targetCompatibility = JavaVersion.toVersion('1.1')
      }
      withProperties {
        hooks << 'withProperties'
        it.dummy = 'testValue'
      }
    }
  }
}

eclipseJdt.doLast() {

        disableProblemsApiCheck()
        def currentJdk = Jvm.current()
        def newerJdk = AvailableJavaHomes.getDifferentVersion { it.languageVersion > currentJdk.javaVersion }
        Assume.assumeNotNull(newerJdk)

        def installationPaths = [currentJdk, newerJdk].collect { it.javaHome.absolutePath }.join(",")

        given:
        javaTaskSource << """

gradle.settingsEvaluated {
    if ("true" == System.getProperty("org.gradle.ignoreBuildJavaVersionCheck")) {
        return@settingsEvaluated
    }

    if (!JavaVersion.current().isJava11) {
        throw GradleException("This build requires JDK 11. It's currently ${getBuildJavaHome()}. You can ignore this check by passing '-Dorg.gradle.ignoreBuildJavaVersionCheck=true'.")
    }
}

                add(new IgnoredGradleRunnerExecution(testedGradleDistribution, 'does not work with current JVM'))
            } else if (releasedDist && !releasedDist.isToolingApiTargetJvmSupported(Jvm.current().javaVersion)) {
                add(new IgnoredGradleRunnerExecution(testedGradleDistribution, 'does not work with current JVM due to an incompatibility with the tooling API'))